Update autosetup to v0.6.3

Signed-off-by: Steve Bennett <steveb@workware.net.au>

1 files changed, 2230 insertions, 5470 deletions

diff --git a/autosetup/jimsh0.c b/autosetup/jimsh0.c
index 738195d..e45a492 100644
--- a/autosetup/jimsh0.c
+++ b/autosetup/jimsh0.c
@@ -24,6 +24,8 @@
 #define TCL_PLATFORM_PATH_SEPARATOR ";"
 #define HAVE_MKDIR_ONE_ARG
 #define HAVE_SYSTEM
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
 #else
 #define TCL_PLATFORM_OS "unknown"
 #define TCL_PLATFORM_PLATFORM "unix"
@@ -33,26 +35,13 @@
 #endif
 #ifndef UTF8_UTIL_H
 #define UTF8_UTIL_H
-/**
- * UTF-8 utility functions
- *
- * (c) 2010 Steve Bennett <steveb@workware.net.au>
- *
- * See LICENCE for licence details.
- */
-
-/**
- * Converts the given unicode codepoint (0 - 0xffff) to utf-8
- * and stores the result at 'p'.
- * 
- * Returns the number of utf-8 characters (1-3).
- */
+
 int utf8_fromunicode(char *p, unsigned short uc);
 
 #ifndef JIM_UTF8
 #include <ctype.h>
 
-/* No utf-8 support. 1 byte = 1 char */
+
 #define utf8_strlen(S, B) (B) < 0 ? strlen(S) : (B)
 #define utf8_tounicode(S, CP) (*(CP) = *(S), 1)
 #define utf8_upper(C) toupper(C)
@@ -61,147 +50,9 @@ int utf8_fromunicode(char *p, unsigned short uc);
 #define utf8_charlen(C) 1
 #define utf8_prev_len(S, L) 1
 
-#else
-/**
- * Returns the length of the utf-8 sequence starting with 'c'.
- * 
- * Returns 1-4, or -1 if this is not a valid start byte.
- *
- * Note that charlen=4 is not supported by the rest of the API.
- */
-int utf8_charlen(int c);
-
-/**
- * Returns the number of characters in the utf-8 
- * string of the given byte length.
- *
- * Any bytes which are not part of an valid utf-8
- * sequence are treated as individual characters.
- *
- * The string *must* be null terminated.
- *
- * Does not support unicode code points > \uffff
- */
-int utf8_strlen(const char *str, int bytelen);
-
-/**
- * Returns the byte index of the given character in the utf-8 string.
- * 
- * The string *must* be null terminated.
- *
- * This will return the byte length of a utf-8 string
- * if given the char length.
- */
-int utf8_index(const char *str, int charindex);
-
-/**
- * Returns the unicode codepoint corresponding to the
- * utf-8 sequence 'str'.
- * 
- * Stores the result in *uc and returns the number of bytes
- * consumed.
- *
- * If 'str' is null terminated, then an invalid utf-8 sequence
- * at the end of the string will be returned as individual bytes.
- *
- * If it is not null terminated, the length *must* be checked first.
- *
- * Does not support unicode code points > \uffff
- */
-int utf8_tounicode(const char *str, int *uc);
-
-/**
- * Returns the number of bytes before 'str' that the previous
- * utf-8 character sequence starts (which may be the middle of a sequence).
- *
- * Looks back at most 'len' bytes backwards, which must be > 0.
- * If no start char is found, returns -len
- */
-int utf8_prev_len(const char *str, int len);
-
-/**
- * Returns the upper-case variant of the given unicode codepoint.
- *
- * Does not support unicode code points > \uffff
- */
-int utf8_upper(int uc);
-
-/**
- * Returns the lower-case variant of the given unicode codepoint.
- *
- * NOTE: Use utf8_upper() in preference for case-insensitive matching.
- *
- * Does not support unicode code points > \uffff
- */
-int utf8_lower(int uc);
 
 #endif
 
-#endif
-/* Jim - A small embeddable Tcl interpreter
- *
- * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
- * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>
- * Copyright 2005 patthoyts - Pat Thoyts <patthoyts@users.sf.net> 
- * Copyright 2008 oharboe - Øyvind Harboe - oyvind.harboe@zylin.com
- * Copyright 2008 Andrew Lunn <andrew@lunn.ch>
- * Copyright 2008 Duane Ellis <openocd@duaneellis.com>
- * Copyright 2008 Uwe Klein <uklein@klein-messgeraete.de>
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- * The views and conclusions contained in the software and documentation
- * are those of the authors and should not be interpreted as representing
- * official policies, either expressed or implied, of the Jim Tcl Project.
- *
- *--- Inline Header File Documentation --- 
- *    [By Duane Ellis, openocd@duaneellis.com, 8/18/8]
- *
- * Belief is "Jim" would greatly benifit if Jim Internals where
- * documented in some way - form whatever, and perhaps - the package:
- * 'doxygen' is the correct approach to do that.
- *
- *   Details, see: http://www.stack.nl/~dimitri/doxygen/
- *
- * To that end please follow these guide lines:
- *
- *    (A) Document the PUBLIC api in the .H file.
- *
- *    (B) Document JIM Internals, in the .C file.
- *
- *    (C) Remember JIM is embedded in other packages, to that end do
- *    not assume that your way of documenting is the right way, Jim's
- *    public documentation should be agnostic, such that it is some
- *    what agreeable with the "package" that is embedding JIM inside
- *    of it's own doxygen documentation.
- *
- *    (D) Use minimal Doxygen tags.
- *
- * This will be an "ongoing work in progress" for some time.
- **/
-
 #ifndef __JIM__H
 #define __JIM__H
 
@@ -211,23 +62,16 @@ extern "C" {
 
 #include <time.h>
 #include <limits.h>
-#include <stdio.h>  /* for the FILE typedef definition */
-#include <stdlib.h> /* In order to export the Jim_Free() macro */
-#include <stdarg.h> /* In order to get type va_list */
+#include <stdio.h>  
+#include <stdlib.h> 
+#include <stdarg.h> 
 
-/* -----------------------------------------------------------------------------
- * System configuration
- * autoconf (configure) will set these
- * ---------------------------------------------------------------------------*/
 
 #ifndef HAVE_NO_AUTOCONF
 #endif
 
-/* -----------------------------------------------------------------------------
- * Compiler specific fixes.
- * ---------------------------------------------------------------------------*/
 
-/* Long Long type and related issues */
+
 #ifndef jim_wide
 #  ifdef HAVE_LONG_LONG
 #    define jim_wide long long
@@ -245,9 +89,6 @@ extern "C" {
 #    define JIM_WIDE_MAX LONG_MAX
 #  endif
 
-/* -----------------------------------------------------------------------------
- * LIBC specific fixes
- * ---------------------------------------------------------------------------*/
 
 #  ifdef HAVE_LONG_LONG
 #    define JIM_WIDE_MODIFIER "lld"
@@ -259,14 +100,8 @@ extern "C" {
 
 #define UCHAR(c) ((unsigned char)(c))
 
-/* -----------------------------------------------------------------------------
- * Exported defines
- * ---------------------------------------------------------------------------*/
 
-/* Jim version numbering: every version of jim is marked with a
- * successive integer number. This is version 0. The first
- * stable version will be 1, then 2, 3, and so on. */
-#define JIM_VERSION 71
+#define JIM_VERSION 72
 
 #define JIM_OK 0
 #define JIM_ERR 1
@@ -275,38 +110,36 @@ extern "C" {
 #define JIM_CONTINUE 4
 #define JIM_SIGNAL 5
 #define JIM_EXIT 6
-/* The following are internal codes and should never been seen/used */
+
 #define JIM_EVAL 7
 
-#define JIM_MAX_NESTING_DEPTH 1000 /* default max nesting depth */
+#define JIM_MAX_NESTING_DEPTH 1000 
 
-/* Some function get an integer argument with flags to change
- * the behaviour. */
-#define JIM_NONE 0    /* no flags set */
-#define JIM_ERRMSG 1    /* set an error message in the interpreter. */
+#define JIM_NONE 0    
+#define JIM_ERRMSG 1    
 
-#define JIM_UNSHARED 4 /* Flag to Jim_GetVariable() */
+#define JIM_UNSHARED 4 
+
+
+#define JIM_SUBST_NOVAR 1 
+#define JIM_SUBST_NOCMD 2 
+#define JIM_SUBST_NOESC 4 
+#define JIM_SUBST_FLAG 128 
 
-/* Flags for Jim_SubstObj() */
-#define JIM_SUBST_NOVAR 1 /* don't perform variables substitutions */
-#define JIM_SUBST_NOCMD 2 /* don't perform command substitutions */
-#define JIM_SUBST_NOESC 4 /* don't perform escapes substitutions */
-#define JIM_SUBST_FLAG 128 /* flag to indicate that this is a real substition object */
 
-/* Unused arguments generate annoying warnings... */
 #define JIM_NOTUSED(V) ((void) V)
 
-/* Flags for Jim_GetEnum() */
-#define JIM_ENUM_ABBREV 2    /* Allow unambiguous abbreviation */
 
-/* Flags used by API calls getting a 'nocase' argument. */
-#define JIM_CASESENS    0   /* case sensitive */
-#define JIM_NOCASE      1   /* no case */
+#define JIM_ENUM_ABBREV 2    
+
+
+#define JIM_CASESENS    0   
+#define JIM_NOCASE      1   
+
 
-/* Filesystem related */
 #define JIM_PATH_LEN 1024
 
-/* Newline, some embedded system may need -DJIM_CRLF */
+
 #ifdef JIM_CRLF
 #define JIM_NL "\r\n"
 #else
@@ -316,9 +149,6 @@ extern "C" {
 #define JIM_LIBPATH "auto_path"
 #define JIM_INTERACTIVE "tcl_interactive"
 
-/* -----------------------------------------------------------------------------
- * Stack
- * ---------------------------------------------------------------------------*/
 
 typedef struct Jim_Stack {
     int len;
@@ -326,9 +156,6 @@ typedef struct Jim_Stack {
     void **vector;
 } Jim_Stack;
 
-/* -----------------------------------------------------------------------------
- * Hash table
- * ---------------------------------------------------------------------------*/
 
 typedef struct Jim_HashEntry {
     const void *key;
@@ -364,10 +191,10 @@ typedef struct Jim_HashTableIterator {
     Jim_HashEntry *entry, *nextEntry;
 } Jim_HashTableIterator;
 
-/* This is the initial size of every hash table */
+
 #define JIM_HT_INITIAL_SIZE     16
 
-/* ------------------------------- Macros ------------------------------------*/
+
 #define Jim_FreeEntryVal(ht, entry) \
     if ((ht)->type->valDestructor) \
         (ht)->type->valDestructor((ht)->privdata, (entry)->u.val)
@@ -403,103 +230,87 @@ typedef struct Jim_HashTableIterator {
 #define Jim_GetHashTableSize(ht) ((ht)->size)
 #define Jim_GetHashTableUsed(ht) ((ht)->used)
 
-/* -----------------------------------------------------------------------------
- * Jim_Obj structure
- * ---------------------------------------------------------------------------*/
-
-/* -----------------------------------------------------------------------------
- * Jim object. This is mostly the same as Tcl_Obj itself,
- * with the addition of the 'prev' and 'next' pointers.
- * In Jim all the objects are stored into a linked list for GC purposes,
- * so that it's possible to access every object living in a given interpreter
- * sequentially. When an object is freed, it's moved into a different
- * linked list, used as object pool.
- *
- * The refcount of a freed object is always -1.
- * ---------------------------------------------------------------------------*/
+
 typedef struct Jim_Obj {
-    int refCount; /* reference count */
-    char *bytes; /* string representation buffer. NULL = no string repr. */
-    int length; /* number of bytes in 'bytes', not including the numterm. */
-    const struct Jim_ObjType *typePtr; /* object type. */
-    /* Internal representation union */
+    int refCount; 
+    char *bytes; 
+    int length; 
+    const struct Jim_ObjType *typePtr; 
+    
     union {
-        /* integer number type */
+        
         jim_wide wideValue;
-        /* hashed object type value */
+        
         int hashValue;
-        /* index type */
+        
         int indexValue;
-        /* return code type */
+        
         int returnCode;
-        /* double number type */
+        
         double doubleValue;
-        /* Generic pointer */
+        
         void *ptr;
-        /* Generic two pointers value */
+        
         struct {
             void *ptr1;
             void *ptr2;
         } twoPtrValue;
-        /* Variable object */
+        
         struct {
             unsigned jim_wide callFrameId;
             struct Jim_Var *varPtr;
         } varValue;
-        /* Command object */
+        
         struct {
             unsigned jim_wide procEpoch;
             struct Jim_Cmd *cmdPtr;
         } cmdValue;
-        /* List object */
+        
         struct {
-            struct Jim_Obj **ele;    /* Elements vector */
-            int len;        /* Length */
-            int maxLen;        /* Allocated 'ele' length */
+            struct Jim_Obj **ele;    
+            int len;        
+            int maxLen;        
         } listValue;
-        /* String type */
+        
         struct {
             int maxLength;
-            int charLength;     /* utf-8 char length. -1 if unknown */
+            int charLength;     
         } strValue;
-        /* Reference type */
+        
         struct {
             jim_wide id;
             struct Jim_Reference *refPtr;
         } refValue;
-        /* Source type */
+        
         struct {
-            const char *fileName;
+            struct Jim_Obj *fileNameObj;
             int lineNumber;
         } sourceValue;
-        /* Dict substitution type */
+        
         struct {
             struct Jim_Obj *varNameObjPtr;
             struct Jim_Obj *indexObjPtr;
         } dictSubstValue;
-        /* tagged binary type */
+        
         struct {
             unsigned char *data;
             size_t         len;
         } binaryValue;
-        /* Regular expression pattern */
+        
         struct {
             unsigned flags;
-            void *compre;       /* really an allocated (regex_t *) */
+            void *compre;       
         } regexpValue;
         struct {
             int line;
             int argc;
         } scriptLineValue;
     } internalRep;
-    /* This are 8 or 16 bytes more for every object
-     * but this is required for efficient garbage collection
-     * of Jim references. */
-    struct Jim_Obj *prevObjPtr; /* pointer to the prev object. */
-    struct Jim_Obj *nextObjPtr; /* pointer to the next object. */
+    struct Jim_Obj *prevObjPtr; 
+    struct Jim_Obj *nextObjPtr; 
 } Jim_Obj;
 
-/* Jim_Obj related macros */
+
 #define Jim_IncrRefCount(objPtr) \
     ++(objPtr)->refCount
 #define Jim_DecrRefCount(interp, objPtr) \
@@ -507,40 +318,20 @@ typedef struct Jim_Obj {
 #define Jim_IsShared(objPtr) \
     ((objPtr)->refCount > 1)
 
-/* This macro is used when we allocate a new object using
- * Jim_New...Obj(), but for some error we need to destroy it.
- * Instead to use Jim_IncrRefCount() + Jim_DecrRefCount() we
- * can just call Jim_FreeNewObj. To call Jim_Free directly
- * seems too raw, the object handling may change and we want
- * that Jim_FreeNewObj() can be called only against objects
- * that are belived to have refcount == 0. */
 #define Jim_FreeNewObj Jim_FreeObj
 
-/* Free the internal representation of the object. */
+
 #define Jim_FreeIntRep(i,o) \
     if ((o)->typePtr && (o)->typePtr->freeIntRepProc) \
         (o)->typePtr->freeIntRepProc(i, o)
 
-/* Get the internal representation pointer */
+
 #define Jim_GetIntRepPtr(o) (o)->internalRep.ptr
 
-/* Set the internal representation pointer */
+
 #define Jim_SetIntRepPtr(o, p) \
     (o)->internalRep.ptr = (p)
 
-/* The object type structure.
- * There are four methods.
- *
- * - FreeIntRep is used to free the internal representation of the object.
- *   Can be NULL if there is nothing to free.
- * - DupIntRep is used to duplicate the internal representation of the object.
- *   If NULL, when an object is duplicated, the internalRep union is
- *   directly copied from an object to another.
- *   Note that it's up to the caller to free the old internal repr of the
- *   object before to call the Dup method.
- * - UpdateString is used to create the string from the internal repr.
- * - setFromAny is used to convert the current object into one of this type.
- */
 
 struct Jim_Interp;
 
@@ -549,121 +340,101 @@ typedef void (Jim_FreeInternalRepProc)(struct Jim_Interp *interp,
 typedef void (Jim_DupInternalRepProc)(struct Jim_Interp *interp,
         struct Jim_Obj *srcPtr, Jim_Obj *dupPtr);
 typedef void (Jim_UpdateStringProc)(struct Jim_Obj *objPtr);
-    
+
 typedef struct Jim_ObjType {
-    const char *name; /* The name of the type. */
+    const char *name; 
     Jim_FreeInternalRepProc *freeIntRepProc;
     Jim_DupInternalRepProc *dupIntRepProc;
     Jim_UpdateStringProc *updateStringProc;
     int flags;
 } Jim_ObjType;
 
-/* Jim_ObjType flags */
-#define JIM_TYPE_NONE 0        /* No flags */
-#define JIM_TYPE_REFERENCES 1    /* The object may contain referneces. */
 
-/* Starting from 1 << 20 flags are reserved for private uses of
- * different calls. This way the same 'flags' argument may be used
- * to pass both global flags and private flags. */
+#define JIM_TYPE_NONE 0        
+#define JIM_TYPE_REFERENCES 1    
+
 #define JIM_PRIV_FLAG_SHIFT 20
 
-/* -----------------------------------------------------------------------------
- * Call frame, vars, commands structures
- * ---------------------------------------------------------------------------*/
 
-/* Call frame */
+
 typedef struct Jim_CallFrame {
-    unsigned jim_wide id; /* Call Frame ID. Used for caching. */
-    int level; /* Level of this call frame. 0 = global */
-    struct Jim_HashTable vars; /* Where local vars are stored */
-    struct Jim_HashTable *staticVars; /* pointer to procedure static vars */
+    unsigned jim_wide id; 
+    int level; 
+    struct Jim_HashTable vars; 
+    struct Jim_HashTable *staticVars; 
     struct Jim_CallFrame *parentCallFrame;
-    Jim_Obj *const *argv; /* object vector of the current procedure call. */
-    int argc; /* number of args of the current procedure call. */
-    Jim_Obj *procArgsObjPtr; /* arglist object of the running procedure */
-    Jim_Obj *procBodyObjPtr; /* body object of the running procedure */
+    Jim_Obj *const *argv; 
+    int argc; 
+    Jim_Obj *procArgsObjPtr; 
+    Jim_Obj *procBodyObjPtr; 
     struct Jim_CallFrame *nextFramePtr;
-    const char *filename;       /* file and line of caller of this proc (if available) */
+    Jim_Obj *fileNameObj;       
     int line;
 } Jim_CallFrame;
 
-/* The var structure. It just holds the pointer of the referenced
- * object. If linkFramePtr is not NULL the variable is a link
- * to a variable of name store on objPtr living on the given callframe
- * (this happens when the [global] or [upvar] command is used).
- * The interp in order to always know how to free the Jim_Obj associated
- * with a given variable because In Jim objects memory managment is
- * bound to interpreters. */
 typedef struct Jim_Var {
     Jim_Obj *objPtr;
     struct Jim_CallFrame *linkFramePtr;
 } Jim_Var;
 
-/* The cmd structure. */
+
 typedef int (*Jim_CmdProc)(struct Jim_Interp *interp, int argc,
     Jim_Obj *const *argv);
 typedef void (*Jim_DelCmdProc)(struct Jim_Interp *interp, void *privData);
 
 
 
-/* A command is implemented in C if funcPtr is != NULL, otherwise
- * it's a Tcl procedure with the arglist and body represented by the
- * two objects referenced by arglistObjPtr and bodyoObjPtr. */
 typedef struct Jim_Cmd {
-    int inUse;           /* Reference count */
-    int isproc;          /* Is this a procedure? */
+    int inUse;           
+    int isproc;          
     union {
         struct {
-            /* native (C) command */
-            Jim_CmdProc cmdProc; /* The command implementation */
-            Jim_DelCmdProc delProc; /* Called when the command is deleted if != NULL */
-            void *privData; /* command-private data available via Jim_CmdPrivData() */
+            
+            Jim_CmdProc cmdProc; 
+            Jim_DelCmdProc delProc; 
+            void *privData; 
         } native;
         struct {
-            /* Tcl procedure */
+            
             Jim_Obj *argListObjPtr;
             Jim_Obj *bodyObjPtr;
-            Jim_HashTable *staticVars;  /* Static vars hash table. NULL if no statics. */
-            struct Jim_Cmd *prevCmd;    /* Previous command defn if proc created 'local' */
-            int argListLen;             /* Length of argListObjPtr */
-            int reqArity;               /* Number of required parameters */
-            int optArity;               /* Number of optional parameters */
-            int argsPos;                /* Position of 'args', if specified, or -1 */
-            int upcall;                 /* True if proc is currently in upcall */
+            Jim_HashTable *staticVars;  
+            struct Jim_Cmd *prevCmd;    
+            int argListLen;             
+            int reqArity;               
+            int optArity;               
+            int argsPos;                
+            int upcall;                 
             struct Jim_ProcArg {
-                Jim_Obj *nameObjPtr;    /* Name of this arg */
-                Jim_Obj *defaultObjPtr; /* Default value, (or rename for $args) */
+                Jim_Obj *nameObjPtr;    
+                Jim_Obj *defaultObjPtr; 
             } *arglist;
         } proc;
     } u;
 } Jim_Cmd;
 
-/* Pseudo Random Number Generator State structure */
+
 typedef struct Jim_PrngState {
     unsigned char sbox[256];
     unsigned int i, j;
 } Jim_PrngState;
 
-/* -----------------------------------------------------------------------------
- * Jim interpreter structure.
- * Fields similar to the real Tcl interpreter structure have the same names.
- * ---------------------------------------------------------------------------*/
 typedef struct Jim_Interp {
-    Jim_Obj *result; /* object returned by the last command called. */
-    int errorLine; /* Error line where an error occurred. */
-    char *errorFileName; /* Error file where an error occurred. */
-    int addStackTrace; /* > 0 If a level should be added to the stack trace */
-    int maxNestingDepth; /* Used for infinite loop detection. */
-    int returnCode; /* Completion code to return on JIM_RETURN. */
-    int returnLevel; /* Current level of 'return -level' */
-    int exitCode; /* Code to return to the OS on JIM_EXIT. */
-    long id; /* Hold unique id for various purposes */
-    int signal_level; /* A nesting level of catch -signal */
-    jim_wide sigmask;  /* Bit mask of caught signals, or 0 if none */
-    int (*signal_set_result)(struct Jim_Interp *interp, jim_wide sigmask); /* Set a result for the sigmask */
-    Jim_CallFrame *framePtr; /* Pointer to the current call frame */
-    Jim_CallFrame *topFramePtr; /* toplevel/global frame pointer. */
-    struct Jim_HashTable commands; /* Commands hash table */
+    Jim_Obj *result; 
+    int errorLine; 
+    Jim_Obj *errorFileNameObj; 
+    int addStackTrace; 
+    int maxNestingDepth; 
+    int returnCode; 
+    int returnLevel; 
+    int exitCode; 
+    long id; 
+    int signal_level; 
+    jim_wide sigmask;  
+    int (*signal_set_result)(struct Jim_Interp *interp, jim_wide sigmask); 
+    Jim_CallFrame *framePtr; 
+    Jim_CallFrame *topFramePtr; 
+    struct Jim_HashTable commands; 
     unsigned jim_wide procEpoch; /* Incremented every time the result
                 of procedures names lookup caching
                 may no longer be valid. */
@@ -671,55 +442,48 @@ typedef struct Jim_Interp {
                 callframe is created. This id is used for the
                 'ID' field contained in the Jim_CallFrame
                 structure. */
-    int local; /* If 'local' is in effect, newly defined procs keep a reference to the old defn */ 
-    Jim_Obj *liveList; /* Linked list of all the live objects. */
-    Jim_Obj *freeList; /* Linked list of all the unused objects. */
-    Jim_Obj *currentScriptObj; /* Script currently in execution. */
-    Jim_Obj *emptyObj; /* Shared empty string object. */
-    Jim_Obj *trueObj; /* Shared true int object. */
-    Jim_Obj *falseObj; /* Shared false int object. */
-    unsigned jim_wide referenceNextId; /* Next id for reference. */
-    struct Jim_HashTable references; /* References hash table. */
+    int local; 
+    Jim_Obj *liveList; 
+    Jim_Obj *freeList; 
+    Jim_Obj *currentScriptObj; 
+    Jim_Obj *emptyObj; 
+    Jim_Obj *trueObj; 
+    Jim_Obj *falseObj; 
+    unsigned jim_wide referenceNextId; 
+    struct Jim_HashTable references; 
     jim_wide lastCollectId; /* reference max Id of the last GC
                 execution. It's set to -1 while the collection
                 is running as sentinel to avoid to recursive
                 calls via the [collect] command inside
                 finalizers. */
-    time_t lastCollectTime; /* unix time of the last GC execution */
-    struct Jim_HashTable sharedStrings; /* Shared Strings hash table */
-    Jim_Obj *stackTrace; /* Stack trace object. */
-    Jim_Obj *errorProc; /* Name of last procedure which returned an error */
-    Jim_Obj *unknown; /* Unknown command cache */
-    int unknown_called; /* The unknown command has been invoked */
-    int errorFlag; /* Set if an error occurred during execution. */
+    time_t lastCollectTime; 
+    Jim_Obj *stackTrace; 
+    Jim_Obj *errorProc; 
+    Jim_Obj *unknown; 
+    int unknown_called; 
+    int errorFlag; 
     void *cmdPrivData; /* Used to pass the private data pointer to
                   a command. It is set to what the user specified
                   via Jim_CreateCommand(). */
 
-    struct Jim_CallFrame *freeFramesList; /* list of CallFrame structures. */
-    struct Jim_HashTable assocData; /* per-interp storage for use by packages */
-    Jim_PrngState *prngState; /* per interpreter Random Number Gen. state. */
-    struct Jim_HashTable packages; /* Provided packages hash table */
-    Jim_Stack *localProcs; /* procs to be destroyed on end of evaluation */
-    Jim_Stack *loadHandles; /* handles of loaded modules [load] */
+    struct Jim_CallFrame *freeFramesList; 
+    struct Jim_HashTable assocData; 
+    Jim_PrngState *prngState; 
+    struct Jim_HashTable packages; 
+    Jim_Stack *localProcs; 
+    Jim_Stack *loadHandles; 
 } Jim_Interp;
 
-/* Currently provided as macro that performs the increment.
- * At some point may be a real function doing more work.
- * The proc epoch is used in order to know when a command lookup
- * cached can no longer considered valid. */
 #define Jim_InterpIncrProcEpoch(i) (i)->procEpoch++
 #define Jim_SetResultString(i,s,l) Jim_SetResult(i, Jim_NewStringObj(i,s,l))
 #define Jim_SetResultInt(i,intval) Jim_SetResult(i, Jim_NewIntObj(i,intval))
-/* Note: Using trueObj and falseObj here makes some things slower...*/
+
 #define Jim_SetResultBool(i,b) Jim_SetResultInt(i, b)
 #define Jim_SetEmptyResult(i) Jim_SetResult(i, (i)->emptyObj)
 #define Jim_GetResult(i) ((i)->result)
 #define Jim_CmdPrivData(i) ((i)->cmdPrivData)
 #define Jim_String(o) Jim_GetString((o), NULL)
 
-/* Note that 'o' is expanded only one time inside this macro,
- * so it's safe to use side effects. */
 #define Jim_SetResult(i,o) do {     \
     Jim_Obj *_resultObjPtr_ = (o);    \
     Jim_IncrRefCount(_resultObjPtr_); \
@@ -727,10 +491,10 @@ typedef struct Jim_Interp {
     (i)->result = _resultObjPtr_;     \
 } while(0)
 
-/* Use this for filehandles, etc. which need a unique id */
+
 #define Jim_GetId(i) (++(i)->id)
 
-/* Reference structure. The interpreter pointer is held within privdata member in HashTable */
+
 #define JIM_REFERENCE_TAGLEN 7 /* The tag is fixed-length, because the reference
                                   string representation must be fixed length. */
 typedef struct Jim_Reference {
@@ -739,56 +503,48 @@ typedef struct Jim_Reference {
     char tag[JIM_REFERENCE_TAGLEN+1];
 } Jim_Reference;
 
-/* -----------------------------------------------------------------------------
- * Exported API prototypes.
- * ---------------------------------------------------------------------------*/
 
-/* Macros that are common for extensions and core. */
+
 #define Jim_NewEmptyStringObj(i) Jim_NewStringObj(i, "", 0)
 
-/* The core includes real prototypes, extensions instead
- * include a global function pointer for every function exported.
- * Once the extension calls Jim_InitExtension(), the global
- * functon pointers are set to the value of the STUB table
- * contained in the Jim_Interp structure.
- *
- * This makes Jim able to load extensions even if it is statically
- * linked itself, and to load extensions compiled with different
- * versions of Jim (as long as the API is still compatible.) */
-
-/* Macros are common for core and extensions */
+
+
 #define Jim_FreeHashTableIterator(iter) Jim_Free(iter)
 
 #define JIM_EXPORT
 
-/* Memory allocation */
+
 JIM_EXPORT void *Jim_Alloc (int size);
 JIM_EXPORT void *Jim_Realloc(void *ptr, int size);
 JIM_EXPORT void Jim_Free (void *ptr);
 JIM_EXPORT char * Jim_StrDup (const char *s);
 JIM_EXPORT char *Jim_StrDupLen(const char *s, int l);
 
-/* environment */
+
 JIM_EXPORT char **Jim_GetEnviron(void);
 JIM_EXPORT void Jim_SetEnviron(char **env);
 
-/* evaluation */
+
 JIM_EXPORT int Jim_Eval(Jim_Interp *interp, const char *script);
-/* in C code, you can do this and get better error messages */
-/*   Jim_Eval_Named( interp, "some tcl commands", __FILE__, __LINE__ ); */
-JIM_EXPORT int Jim_Eval_Named(Jim_Interp *interp, const char *script,const char *filename, int lineno);
+
+
+JIM_EXPORT int Jim_EvalSource(Jim_Interp *interp, const char *filename, int lineno, const char *script);
+
+#define Jim_Eval_Named(I, S, F, L) Jim_EvalSource((I), (F), (L), (S))
+
 JIM_EXPORT int Jim_EvalGlobal(Jim_Interp *interp, const char *script);
 JIM_EXPORT int Jim_EvalFile(Jim_Interp *interp, const char *filename);
 JIM_EXPORT int Jim_EvalFileGlobal(Jim_Interp *interp, const char *filename);
 JIM_EXPORT int Jim_EvalObj (Jim_Interp *interp, Jim_Obj *scriptObjPtr);
 JIM_EXPORT int Jim_EvalObjVector (Jim_Interp *interp, int objc,
         Jim_Obj *const *objv);
-JIM_EXPORT int Jim_EvalObjPrefix(Jim_Interp *interp, const char *prefix,
+JIM_EXPORT int Jim_EvalObjPrefix(Jim_Interp *interp, Jim_Obj *prefix,
         int objc, Jim_Obj *const *objv);
+#define Jim_EvalPrefix(i, p, oc, ov) Jim_EvalObjPrefix((i), Jim_NewStringObj((i), (p), -1), (oc), (ov))
 JIM_EXPORT int Jim_SubstObj (Jim_Interp *interp, Jim_Obj *substObjPtr,
         Jim_Obj **resObjPtrPtr, int flags);
 
-/* stack */
+
 JIM_EXPORT void Jim_InitStack(Jim_Stack *stack);
 JIM_EXPORT void Jim_FreeStack(Jim_Stack *stack);
 JIM_EXPORT int Jim_StackLen(Jim_Stack *stack);
@@ -797,7 +553,7 @@ JIM_EXPORT void * Jim_StackPop(Jim_Stack *stack);
 JIM_EXPORT void * Jim_StackPeek(Jim_Stack *stack);
 JIM_EXPORT void Jim_FreeStackElements(Jim_Stack *stack, void (*freeFunc)(void *ptr));
 
-/* hash table */
+
 JIM_EXPORT int Jim_InitHashTable (Jim_HashTable *ht,
         const Jim_HashTableType *type, void *privdata);
 JIM_EXPORT int Jim_ExpandHashTable (Jim_HashTable *ht,
@@ -817,7 +573,7 @@ JIM_EXPORT Jim_HashTableIterator *Jim_GetHashTableIterator
 JIM_EXPORT Jim_HashEntry * Jim_NextHashEntry
         (Jim_HashTableIterator *iter);
 
-/* objects */
+
 JIM_EXPORT Jim_Obj * Jim_NewObj (Jim_Interp *interp);
 JIM_EXPORT void Jim_FreeObj (Jim_Interp *interp, Jim_Obj *objPtr);
 JIM_EXPORT void Jim_InvalidateStringRep (Jim_Obj *objPtr);
@@ -829,7 +585,7 @@ JIM_EXPORT const char * Jim_GetString(Jim_Obj *objPtr,
         int *lenPtr);
 JIM_EXPORT int Jim_Length(Jim_Obj *objPtr);
 
-/* string object */
+
 JIM_EXPORT Jim_Obj * Jim_NewStringObj (Jim_Interp *interp,
         const char *s, int len);
 JIM_EXPORT Jim_Obj *Jim_NewStringObjUtf8(Jim_Interp *interp,
@@ -858,7 +614,7 @@ JIM_EXPORT int Jim_StringCompareObj(Jim_Interp *interp, Jim_Obj *firstObjPtr,
         Jim_Obj *secondObjPtr, int nocase);
 JIM_EXPORT int Jim_Utf8Length(Jim_Interp *interp, Jim_Obj *objPtr);
 
-/* reference object */
+
 JIM_EXPORT Jim_Obj * Jim_NewReference (Jim_Interp *interp,
         Jim_Obj *objPtr, Jim_Obj *tagPtr, Jim_Obj *cmdNamePtr);
 JIM_EXPORT Jim_Reference * Jim_GetReference (Jim_Interp *interp,
@@ -866,21 +622,21 @@ JIM_EXPORT Jim_Reference * Jim_GetReference (Jim_Interp *interp,
 JIM_EXPORT int Jim_SetFinalizer (Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *cmdNamePtr);
 JIM_EXPORT int Jim_GetFinalizer (Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj **cmdNamePtrPtr);
 
-/* interpreter */
+
 JIM_EXPORT Jim_Interp * Jim_CreateInterp (void);
 JIM_EXPORT void Jim_FreeInterp (Jim_Interp *i);
 JIM_EXPORT int Jim_GetExitCode (Jim_Interp *interp);
 JIM_EXPORT const char *Jim_ReturnCode(int code);
 JIM_EXPORT void Jim_SetResultFormatted(Jim_Interp *interp, const char *format, ...);
 
-/* commands */
+
 JIM_EXPORT void Jim_RegisterCoreCommands (Jim_Interp *interp);
-JIM_EXPORT int Jim_CreateCommand (Jim_Interp *interp, 
+JIM_EXPORT int Jim_CreateCommand (Jim_Interp *interp,
         const char *cmdName, Jim_CmdProc cmdProc, void *privData,
          Jim_DelCmdProc delProc);
 JIM_EXPORT int Jim_DeleteCommand (Jim_Interp *interp,
         const char *cmdName);
-JIM_EXPORT int Jim_RenameCommand (Jim_Interp *interp, 
+JIM_EXPORT int Jim_RenameCommand (Jim_Interp *interp,
         const char *oldName, const char *newName);
 JIM_EXPORT Jim_Cmd * Jim_GetCommand (Jim_Interp *interp,
         Jim_Obj *objPtr, int flags);
@@ -906,19 +662,19 @@ JIM_EXPORT Jim_Obj * Jim_GetGlobalVariableStr (Jim_Interp *interp,
 JIM_EXPORT int Jim_UnsetVariable (Jim_Interp *interp,
         Jim_Obj *nameObjPtr, int flags);
 
-/* call frame */
+
 JIM_EXPORT Jim_CallFrame *Jim_GetCallFrameByLevel(Jim_Interp *interp,
         Jim_Obj *levelObjPtr);
 
-/* garbage collection */
+
 JIM_EXPORT int Jim_Collect (Jim_Interp *interp);
 JIM_EXPORT void Jim_CollectIfNeeded (Jim_Interp *interp);
 
-/* index object */
+
 JIM_EXPORT int Jim_GetIndex (Jim_Interp *interp, Jim_Obj *objPtr,
         int *indexPtr);
 
-/* list object */
+
 JIM_EXPORT Jim_Obj * Jim_NewListObj (Jim_Interp *interp,
         Jim_Obj *const *elements, int len);
 JIM_EXPORT void Jim_ListInsertElements (Jim_Interp *interp,
@@ -936,7 +692,7 @@ JIM_EXPORT int Jim_SetListIndex (Jim_Interp *interp,
 JIM_EXPORT Jim_Obj * Jim_ConcatObj (Jim_Interp *interp, int objc,
         Jim_Obj *const *objv);
 
-/* dict object */
+
 JIM_EXPORT Jim_Obj * Jim_NewDictObj (Jim_Interp *interp,
         Jim_Obj *const *elements, int len);
 JIM_EXPORT int Jim_DictKey (Jim_Interp *interp, Jim_Obj *dictPtr,
@@ -946,7 +702,7 @@ JIM_EXPORT int Jim_DictKeysVector (Jim_Interp *interp,
         Jim_Obj **objPtrPtr, int flags);
 JIM_EXPORT int Jim_SetDictKeysVector (Jim_Interp *interp,
         Jim_Obj *varNamePtr, Jim_Obj *const *keyv, int keyc,
-        Jim_Obj *newObjPtr);
+        Jim_Obj *newObjPtr, int flags);
 JIM_EXPORT int Jim_DictPairs(Jim_Interp *interp,
         Jim_Obj *dictPtr, Jim_Obj ***objPtrPtr, int *len);
 JIM_EXPORT int Jim_DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
@@ -954,17 +710,17 @@ JIM_EXPORT int Jim_DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
 JIM_EXPORT int Jim_DictKeys(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *patternObj);
 JIM_EXPORT int Jim_DictSize(Jim_Interp *interp, Jim_Obj *objPtr);
 
-/* return code object */
+
 JIM_EXPORT int Jim_GetReturnCode (Jim_Interp *interp, Jim_Obj *objPtr,
         int *intPtr);
 
-/* expression object */
+
 JIM_EXPORT int Jim_EvalExpression (Jim_Interp *interp,
         Jim_Obj *exprObjPtr, Jim_Obj **exprResultPtrPtr);
 JIM_EXPORT int Jim_GetBoolFromExpr (Jim_Interp *interp,
         Jim_Obj *exprObjPtr, int *boolPtr);
 
-/* integer object */
+
 JIM_EXPORT int Jim_GetWide (Jim_Interp *interp, Jim_Obj *objPtr,
         jim_wide *widePtr);
 JIM_EXPORT int Jim_GetLong (Jim_Interp *interp, Jim_Obj *objPtr,
@@ -973,68 +729,61 @@ JIM_EXPORT int Jim_GetLong (Jim_Interp *interp, Jim_Obj *objPtr,
 JIM_EXPORT Jim_Obj * Jim_NewIntObj (Jim_Interp *interp,
         jim_wide wideValue);
 
-/* double object */
+
 JIM_EXPORT int Jim_GetDouble(Jim_Interp *interp, Jim_Obj *objPtr,
         double *doublePtr);
 JIM_EXPORT void Jim_SetDouble(Jim_Interp *interp, Jim_Obj *objPtr,
         double doubleValue);
 JIM_EXPORT Jim_Obj * Jim_NewDoubleObj(Jim_Interp *interp, double doubleValue);
 
-/* shared strings */
-JIM_EXPORT const char * Jim_GetSharedString (Jim_Interp *interp, 
+
+JIM_EXPORT const char * Jim_GetSharedString (Jim_Interp *interp,
         const char *str);
 JIM_EXPORT void Jim_ReleaseSharedString (Jim_Interp *interp,
         const char *str);
 
-/* commands utilities */
+
 JIM_EXPORT void Jim_WrongNumArgs (Jim_Interp *interp, int argc,
         Jim_Obj *const *argv, const char *msg);
 JIM_EXPORT int Jim_GetEnum (Jim_Interp *interp, Jim_Obj *objPtr,
         const char * const *tablePtr, int *indexPtr, const char *name, int flags);
 JIM_EXPORT int Jim_ScriptIsComplete (const char *s, int len,
         char *stateCharPtr);
-/**
- * Find a matching name in the array of the given length.
- * 
- * NULL entries are ignored.
- *
- * Returns the matching index if found, or -1 if not.
- */
 JIM_EXPORT int Jim_FindByName(const char *name, const char * const array[], size_t len);
 
-/* package utilities */
+
 typedef void (Jim_InterpDeleteProc)(Jim_Interp *interp, void *data);
 JIM_EXPORT void * Jim_GetAssocData(Jim_Interp *interp, const char *key);
 JIM_EXPORT int Jim_SetAssocData(Jim_Interp *interp, const char *key,
         Jim_InterpDeleteProc *delProc, void *data);
 JIM_EXPORT int Jim_DeleteAssocData(Jim_Interp *interp, const char *key);
 
-/* Packages C API */
-/* jim-package.c */
+
+
 JIM_EXPORT int Jim_PackageProvide (Jim_Interp *interp,
         const char *name, const char *ver, int flags);
 JIM_EXPORT int Jim_PackageRequire (Jim_Interp *interp,
         const char *name, int flags);
 
-/* error messages */
+
 JIM_EXPORT void Jim_MakeErrorMessage (Jim_Interp *interp);
 
-/* interactive mode */
+
 JIM_EXPORT int Jim_InteractivePrompt (Jim_Interp *interp);
 
-/* Misc */
+
 JIM_EXPORT int Jim_InitStaticExtensions(Jim_Interp *interp);
 JIM_EXPORT int Jim_StringToWide(const char *str, jim_wide *widePtr, int base);
 
-/* jim-load.c */
+
 JIM_EXPORT int Jim_LoadLibrary(Jim_Interp *interp, const char *pathName);
 JIM_EXPORT void Jim_FreeLoadHandles(Jim_Interp *interp);
 
-/* jim-aio.c */
+
 JIM_EXPORT FILE *Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *command);
 
 
-/* type inspection - avoid where possible */
+
 JIM_EXPORT int Jim_IsDict(Jim_Obj *objPtr);
 JIM_EXPORT int Jim_IsList(Jim_Obj *objPtr);
 
@@ -1042,95 +791,48 @@ JIM_EXPORT int Jim_IsList(Jim_Obj *objPtr);
 }
 #endif
 
-#endif /* __JIM__H */
-
-/*
- * Local Variables: ***
- * c-basic-offset: 4 ***
- * tab-width: 4 ***
- * End: ***
- */
-/* Provides a common approach to implementing Tcl commands
- * which implement subcommands
- */
+#endif 
+
 #ifndef JIM_SUBCMD_H
 #define JIM_SUBCMD_H
 
 
-#define JIM_MODFLAG_HIDDEN   0x0001		/* Don't show the subcommand in usage or commands */
-#define JIM_MODFLAG_FULLARGV 0x0002		/* Subcmd proc gets called with full argv */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define JIM_MODFLAG_HIDDEN   0x0001		
+#define JIM_MODFLAG_FULLARGV 0x0002		
+
 
-/* Custom flags start at 0x0100 */
 
-/**
- * Returns JIM_OK if OK, JIM_ERR (etc.) on error, break, continue, etc.
- * Returns -1 if invalid args.
- */
 typedef int tclmod_cmd_function(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
 
 typedef struct {
-	const char *cmd;				/* Name of the (sub)command */
-	const char *args;				/* Textual description of allowed args */
-	tclmod_cmd_function *function;	/* Function implementing the subcommand */
-	short minargs;					/* Minimum required arguments */
-	short maxargs;					/* Maximum allowed arguments or -1 if no limit */
-	unsigned flags;					/* JIM_MODFLAG_... plus custom flags */
-	const char *description;		/* Description of the subcommand */
+	const char *cmd;				
+	const char *args;				
+	tclmod_cmd_function *function;	
+	short minargs;					
+	short maxargs;					
+	unsigned flags;					
+	const char *description;		
 } jim_subcmd_type;
 
-/**
- * Looks up the appropriate subcommand in the given command table and return
- * the command function which implements the subcommand.
- * NULL will be returned and an appropriate error will be set if the subcommand or 
- * arguments are invalid.
- *
- * Typical usage is:
- *  {
- *    const jim_subcmd_type *ct = Jim_ParseSubCmd(interp, command_table, argc, argv);
- *
- *    return Jim_CallSubCmd(interp, ct, argc, argv);
- *  }
- *
- */
 const jim_subcmd_type *
 Jim_ParseSubCmd(Jim_Interp *interp, const jim_subcmd_type *command_table, int argc, Jim_Obj *const *argv);
 
-/**
- * Parses the args against the given command table and executes the subcommand if found
- * or sets an appropriate error if the subcommand or arguments is invalid.
- *
- * Can be used directly with Jim_CreateCommand() where the ClientData is the command table.
- *
- * e.g. Jim_CreateCommand(interp, "mycmd", Jim_SubCmdProc, command_table, NULL);
- */
 int Jim_SubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
 
-/**
- * Invokes the given subcmd with the given args as returned
- * by Jim_ParseSubCmd()
- * 
- * If ct is NULL, returns JIM_ERR, leaving any message.
- * Otherwise invokes ct->function
- *
- * If ct->function returns -1, sets an error message and returns JIM_ERR.
- * Otherwise returns the result of ct->function.
- */
 int Jim_CallSubCmd(Jim_Interp *interp, const jim_subcmd_type *ct, int argc, Jim_Obj *const *argv);
 
-/**
- * Standard processing for a command.
- * 
- * This does the '-help' and '-usage' check and the number of args checks.
- * for a top level command against a single 'jim_subcmd_type' structure.
- *
- * Additionally, if command_table->function is set, it should point to a sub command table
- * and '-subhelp ?subcmd?', '-subusage' and '-subcommands' are then also recognised.
- * 
- * Returns 0 if user requested usage, -1 on arg error, 1 if OK to process.
- */
 int
 Jim_CheckCmdUsage(Jim_Interp *interp, const jim_subcmd_type *command_table, int argc, Jim_Obj *const *argv);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
 #ifndef JIMREGEXP_H
 #define JIMREGEXP_H
@@ -1140,74 +842,47 @@ Jim_CheckCmdUsage(Jim_Interp *interp, const jim_subcmd_type *command_table, int
 #endif
 
 #if defined(HAVE_REGCOMP) && !defined(JIM_REGEXP)
-/* Use POSIX regex */
+
 #include <regex.h>
 
 #else
 
 #include <stdlib.h>
 
-/*
- * Definitions etc. for regexp(3) routines.
- *
- * Caveat:  this is V8 regexp(3) [actually, a reimplementation thereof],
- * not the System V one.
- *
- * 11/04/02 (seiwald) - const-ing for string literals
- */
 
 typedef struct {
 	int rm_so;
 	int rm_eo;
 } regmatch_t;
 
-/*
- * The "internal use only" fields in regexp.h are present to pass info from
- * compile to execute that permits the execute phase to run lots faster on
- * simple cases.  They are:
- *
- * regstart	char that must begin a match; '\0' if none obvious
- * reganch	is the match anchored (at beginning-of-line only)?
- * regmust	string (pointer into program) that match must include, or NULL
- * regmlen	length of regmust string
- *
- * Regstart and reganch permit very fast decisions on suitable starting points
- * for a match, cutting down the work a lot.  Regmust permits fast rejection
- * of lines that cannot possibly match.  The regmust tests are costly enough
- * that regcomp() supplies a regmust only if the r.e. contains something
- * potentially expensive (at present, the only such thing detected is * or +
- * at the start of the r.e., which can involve a lot of backup).  Regmlen is
- * supplied because the test in regexec() needs it and regcomp() is computing
- * it anyway.
- */
 
 typedef struct regexp {
-	/* -- public -- */
-	int re_nsub;		/* number of parenthesized subexpressions */
-
-	/* -- private -- */
-	int cflags;			/* Flags used when compiling */
-	int err;			/* Any error which occurred during compile */
-	int regstart;		/* Internal use only. */
-	int reganch;		/* Internal use only. */
-	int regmust;		/* Internal use only. */
-	int regmlen;		/* Internal use only. */
-	int *program;		/* Allocated */
-
-	/* working state - compile */
-	const char *regparse;		/* Input-scan pointer. */
-	int p;				/* Current output pos in program */
-	int proglen;		/* Allocated program size */
-
-	/* working state - exec */
-	int eflags;				/* Flags used when executing */
-	const char *start;		/* Initial string pointer. */
-	const char *reginput;	/* Current input pointer. */
-	const char *regbol;		/* Beginning of input, for ^ check. */
-
-	/* Input to regexec() */
-	regmatch_t *pmatch;		/* submatches will be stored here */
-	int nmatch;				/* size of pmatch[] */
+	
+	int re_nsub;		
+
+	
+	int cflags;			
+	int err;			
+	int regstart;		
+	int reganch;		
+	int regmust;		
+	int regmlen;		
+	int *program;		
+
+	
+	const char *regparse;		
+	int p;				
+	int proglen;		
+
+	
+	int eflags;				
+	const char *start;		
+	const char *reginput;	
+	const char *regbol;		
+
+	
+	regmatch_t *pmatch;		
+	int nmatch;				
 } regexp;
 
 typedef regexp regex_t;
@@ -1219,9 +894,9 @@ typedef regexp regex_t;
 #define REG_NOTBOL 16
 
 enum {
-	REG_NOERROR,      /* Success.  */
-	REG_NOMATCH,      /* Didn't find a match (for regexec).  */
-	REG_BADPAT,		  /* >= REG_BADPAT is an error */
+	REG_NOERROR,      
+	REG_NOMATCH,      
+	REG_BADPAT,		  
 	REG_ERR_NULL_ARGUMENT,
 	REG_ERR_UNKNOWN,
 	REG_ERR_TOO_BIG,
@@ -1254,18 +929,18 @@ int Jim_bootstrapInit(Jim_Interp *interp)
 	if (Jim_PackageProvide(interp, "bootstrap", "1.0", JIM_ERRMSG))
 		return JIM_ERR;
 
-	return Jim_Eval_Named(interp, 
+	return Jim_EvalSource(interp, "bootstrap.tcl", 1,
 "\n"
 "\n"
 "proc package {args} {}\n"
-,"bootstrap.tcl", 1);
+);
 }
 int Jim_initjimshInit(Jim_Interp *interp)
 {
 	if (Jim_PackageProvide(interp, "initjimsh", "1.0", JIM_ERRMSG))
 		return JIM_ERR;
 
-	return Jim_Eval_Named(interp, 
+	return Jim_EvalSource(interp, "initjimsh.tcl", 1,
 "\n"
 "\n"
 "\n"
@@ -1293,14 +968,14 @@ int Jim_initjimshInit(Jim_Interp *interp)
 "}\n"
 "\n"
 "_jimsh_init\n"
-,"initjimsh.tcl", 1);
+);
 }
 int Jim_globInit(Jim_Interp *interp)
 {
 	if (Jim_PackageProvide(interp, "glob", "1.0", JIM_ERRMSG))
 		return JIM_ERR;
 
-	return Jim_Eval_Named(interp, 
+	return Jim_EvalSource(interp, "glob.tcl", 1,
 "\n"
 "\n"
 "\n"
@@ -1430,14 +1105,14 @@ int Jim_globInit(Jim_Interp *interp)
 "\n"
 "	return $result\n"
 "}\n"
-,"glob.tcl", 1);
+);
 }
 int Jim_stdlibInit(Jim_Interp *interp)
 {
 	if (Jim_PackageProvide(interp, "stdlib", "1.0", JIM_ERRMSG))
 		return JIM_ERR;
 
-	return Jim_Eval_Named(interp, 
+	return Jim_EvalSource(interp, "stdlib.tcl", 1,
 "\n"
 "\n"
 "\n"
@@ -1588,14 +1263,14 @@ int Jim_stdlibInit(Jim_Interp *interp)
 "	}\n"
 "	return $dict\n"
 "}\n"
-,"stdlib.tcl", 1);
+);
 }
 int Jim_tclcompatInit(Jim_Interp *interp)
 {
 	if (Jim_PackageProvide(interp, "tclcompat", "1.0", JIM_ERRMSG))
 		return JIM_ERR;
 
-	return Jim_Eval_Named(interp, 
+	return Jim_EvalSource(interp, "tclcompat.tcl", 1,
 "\n"
 "\n"
 "\n"
@@ -1875,47 +1550,9 @@ int Jim_tclcompatInit(Jim_Interp *interp)
 "	}\n"
 "	file delete $path\n"
 "}\n"
-,"tclcompat.tcl", 1);
-}
-
-/* Jim - A small embeddable Tcl interpreter
- *
- * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
- * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>
- * Copyright 2005 patthoyts - Pat Thoyts <patthoyts@users.sf.net> 
- * Copyright 2008 oharboe - Øyvind Harboe - oyvind.harboe@zylin.com
- * Copyright 2008 Andrew Lunn <andrew@lunn.ch>
- * Copyright 2008 Duane Ellis <openocd@duaneellis.com>
- * Copyright 2008 Uwe Klein <uklein@klein-messgeraete.de>
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- * The views and conclusions contained in the software and documentation
- * are those of the authors and should not be interpreted as representing
- * official policies, either expressed or implied, of the Jim Tcl Project.
- **/
+);
+}
+
 
 #include <unistd.h>
 #include <stdio.h>
@@ -1937,8 +1574,8 @@ int Jim_tclcompatInit(Jim_Interp *interp)
 #endif
 
 
-#define AIO_CMD_LEN 32      /* e.g. aio.handleXXXXXX */
-#define AIO_BUF_LEN 256     /* Can keep this small and rely on stdio buffering */
+#define AIO_CMD_LEN 32      
+#define AIO_BUF_LEN 256     
 
 #define AIO_KEEPOPEN 1
 
@@ -1951,33 +1588,13 @@ int Jim_tclcompatInit(Jim_Interp *interp)
 #endif
 #endif
 
-#ifndef JIM_ANSIC
-union sockaddr_any {
-    struct sockaddr sa;
-    struct sockaddr_in sin;
-#if IPV6
-    struct sockaddr_in6 sin6;
-#endif
-};
-
-#ifndef HAVE_INET_NTOP
-const char *inet_ntop(int af, const void *src, char *dst, int size)
-{
-    if (af != PF_INET) {
-        return NULL;
-    }
-    snprintf(dst, size, "%s", inet_ntoa(((struct sockaddr_in *)src)->sin_addr));
-    return dst;
-}
-#endif
-#endif
 
 typedef struct AioFile
 {
     FILE *fp;
     Jim_Obj *filename;
     int type;
-    int OpenFlags;              /* AIO_KEEPOPEN? keep FILE* */
+    int OpenFlags;              
     int fd;
 #ifdef O_NDELAY
     int flags;
@@ -1992,149 +1609,6 @@ typedef struct AioFile
 
 static int JimAioSubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
 
-#ifndef JIM_ANSIC
-static int JimParseIPv6Address(Jim_Interp *interp, const char *hostport, union sockaddr_any *sa, int *salen)
-{
-#if IPV6
-    /*
-     * An IPv6 addr/port looks like:
-     *   [::1]
-     *   [::1]:2000
-     *   [fe80::223:6cff:fe95:bdc0%en1]:2000
-     *   [::]:2000
-     *   2000
-     *
-     *   Note that the "any" address is ::, which is the same as when no address is specified.
-     */
-     char *sthost = NULL;
-     const char *stport;
-     int ret = JIM_OK;
-     struct addrinfo req;
-     struct addrinfo *ai;
-
-    stport = strrchr(hostport, ':');
-    if (!stport) {
-        /* No : so, the whole thing is the port */
-        stport = hostport;
-        hostport = "::";
-        sthost = Jim_StrDup(hostport);
-    }
-    else {
-        stport++;
-    }
-
-    if (*hostport == '[') {
-        /* This is a numeric ipv6 address */
-        char *pt = strchr(++hostport, ']');
-        if (pt) {
-            sthost = Jim_StrDupLen(hostport, pt - hostport);
-        }
-    }
-
-    if (!sthost) {
-        sthost = Jim_StrDupLen(hostport, stport - hostport - 1);
-    }
-
-    memset(&req, '\0', sizeof(req));
-    req.ai_family = PF_INET6;
-    
-    if (getaddrinfo(sthost, NULL, &req, &ai)) {
-        Jim_SetResultFormatted(interp, "Not a valid address: %s", hostport);
-        ret = JIM_ERR;
-    }
-    else {
-        memcpy(&sa->sin, ai->ai_addr, ai->ai_addrlen);
-        *salen = ai->ai_addrlen;
-
-        sa->sin.sin_port = htons(atoi(stport));
-
-        freeaddrinfo(ai);
-    }
-    Jim_Free(sthost);
-
-    return ret;
-#else
-    Jim_SetResultString(interp, "ipv6 not supported", -1);
-    return JIM_ERR;
-#endif
-}
-
-static int JimParseIpAddress(Jim_Interp *interp, const char *hostport, union sockaddr_any *sa, int *salen)
-{
-    /* An IPv4 addr/port looks like:
-     *   192.168.1.5
-     *   192.168.1.5:2000
-     *   2000
-     *
-     * If the address is missing, INADDR_ANY is used.
-     * If the port is missing, 0 is used (only useful for server sockets).
-     */
-    char *sthost = NULL;
-    const char *stport;
-    int ret = JIM_OK;
-
-    stport = strrchr(hostport, ':');
-    if (!stport) {
-        /* No : so, the whole thing is the port */
-        stport = hostport;
-        sthost = Jim_StrDup("0.0.0.0");
-    }
-    else {
-        sthost = Jim_StrDupLen(hostport, stport - hostport);
-        stport++;
-    }
-
-    {
-#ifdef HAVE_GETADDRINFO
-        struct addrinfo req;
-        struct addrinfo *ai;
-        memset(&req, '\0', sizeof(req));
-        req.ai_family = PF_INET;
-        
-        if (getaddrinfo(sthost, NULL, &req, &ai)) {
-            ret = JIM_ERR;
-        }
-        else {
-            memcpy(&sa->sin, ai->ai_addr, ai->ai_addrlen);
-            *salen = ai->ai_addrlen;
-            freeaddrinfo(ai);
-        }
-#else
-        struct hostent *he;
-
-        ret = JIM_ERR;
-
-        if ((he = gethostbyname(sthost)) != NULL) {
-            if (he->h_length == sizeof(sa->sin.sin_addr)) {
-                *salen = sizeof(sa->sin);
-                sa->sin.sin_family= he->h_addrtype;
-                memcpy(&sa->sin.sin_addr, he->h_addr, he->h_length); /* set address */
-                ret = JIM_OK;
-            }
-        }
-#endif
-
-        sa->sin.sin_port = htons(atoi(stport));
-    }
-    Jim_Free(sthost);
-
-    if (ret != JIM_OK) {
-        Jim_SetResultFormatted(interp, "Not a valid address: %s", hostport);
-    }
-
-    return ret;
-}
-
-#ifdef HAVE_SYS_UN_H
-static int JimParseDomainAddress(Jim_Interp *interp, const char *path, struct sockaddr_un *sa)
-{
-    sa->sun_family = PF_UNIX;
-    snprintf(sa->sun_path, sizeof(sa->sun_path), "%s", path);
-
-    return JIM_OK;
-}
-#endif
-#endif
 
 static void JimAioSetError(Jim_Interp *interp, Jim_Obj *name)
 {
@@ -2158,7 +1632,7 @@ static void JimAioDelProc(Jim_Interp *interp, void *privData)
         fclose(af->fp);
     }
 #ifdef jim_ext_eventloop
-    /* remove existing EventHandlers */
+    
     if (af->rEvent) {
         Jim_DeleteFileHandler(interp, af->fp);
     }
@@ -2178,7 +1652,7 @@ static int aio_cmd_read(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     char buf[AIO_BUF_LEN];
     Jim_Obj *objPtr;
     int nonewline = 0;
-    int neededLen = -1;         /* -1 is "read as much as possible" */
+    int neededLen = -1;         
 
     if (argc && Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) {
         nonewline = 1;
@@ -2220,12 +1694,12 @@ static int aio_cmd_read(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
         if (retval != readlen)
             break;
     }
-    /* Check for error conditions */
+    
     if (ferror(af->fp)) {
         clearerr(af->fp);
-        /* eof and EAGAIN are not error conditions */
+        
         if (!feof(af->fp) && errno != EAGAIN) {
-            /* I/O error */
+            
             Jim_FreeNewObj(interp, objPtr);
             JimAioSetError(interp, af->filename);
             return JIM_ERR;
@@ -2313,7 +1787,7 @@ static int aio_cmd_gets(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
             if (len) {
                 int hasnl = (buf[len - 1] == '\n');
 
-                /* strip "\n" */
+                
                 Jim_AppendString(interp, objPtr, buf, strlen(buf) - hasnl);
             }
         }
@@ -2321,13 +1795,13 @@ static int aio_cmd_gets(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
             break;
     }
     if (ferror(af->fp) && errno != EAGAIN && errno != EINTR) {
-        /* I/O error */
+        
         Jim_FreeNewObj(interp, objPtr);
         JimAioSetError(interp, af->filename);
         clearerr(af->fp);
         return JIM_ERR;
     }
-    /* On EOF returns -1 if varName was specified, or the empty string. */
+    
     if (feof(af->fp) && Jim_Length(objPtr) == 0) {
         Jim_FreeNewObj(interp, objPtr);
         if (argc) {
@@ -2378,127 +1852,6 @@ static int aio_cmd_puts(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     return JIM_ERR;
 }
 
-#ifndef JIM_ANSIC
-static int aio_cmd_recvfrom(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-    char *buf;
-    union sockaddr_any sa;
-    long len;
-    socklen_t salen = sizeof(sa);
-    int rlen;
-
-    if (Jim_GetLong(interp, argv[0], &len) != JIM_OK) {
-        return JIM_ERR;
-    }
-
-    buf = Jim_Alloc(len + 1);
-
-    rlen = recvfrom(fileno(af->fp), buf, len, 0, &sa.sa, &salen);
-    if (rlen < 0) {
-        Jim_Free(buf);
-        JimAioSetError(interp, NULL);
-        return JIM_ERR;
-    }
-    buf[rlen] = 0;
-    Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, buf, rlen));
-
-    if (argc > 1) {
-        /* INET6_ADDRSTRLEN is 46. Add some for [] and port */
-        char addrbuf[60];
-
-#if IPV6
-        if (sa.sa.sa_family == PF_INET6) {
-            addrbuf[0] = '[';
-            /* Allow 9 for []:65535\0 */
-            inet_ntop(sa.sa.sa_family, &sa.sin6.sin6_addr, addrbuf + 1, sizeof(addrbuf) - 9);
-            snprintf(addrbuf + strlen(addrbuf), 8, "]:%d", ntohs(sa.sin.sin_port));
-        }
-        else
-#endif
-        {
-            /* Allow 7 for :65535\0 */
-            inet_ntop(sa.sa.sa_family, &sa.sin.sin_addr, addrbuf, sizeof(addrbuf) - 7);
-            snprintf(addrbuf + strlen(addrbuf), 7, ":%d", ntohs(sa.sin.sin_port));
-        }
-
-        if (Jim_SetVariable(interp, argv[1], Jim_NewStringObj(interp, addrbuf, -1)) != JIM_OK) {
-            return JIM_ERR;
-        }
-    }
-
-    return JIM_OK;
-}
-
-
-static int aio_cmd_sendto(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *af = Jim_CmdPrivData(interp);
-    int wlen;
-    int len;
-    const char *wdata;
-    union sockaddr_any sa;
-    const char *addr = Jim_String(argv[1]);
-    int salen;
-
-    if (IPV6 && af->addr_family == PF_INET6) {
-        if (JimParseIPv6Address(interp, addr, &sa, &salen) != JIM_OK) {
-            return JIM_ERR;
-        }
-    }
-    else if (JimParseIpAddress(interp, addr, &sa, &salen) != JIM_OK) {
-        return JIM_ERR;
-    }
-    wdata = Jim_GetString(argv[0], &wlen);
-
-    /* Note that we don't validate the socket type. Rely on sendto() failing if appropriate */
-    len = sendto(fileno(af->fp), wdata, wlen, 0, &sa.sa, salen);
-    if (len < 0) {
-        JimAioSetError(interp, NULL);
-        return JIM_ERR;
-    }
-    Jim_SetResultInt(interp, len);
-    return JIM_OK;
-}
-
-static int aio_cmd_accept(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    AioFile *serv_af = Jim_CmdPrivData(interp);
-    int sock;
-    union sockaddr_any sa;
-    socklen_t addrlen = sizeof(sa);
-    AioFile *af;
-    char buf[AIO_CMD_LEN];
-
-    sock = accept(serv_af->fd, &sa.sa, &addrlen);
-    if (sock < 0)
-        return JIM_ERR;
-
-    /* Create the file command */
-    af = Jim_Alloc(sizeof(*af));
-    af->fd = sock;
-#ifdef FD_CLOEXEC
-    fcntl(af->fd, F_SETFD, FD_CLOEXEC);
-#endif
-    af->filename = Jim_NewStringObj(interp, "accept", -1);
-    Jim_IncrRefCount(af->filename);
-    af->fp = fdopen(sock, "r+");
-
-    af->OpenFlags = 0;
-#ifdef O_NDELAY
-    af->flags = fcntl(af->fd, F_GETFL);
-#endif
-    af->rEvent = NULL;
-    af->wEvent = NULL;
-    af->eEvent = NULL;
-    af->addr_family = serv_af->addr_family;
-    snprintf(buf, sizeof(buf), "aio.sockstream%ld", Jim_GetId(interp));
-    Jim_CreateCommand(interp, buf, JimAioSubCmdProc, af, JimAioDelProc);
-    Jim_SetResultString(interp, buf, -1);
-    return JIM_OK;
-}
-
-#endif
 
 static int aio_cmd_flush(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
@@ -2651,7 +2004,7 @@ static int aio_eventinfo(Jim_Interp *interp, AioFile * af, unsigned mask, Jim_Ob
     int scriptlen = 0;
 
     if (argc == 0) {
-        /* Return current script */
+        
         if (*scriptHandlerObj) {
             Jim_SetResult(interp, *scriptHandlerObj);
         }
@@ -2659,19 +2012,19 @@ static int aio_eventinfo(Jim_Interp *interp, AioFile * af, unsigned mask, Jim_Ob
     }
 
     if (*scriptHandlerObj) {
-        /* Delete old handler */
+        
         Jim_DeleteFileHandler(interp, af->fp);
         *scriptHandlerObj = NULL;
     }
 
-    /* Now possibly add the new script(s) */
+    
     Jim_GetString(argv[0], &scriptlen);
     if (scriptlen == 0) {
-        /* Empty script, so done */
+        
         return JIM_OK;
     }
 
-    /* A new script to add */
+    
     Jim_IncrRefCount(argv[0]);
     *scriptHandlerObj = argv[0];
 
@@ -2732,26 +2085,6 @@ static const jim_subcmd_type aio_command_table[] = {
         .maxargs = 2,
         .description = "Write the string, with newline unless -nonewline"
     },
-#ifndef JIM_ANSIC
-    {   .cmd = "recvfrom",
-        .args = "len ?addrvar?",
-        .function = aio_cmd_recvfrom,
-        .minargs = 1,
-        .maxargs = 2,
-        .description = "Receive up to 'len' bytes on the socket. Sets 'addrvar' with receive address, if set"
-    },
-    {   .cmd = "sendto",
-        .args = "str address",
-        .function = aio_cmd_sendto,
-        .minargs = 2,
-        .maxargs = 2,
-        .description = "Send 'str' to the given address (dgram only)"
-    },
-    {   .cmd = "accept",
-        .function = aio_cmd_accept,
-        .description = "Server socket only: Accept a connection and return stream"
-    },
-#endif
     {   .cmd = "flush",
         .function = aio_cmd_flush,
         .description = "Flush the stream"
@@ -2827,7 +2160,7 @@ static int JimAioSubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     return Jim_CallSubCmd(interp, Jim_ParseSubCmd(interp, aio_command_table, argc, argv), argc, argv);
 }
 
-static int JimAioOpenCommand(Jim_Interp *interp, int argc, 
+static int JimAioOpenCommand(Jim_Interp *interp, int argc,
         Jim_Obj *const *argv)
 {
     FILE *fp;
@@ -2858,7 +2191,7 @@ static int JimAioOpenCommand(Jim_Interp *interp, int argc,
         const char *filename = Jim_String(argv[1]);
 
 #ifdef jim_ext_tclcompat
-        /* If the filename starts with '|', use popen instead */
+        
         if (*filename == '|') {
             Jim_Obj *evalObj[3];
 
@@ -2874,12 +2207,12 @@ static int JimAioOpenCommand(Jim_Interp *interp, int argc,
             JimAioSetError(interp, argv[1]);
             return JIM_ERR;
         }
-        /* Get the next file id */
+        
         snprintf(buf, sizeof(buf), "aio.handle%ld", Jim_GetId(interp));
         cmdname = buf;
     }
 
-    /* Create the file command */
+    
     af = Jim_Alloc(sizeof(*af));
     af->fp = fp;
     af->fd = fileno(fp);
@@ -2902,310 +2235,6 @@ static int JimAioOpenCommand(Jim_Interp *interp, int argc,
     return JIM_OK;
 }
 
-#ifndef JIM_ANSIC
-
-/**
- * Creates a channel for fd.
- * 
- * hdlfmt is a sprintf format for the filehandle. Anything with %ld at the end will do.
- * mode is usual "r+", but may be another fdopen() mode as required.
- *
- * Creates the command and lappends the name of the command to the current result.
- *
- */
-static int JimMakeChannel(Jim_Interp *interp, Jim_Obj *filename, const char *hdlfmt, int fd, int family,
-    const char *mode)
-{
-    AioFile *af;
-    char buf[AIO_CMD_LEN];
-
-    FILE *fp = fdopen(fd, mode);
-
-    if (fp == NULL) {
-        close(fd);
-        JimAioSetError(interp, NULL);
-        return JIM_ERR;
-    }
-
-    /* Create the file command */
-    af = Jim_Alloc(sizeof(*af));
-    af->fp = fp;
-    af->fd = fd;
-    fcntl(af->fd, F_SETFD, FD_CLOEXEC);
-    af->OpenFlags = 0;
-    af->filename = filename;
-    Jim_IncrRefCount(af->filename);
-#ifdef O_NDELAY
-    af->flags = fcntl(af->fd, F_GETFL);
-#endif
-    af->rEvent = NULL;
-    af->wEvent = NULL;
-    af->eEvent = NULL;
-    af->addr_family = family;
-    snprintf(buf, sizeof(buf), hdlfmt, Jim_GetId(interp));
-    Jim_CreateCommand(interp, buf, JimAioSubCmdProc, af, JimAioDelProc);
-
-    Jim_ListAppendElement(interp, Jim_GetResult(interp), Jim_NewStringObj(interp, buf, -1));
-
-    return JIM_OK;
-}
-
-static int JimAioSockCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-    const char *hdlfmt = "aio.unknown%ld";
-    const char *socktypes[] = {
-        "unix",
-        "unix.server",
-        "dgram",
-        "dgram.server",
-        "stream",
-        "stream.server",
-        "pipe",
-        NULL
-    };
-    enum
-    {
-        SOCK_UNIX,
-        SOCK_UNIX_SERVER,
-        SOCK_DGRAM_CLIENT,
-        SOCK_DGRAM_SERVER,
-        SOCK_STREAM_CLIENT,
-        SOCK_STREAM_SERVER,
-        SOCK_STREAM_PIPE,
-        SOCK_DGRAM6_CLIENT,
-        SOCK_DGRAM6_SERVER,
-        SOCK_STREAM6_CLIENT,
-        SOCK_STREAM6_SERVER,
-    };
-    int socktype;
-    int sock;
-    const char *hostportarg = NULL;
-    int res;
-    int on = 1;
-    const char *mode = "r+";
-    int family = PF_INET;
-    Jim_Obj *argv0 = argv[0];
-    int ipv6 = 0;
-
-    if (argc > 1 && Jim_CompareStringImmediate(interp, argv[1], "-ipv6")) {
-        if (!IPV6) {
-            Jim_SetResultString(interp, "ipv6 not supported", -1);
-            return JIM_ERR;
-        }
-        ipv6 = 1;
-        family = PF_INET6;
-    }
-    argc -= ipv6;
-    argv += ipv6;
-
-    if (argc < 2) {
-      wrongargs:
-        Jim_WrongNumArgs(interp, 1, &argv0, "?-ipv6? type ?address?");
-        return JIM_ERR;
-    }
-
-    if (Jim_GetEnum(interp, argv[1], socktypes, &socktype, "socket type", JIM_ERRMSG) != JIM_OK)
-        return JIM_ERR;
-
-    Jim_SetResultString(interp, "", 0);
-
-    hdlfmt = "aio.sock%ld";
-
-    if (argc > 2) {
-        hostportarg = Jim_String(argv[2]);
-    }
-
-    switch (socktype) {
-        case SOCK_DGRAM_CLIENT:
-            if (argc == 2) {
-                /* No address, so an unconnected dgram socket */
-                sock = socket(family, SOCK_DGRAM, 0);
-                if (sock < 0) {
-                    JimAioSetError(interp, NULL);
-                    return JIM_ERR;
-                }
-                break;
-            }
-            /* fall through */
-        case SOCK_STREAM_CLIENT:
-            {
-                union sockaddr_any sa;
-                int salen;
-
-                if (argc != 3) {
-                    goto wrongargs;
-                }
-
-                if (ipv6) {
-                    if (JimParseIPv6Address(interp, hostportarg, &sa, &salen) != JIM_OK) {
-                        return JIM_ERR;
-                    }
-                }
-                else if (JimParseIpAddress(interp, hostportarg, &sa, &salen) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                sock = socket(family, (socktype == SOCK_DGRAM_CLIENT) ? SOCK_DGRAM : SOCK_STREAM, 0);
-                if (sock < 0) {
-                    JimAioSetError(interp, NULL);
-                    return JIM_ERR;
-                }
-                res = connect(sock, &sa.sa, salen);
-                if (res) {
-                    JimAioSetError(interp, argv[2]);
-                    close(sock);
-                    return JIM_ERR;
-                }
-            }
-            break;
-
-        case SOCK_STREAM_SERVER:
-        case SOCK_DGRAM_SERVER:
-            {
-                union sockaddr_any sa;
-                int salen;
-
-                if (argc != 3) {
-                    goto wrongargs;
-                }
-
-                if (ipv6) {
-                    if (JimParseIPv6Address(interp, hostportarg, &sa, &salen) != JIM_OK) {
-                        return JIM_ERR;
-                    }
-                }
-                else if (JimParseIpAddress(interp, hostportarg, &sa, &salen) != JIM_OK) {
-                    return JIM_ERR;
-                }
-                sock = socket(family, (socktype == SOCK_DGRAM_SERVER) ? SOCK_DGRAM : SOCK_STREAM, 0);
-                if (sock < 0) {
-                    JimAioSetError(interp, NULL);
-                    return JIM_ERR;
-                }
-
-                /* Enable address reuse */
-                setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(on));
-
-                res = bind(sock, &sa.sa, salen);
-                if (res) {
-                    JimAioSetError(interp, argv[2]);
-                    close(sock);
-                    return JIM_ERR;
-                }
-                if (socktype == SOCK_STREAM_SERVER) {
-                    res = listen(sock, 5);
-                    if (res) {
-                        JimAioSetError(interp, NULL);
-                        close(sock);
-                        return JIM_ERR;
-                    }
-                }
-                hdlfmt = "aio.socksrv%ld";
-            }
-            break;
-
-#ifdef HAVE_SYS_UN_H
-        case SOCK_UNIX:
-            {
-                struct sockaddr_un sa;
-                socklen_t len;
-
-                if (argc != 3 || ipv6) {
-                    goto wrongargs;
-                }
-
-                if (JimParseDomainAddress(interp, hostportarg, &sa) != JIM_OK) {
-                    JimAioSetError(interp, argv[2]);
-                    return JIM_ERR;
-                }
-                family = PF_UNIX;
-                sock = socket(PF_UNIX, SOCK_STREAM, 0);
-                if (sock < 0) {
-                    JimAioSetError(interp, NULL);
-                    return JIM_ERR;
-                }
-                len = strlen(sa.sun_path) + 1 + sizeof(sa.sun_family);
-                res = connect(sock, (struct sockaddr *)&sa, len);
-                if (res) {
-                    JimAioSetError(interp, argv[2]);
-                    close(sock);
-                    return JIM_ERR;
-                }
-                hdlfmt = "aio.sockunix%ld";
-                break;
-            }
-
-        case SOCK_UNIX_SERVER:
-            {
-                struct sockaddr_un sa;
-                socklen_t len;
-
-                if (argc != 3 || ipv6) {
-                    goto wrongargs;
-                }
-
-                if (JimParseDomainAddress(interp, hostportarg, &sa) != JIM_OK) {
-                    JimAioSetError(interp, argv[2]);
-                    return JIM_ERR;
-                }
-                family = PF_UNIX;
-                sock = socket(PF_UNIX, SOCK_STREAM, 0);
-                if (sock < 0) {
-                    JimAioSetError(interp, NULL);
-                    return JIM_ERR;
-                }
-                len = strlen(sa.sun_path) + 1 + sizeof(sa.sun_family);
-                res = bind(sock, (struct sockaddr *)&sa, len);
-                if (res) {
-                    JimAioSetError(interp, argv[2]);
-                    close(sock);
-                    return JIM_ERR;
-                }
-                res = listen(sock, 5);
-                if (res) {
-                    JimAioSetError(interp, NULL);
-                    close(sock);
-                    return JIM_ERR;
-                }
-                hdlfmt = "aio.sockunixsrv%ld";
-                break;
-            }
-#endif
-
-#ifdef HAVE_PIPE
-        case SOCK_STREAM_PIPE:
-            {
-                int p[2];
-
-                if (argc != 2 || ipv6) {
-                    goto wrongargs;
-                }
-
-                if (pipe(p) < 0) {
-                    JimAioSetError(interp, NULL);
-                    return JIM_ERR;
-                }
-
-                hdlfmt = "aio.pipe%ld";
-                if (JimMakeChannel(interp, argv[1], hdlfmt, p[0], family, "r") != JIM_OK) {
-                    close(p[0]);
-                    close(p[1]);
-                    JimAioSetError(interp, NULL);
-                    return JIM_ERR;
-                }
-                /* Note, if this fails it will leave p[0] open, but this should never happen */
-                mode = "w";
-                sock = p[1];
-            }
-            break;
-#endif
-        default:
-            Jim_SetResultString(interp, "Unsupported socket type", -1);
-            return JIM_ERR;
-    }
-
-    return JimMakeChannel(interp, argv[1], hdlfmt, sock, family, mode);
-}
-#endif
 
 FILE *Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *command)
 {
@@ -3228,57 +2257,12 @@ int Jim_aioInit(Jim_Interp *interp)
     Jim_CreateCommand(interp, "socket", JimAioSockCommand, NULL, NULL);
 #endif
 
-    /* Takeover stdin, stdout and stderr */
+    
     Jim_EvalGlobal(interp, "open stdin; open stdout; open stderr");
 
     return JIM_OK;
 }
 
-/*
- * Tcl readdir command.
- *
- * (c) 2008 Steve Bennett <steveb@worware.net.au>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- * The views and conclusions contained in the software and documentation
- * are those of the authors and should not be interpreted as representing
- * official policies, either expressed or implied, of the Jim Tcl Project.
- *
- * Based on original work by:
- *-----------------------------------------------------------------------------
- * Copyright 1991-1994 Karl Lehenbauer and Mark Diekhans.
- *
- * Permission to use, copy, modify, and distribute this software and its
- * documentation for any purpose and without fee is hereby granted, provided
- * that the above copyright notice appear in all copies.  Karl Lehenbauer and
- * Mark Diekhans make no representations about the suitability of this
- * software for any purpose.  It is provided "as is" without express or
- * implied warranty.
- *-----------------------------------------------------------------------------
- */
 
 #include <errno.h>
 #include <stdio.h>
@@ -3286,17 +2270,6 @@ int Jim_aioInit(Jim_Interp *interp)
 #include <dirent.h>
 
 
-/*
- *-----------------------------------------------------------------------------
- *
- * Jim_ReaddirCmd --
- *     Implements the rename TCL command:
- *         readdir ?-nocomplain? dirPath
- *
- * Results:
- *      Standard TCL result.
- *-----------------------------------------------------------------------------
- */
 int Jim_ReaddirCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     const char *dirPath;
@@ -3350,52 +2323,6 @@ int Jim_readdirInit(Jim_Interp *interp)
     Jim_CreateCommand(interp, "readdir", Jim_ReaddirCmd, NULL, NULL);
     return JIM_OK;
 }
-/* 
- * Implements the regexp and regsub commands for Jim
- *
- * (c) 2008 Steve Bennett <steveb@workware.net.au>
- *
- * Uses C library regcomp()/regexec() for the matching.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- * The views and conclusions contained in the software and documentation
- * are those of the authors and should not be interpreted as representing
- * official policies, either expressed or implied, of the Jim Tcl Project.
- *
- * Based on code originally from Tcl 6.7:
- *
- * Copyright 1987-1991 Regents of the University of California
- * Permission to use, copy, modify, and distribute this
- * software and its documentation for any purpose and without
- * fee is hereby granted, provided that the above copyright
- * notice appear in all copies.  The University of California
- * makes no representations about the suitability of this
- * software for any purpose.  It is provided "as is" without
- * express or implied warranty.
- */
 
 #include <stdlib.h>
 #include <string.h>
@@ -3421,20 +2348,16 @@ static regex_t *SetRegexpFromAny(Jim_Interp *interp, Jim_Obj *objPtr, unsigned f
     const char *pattern;
     int ret;
 
-    /* Check if the object is already an uptodate variable */
+    
     if (objPtr->typePtr == &regexpObjType &&
         objPtr->internalRep.regexpValue.compre && objPtr->internalRep.regexpValue.flags == flags) {
-        /* nothing to do */
+        
         return objPtr->internalRep.regexpValue.compre;
     }
 
-    /* Not a regexp or the flags do not match */
-    if (objPtr->typePtr == &regexpObjType) {
-        FreeRegexpInternalRep(interp, objPtr);
-        objPtr->typePtr = NULL;
-    }
+    
 
-    /* Get the string representation */
+    
     pattern = Jim_String(objPtr);
     compre = Jim_Alloc(sizeof(regex_t));
 
@@ -3448,6 +2371,8 @@ static regex_t *SetRegexpFromAny(Jim_Interp *interp, Jim_Obj *objPtr, unsigned f
         return NULL;
     }
 
+    Jim_FreeIntRep(interp, objPtr);
+
     objPtr->typePtr = &regexpObjType;
     objPtr->internalRep.regexpValue.flags = flags;
     objPtr->internalRep.regexpValue.compre = compre;
@@ -3558,9 +2483,6 @@ int Jim_RegexpCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
     pmatch = Jim_Alloc((num_vars + 1) * sizeof(*pmatch));
 
-    /* If an offset has been specified, adjust for that now.
-     * If it points past the end of the string, point to the terminating null
-     */
     if (offset) {
         if (offset < 0) {
             offset += source_len + 1;
@@ -3596,14 +2518,10 @@ int Jim_RegexpCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     num_matches++;
 
     if (opt_all && !opt_inline) {
-        /* Just count the number of matches, so skip the substitution h */
+        
         goto try_next_match;
     }
 
-    /*
-     * If additional variable names have been specified, return
-     * index information in those variables.
-     */
 
     j = 0;
     for (i += 2; opt_inline ? j < num_vars : i < argc; i++, j++) {
@@ -3640,7 +2558,7 @@ int Jim_RegexpCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
             Jim_ListAppendElement(interp, resultListObj, resultObj);
         }
         else {
-            /* And now set the result variable */
+            
             result = Jim_SetVariable(interp, argv[i], resultObj);
 
             if (result != JIM_OK) {
@@ -3767,12 +2685,9 @@ int Jim_RegsubCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     replace_str = Jim_GetString(argv[i + 2], &replace_len);
     varname = argv[i + 3];
 
-    /* Create the result string */
+    
     resultObj = Jim_NewStringObj(interp, "", 0);
 
-    /* If an offset has been specified, adjust for that now.
-     * If it points past the end of the string, point to the terminating null
-     */
     if (offset) {
         if (offset < 0) {
             offset += source_len + 1;
@@ -3785,15 +2700,9 @@ int Jim_RegsubCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
         }
     }
 
-    /* Copy the part before -start */
+    
     Jim_AppendString(interp, resultObj, source_str, offset);
 
-    /*
-     * The following loop is to handle multiple matches within the
-     * same source string;  each iteration handles one match and its
-     * corresponding substitution.  If "-all" hasn't been specified
-     * then the loop body only gets executed once.
-     */
 
     n = source_len - offset;
     p = source_str + offset;
@@ -3813,18 +2722,8 @@ int Jim_RegsubCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
         num_matches++;
 
-        /*
-         * Copy the portion of the source string before the match to the
-         * result variable.
-         */
         Jim_AppendString(interp, resultObj, p, pmatch[0].rm_so);
 
-        /*
-         * Append the subSpec (replace_str) argument to the variable, making appropriate
-         * substitutions.  This code is a bit hairy because of the backslash
-         * conventions and because the code saves up ranges of characters in
-         * subSpec to reduce the number of calls to Jim_SetVar.
-         */
 
         for (j = 0; j < replace_len; j++) {
             int idx;
@@ -3860,34 +2759,30 @@ int Jim_RegsubCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
         p += pmatch[0].rm_eo;
         n -= pmatch[0].rm_eo;
 
-        /* If -all is not specified, or there is no source left, we are done */
+        
         if (!opt_all || n == 0) {
             break;
         }
 
-        /* An anchored pattern without -line must be done */
+        
         if ((regcomp_flags & REG_NEWLINE) == 0 && pattern[0] == '^') {
             break;
         }
 
-        /* If the pattern is empty, need to step forwards */
+        
         if (pattern[0] == '\0' && n) {
-            /* Need to copy the char we are moving over */
+            
             Jim_AppendString(interp, resultObj, p, 1);
             p++;
             n--;
         }
-        
+
         regexec_flags |= REG_NOTBOL;
     } while (n);
 
-    /*
-     * Copy the portion of the string after the last match to the
-     * result variable.
-     */
     Jim_AppendString(interp, resultObj, p, -1);
 
-    /* And now set or return the result variable */
+    
     if (argc - i == 4) {
         result = Jim_SetVariable(interp, varname, resultObj);
 
@@ -3915,50 +2810,6 @@ int Jim_regexpInit(Jim_Interp *interp)
     Jim_CreateCommand(interp, "regsub", Jim_RegsubCmd, NULL, NULL);
     return JIM_OK;
 }
-/* 
- * Implements the file command for jim
- *
- * (c) 2008 Steve Bennett <steveb@workware.net.au>
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- * The views and conclusions contained in the software and documentation
- * are those of the authors and should not be interpreted as representing
- * official policies, either expressed or implied, of the Jim Tcl Project.
- *
- * Based on code originally from Tcl 6.7:
- *
- * Copyright 1987-1991 Regents of the University of California
- * Permission to use, copy, modify, and distribute this
- * software and its documentation for any purpose and without
- * fee is hereby granted, provided that the above copyright
- * notice appear in all copies.  The University of California
- * makes no representations about the suitability of this
- * software for any purpose.  It is provided "as is" without
- * express or implied warranty.
- */
 
 #include <limits.h>
 #include <stdlib.h>
@@ -3968,28 +2819,13 @@ int Jim_regexpInit(Jim_Interp *interp)
 #include <errno.h>
 #include <sys/stat.h>
 #include <sys/param.h>
+#include <sys/time.h>
 
 
 # ifndef MAXPATHLEN
 # define MAXPATHLEN JIM_PATH_LEN
 # endif
 
-/*
- *----------------------------------------------------------------------
- *
- * JimGetFileType --
- *
- *  Given a mode word, returns a string identifying the type of a
- *  file.
- *
- * Results:
- *  A static text string giving the file type from mode.
- *
- * Side effects:
- *  None.
- *
- *----------------------------------------------------------------------
- */
 
 static const char *JimGetFileType(int mode)
 {
@@ -4021,24 +2857,6 @@ static const char *JimGetFileType(int mode)
     return "unknown";
 }
 
-/*
- *----------------------------------------------------------------------
- *
- * StoreStatData --
- *
- *  This is a utility procedure that breaks out the fields of a
- *  "stat" structure and stores them in textual form into the
- *  elements of an associative array.
- *
- * Results:
- *  Returns a standard Tcl return value.  If an error occurs then
- *  a message is left in interp->result.
- *
- * Side effects:
- *  Elements of the associative array given by "varName" are modified.
- *
- *----------------------------------------------------------------------
- */
 
 static int set_array_int_value(Jim_Interp *interp, Jim_Obj *container, const char *key,
     jim_wide value)
@@ -4046,7 +2864,7 @@ static int set_array_int_value(Jim_Interp *interp, Jim_Obj *container, const cha
     Jim_Obj *nameobj = Jim_NewStringObj(interp, key, -1);
     Jim_Obj *valobj = Jim_NewWideObj(interp, value);
 
-    if (Jim_SetDictKeysVector(interp, container, &nameobj, 1, valobj) != JIM_OK) {
+    if (Jim_SetDictKeysVector(interp, container, &nameobj, 1, valobj, JIM_ERRMSG) != JIM_OK) {
         Jim_FreeObj(interp, nameobj);
         Jim_FreeObj(interp, valobj);
         return JIM_ERR;
@@ -4060,7 +2878,7 @@ static int set_array_string_value(Jim_Interp *interp, Jim_Obj *container, const
     Jim_Obj *nameobj = Jim_NewStringObj(interp, key, -1);
     Jim_Obj *valobj = Jim_NewStringObj(interp, value, -1);
 
-    if (Jim_SetDictKeysVector(interp, container, &nameobj, 1, valobj) != JIM_OK) {
+    if (Jim_SetDictKeysVector(interp, container, &nameobj, 1, valobj, JIM_ERRMSG) != JIM_OK) {
         Jim_FreeObj(interp, nameobj);
         Jim_FreeObj(interp, valobj);
         return JIM_ERR;
@@ -4085,7 +2903,7 @@ static int StoreStatData(Jim_Interp *interp, Jim_Obj *varName, const struct stat
     set_array_int_value(interp, varName, "ctime", sb->st_ctime);
     set_array_string_value(interp, varName, "type", JimGetFileType((int)sb->st_mode));
 
-    /* And also return the value */
+    
     Jim_SetResult(interp, Jim_GetVariable(interp, varName, 0));
 
     return JIM_OK;
@@ -4104,7 +2922,7 @@ static int file_cmd_dirname(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     }
 #if defined(__MINGW32__)
     else if (p[-1] == ':') {
-        /* z:/dir => z:/ */
+        
         Jim_SetResultString(interp, path, p - path + 1);
     }
 #endif
@@ -4184,18 +3002,18 @@ static int file_cmd_join(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
     *newname = 0;
 
-    /* Simple implementation for now */
+    
     for (i = 0; i < argc; i++) {
         int len;
         const char *part = Jim_GetString(argv[i], &len);
 
         if (*part == '/') {
-            /* Absolute component, so go back to the start */
+            
             last = newname;
         }
 #if defined(__MINGW32__)
         else if (strchr(part, ':')) {
-            /* Absolute compontent on mingw, so go back to the start */
+            
             last = newname;
         }
 #endif
@@ -4205,12 +3023,12 @@ static int file_cmd_join(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
                 len -= 2;
             }
             else if (part[1] == 0 && last != newname) {
-                /* Adding '.' to an existing path does nothing */
+                
                 continue;
             }
         }
 
-        /* Add a slash if needed */
+        
         if (last != newname && last[-1] != '/') {
             *last++ = '/';
         }
@@ -4225,7 +3043,7 @@ static int file_cmd_join(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
             last += len;
         }
 
-        /* Remove a slash if needed */
+        
         if (last > newname + 1 && last[-1] == '/') {
             *--last = 0;
         }
@@ -4233,7 +3051,7 @@ static int file_cmd_join(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
     *last = 0;
 
-    /* Probably need to handle some special cases ... */
+    
 
     Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, newname, last - newname));
 
@@ -4284,8 +3102,8 @@ static int file_cmd_delete(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
         if (unlink(path) == -1 && errno != ENOENT) {
             if (rmdir(path) == -1) {
-                /* Maybe try using the script helper */
-                if (!force || Jim_EvalObjPrefix(interp, "file delete force", 1, argv) != JIM_OK) {
+                
+                if (!force || Jim_EvalPrefix(interp, "file delete force", 1, argv) != JIM_OK) {
                     Jim_SetResultFormatted(interp, "couldn't delete file \"%s\": %s", path,
                         strerror(errno));
                     return JIM_ERR;
@@ -4303,22 +3121,15 @@ static int file_cmd_delete(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 #define MKDIR_DEFAULT(PATHNAME) mkdir(PATHNAME, 0755)
 #endif
 
-/**
- * Create directory, creating all intermediate paths if necessary.
- *
- * Returns 0 if OK or -1 on failure (and sets errno)
- *
- * Note: The path may be modified.
- */
 static int mkdir_all(char *path)
 {
     int ok = 1;
 
-    /* First time just try to make the dir */
+    
     goto first;
 
     while (ok--) {
-        /* Must have failed the first time, so recursively make the parent and try again */
+        
         char *slash = strrchr(path, '/');
 
         if (slash && slash != path) {
@@ -4333,20 +3144,20 @@ static int mkdir_all(char *path)
             return 0;
         }
         if (errno == ENOENT) {
-            /* Create the parent and try again */
+            
             continue;
         }
-        /* Maybe it already exists as a directory */
+        
         if (errno == EEXIST) {
             struct stat sb;
 
             if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
                 return 0;
             }
-            /* Restore errno */
+            
             errno = EEXIST;
         }
-        /* Failed */
+        
         break;
     }
     return -1;
@@ -4467,6 +3278,27 @@ static int file_cmd_mtime(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     struct stat sb;
 
+    if (argc == 2) {
+#ifdef HAVE_UTIMES
+        jim_wide newtime;
+        struct timeval times[2];
+
+        if (Jim_GetWide(interp, argv[1], &newtime) != JIM_OK) {
+            return JIM_ERR;
+        }
+
+        times[1].tv_sec = times[0].tv_sec = newtime;
+        times[1].tv_usec = times[0].tv_usec = 0;
+
+        if (utimes(Jim_String(argv[0]), times) != 0) {
+            Jim_SetResultFormatted(interp, "can't set time on \"%#s\": %s", argv[0], strerror(errno));
+            return JIM_ERR;
+        }
+#else
+        Jim_SetResultString(interp, "Not implemented", -1);
+        return JIM_ERR;
+#endif
+    }
     if (file_stat(interp, argv[0], &sb) != JIM_OK) {
         return JIM_ERR;
     }
@@ -4476,7 +3308,7 @@ static int file_cmd_mtime(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
 static int file_cmd_copy(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-    return Jim_EvalObjPrefix(interp, "file copy", argc, argv);
+    return Jim_EvalPrefix(interp, "file copy", argc, argv);
 }
 
 static int file_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
@@ -4538,7 +3370,7 @@ static int file_cmd_readlink(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
     if (linkLength == -1) {
         Jim_Free(linkValue);
-        Jim_SetResultFormatted(interp, "couldn't readlink \"%s\": %s", argv[0], strerror(errno));
+        Jim_SetResultFormatted(interp, "couldn't readlink \"%#s\": %s", argv[0], strerror(errno));
         return JIM_ERR;
     }
     linkValue[linkLength] = 0;
@@ -4587,11 +3419,11 @@ static const jim_subcmd_type file_command_table[] = {
         .description = "Last access time"
     },
     {   .cmd = "mtime",
-        .args = "name",
+        .args = "name ?time?",
         .function = file_cmd_mtime,
         .minargs = 1,
-        .maxargs = 1,
-        .description = "Last modification time"
+        .maxargs = 2,
+        .description = "Get or set last modification time"
     },
     {   .cmd = "copy",
         .args = "?-force? source dest",
@@ -4795,7 +3627,7 @@ static int Jim_PwdCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     }
 #if defined(__MINGW32__)
     {
-        /* Try to keep backlashes out of paths */
+        
         char *p = cwd;
         while ((p = strchr(p, '\\')) != NULL) {
             *p++ = '/';
@@ -4820,50 +3652,135 @@ int Jim_fileInit(Jim_Interp *interp)
     return JIM_OK;
 }
 
-/* 
- * (c) 2008 Steve Bennett <steveb@workware.net.au>
- *
- * Implements the exec command for Jim
- *
- * Based on code originally from Tcl 6.7 by John Ousterhout.
- * From that code:
- *
- * The Tcl_Fork and Tcl_WaitPids procedures are based on code
- * contributed by Karl Lehenbauer, Mark Diekhans and Peter
- * da Silva.
- *
- * Copyright 1987-1991 Regents of the University of California
- * Permission to use, copy, modify, and distribute this
- * software and its documentation for any purpose and without
- * fee is hereby granted, provided that the above copyright
- * notice appear in all copies.  The University of California
- * makes no representations about the suitability of this
- * software for any purpose.  It is provided "as is" without
- * express or implied warranty.
- */
-
 #include <string.h>
-#include <signal.h>
+#include <ctype.h>
 
 
-#if defined(HAVE_VFORK) && defined(HAVE_WAITPID)
+#if (!defined(HAVE_VFORK) || !defined(HAVE_WAITPID)) && !defined(__MINGW32__)
+static int Jim_ExecCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+    Jim_Obj *cmdlineObj = Jim_NewEmptyStringObj(interp);
+    int i, j;
+    int rc;
+
+    
+    for (i = 1; i < argc; i++) {
+        int len;
+        const char *arg = Jim_GetString(argv[i], &len);
+
+        if (i > 1) {
+            Jim_AppendString(interp, cmdlineObj, " ", 1);
+        }
+        if (strpbrk(arg, "\\\" ") == NULL) {
+            
+            Jim_AppendString(interp, cmdlineObj, arg, len);
+            continue;
+        }
+
+        Jim_AppendString(interp, cmdlineObj, "\"", 1);
+        for (j = 0; j < len; j++) {
+            if (arg[j] == '\\' || arg[j] == '"') {
+                Jim_AppendString(interp, cmdlineObj, "\\", 1);
+            }
+            Jim_AppendString(interp, cmdlineObj, &arg[j], 1);
+        }
+        Jim_AppendString(interp, cmdlineObj, "\"", 1);
+    }
+    rc = system(Jim_String(cmdlineObj));
+
+    Jim_FreeNewObj(interp, cmdlineObj);
+
+    if (rc) {
+        Jim_Obj *errorCode = Jim_NewListObj(interp, NULL, 0);
+        Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, "CHILDSTATUS", -1));
+        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, 0));
+        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, rc));
+        Jim_SetGlobalVariableStr(interp, "errorCode", errorCode);
+        return JIM_ERR;
+    }
+
+    return JIM_OK;
+}
+
+int Jim_execInit(Jim_Interp *interp)
+{
+    if (Jim_PackageProvide(interp, "exec", "1.0", JIM_ERRMSG))
+        return JIM_ERR;
+    Jim_CreateCommand(interp, "exec", Jim_ExecCmd, NULL, NULL);
+    return JIM_OK;
+}
+#else
 
 
-#include <unistd.h>
-#include <fcntl.h>
 #include <errno.h>
-#include <sys/wait.h>
+#include <signal.h>
 
-#if defined(__GNUC__) && !defined(__clang__)
-#define IGNORE_RC(EXPR) ((EXPR) < 0 ? -1 : 0)
+#define XXX printf("@%s:%d\n", __FILE__, __LINE__); fflush(stdout);
+
+#if defined(__MINGW32__)
+    
+    #include <fcntl.h>
+
+    typedef HANDLE fdtype;
+    typedef HANDLE pidtype;
+    #define JIM_BAD_FD INVALID_HANDLE_VALUE
+    #define JIM_BAD_PID INVALID_HANDLE_VALUE
+    #define JimCloseFd CloseHandle
+
+    #define WIFEXITED(STATUS) 1
+    #define WEXITSTATUS(STATUS) (STATUS)
+    #define WIFSIGNALED(STATUS) 0
+    #define WTERMSIG(STATUS) 0
+    #define WNOHANG 1
+
+    static fdtype JimFileno(FILE *fh);
+    static pidtype JimWaitPid(pidtype pid, int *status, int nohang);
+    static fdtype JimDupFd(fdtype infd);
+    static fdtype JimOpenForRead(const char *filename);
+    static FILE *JimFdOpenForRead(fdtype fd);
+    static int JimPipe(fdtype pipefd[2]);
+    static pidtype JimStartWinProcess(Jim_Interp *interp, char **argv, char *env,
+        fdtype inputId, fdtype outputId, fdtype errorId);
+    static int JimErrno(void);
 #else
-#define IGNORE_RC(EXPR) EXPR
+    #include <unistd.h>
+    #include <fcntl.h>
+    #include <sys/wait.h>
+
+    typedef int fdtype;
+    typedef int pidtype;
+    #define JimPipe pipe
+    #define JimErrno() errno
+    #define JIM_BAD_FD -1
+    #define JIM_BAD_PID -1
+    #define JimFileno fileno
+    #define JimReadFd read
+    #define JimCloseFd close
+    #define JimWaitPid waitpid
+    #define JimDupFd dup
+    #define JimFdOpenForRead(FD) fdopen((FD), "r")
+    #define JimOpenForRead(NAME) open((NAME), O_RDONLY, 0)
 #endif
 
-/* These two could be moved into the Tcl core */
+static const char *JimStrError(void);
+static char **JimSaveEnv(char **env);
+static void JimRestoreEnv(char **env);
+static int JimCreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv,
+    pidtype **pidArrayPtr, fdtype *inPipePtr, fdtype *outPipePtr, fdtype *errFilePtr);
+static void JimDetachPids(Jim_Interp *interp, int numPids, const pidtype *pidPtr);
+static int JimCleanupChildren(Jim_Interp *interp, int numPids, pidtype *pidPtr, fdtype errorId);
+static fdtype JimCreateTemp(Jim_Interp *interp, const char *contents);
+static fdtype JimOpenForWrite(const char *filename, int append);
+static int JimRewindFd(fdtype fd);
+
 static void Jim_SetResultErrno(Jim_Interp *interp, const char *msg)
 {
-    Jim_SetResultFormatted(interp, "%s: %s", msg, strerror(errno));
+    Jim_SetResultFormatted(interp, "%s: %s", msg, JimStrError());
+}
+
+static const char *JimStrError(void)
+{
+    return strerror(JimErrno());
 }
 
 static void Jim_RemoveTrailingNewline(Jim_Obj *objPtr)
@@ -4877,36 +3794,28 @@ static void Jim_RemoveTrailingNewline(Jim_Obj *objPtr)
     }
 }
 
-/**
- * Read from 'fd' and append the data to strObj
- * Returns JIM_OK if OK, or JIM_ERR on error.
- */
-static int JimAppendStreamToString(Jim_Interp *interp, int fd, Jim_Obj *strObj)
+static int JimAppendStreamToString(Jim_Interp *interp, fdtype fd, Jim_Obj *strObj)
 {
-    while (1) {
-        char buffer[256];
-        int count;
-
-        count = read(fd, buffer, sizeof(buffer));
+    char buf[256];
+    FILE *fh = JimFdOpenForRead(fd);
+    if (fh == NULL) {
+        return JIM_ERR;
+    }
 
-        if (count == 0) {
-            Jim_RemoveTrailingNewline(strObj);
-            return JIM_OK;
+    while (1) {
+        int retval = fread(buf, 1, sizeof(buf), fh);
+        if (retval > 0) {
+            Jim_AppendString(interp, strObj, buf, retval);
         }
-        if (count < 0) {
-            return JIM_ERR;
+        if (retval != sizeof(buf)) {
+            break;
         }
-        Jim_AppendString(interp, strObj, buffer, count);
     }
+    Jim_RemoveTrailingNewline(strObj);
+    fclose(fh);
+    return JIM_OK;
 }
 
-/*
- * If the last character of the result is a newline, then remove
- * the newline character (the newline would just confuse things).
- *
- * Note: Ideally we could do this by just reducing the length of stringrep
- *       by 1, but there is no API for this :-(
- */
 static void JimTrimTrailingNewline(Jim_Interp *interp)
 {
     int len;
@@ -4917,22 +3826,15 @@ static void JimTrimTrailingNewline(Jim_Interp *interp)
     }
 }
 
-/**
- * Builds the environment array from $::env
- *
- * If $::env is not set, simply returns environ.
- *
- * Otherwise allocates the environ array from the contents of $::env
- *
- * If the exec fails, memory can be freed via JimFreeEnv()
- */
 static char **JimBuildEnv(Jim_Interp *interp)
 {
-#ifdef jim_ext_tclcompat
+#if defined(jim_ext_tclcompat)
     int i;
-    int len;
+    int size;
+    int num;
     int n;
-    char **env;
+    char **envptr;
+    char *envdata;
 
     Jim_Obj *objPtr = Jim_GetGlobalVariableStr(interp, "env", JIM_NONE);
 
@@ -4940,62 +3842,52 @@ static char **JimBuildEnv(Jim_Interp *interp)
         return Jim_GetEnviron();
     }
 
-    /* Calculate the required size */
-    len = Jim_ListLength(interp, objPtr);
-    if (len % 2) {
-        len--;
+
+    
+    num = Jim_ListLength(interp, objPtr);
+    if (num % 2) {
+        num--;
     }
+    size = Jim_Length(objPtr);
+    size++;
 
-    env = Jim_Alloc(sizeof(*env) * (len / 2 + 1));
+    envptr = Jim_Alloc(sizeof(*envptr) * (num / 2 + 1) + size);
+    envdata = (char *)&envptr[num / 2 + 1];
 
     n = 0;
-    for (i = 0; i < len; i += 2) {
-        int l1, l2;
+    for (i = 0; i < num; i += 2) {
         const char *s1, *s2;
         Jim_Obj *elemObj;
 
         Jim_ListIndex(interp, objPtr, i, &elemObj, JIM_NONE);
-        s1 = Jim_GetString(elemObj, &l1);
+        s1 = Jim_String(elemObj);
         Jim_ListIndex(interp, objPtr, i + 1, &elemObj, JIM_NONE);
-        s2 = Jim_GetString(elemObj, &l2);
+        s2 = Jim_String(elemObj);
 
-        env[n] = Jim_Alloc(l1 + l2 + 2);
-        sprintf(env[n], "%s=%s", s1, s2);
+        envptr[n] = envdata;
+        envdata += sprintf(envdata, "%s=%s", s1, s2);
+        envdata++;
         n++;
     }
-    env[n] = NULL;
+    envptr[n] = NULL;
+    *envdata = 0;
 
-    return env;
+    return envptr;
 #else
     return Jim_GetEnviron();
 #endif
 }
 
-/**
- * Frees the environment allocated by JimBuildEnv()
- *
- * Must pass original_environ.
- */
-static void JimFreeEnv(Jim_Interp *interp, char **env, char **original_environ)
+static void JimFreeEnv(char **env, char **original_environ)
 {
 #ifdef jim_ext_tclcompat
     if (env != original_environ) {
-        int i;
-        for (i = 0; env[i]; i++) {
-            Jim_Free(env[i]);
-        }
         Jim_Free(env);
     }
 #endif
 }
 
-/*
- * Create error messages for unusual process exits.  An
- * extra newline gets appended to each error message, but
- * it gets removed below (in the same fashion that an
- * extra newline in the command's output is removed).
- */
-static int JimCheckWaitStatus(Jim_Interp *interp, int pid, int waitStatus)
+static int JimCheckWaitStatus(Jim_Interp *interp, pidtype pid, int waitStatus)
 {
     Jim_Obj *errorCode = Jim_NewListObj(interp, NULL, 0);
     int rc = JIM_ERR;
@@ -5007,7 +3899,7 @@ static int JimCheckWaitStatus(Jim_Interp *interp, int pid, int waitStatus)
         }
         else {
             Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, "CHILDSTATUS", -1));
-            Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, pid));
+            Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, (long)pid));
             Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, WEXITSTATUS(waitStatus)));
         }
     }
@@ -5034,7 +3926,7 @@ static int JimCheckWaitStatus(Jim_Interp *interp, int pid, int waitStatus)
 #else
         Jim_SetResultFormatted(interp, "child %s by signal %d", action, WTERMSIG(waitStatus));
         Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, WTERMSIG(waitStatus)));
-        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, pid));
+        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, (long)pid));
         Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, WTERMSIG(waitStatus)));
 #endif
     }
@@ -5042,16 +3934,12 @@ static int JimCheckWaitStatus(Jim_Interp *interp, int pid, int waitStatus)
     return rc;
 }
 
-/*
- * Data structures of the following type are used by JimFork and
- * JimWaitPids to keep track of child processes.
- */
 
 struct WaitInfo
 {
-    int pid;                    /* Process id of child. */
-    int status;                 /* Status returned when child exited or suspended. */
-    int flags;                  /* Various flag bits;  see below for definitions. */
+    pidtype pid;                    
+    int status;                 
+    int flags;                  
 };
 
 struct WaitInfoTable {
@@ -5060,13 +3948,6 @@ struct WaitInfoTable {
     int used;
 };
 
-/*
- * Flag bits in WaitInfo structures:
- *
- * WI_DETACHED -        Non-zero means no-one cares about the
- *                      process anymore.  Ignore it until it
- *                      exits, then forget about it.
- */
 
 #define WI_DETACHED 2
 
@@ -5089,37 +3970,28 @@ static struct WaitInfoTable *JimAllocWaitInfoTable(void)
     return table;
 }
 
-static int Jim_CreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv,
-    int **pidArrayPtr, int *inPipePtr, int *outPipePtr, int *errFilePtr);
-static void JimDetachPids(Jim_Interp *interp, int numPids, const int *pidPtr);
-static int Jim_CleanupChildren(Jim_Interp *interp, int numPids, int *pidPtr, int errorId);
-
 static int Jim_ExecCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-    int outputId;               /* File id for output pipe.  -1
+    fdtype outputId;               /* File id for output pipe.  -1
                                  * means command overrode. */
-    int errorId;                /* File id for temporary file
+    fdtype errorId;                /* File id for temporary file
                                  * containing error output. */
-    int *pidPtr;
+    pidtype *pidPtr;
     int numPids, result;
 
-    /*
-     * See if the command is to be run in background;  if so, create
-     * the command, detach it, and return.
-     */
     if (argc > 1 && Jim_CompareStringImmediate(interp, argv[argc - 1], "&")) {
         Jim_Obj *listObj;
         int i;
 
         argc--;
-        numPids = Jim_CreatePipeline(interp, argc - 1, argv + 1, &pidPtr, NULL, NULL, NULL);
+        numPids = JimCreatePipeline(interp, argc - 1, argv + 1, &pidPtr, NULL, NULL, NULL);
         if (numPids < 0) {
             return JIM_ERR;
         }
-        /* The return value is a list of the pids */
+        
         listObj = Jim_NewListObj(interp, NULL, 0);
         for (i = 0; i < numPids; i++) {
-            Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, pidPtr[i]));
+            Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, (long)pidPtr[i]));
         }
         Jim_SetResult(interp, listObj);
         JimDetachPids(interp, numPids, pidPtr);
@@ -5127,36 +3999,30 @@ static int Jim_ExecCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
         return JIM_OK;
     }
 
-    /*
-     * Create the command's pipeline.
-     */
     numPids =
-        Jim_CreatePipeline(interp, argc - 1, argv + 1, &pidPtr, (int *)NULL, &outputId, &errorId);
+        JimCreatePipeline(interp, argc - 1, argv + 1, &pidPtr, NULL, &outputId, &errorId);
+
     if (numPids < 0) {
         return JIM_ERR;
     }
 
-    /*
-     * Read the child's output (if any) and put it into the result.
-     */
     Jim_SetResultString(interp, "", 0);
 
     result = JIM_OK;
-    if (outputId != -1) {
+    if (outputId != JIM_BAD_FD) {
         result = JimAppendStreamToString(interp, outputId, Jim_GetResult(interp));
         if (result < 0) {
             Jim_SetResultErrno(interp, "error reading from output pipe");
         }
-        close(outputId);
     }
 
-    if (Jim_CleanupChildren(interp, numPids, pidPtr, errorId) != JIM_OK) {
+    if (JimCleanupChildren(interp, numPids, pidPtr, errorId) != JIM_OK) {
         result = JIM_ERR;
     }
     return result;
 }
 
-void Jim_ReapDetachedPids(struct WaitInfoTable *table)
+static void JimReapDetachedPids(struct WaitInfoTable *table)
 {
     struct WaitInfo *waitPtr;
     int count;
@@ -5168,8 +4034,8 @@ void Jim_ReapDetachedPids(struct WaitInfoTable *table)
     for (waitPtr = table->info, count = table->used; count > 0; waitPtr++, count--) {
         if (waitPtr->flags & WI_DETACHED) {
             int status;
-            int pid = waitpid(waitPtr->pid, &status, WNOHANG);
-            if (pid > 0) {
+            pidtype pid = JimWaitPid(waitPtr->pid, &status, WNOHANG);
+            if (pid != JIM_BAD_PID) {
                 if (waitPtr != &table->info[table->used - 1]) {
                     *waitPtr = table->info[table->used - 1];
                 }
@@ -5179,24 +4045,17 @@ void Jim_ReapDetachedPids(struct WaitInfoTable *table)
     }
 }
 
-/**
- * Does waitpid() on the given pid, and then removes the
- * entry from the wait table.
- * 
- * Returns the pid if OK and updates *statusPtr with the status,
- * or -1 if the pid was not in the table.
- */
-static int JimWaitPid(struct WaitInfoTable *table, int pid, int *statusPtr)
+static pidtype JimWaitForProcess(struct WaitInfoTable *table, pidtype pid, int *statusPtr)
 {
     int i;
 
-    /* Find it in the table */
+    
     for (i = 0; i < table->used; i++) {
         if (pid == table->info[i].pid) {
-            /* wait for it */
-            waitpid(pid, statusPtr, 0);
+            
+            JimWaitPid(pid, statusPtr, 0);
 
-            /* Remove it from the table */
+            
             if (i != table->used - 1) {
                 table->info[i] = table->info[table->used - 1];
             }
@@ -5205,35 +4064,18 @@ static int JimWaitPid(struct WaitInfoTable *table, int pid, int *statusPtr)
         }
     }
 
-    /* Not found */
-    return -1;
+    
+    return JIM_BAD_PID;
 }
 
-/*
- *----------------------------------------------------------------------
- *
- * JimDetachPids --
- *
- *  This procedure is called to indicate that one or more child
- *  processes have been placed in background and are no longer
- *  cared about.  These children can be cleaned up with JimReapDetachedPids().
- *
- * Results:
- *  None.
- *
- * Side effects:
- *  None.
- *
- *----------------------------------------------------------------------
- */
-
-static void JimDetachPids(Jim_Interp *interp, int numPids, const int *pidPtr)
+
+static void JimDetachPids(Jim_Interp *interp, int numPids, const pidtype *pidPtr)
 {
     int j;
     struct WaitInfoTable *table = Jim_CmdPrivData(interp);
 
     for (j = 0; j < numPids; j++) {
-        /* Find it in the table */
+        
         int i;
         for (i = 0; i < table->used; i++) {
             if (pidPtr[j] == table->info[i].pid) {
@@ -5244,39 +4086,11 @@ static void JimDetachPids(Jim_Interp *interp, int numPids, const int *pidPtr)
     }
 }
 
-/*
- *----------------------------------------------------------------------
- *
- * Jim_CreatePipeline --
- *
- *  Given an argc/argv array, instantiate a pipeline of processes
- *  as described by the argv.
- *
- * Results:
- *  The return value is a count of the number of new processes
- *  created, or -1 if an error occurred while creating the pipeline.
- *  *pidArrayPtr is filled in with the address of a dynamically
- *  allocated array giving the ids of all of the processes.  It
- *  is up to the caller to free this array when it isn't needed
- *  anymore.  If inPipePtr is non-NULL, *inPipePtr is filled in
- *  with the file id for the input pipe for the pipeline (if any):
- *  the caller must eventually close this file.  If outPipePtr
- *  isn't NULL, then *outPipePtr is filled in with the file id
- *  for the output pipe from the pipeline:  the caller must close
- *  this file.  If errFilePtr isn't NULL, then *errFilePtr is filled
- *  with a file id that may be used to read error output after the
- *  pipeline completes.
- *
- * Side effects:
- *  Processes and pipes are created.
- *
- *----------------------------------------------------------------------
- */
 static int
-Jim_CreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int **pidArrayPtr,
-    int *inPipePtr, int *outPipePtr, int *errFilePtr)
+JimCreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv, pidtype **pidArrayPtr,
+    fdtype *inPipePtr, fdtype *outPipePtr, fdtype *errFilePtr)
 {
-    int *pidPtr = NULL;         /* Points to malloc-ed array holding all
+    pidtype *pidPtr = NULL;         /* Points to malloc-ed array holding all
                                  * the pids of child processes. */
     int numPids = 0;            /* Actual number of processes that exist
                                  * at *pidPtr right now. */
@@ -5286,10 +4100,10 @@ Jim_CreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int **pid
                                  * on "inputFile".  NULL means take input
                                  * from stdin/pipe. */
 
-#define FILE_NAME   0           /* input/output: filename */
-#define FILE_APPEND 1           /* output only:  filename, append */
-#define FILE_HANDLE 2           /* input/output: filehandle */
-#define FILE_TEXT   3           /* input only:   input is actual text */
+#define FILE_NAME   0           
+#define FILE_APPEND 1           
+#define FILE_HANDLE 2           
+#define FILE_TEXT   3           
 
     int inputFile = FILE_NAME;  /* 1 means input is name of input file.
                                  * 2 means input is filehandle name.
@@ -5310,51 +4124,36 @@ Jim_CreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int **pid
                                  * or NULL if output goes to stdout/pipe. */
     const char *error = NULL;   /* Holds name of stderr file to pipe to,
                                  * or NULL if stderr goes to stderr/pipe. */
-    int inputId = -1;           /* Readable file id input to current command in
-                                 * pipeline (could be file or pipe).  -1
-                                 * means use stdin. */
-    int outputId = -1;          /* Writable file id for output from current
-                                 * command in pipeline (could be file or pipe).
-                                 * -1 means use stdout. */
-    int errorId = -1;           /* Writable file id for all standard error
-                                 * output from all commands in pipeline.  -1
-                                 * means use stderr. */
-    int lastOutputId = -1;      /* Write file id for output from last command
-                                 * in pipeline (could be file or pipe).
-                                 * -1 means use stdout. */
-    int pipeIds[2];             /* File ids for pipe that's being created. */
+    fdtype inputId = JIM_BAD_FD;
+    fdtype outputId = JIM_BAD_FD;
+    fdtype errorId = JIM_BAD_FD;
+    fdtype lastOutputId = JIM_BAD_FD;
+    fdtype pipeIds[2];           
     int firstArg, lastArg;      /* Indexes of first and last arguments in
                                  * current command. */
     int lastBar;
-    char *execName;
-    int i, pid;
-    char **orig_environ;
+    int i;
+    pidtype pid;
+    char **save_environ;
     struct WaitInfoTable *table = Jim_CmdPrivData(interp);
 
-    /* Holds the args which will be used to exec */
+    
     char **arg_array = Jim_Alloc(sizeof(*arg_array) * (argc + 1));
     int arg_count = 0;
 
-    Jim_ReapDetachedPids(table);
+    JimReapDetachedPids(table);
 
     if (inPipePtr != NULL) {
-        *inPipePtr = -1;
+        *inPipePtr = JIM_BAD_FD;
     }
     if (outPipePtr != NULL) {
-        *outPipePtr = -1;
+        *outPipePtr = JIM_BAD_FD;
     }
     if (errFilePtr != NULL) {
-        *errFilePtr = -1;
+        *errFilePtr = JIM_BAD_FD;
     }
-    pipeIds[0] = pipeIds[1] = -1;
+    pipeIds[0] = pipeIds[1] = JIM_BAD_FD;
 
-    /*
-     * First, scan through all the arguments to figure out the structure
-     * of the pipeline.  Count the number of distinct processes (it's the
-     * number of "|" arguments).  If there are "<", "<<", or ">" arguments
-     * then make note of input and output redirection and remove these
-     * arguments and the arguments that follow them.
-     */
     cmdCount = 1;
     lastBar = -1;
     for (i = 0; i < argc; i++) {
@@ -5387,7 +4186,7 @@ Jim_CreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int **pid
                 output++;
             }
             if (*output == '&') {
-                /* Redirect stderr too */
+                
                 output++;
                 dup_error = 1;
             }
@@ -5428,7 +4227,7 @@ Jim_CreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int **pid
                 lastBar = i;
                 cmdCount++;
             }
-            /* Either |, |& or a "normal" arg, so store it in the arg array */
+            
             arg_array[arg_count++] = (char *)arg;
             continue;
         }
@@ -5446,43 +4245,18 @@ badargs:
         return -1;
     }
 
-    /* Must do this before vfork(), so do it now */
-    orig_environ = Jim_GetEnviron();
-    Jim_SetEnviron(JimBuildEnv(interp));
+    
+    save_environ = JimSaveEnv(JimBuildEnv(interp));
 
-    /*
-     * Set up the redirected input source for the pipeline, if
-     * so requested.
-     */
     if (input != NULL) {
         if (inputFile == FILE_TEXT) {
-            /*
-             * Immediate data in command.  Create temporary file and
-             * put data into file.
-             */
-
-#define TMP_STDIN_NAME "/tmp/tcl.in.XXXXXX"
-            char inName[sizeof(TMP_STDIN_NAME) + 1];
-            int length;
-
-            strcpy(inName, TMP_STDIN_NAME);
-            inputId = mkstemp(inName);
-            if (inputId < 0) {
-                Jim_SetResultErrno(interp, "couldn't create input file for command");
-                goto error;
-            }
-            length = strlen(input);
-            if (write(inputId, input, length) != length) {
-                Jim_SetResultErrno(interp, "couldn't write file input for command");
-                goto error;
-            }
-            if (lseek(inputId, 0L, SEEK_SET) == -1 || unlink(inName) == -1) {
-                Jim_SetResultErrno(interp, "couldn't reset or remove input file for command");
+            inputId = JimCreateTemp(interp, input);
+            if (inputId == JIM_BAD_FD) {
                 goto error;
             }
         }
         else if (inputFile == FILE_HANDLE) {
-            /* Should be a file descriptor */
+            
             Jim_Obj *fhObj = Jim_NewStringObj(interp, input, -1);
             FILE *fh = Jim_AioFilehandle(interp, fhObj);
 
@@ -5490,34 +4264,26 @@ badargs:
             if (fh == NULL) {
                 goto error;
             }
-            inputId = dup(fileno(fh));
+            inputId = JimDupFd(JimFileno(fh));
         }
         else {
-            /*
-             * File redirection.  Just open the file.
-             */
-            inputId = open(input, O_RDONLY, 0);
-            if (inputId < 0) {
-                Jim_SetResultFormatted(interp, "couldn't read file \"%s\": %s", input,
-                    strerror(errno));
+            inputId = JimOpenForRead(input);
+            if (inputId == JIM_BAD_FD) {
+                Jim_SetResultFormatted(interp, "couldn't read file \"%s\": %s", input, JimStrError());
                 goto error;
             }
         }
     }
     else if (inPipePtr != NULL) {
-        if (pipe(pipeIds) != 0) {
+        if (JimPipe(pipeIds) != 0) {
             Jim_SetResultErrno(interp, "couldn't create input pipe for command");
             goto error;
         }
         inputId = pipeIds[0];
         *inPipePtr = pipeIds[1];
-        pipeIds[0] = pipeIds[1] = -1;
+        pipeIds[0] = pipeIds[1] = JIM_BAD_FD;
     }
 
-    /*
-     * Set up the redirected output sink for the pipeline from one
-     * of two places, if requested.
-     */
     if (output != NULL) {
         if (outputFile == FILE_HANDLE) {
             Jim_Obj *fhObj = Jim_NewStringObj(interp, output, -1);
@@ -5528,53 +4294,39 @@ badargs:
                 goto error;
             }
             fflush(fh);
-            lastOutputId = dup(fileno(fh));
+            lastOutputId = JimDupFd(JimFileno(fh));
         }
         else {
-            /*
-             * Output is to go to a file.
-             */
-            int mode = O_WRONLY | O_CREAT | O_TRUNC;
-
-            if (outputFile == FILE_APPEND) {
-                mode = O_WRONLY | O_CREAT | O_APPEND;
-            }
-
-            lastOutputId = open(output, mode, 0666);
-            if (lastOutputId < 0) {
-                Jim_SetResultFormatted(interp, "couldn't write file \"%s\": %s", output,
-                    strerror(errno));
+            lastOutputId = JimOpenForWrite(output, outputFile == FILE_APPEND);
+            if (lastOutputId == JIM_BAD_FD) {
+                Jim_SetResultFormatted(interp, "couldn't write file \"%s\": %s", output, JimStrError());
                 goto error;
             }
         }
     }
     else if (outPipePtr != NULL) {
-        /*
-         * Output is to go to a pipe.
-         */
-        if (pipe(pipeIds) != 0) {
+        if (JimPipe(pipeIds) != 0) {
             Jim_SetResultErrno(interp, "couldn't create output pipe");
             goto error;
         }
         lastOutputId = pipeIds[1];
         *outPipePtr = pipeIds[0];
-        pipeIds[0] = pipeIds[1] = -1;
+        pipeIds[0] = pipeIds[1] = JIM_BAD_FD;
     }
-
-    /* If we are redirecting stderr with 2>filename or 2>@fileId, then we ignore errFilePtr */
+    
     if (error != NULL) {
         if (errorFile == FILE_HANDLE) {
             if (strcmp(error, "1") == 0) {
-                /* Special 2>@1 */
-                if (lastOutputId >= 0) {
-                    errorId = dup(lastOutputId);
+                
+                if (lastOutputId != JIM_BAD_FD) {
+                    errorId = JimDupFd(lastOutputId);
                 }
                 else {
-                    /* No redirection of stdout, so just use 2>@stdout */
+                    
                     error = "stdout";
                 }
             }
-            if (errorId < 0) {
+            if (errorId == JIM_BAD_FD) {
                 Jim_Obj *fhObj = Jim_NewStringObj(interp, error, -1);
                 FILE *fh = Jim_AioFilehandle(interp, fhObj);
 
@@ -5583,70 +4335,33 @@ badargs:
                     goto error;
                 }
                 fflush(fh);
-                errorId = dup(fileno(fh));
+                errorId = JimDupFd(JimFileno(fh));
             }
         }
         else {
-            /*
-             * Output is to go to a file.
-             */
-            int mode = O_WRONLY | O_CREAT | O_TRUNC;
-
-            if (errorFile == FILE_APPEND) {
-                mode = O_WRONLY | O_CREAT | O_APPEND;
-            }
-
-            errorId = open(error, mode, 0666);
-            if (errorId < 0) {
-                Jim_SetResultFormatted(interp, "couldn't write file \"%s\": %s", error,
-                    strerror(errno));
+            errorId = JimOpenForWrite(error, errorFile == FILE_APPEND);
+            if (errorId == JIM_BAD_FD) {
+                Jim_SetResultFormatted(interp, "couldn't write file \"%s\": %s", error, JimStrError());
+                goto error;
             }
         }
     }
     else if (errFilePtr != NULL) {
-        /*
-         * Set up the standard error output sink for the pipeline, if
-         * requested.  Use a temporary file which is opened, then deleted.
-         * Could potentially just use pipe, but if it filled up it could
-         * cause the pipeline to deadlock:  we'd be waiting for processes
-         * to complete before reading stderr, and processes couldn't complete
-         * because stderr was backed up.
-         */
-
-#define TMP_STDERR_NAME "/tmp/tcl.err.XXXXXX"
-        char errName[sizeof(TMP_STDERR_NAME) + 1];
-
-        strcpy(errName, TMP_STDERR_NAME);
-        errorId = mkstemp(errName);
-        if (errorId < 0) {
-          errFileError:
-            Jim_SetResultErrno(interp, "couldn't create error file for command");
-            goto error;
-        }
-        *errFilePtr = open(errName, O_RDONLY, 0);
-        if (*errFilePtr < 0) {
-            goto errFileError;
-        }
-        if (unlink(errName) == -1) {
-            Jim_SetResultErrno(interp, "couldn't remove error file for command");
+        errorId = JimCreateTemp(interp, NULL);
+        if (errorId == JIM_BAD_FD) {
             goto error;
         }
+        *errFilePtr = JimDupFd(errorId);
     }
 
-    /*
-     * Scan through the argc array, forking off a process for each
-     * group of arguments between "|" arguments.
-     */
 
-    pidPtr = (int *)Jim_Alloc(cmdCount * sizeof(*pidPtr));
+    pidPtr = Jim_Alloc(cmdCount * sizeof(*pidPtr));
     for (i = 0; i < numPids; i++) {
-        pidPtr[i] = -1;
+        pidPtr[i] = JIM_BAD_PID;
     }
     for (firstArg = 0; firstArg < arg_count; numPids++, firstArg = lastArg + 1) {
         int pipe_dup_err = 0;
-        int origErrorId = errorId;
-        char execerr[64];
-        int execerrlen;
+        fdtype origErrorId = errorId;
 
         for (lastArg = firstArg; lastArg < arg_count; lastArg++) {
             if (arg_array[lastArg][0] == '|') {
@@ -5656,53 +4371,44 @@ badargs:
                 break;
             }
         }
-        /* Replace | with NULL for execv() */
+        
         arg_array[lastArg] = NULL;
         if (lastArg == arg_count) {
             outputId = lastOutputId;
         }
         else {
-            if (pipe(pipeIds) != 0) {
+            if (JimPipe(pipeIds) != 0) {
                 Jim_SetResultErrno(interp, "couldn't create pipe");
                 goto error;
             }
             outputId = pipeIds[1];
         }
-        execName = arg_array[firstArg];
 
-        /* Now fork the child */
+        
 
-        /*
-         * Disable SIGPIPE signals:  if they were allowed, this process
-         * might go away unexpectedly if children misbehave.  This code
-         * can potentially interfere with other application code that
-         * expects to handle SIGPIPEs;  what's really needed is an
-         * arbiter for signals to allow them to be "shared".
-         */
+#ifdef __MINGW32__
+        pid = JimStartWinProcess(interp, &arg_array[firstArg], save_environ ? save_environ[0] : NULL, inputId, outputId, errorId);
+        if (pid == JIM_BAD_PID) {
+            Jim_SetResultFormatted(interp, "couldn't exec \"%s\"", arg_array[firstArg]);
+            goto error;
+        }
+#else
         if (table->info == NULL) {
             (void)signal(SIGPIPE, SIG_IGN);
         }
 
-        /* Need to do this befor vfork() */
+        
         if (pipe_dup_err) {
             errorId = outputId;
         }
 
-        /* Need to prep an error message before vfork(), just in case */
-        snprintf(execerr, sizeof(execerr), "couldn't exec \"%s\"", execName);
-        execerrlen = strlen(execerr);
-
-        /*
-         * Make a new process and enter it into the table if the fork
-         * is successful.
-         */
         pid = vfork();
         if (pid < 0) {
             Jim_SetResultErrno(interp, "couldn't fork child process");
             goto error;
         }
         if (pid == 0) {
-            /* Child */
+            
 
             if (inputId != -1) dup2(inputId, 0);
             if (outputId != -1) dup2(outputId, 1);
@@ -5712,19 +4418,16 @@ badargs:
                 close(i);
             }
 
-            execvp(execName, &arg_array[firstArg]);
+            execvp(arg_array[firstArg], &arg_array[firstArg]);
 
-            /* we really can ignore the error here! */
-            IGNORE_RC(write(2, execerr, execerrlen));
+            
+            fprintf(stderr, "couldn't exec \"%s\"", arg_array[firstArg]);
             _exit(127);
         }
+#endif
 
-        /* parent */
+        
 
-        /*
-         * Enlarge the wait table if there isn't enough space for a new
-         * entry.
-         */
         if (table->used == table->size) {
             table->size += WAIT_TABLE_GROW_BY;
             table->info = Jim_Realloc(table->info, table->size * sizeof(*table->info));
@@ -5736,74 +4439,61 @@ badargs:
 
         pidPtr[numPids] = pid;
 
-        /* Restore in case of pipe_dup_err */
+        
         errorId = origErrorId;
 
-        /*
-         * Close off our copies of file descriptors that were set up for
-         * this child, then set up the input for the next child.
-         */
 
-        if (inputId != -1) {
-            close(inputId);
+        if (inputId != JIM_BAD_FD) {
+            JimCloseFd(inputId);
         }
-        if (outputId != -1) {
-            close(outputId);
+        if (outputId != JIM_BAD_FD) {
+            JimCloseFd(outputId);
         }
         inputId = pipeIds[0];
-        pipeIds[0] = pipeIds[1] = -1;
+        pipeIds[0] = pipeIds[1] = JIM_BAD_FD;
     }
     *pidArrayPtr = pidPtr;
 
-    /*
-     * All done.  Cleanup open files lying around and then return.
-     */
 
   cleanup:
-    if (inputId != -1) {
-        close(inputId);
+    if (inputId != JIM_BAD_FD) {
+        JimCloseFd(inputId);
     }
-    if (lastOutputId != -1) {
-        close(lastOutputId);
+    if (lastOutputId != JIM_BAD_FD) {
+        JimCloseFd(lastOutputId);
     }
-    if (errorId != -1) {
-        close(errorId);
+    if (errorId != JIM_BAD_FD) {
+        JimCloseFd(errorId);
     }
     Jim_Free(arg_array);
 
-    JimFreeEnv(interp, Jim_GetEnviron(), orig_environ);
-    Jim_SetEnviron(orig_environ);
+    JimRestoreEnv(save_environ);
 
     return numPids;
 
-    /*
-     * An error occurred.  There could have been extra files open, such
-     * as pipes between children.  Clean them all up.  Detach any child
-     * processes that have been created.
-     */
 
   error:
-    if ((inPipePtr != NULL) && (*inPipePtr != -1)) {
-        close(*inPipePtr);
-        *inPipePtr = -1;
+    if ((inPipePtr != NULL) && (*inPipePtr != JIM_BAD_FD)) {
+        JimCloseFd(*inPipePtr);
+        *inPipePtr = JIM_BAD_FD;
     }
-    if ((outPipePtr != NULL) && (*outPipePtr != -1)) {
-        close(*outPipePtr);
-        *outPipePtr = -1;
+    if ((outPipePtr != NULL) && (*outPipePtr != JIM_BAD_FD)) {
+        JimCloseFd(*outPipePtr);
+        *outPipePtr = JIM_BAD_FD;
     }
-    if ((errFilePtr != NULL) && (*errFilePtr != -1)) {
-        close(*errFilePtr);
-        *errFilePtr = -1;
+    if ((errFilePtr != NULL) && (*errFilePtr != JIM_BAD_FD)) {
+        JimCloseFd(*errFilePtr);
+        *errFilePtr = JIM_BAD_FD;
     }
-    if (pipeIds[0] != -1) {
-        close(pipeIds[0]);
+    if (pipeIds[0] != JIM_BAD_FD) {
+        JimCloseFd(pipeIds[0]);
     }
-    if (pipeIds[1] != -1) {
-        close(pipeIds[1]);
+    if (pipeIds[1] != JIM_BAD_FD) {
+        JimCloseFd(pipeIds[1]);
     }
     if (pidPtr != NULL) {
         for (i = 0; i < numPids; i++) {
-            if (pidPtr[i] != -1) {
+            if (pidPtr[i] != JIM_BAD_PID) {
                 JimDetachPids(interp, 1, &pidPtr[i]);
             }
         }
@@ -5813,29 +4503,8 @@ badargs:
     goto cleanup;
 }
 
-/*
- *----------------------------------------------------------------------
- *
- * CleanupChildren --
- *
- *  This is a utility procedure used to wait for child processes
- *  to exit, record information about abnormal exits, and then
- *  collect any stderr output generated by them.
- *
- * Results:
- *  The return value is a standard Tcl result.  If anything at
- *  weird happened with the child processes, JIM_ERROR is returned
- *  and a message is left in interp->result.
- *
- * Side effects:
- *  If the last character of interp->result is a newline, then it
- *  is removed.  File errorId gets closed, and pidPtr is freed
- *  back to the storage allocator.
- *
- *----------------------------------------------------------------------
- */
-
-static int Jim_CleanupChildren(Jim_Interp *interp, int numPids, int *pidPtr, int errorId)
+
+static int JimCleanupChildren(Jim_Interp *interp, int numPids, pidtype *pidPtr, fdtype errorId)
 {
     struct WaitInfoTable *table = Jim_CmdPrivData(interp);
     int result = JIM_OK;
@@ -5843,7 +4512,7 @@ static int Jim_CleanupChildren(Jim_Interp *interp, int numPids, int *pidPtr, int
 
     for (i = 0; i < numPids; i++) {
         int waitStatus = 0;
-        if (JimWaitPid(table, pidPtr[i], &waitStatus) > 0) {
+        if (JimWaitForProcess(table, pidPtr[i], &waitStatus) != JIM_BAD_PID) {
             if (JimCheckWaitStatus(interp, pidPtr[i], waitStatus) != JIM_OK) {
                 result = JIM_ERR;
             }
@@ -5851,17 +4520,11 @@ static int Jim_CleanupChildren(Jim_Interp *interp, int numPids, int *pidPtr, int
     }
     Jim_Free(pidPtr);
 
-    /*
-     * Read the standard error file.  If there's anything there,
-     * then add the file's contents to the result
-     * string.
-     */
-    if (errorId >= 0) {
+    if (errorId != JIM_BAD_FD) {
+        JimRewindFd(errorId);
         if (JimAppendStreamToString(interp, errorId, Jim_GetResult(interp)) != JIM_OK) {
-            Jim_SetResultErrno(interp, "error reading from stderr output file");
             result = JIM_ERR;
         }
-        close(errorId);
     }
 
     JimTrimTrailingNewline(interp);
@@ -5873,78 +4536,464 @@ int Jim_execInit(Jim_Interp *interp)
 {
     if (Jim_PackageProvide(interp, "exec", "1.0", JIM_ERRMSG))
         return JIM_ERR;
-
     Jim_CreateCommand(interp, "exec", Jim_ExecCmd, JimAllocWaitInfoTable(), JimFreeWaitInfoTable);
     return JIM_OK;
 }
-#else
-/* e.g. Windows. Poor mans implementation of exec with system()
- *      The system() call *may* do command line redirection, etc.
- *      The standard output is not available.
- *      Can't redirect filehandles.
- */
-static int Jim_ExecCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+
+#if defined(__MINGW32__)
+
+
+static SECURITY_ATTRIBUTES *JimStdSecAttrs(void)
+{
+    static SECURITY_ATTRIBUTES secAtts;
+
+    secAtts.nLength = sizeof(SECURITY_ATTRIBUTES);
+    secAtts.lpSecurityDescriptor = NULL;
+    secAtts.bInheritHandle = TRUE;
+    return &secAtts;
+}
+
+static int JimErrno(void)
+{
+    switch (GetLastError()) {
+    case ERROR_FILE_NOT_FOUND: return ENOENT;
+    case ERROR_PATH_NOT_FOUND: return ENOENT;
+    case ERROR_TOO_MANY_OPEN_FILES: return EMFILE;
+    case ERROR_ACCESS_DENIED: return EACCES;
+    case ERROR_INVALID_HANDLE: return EBADF;
+    case ERROR_BAD_ENVIRONMENT: return E2BIG;
+    case ERROR_BAD_FORMAT: return ENOEXEC;
+    case ERROR_INVALID_ACCESS: return EACCES;
+    case ERROR_INVALID_DRIVE: return ENOENT;
+    case ERROR_CURRENT_DIRECTORY: return EACCES;
+    case ERROR_NOT_SAME_DEVICE: return EXDEV;
+    case ERROR_NO_MORE_FILES: return ENOENT;
+    case ERROR_WRITE_PROTECT: return EROFS;
+    case ERROR_BAD_UNIT: return ENXIO;
+    case ERROR_NOT_READY: return EBUSY;
+    case ERROR_BAD_COMMAND: return EIO;
+    case ERROR_CRC: return EIO;
+    case ERROR_BAD_LENGTH: return EIO;
+    case ERROR_SEEK: return EIO;
+    case ERROR_WRITE_FAULT: return EIO;
+    case ERROR_READ_FAULT: return EIO;
+    case ERROR_GEN_FAILURE: return EIO;
+    case ERROR_SHARING_VIOLATION: return EACCES;
+    case ERROR_LOCK_VIOLATION: return EACCES;
+    case ERROR_SHARING_BUFFER_EXCEEDED: return ENFILE;
+    case ERROR_HANDLE_DISK_FULL: return ENOSPC;
+    case ERROR_NOT_SUPPORTED: return ENODEV;
+    case ERROR_REM_NOT_LIST: return EBUSY;
+    case ERROR_DUP_NAME: return EEXIST;
+    case ERROR_BAD_NETPATH: return ENOENT;
+    case ERROR_NETWORK_BUSY: return EBUSY;
+    case ERROR_DEV_NOT_EXIST: return ENODEV;
+    case ERROR_TOO_MANY_CMDS: return EAGAIN;
+    case ERROR_ADAP_HDW_ERR: return EIO;
+    case ERROR_BAD_NET_RESP: return EIO;
+    case ERROR_UNEXP_NET_ERR: return EIO;
+    case ERROR_NETNAME_DELETED: return ENOENT;
+    case ERROR_NETWORK_ACCESS_DENIED: return EACCES;
+    case ERROR_BAD_DEV_TYPE: return ENODEV;
+    case ERROR_BAD_NET_NAME: return ENOENT;
+    case ERROR_TOO_MANY_NAMES: return ENFILE;
+    case ERROR_TOO_MANY_SESS: return EIO;
+    case ERROR_SHARING_PAUSED: return EAGAIN;
+    case ERROR_REDIR_PAUSED: return EAGAIN;
+    case ERROR_FILE_EXISTS: return EEXIST;
+    case ERROR_CANNOT_MAKE: return ENOSPC;
+    case ERROR_OUT_OF_STRUCTURES: return ENFILE;
+    case ERROR_ALREADY_ASSIGNED: return EEXIST;
+    case ERROR_INVALID_PASSWORD: return EPERM;
+    case ERROR_NET_WRITE_FAULT: return EIO;
+    case ERROR_NO_PROC_SLOTS: return EAGAIN;
+    case ERROR_DISK_CHANGE: return EXDEV;
+    case ERROR_BROKEN_PIPE: return EPIPE;
+    case ERROR_OPEN_FAILED: return ENOENT;
+    case ERROR_DISK_FULL: return ENOSPC;
+    case ERROR_NO_MORE_SEARCH_HANDLES: return EMFILE;
+    case ERROR_INVALID_TARGET_HANDLE: return EBADF;
+    case ERROR_INVALID_NAME: return ENOENT;
+    case ERROR_PROC_NOT_FOUND: return ESRCH;
+    case ERROR_WAIT_NO_CHILDREN: return ECHILD;
+    case ERROR_CHILD_NOT_COMPLETE: return ECHILD;
+    case ERROR_DIRECT_ACCESS_HANDLE: return EBADF;
+    case ERROR_SEEK_ON_DEVICE: return ESPIPE;
+    case ERROR_BUSY_DRIVE: return EAGAIN;
+    case ERROR_DIR_NOT_EMPTY: return EEXIST;
+    case ERROR_NOT_LOCKED: return EACCES;
+    case ERROR_BAD_PATHNAME: return ENOENT;
+    case ERROR_LOCK_FAILED: return EACCES;
+    case ERROR_ALREADY_EXISTS: return EEXIST;
+    case ERROR_FILENAME_EXCED_RANGE: return ENAMETOOLONG;
+    case ERROR_BAD_PIPE: return EPIPE;
+    case ERROR_PIPE_BUSY: return EAGAIN;
+    case ERROR_PIPE_NOT_CONNECTED: return EPIPE;
+    case ERROR_DIRECTORY: return ENOTDIR;
+    }
+    return EINVAL;
+}
+
+static int JimPipe(fdtype pipefd[2])
+{
+    if (CreatePipe(&pipefd[0], &pipefd[1], NULL, 0)) {
+        return 0;
+    }
+    return -1;
+}
+
+static fdtype JimDupFd(fdtype infd)
 {
-    Jim_Obj *cmdlineObj = Jim_NewEmptyStringObj(interp);
-    int i, j;
-    int rc;
+    fdtype dupfd;
+    pidtype pid = GetCurrentProcess();
 
-    /* Create a quoted command line */
-    for (i = 1; i < argc; i++) {
-        int len;
-        const char *arg = Jim_GetString(argv[i], &len);
+    if (DuplicateHandle(pid, infd, pid, &dupfd, 0, TRUE, DUPLICATE_SAME_ACCESS)) {
+        return dupfd;
+    }
+    return JIM_BAD_FD;
+}
 
-        if (i > 1) {
-            Jim_AppendString(interp, cmdlineObj, " ", 1);
+static int JimRewindFd(fdtype fd)
+{
+    return SetFilePointer(fd, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER ? -1 : 0;
+}
+
+#if 0
+static int JimReadFd(fdtype fd, char *buffer, size_t len)
+{
+    DWORD num;
+
+    if (ReadFile(fd, buffer, len, &num, NULL)) {
+        return num;
+    }
+    if (GetLastError() == ERROR_HANDLE_EOF || GetLastError() == ERROR_BROKEN_PIPE) {
+        return 0;
+    }
+    return -1;
+}
+#endif
+
+static FILE *JimFdOpenForRead(fdtype fd)
+{
+    return _fdopen(_open_osfhandle((int)fd, _O_RDONLY | _O_TEXT), "r");
+}
+
+static fdtype JimFileno(FILE *fh)
+{
+    return (fdtype)_get_osfhandle(_fileno(fh));
+}
+
+static fdtype JimOpenForRead(const char *filename)
+{
+    return CreateFile(filename, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
+        JimStdSecAttrs(), OPEN_EXISTING, 0, NULL);
+}
+
+static fdtype JimOpenForWrite(const char *filename, int append)
+{
+    return CreateFile(filename, append ? FILE_APPEND_DATA : GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
+        JimStdSecAttrs(), append ? OPEN_ALWAYS : CREATE_ALWAYS, 0, (HANDLE) NULL);
+}
+
+static FILE *JimFdOpenForWrite(fdtype fd)
+{
+    return _fdopen(_open_osfhandle((int)fd, _O_TEXT), "w");
+}
+
+static pidtype JimWaitPid(pidtype pid, int *status, int nohang)
+{
+    DWORD ret = WaitForSingleObject(pid, nohang ? 0 : INFINITE);
+    if (ret == WAIT_TIMEOUT || ret == WAIT_FAILED) {
+        
+        return JIM_BAD_PID;
+    }
+    GetExitCodeProcess(pid, &ret);
+    *status = ret;
+    CloseHandle(pid);
+    return pid;
+}
+
+static HANDLE JimCreateTemp(Jim_Interp *interp, const char *contents)
+{
+    char name[MAX_PATH];
+    HANDLE handle;
+
+    if (!GetTempPath(MAX_PATH, name) || !GetTempFileName(name, "JIM", 0, name)) {
+        return JIM_BAD_FD;
+    }
+
+    handle = CreateFile(name, GENERIC_READ | GENERIC_WRITE, 0, JimStdSecAttrs(),
+            CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
+            NULL);
+
+    if (handle == INVALID_HANDLE_VALUE) {
+        goto error;
+    }
+
+    if (contents != NULL) {
+        
+        FILE *fh = JimFdOpenForWrite(JimDupFd(handle));
+        if (fh == NULL) {
+            goto error;
         }
-        if (strpbrk(arg, "\\\" ") == NULL) {
-            /* No quoting required */
-            Jim_AppendString(interp, cmdlineObj, arg, len);
+
+        if (fwrite(contents, strlen(contents), 1, fh) != 1) {
+            fclose(fh);
+            goto error;
+        }
+        fseek(fh, 0, SEEK_SET);
+        fclose(fh);
+    }
+    return handle;
+
+  error:
+    Jim_SetResultErrno(interp, "failed to create temp file");
+    CloseHandle(handle);
+    DeleteFile(name);
+    return JIM_BAD_FD;
+}
+
+static int
+JimWinFindExecutable(const char *originalName, char fullPath[MAX_PATH])
+{
+    int i;
+    static char extensions[][5] = {".exe", "", ".bat"};
+
+    for (i = 0; i < (int) (sizeof(extensions) / sizeof(extensions[0])); i++) {
+        lstrcpyn(fullPath, originalName, MAX_PATH - 5);
+        lstrcat(fullPath, extensions[i]);
+
+        if (SearchPath(NULL, fullPath, NULL, MAX_PATH, fullPath, NULL) == 0) {
             continue;
         }
+        if (GetFileAttributes(fullPath) & FILE_ATTRIBUTE_DIRECTORY) {
+            continue;
+        }
+        return 0;
+    }
 
-        Jim_AppendString(interp, cmdlineObj, "\"", 1);
-        for (j = 0; j < len; j++) {
-            if (arg[j] == '\\' || arg[j] == '"') {
-                Jim_AppendString(interp, cmdlineObj, "\\", 1);
+    return -1;
+}
+
+static char **JimSaveEnv(char **env)
+{
+    return env;
+}
+
+static void JimRestoreEnv(char **env)
+{
+    JimFreeEnv(env, NULL);
+}
+
+static Jim_Obj *
+JimWinBuildCommandLine(Jim_Interp *interp, char **argv)
+{
+    char *start, *special;
+    int quote, i;
+
+    Jim_Obj *strObj = Jim_NewStringObj(interp, "", 0);
+
+    for (i = 0; argv[i]; i++) {
+        if (i > 0) {
+            Jim_AppendString(interp, strObj, " ", 1);
+        }
+
+        if (argv[i][0] == '\0') {
+            quote = 1;
+        }
+        else {
+            quote = 0;
+            for (start = argv[i]; *start != '\0'; start++) {
+                if (isspace(UCHAR(*start))) {
+                    quote = 1;
+                    break;
+                }
             }
-            Jim_AppendString(interp, cmdlineObj, &arg[j], 1);
         }
-        Jim_AppendString(interp, cmdlineObj, "\"", 1);
+        if (quote) {
+            Jim_AppendString(interp, strObj, "\"" , 1);
+        }
+
+        start = argv[i];
+        for (special = argv[i]; ; ) {
+            if ((*special == '\\') && (special[1] == '\\' ||
+                    special[1] == '"' || (quote && special[1] == '\0'))) {
+                Jim_AppendString(interp, strObj, start, special - start);
+                start = special;
+                while (1) {
+                    special++;
+                    if (*special == '"' || (quote && *special == '\0')) {
+
+                        Jim_AppendString(interp, strObj, start, special - start);
+                        break;
+                    }
+                    if (*special != '\\') {
+                        break;
+                    }
+                }
+                Jim_AppendString(interp, strObj, start, special - start);
+                start = special;
+            }
+            if (*special == '"') {
+        if (special == start) {
+            Jim_AppendString(interp, strObj, "\"", 1);
+        }
+        else {
+            Jim_AppendString(interp, strObj, start, special - start);
+        }
+                Jim_AppendString(interp, strObj, "\\\"", 2);
+                start = special + 1;
+            }
+            if (*special == '\0') {
+                break;
+            }
+            special++;
+        }
+        Jim_AppendString(interp, strObj, start, special - start);
+        if (quote) {
+            Jim_AppendString(interp, strObj, "\"", 1);
+        }
     }
-    rc = system(Jim_String(cmdlineObj));
+    return strObj;
+}
 
-    Jim_FreeNewObj(interp, cmdlineObj);
+static pidtype
+JimStartWinProcess(Jim_Interp *interp, char **argv, char *env, fdtype inputId, fdtype outputId, fdtype errorId)
+{
+    STARTUPINFO startInfo;
+    PROCESS_INFORMATION procInfo;
+    HANDLE hProcess, h;
+    char execPath[MAX_PATH];
+    char *originalName;
+    pidtype pid = JIM_BAD_PID;
+    Jim_Obj *cmdLineObj;
 
-    if (rc) {
-        Jim_Obj *errorCode = Jim_NewListObj(interp, NULL, 0);
-        Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, "CHILDSTATUS", -1));
-        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, 0));
-        Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, rc));
-        Jim_SetGlobalVariableStr(interp, "errorCode", errorCode);
-        return JIM_ERR;
+    if (JimWinFindExecutable(argv[0], execPath) < 0) {
+        return JIM_BAD_PID;
     }
+    originalName = argv[0];
+    argv[0] = execPath;
 
-    return JIM_OK;
+    hProcess = GetCurrentProcess();
+    cmdLineObj = JimWinBuildCommandLine(interp, argv);
+
+
+    ZeroMemory(&startInfo, sizeof(startInfo));
+    startInfo.cb = sizeof(startInfo);
+    startInfo.dwFlags   = STARTF_USESTDHANDLES;
+    startInfo.hStdInput	= INVALID_HANDLE_VALUE;
+    startInfo.hStdOutput= INVALID_HANDLE_VALUE;
+    startInfo.hStdError = INVALID_HANDLE_VALUE;
+
+    if (inputId == JIM_BAD_FD) {
+        if (CreatePipe(&startInfo.hStdInput, &h, JimStdSecAttrs(), 0) != FALSE) {
+            CloseHandle(h);
+        }
+    } else {
+        DuplicateHandle(hProcess, inputId, hProcess, &startInfo.hStdInput,
+                0, TRUE, DUPLICATE_SAME_ACCESS);
+    }
+    if (startInfo.hStdInput == JIM_BAD_FD) {
+        goto end;
+    }
+
+    if (outputId == JIM_BAD_FD) {
+        startInfo.hStdOutput = CreateFile("NUL:", GENERIC_WRITE, 0,
+                JimStdSecAttrs(), OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+    } else {
+        DuplicateHandle(hProcess, outputId, hProcess, &startInfo.hStdOutput,
+                0, TRUE, DUPLICATE_SAME_ACCESS);
+    }
+    if (startInfo.hStdOutput == JIM_BAD_FD) {
+        goto end;
+    }
+
+    if (errorId == JIM_BAD_FD) {
+
+        startInfo.hStdError = CreateFile("NUL:", GENERIC_WRITE, 0,
+                JimStdSecAttrs(), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    } else {
+        DuplicateHandle(hProcess, errorId, hProcess, &startInfo.hStdError,
+                0, TRUE, DUPLICATE_SAME_ACCESS);
+    }
+    if (startInfo.hStdError == JIM_BAD_FD) {
+        goto end;
+    }
+
+    if (!CreateProcess(NULL, (char *)Jim_String(cmdLineObj), NULL, NULL, TRUE,
+            0, env, NULL, &startInfo, &procInfo)) {
+        goto end;
+    }
+
+
+    WaitForInputIdle(procInfo.hProcess, 5000);
+    CloseHandle(procInfo.hThread);
+
+    pid = procInfo.hProcess;
+
+    end:
+    Jim_FreeNewObj(interp, cmdLineObj);
+    if (startInfo.hStdInput != JIM_BAD_FD) {
+        CloseHandle(startInfo.hStdInput);
+    }
+    if (startInfo.hStdOutput != JIM_BAD_FD) {
+        CloseHandle(startInfo.hStdOutput);
+    }
+    if (startInfo.hStdError != JIM_BAD_FD) {
+        CloseHandle(startInfo.hStdError);
+    }
+    return pid;
 }
+#else
 
-int Jim_execInit(Jim_Interp *interp)
+static int JimOpenForWrite(const char *filename, int append)
 {
-    if (Jim_PackageProvide(interp, "exec", "1.0", JIM_ERRMSG))
-        return JIM_ERR;
+    return open(filename, O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC), 0666);
+}
 
-    Jim_CreateCommand(interp, "exec", Jim_ExecCmd, NULL, NULL);
-    return JIM_OK;
+static int JimRewindFd(int fd)
+{
+    return lseek(fd, 0L, SEEK_SET);
+}
+
+static int JimCreateTemp(Jim_Interp *interp, const char *contents)
+{
+    char inName[] = "/tmp/tcl.tmp.XXXXXX";
+
+    int fd = mkstemp(inName);
+    if (fd == JIM_BAD_FD) {
+        Jim_SetResultErrno(interp, "couldn't create temp file");
+        return -1;
+    }
+    if (contents) {
+        int length = strlen(contents);
+        if (unlink(inName) == -1 || write(fd, contents, length) != length) {
+            Jim_SetResultErrno(interp, "couldn't write temp file");
+            close(fd);
+            return -1;
+        }
+        lseek(fd, 0L, SEEK_SET);
+    }
+    return fd;
+}
+
+static char **JimSaveEnv(char **env)
+{
+    char **saveenv = Jim_GetEnviron();
+    Jim_SetEnviron(env);
+    return saveenv;
+}
+
+static void JimRestoreEnv(char **env)
+{
+    JimFreeEnv(Jim_GetEnviron(), env);
+    Jim_SetEnviron(env);
 }
 #endif
+#endif
+
 
-/*
- * tcl_clock.c
- *
- * Implements the clock command
- */
 
-/* For strptime() */
 #ifndef _XOPEN_SOURCE
 #define _XOPEN_SOURCE 500
 #endif
@@ -5958,7 +5007,7 @@ int Jim_execInit(Jim_Interp *interp)
 
 static int clock_cmd_format(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-    /* How big is big enough? */
+    
     char buf[100];
     time_t t;
     long seconds;
@@ -5996,7 +5045,7 @@ static int clock_cmd_scan(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
         return -1;
     }
 
-    /* Initialise with the current date/time */
+    
     localtime_r(&now, &tm);
 
     pt = strptime(Jim_String(argv[0]), Jim_String(argv[2]), &tm);
@@ -6005,7 +5054,7 @@ static int clock_cmd_scan(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
         return JIM_ERR;
     }
 
-    /* Now convert into a time_t */
+    
     Jim_SetResultInt(interp, mktime(&tm));
 
     return JIM_OK;
@@ -6094,50 +5143,6 @@ int Jim_clockInit(Jim_Interp *interp)
     return JIM_OK;
 }
 
-/* 
- * Implements the array command for jim
- *
- * (c) 2008 Steve Bennett <steveb@workware.net.au>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- * The views and conclusions contained in the software and documentation
- * are those of the authors and should not be interpreted as representing
- * official policies, either expressed or implied, of the Jim Tcl Project.
- *
- * Based on code originally from Tcl 6.7:
- *
- * Copyright 1987-1991 Regents of the University of California
- * Permission to use, copy, modify, and distribute this
- * software and its documentation for any purpose and without
- * fee is hereby granted, provided that the above copyright
- * notice appear in all copies.  The University of California
- * makes no representations about the suitability of this
- * software for any purpose.  It is provided "as is" without
- * express or implied warranty.
- */
 
 #include <limits.h>
 #include <stdlib.h>
@@ -6149,7 +5154,7 @@ int Jim_clockInit(Jim_Interp *interp)
 
 static int array_cmd_exists(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-    /* Just a regular [info exists] */
+    
     Jim_SetResultInt(interp, Jim_GetVariable(interp, argv[0], 0) != 0);
     return JIM_OK;
 }
@@ -6172,7 +5177,7 @@ static int array_cmd_get(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
         all = 1;
     }
 
-    /* If it is a dictionary or list with an even number of elements, nothing else to do */
+    
     if (all) {
         if (Jim_IsDict(objPtr) || (Jim_IsList(objPtr) && Jim_ListLength(interp, objPtr) % 2 == 0)) {
             Jim_SetResult(interp, objPtr);
@@ -6189,11 +5194,11 @@ static int array_cmd_get(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     }
 
     if (all) {
-        /* Return the whole array */
+        
         Jim_SetResult(interp, dictObj);
     }
     else {
-        /* Only return the matching values */
+        
         resultObj = Jim_NewListObj(interp, NULL, 0);
 
         for (i = 0; i < len; i += 2) {
@@ -6231,7 +5236,7 @@ static int array_cmd_unset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     Jim_Obj **dictValuesObj;
 
     if (argc == 1 || Jim_CompareStringImmediate(interp, argv[1], "*")) {
-        /* Unset the whole array */
+        
         Jim_UnsetVariable(interp, argv[0], JIM_NONE);
         return JIM_OK;
     }
@@ -6246,7 +5251,7 @@ static int array_cmd_unset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
         return JIM_ERR;
     }
 
-    /* Create a new object with the values which don't match */
+    
     resultObj = Jim_NewDictObj(interp, NULL, 0);
 
     for (i = 0; i < len; i += 2) {
@@ -6265,7 +5270,7 @@ static int array_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     Jim_Obj *objPtr;
     int len = 0;
 
-    /* Not found means zero length */
+    
     objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
     if (objPtr) {
         len = Jim_DictSize(interp, objPtr);
@@ -6287,7 +5292,7 @@ static int array_cmd_set(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     Jim_Obj *listObj = argv[1];
 
     if (Jim_GetVariable(interp, argv[0], JIM_NONE) == NULL) {
-        /* Doesn't exist, so just set the list directly */
+        
         return Jim_SetVariable(interp, argv[0], listObj);
     }
 
@@ -6303,7 +5308,7 @@ static int array_cmd_set(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
         Jim_ListIndex(interp, listObj, i, &nameObj, JIM_NONE);
         Jim_ListIndex(interp, listObj, i + 1, &valueObj, JIM_NONE);
 
-        rc = Jim_SetDictKeysVector(interp, argv[0], &nameObj, 1, valueObj);
+        rc = Jim_SetDictKeysVector(interp, argv[0], &nameObj, 1, valueObj, JIM_ERRMSG);
     }
 
     return rc;
@@ -6391,49 +5396,7 @@ Jim_tclcompatInit(interp);
 return JIM_OK;
 }
 
-/* Jim - A small embeddable Tcl interpreter
- *
- * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
- * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>
- * Copyright 2005 patthoyts - Pat Thoyts <patthoyts@users.sf.net>
- * Copyright 2008,2009 oharboe - Øyvind Harboe - oyvind.harboe@zylin.com
- * Copyright 2008 Andrew Lunn <andrew@lunn.ch>
- * Copyright 2008 Duane Ellis <openocd@duaneellis.com>
- * Copyright 2008 Uwe Klein <uklein@klein-messgeraete.de>
- * Copyright 2008 Steve Bennett <steveb@workware.net.au>
- * Copyright 2009 Nico Coesel <ncoesel@dealogic.nl>
- * Copyright 2009 Zachary T Welch zw@superlucidity.net
- * Copyright 2009 David Brownell
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * The views and conclusions contained in the software and documentation
- * are those of the authors and should not be interpreted as representing
- * official policies, either expressed or implied, of the Jim Tcl Project.
- **/
-#define JIM_OPTIMIZATION        /* comment to avoid optimizations and reduce size */
+#define JIM_OPTIMIZATION        
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -6458,13 +5421,13 @@ return JIM_OK;
 #include <crt_externs.h>
 #endif
 
-/* For INFINITY, even if math functions are not enabled */
+
 #include <math.h>
 
-/* We may decide to switch to using $[...] after all, so leave it as an option */
-/*#define EXPRSUGAR_BRACKET*/
 
-/* For the no-autoconf case */
+
+
+
 #ifndef TCL_LIBRARY
 #define TCL_LIBRARY "."
 #endif
@@ -6478,12 +5441,12 @@ return JIM_OK;
 #define TCL_PLATFORM_PATH_SEPARATOR ":"
 #endif
 
-/*#define DEBUG_SHOW_SCRIPT*/
-/*#define DEBUG_SHOW_SCRIPT_TOKENS*/
-/*#define DEBUG_SHOW_SUBST*/
-/*#define DEBUG_SHOW_EXPR*/
-/*#define DEBUG_SHOW_EXPR_TOKENS*/
-/*#define JIM_DEBUG_GC*/
+
+
+
+
+
+
 #ifdef JIM_MAINTAINER
 #define JIM_DEBUG_COMMAND
 #define JIM_DEBUG_PANIC
@@ -6492,23 +5455,15 @@ return JIM_OK;
 const char *jim_tt_name(int type);
 
 #ifdef JIM_DEBUG_PANIC
-static void JimPanicDump(int panic_condition, Jim_Interp *interp, const char *fmt, ...);
+static void JimPanicDump(int panic_condition, const char *fmt, ...);
 #define JimPanic(X) JimPanicDump X
 #else
 #define JimPanic(X)
 #endif
 
-/* -----------------------------------------------------------------------------
- * Global variables
- * ---------------------------------------------------------------------------*/
 
-/* A shared empty string for the objects string representation.
- * Jim_InvalidateStringRep knows about it and doesn't try to free it. */
 static char JimEmptyStringRep[] = "";
 
-/* -----------------------------------------------------------------------------
- * Required prototypes of not exported functions
- * ---------------------------------------------------------------------------*/
 static void JimChangeCallFrameId(Jim_Interp *interp, Jim_CallFrame *cf);
 static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int flags);
 static int ListSetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int listindex, Jim_Obj *newObjPtr,
@@ -6518,10 +5473,10 @@ static void SetDictSubstFromAny(Jim_Interp *interp, Jim_Obj *objPtr);
 static void JimSetFailedEnumResult(Jim_Interp *interp, const char *arg, const char *badtype,
     const char *prefix, const char *const *tablePtr, const char *name);
 static void JimDeleteLocalProcs(Jim_Interp *interp);
-static int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, const char *filename, int linenr,
+static int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, Jim_Obj *fileNameObj, int linenr,
     int argc, Jim_Obj *const *argv);
 static int JimEvalObjVector(Jim_Interp *interp, int objc, Jim_Obj *const *objv,
-    const char *filename, int linenr);
+    Jim_Obj *fileNameObj, int linenr);
 static int JimGetWideNoErr(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide * widePtr);
 static int JimSign(jim_wide w);
 static int JimValidName(Jim_Interp *interp, const char *type, Jim_Obj *nameObjPtr);
@@ -6531,10 +5486,10 @@ static void JimRandomBytes(Jim_Interp *interp, void *dest, unsigned int len);
 
 static const Jim_HashTableType JimVariablesHashTableType;
 
-/* Fast access to the int (wide) value of an object which is known to be of int type */
+
 #define JimWideValue(objPtr) (objPtr)->internalRep.wideValue
 
-#define JimObjTypeName(O) (objPtr->typePtr ? objPtr->typePtr->name : "none")
+#define JimObjTypeName(O) ((O)->typePtr ? (O)->typePtr->name : "none")
 
 static int utf8_tounicode_case(const char *s, int *uc, int upper)
 {
@@ -6545,26 +5500,10 @@ static int utf8_tounicode_case(const char *s, int *uc, int upper)
     return l;
 }
 
-/* These can be used in addition to JIM_CASESENS/JIM_NOCASE */
+
 #define JIM_CHARSET_SCAN 2
 #define JIM_CHARSET_GLOB 0
 
-/**
- * pattern points to a string like "[^a-z\ub5]"
- *
- * The pattern may contain trailing chars, which are ignored.
- *
- * The pattern is matched against unicode char 'c'.
- *
- * If (flags & JIM_NOCASE), case is ignored when matching.
- * If (flags & JIM_CHARSET_SCAN), the considers ^ and ] special at the start
- * of the charset, per scan, rather than glob/string match.
- *
- * If the unicode char 'c' matches that set, returns a pointer to the ']' character,
- * or the null character if the ']' is missing.
- *
- * Returns NULL on no match.
- */
 static const char *JimCharsetMatch(const char *pattern, int c, int flags)
 {
     int not = 0;
@@ -6583,30 +5522,30 @@ static const char *JimCharsetMatch(const char *pattern, int c, int flags)
             pattern++;
         }
 
-        /* Special case. If the first char is ']', it is part of the set */
+        
         if (*pattern == ']') {
             goto first;
         }
     }
 
     while (*pattern && *pattern != ']') {
-        /* Exact match */
+        
         if (pattern[0] == '\\') {
 first:
             pattern += utf8_tounicode_case(pattern, &pchar, nocase);
         }
         else {
-            /* Is this a range? a-z */
+            
             int start;
             int end;
 
             pattern += utf8_tounicode_case(pattern, &start, nocase);
             if (pattern[0] == '-' && pattern[1]) {
-                /* skip '-' */
+                
                 pattern += utf8_tounicode(pattern, &pchar);
                 pattern += utf8_tounicode_case(pattern, &end, nocase);
 
-                /* Handle reversed range too */
+                
                 if ((c >= start && c <= end) || (c >= end && c <= start)) {
                     match = 1;
                 }
@@ -6626,11 +5565,8 @@ first:
     return match ? pattern : NULL;
 }
 
-/* Glob-style pattern matching. */
 
-/* Note: string *must* be valid UTF-8 sequences
- *       slen is a char length, not byte counts.
- */
+
 static int GlobMatch(const char *pattern, const char *string, int nocase)
 {
     int c;
@@ -6643,15 +5579,15 @@ static int GlobMatch(const char *pattern, const char *string, int nocase)
                 }
                 pattern++;
                 if (!pattern[0]) {
-                    return 1;   /* match */
+                    return 1;   
                 }
                 while (*string) {
-                    /* Recursive call - Does the remaining pattern match anywhere? */
+                    
                     if (GlobMatch(pattern, string, nocase))
-                        return 1;       /* match */
+                        return 1;       
                     string += utf8_tounicode(string, &c);
                 }
-                return 0;       /* no match */
+                return 0;       
 
             case '?':
                 string += utf8_tounicode(string, &c);
@@ -6664,7 +5600,7 @@ static int GlobMatch(const char *pattern, const char *string, int nocase)
                         return 0;
                     }
                     if (!*pattern) {
-                        /* Ran out of pattern (no ']') */
+                        
                         continue;
                     }
                     break;
@@ -6673,7 +5609,7 @@ static int GlobMatch(const char *pattern, const char *string, int nocase)
                 if (pattern[1]) {
                     pattern++;
                 }
-                /* fall through */
+                
             default:
                 string += utf8_tounicode_case(string, &c, nocase);
                 utf8_tounicode_case(pattern, &pchar, nocase);
@@ -6701,11 +5637,6 @@ static int JimStringMatch(Jim_Interp *interp, Jim_Obj *patternObj, const char *s
     return GlobMatch(Jim_String(patternObj), string, nocase);
 }
 
-/**
- * string comparison works on binary data.
- *
- * Note that the lengths are byte lengths, not char lengths.
- */
 static int JimStringCompare(const char *s1, int l1, const char *s2, int l2)
 {
     if (l1 < l2) {
@@ -6719,12 +5650,6 @@ static int JimStringCompare(const char *s1, int l1, const char *s2, int l2)
     }
 }
 
-/**
- * No-case version.
- *
- * If maxchars is -1, compares to end of string.
- * Otherwise compares at most 'maxchars' characters.
- */
 static int JimStringCompareNoCase(const char *s1, const char *s2, int maxchars)
 {
     while (*s1 && *s2 && maxchars) {
@@ -6739,7 +5664,7 @@ static int JimStringCompareNoCase(const char *s1, const char *s2, int maxchars)
     if (!maxchars) {
         return 0;
     }
-    /* One string or both terminated */
+    
     if (*s1) {
         return 1;
     }
@@ -6749,9 +5674,6 @@ static int JimStringCompareNoCase(const char *s1, const char *s2, int maxchars)
     return 0;
 }
 
-/* Search 's1' inside 's2', starting to search from char 'index' of 's2'.
- * The index of the first occurrence of s1 in s2 is returned.
- * If s1 is not found inside s2, -1 is returned. */
 static int JimStringFirst(const char *s1, int l1, const char *s2, int l2, int idx)
 {
     int i;
@@ -6776,9 +5698,6 @@ static int JimStringFirst(const char *s1, int l1, const char *s2, int l2, int id
     return -1;
 }
 
-/**
- * Note: Lengths and return value are in bytes, not chars.
- */
 static int JimStringLast(const char *s1, int l1, const char *s2, int l2)
 {
     const char *p;
@@ -6786,7 +5705,7 @@ static int JimStringLast(const char *s1, int l1, const char *s2, int l2)
     if (!l1 || !l2 || l1 > l2)
         return -1;
 
-    /* Now search for the needle */
+    
     for (p = s2 + l2 - 1; p != s2 - 1; p--) {
         if (*p == *s1 && memcmp(s1, p, l1) == 0) {
             return p - s2;
@@ -6796,9 +5715,6 @@ static int JimStringLast(const char *s1, int l1, const char *s2, int l2)
 }
 
 #ifdef JIM_UTF8
-/**
- * Note: Lengths and return value are in chars.
- */
 static int JimStringLastUtf8(const char *s1, int l1, const char *s2, int l2)
 {
     int n = JimStringLast(s1, utf8_index(s1, l1), s2, utf8_index(s2, l2));
@@ -6816,13 +5732,6 @@ int Jim_WideToString(char *buf, jim_wide wideValue)
     return sprintf(buf, fmt, wideValue);
 }
 
-/**
- * After an strtol()/strtod()-like conversion,
- * check whether something was converted and that
- * the only thing left is white space.
- *
- * Returns JIM_OK or JIM_ERR.
- */
 static int JimCheckConversion(const char *str, const char *endptr)
 {
     if (str[0] == '\0' || str == endptr) {
@@ -6856,16 +5765,14 @@ int Jim_DoubleToString(char *buf, double doubleValue)
 
     len = sprintf(buf, "%.12g", doubleValue);
 
-    /* Add a final ".0" if it's a number. But not
-     * for NaN or InF */
     while (*buf) {
         if (*buf == '.' || isalpha(UCHAR(*buf))) {
-            /* inf -> Inf, nan -> Nan */
+            
             if (*buf == 'i' || *buf == 'n') {
                 *buf = toupper(UCHAR(*buf));
             }
             if (*buf == 'I') {
-                /* Infinity -> Inf */
+                
                 buf[3] = '\0';
                 len = buf - buf0 + 3;
             }
@@ -6885,7 +5792,7 @@ int Jim_StringToDouble(const char *str, double *doublePtr)
 {
     char *endptr;
 
-    /* Callers can check for underflow via ERANGE */
+    
     errno = 0;
 
     *doublePtr = strtod(str, &endptr);
@@ -6905,14 +5812,8 @@ static jim_wide JimPowWide(jim_wide b, jim_wide e)
     return res;
 }
 
-/* -----------------------------------------------------------------------------
- * Special functions
- * ---------------------------------------------------------------------------*/
 #ifdef JIM_DEBUG_PANIC
-/* Note that 'interp' may be NULL if not available in the
- * context of the panic. It's only useful to get the error
- * file descriptor, it will default to stderr otherwise. */
-void JimPanicDump(int condition, Jim_Interp *interp, const char *fmt, ...)
+void JimPanicDump(int condition, const char *fmt, ...)
 {
     va_list ap;
 
@@ -6921,9 +5822,7 @@ void JimPanicDump(int condition, Jim_Interp *interp, const char *fmt, ...)
     }
 
     va_start(ap, fmt);
-    /*
-     * Send it here first.. Assuming STDIO still works
-     */
+
     fprintf(stderr, JIM_NL "JIM INTERPRETER PANIC: ");
     vfprintf(stderr, fmt, ap);
     fprintf(stderr, JIM_NL JIM_NL);
@@ -6948,9 +5847,6 @@ void JimPanicDump(int condition, Jim_Interp *interp, const char *fmt, ...)
 }
 #endif
 
-/* -----------------------------------------------------------------------------
- * Memory allocation
- * ---------------------------------------------------------------------------*/
 
 void *Jim_Alloc(int size)
 {
@@ -6977,15 +5873,12 @@ char *Jim_StrDupLen(const char *s, int l)
     char *copy = Jim_Alloc(l + 1);
 
     memcpy(copy, s, l + 1);
-    copy[l] = 0;                /* Just to be sure, original could be substring */
+    copy[l] = 0;                
     return copy;
 }
 
-/* -----------------------------------------------------------------------------
- * Time related functions
- * ---------------------------------------------------------------------------*/
 
-/* Returns microseconds of CPU used since start. */
+
 static jim_wide JimClock(void)
 {
     struct timeval tv;
@@ -6994,18 +5887,15 @@ static jim_wide JimClock(void)
     return (jim_wide) tv.tv_sec * 1000000 + tv.tv_usec;
 }
 
-/* -----------------------------------------------------------------------------
- * Hash Tables
- * ---------------------------------------------------------------------------*/
 
-/* -------------------------- private prototypes ---------------------------- */
+
 static int JimExpandHashTableIfNeeded(Jim_HashTable *ht);
 static unsigned int JimHashTableNextPower(unsigned int size);
 static int JimInsertHashEntry(Jim_HashTable *ht, const void *key);
 
-/* -------------------------- hash functions -------------------------------- */
 
-/* Thomas Wang's 32 bit Mix Function */
+
+
 unsigned int Jim_IntHashFunction(unsigned int key)
 {
     key += ~(key << 15);
@@ -7017,8 +5907,6 @@ unsigned int Jim_IntHashFunction(unsigned int key)
     return key;
 }
 
-/* Generic hash function (we are using to multiply by 9 and add the byte
- * as Tcl) */
 unsigned int Jim_GenHashFunction(const unsigned char *buf, int len)
 {
     unsigned int h = 0;
@@ -7028,10 +5916,8 @@ unsigned int Jim_GenHashFunction(const unsigned char *buf, int len)
     return h;
 }
 
-/* ----------------------------- API implementation ------------------------- */
 
-/* reset a hashtable already initialized with ht_init().
- * NOTE: This function should only called by ht_destroy(). */
+
 static void JimResetHashTable(Jim_HashTable *ht)
 {
     ht->table = NULL;
@@ -7041,7 +5927,7 @@ static void JimResetHashTable(Jim_HashTable *ht)
     ht->collisions = 0;
 }
 
-/* Initialize the hash table */
+
 int Jim_InitHashTable(Jim_HashTable *ht, const Jim_HashTableType *type, void *privDataPtr)
 {
     JimResetHashTable(ht);
@@ -7050,8 +5936,6 @@ int Jim_InitHashTable(Jim_HashTable *ht, const Jim_HashTableType *type, void *pr
     return JIM_OK;
 }
 
-/* Resize the table to the minimal size that contains all the elements,
- * but with the invariant of a USER/BUCKETS ration near to <= 1 */
 int Jim_ResizeHashTable(Jim_HashTable *ht)
 {
     int minimal = ht->used;
@@ -7061,14 +5945,12 @@ int Jim_ResizeHashTable(Jim_HashTable *ht)
     return Jim_ExpandHashTable(ht, minimal);
 }
 
-/* Expand or create the hashtable */
+
 int Jim_ExpandHashTable(Jim_HashTable *ht, unsigned int size)
 {
-    Jim_HashTable n;            /* the new hashtable */
+    Jim_HashTable n;            
     unsigned int realsize = JimHashTableNextPower(size), i;
 
-    /* the size is invalid if it is smaller than the number of
-     * elements already inside the hashtable */
     if (ht->used >= size)
         return JIM_ERR;
 
@@ -7077,89 +5959,82 @@ int Jim_ExpandHashTable(Jim_HashTable *ht, unsigned int size)
     n.sizemask = realsize - 1;
     n.table = Jim_Alloc(realsize * sizeof(Jim_HashEntry *));
 
-    /* Initialize all the pointers to NULL */
+    
     memset(n.table, 0, realsize * sizeof(Jim_HashEntry *));
 
-    /* Copy all the elements from the old to the new table:
-     * note that if the old hash table is empty ht->size is zero,
-     * so Jim_ExpandHashTable just creates an hash table. */
     n.used = ht->used;
-    for (i = 0; i < ht->size && ht->used > 0; i++) {
+    for (i = 0; ht->used > 0; i++) {
         Jim_HashEntry *he, *nextHe;
 
         if (ht->table[i] == NULL)
             continue;
 
-        /* For each hash entry on this slot... */
+        
         he = ht->table[i];
         while (he) {
             unsigned int h;
 
             nextHe = he->next;
-            /* Get the new element index */
+            
             h = Jim_HashKey(ht, he->key) & n.sizemask;
             he->next = n.table[h];
             n.table[h] = he;
             ht->used--;
-            /* Pass to the next element */
+            
             he = nextHe;
         }
     }
     assert(ht->used == 0);
     Jim_Free(ht->table);
 
-    /* Remap the new hashtable in the old */
+    
     *ht = n;
     return JIM_OK;
 }
 
-/* Add an element to the target hash table */
+
 int Jim_AddHashEntry(Jim_HashTable *ht, const void *key, void *val)
 {
     int idx;
     Jim_HashEntry *entry;
 
-    /* Get the index of the new element, or -1 if
-     * the element already exists. */
     if ((idx = JimInsertHashEntry(ht, key)) == -1)
         return JIM_ERR;
 
-    /* Allocates the memory and stores key */
+    
     entry = Jim_Alloc(sizeof(*entry));
     entry->next = ht->table[idx];
     ht->table[idx] = entry;
 
-    /* Set the hash entry fields. */
+    
     Jim_SetHashKey(ht, entry, key);
     Jim_SetHashVal(ht, entry, val);
     ht->used++;
     return JIM_OK;
 }
 
-/* Add an element, discarding the old if the key already exists */
+
 int Jim_ReplaceHashEntry(Jim_HashTable *ht, const void *key, void *val)
 {
     Jim_HashEntry *entry;
 
-    /* Try to add the element. If the key
-     * does not exists Jim_AddHashEntry will suceed. */
     if (Jim_AddHashEntry(ht, key, val) == JIM_OK)
         return JIM_OK;
-    /* It already exists, get the entry */
+    
     entry = Jim_FindHashEntry(ht, key);
-    /* Free the old value and set the new one */
+    
     Jim_FreeEntryVal(ht, entry);
     Jim_SetHashVal(ht, entry, val);
     return JIM_OK;
 }
 
-/* Search and remove an element */
+
 int Jim_DeleteHashEntry(Jim_HashTable *ht, const void *key)
 {
     unsigned int h;
     Jim_HashEntry *he, *prevHe;
 
-    if (ht->size == 0)
+    if (ht->used == 0)
         return JIM_ERR;
     h = Jim_HashKey(ht, key) & ht->sizemask;
     he = ht->table[h];
@@ -7167,7 +6042,7 @@ int Jim_DeleteHashEntry(Jim_HashTable *ht, const void *key)
     prevHe = NULL;
     while (he) {
         if (Jim_CompareHashKeys(ht, key, he->key)) {
-            /* Unlink the element from the list */
+            
             if (prevHe)
                 prevHe->next = he->next;
             else
@@ -7181,16 +6056,16 @@ int Jim_DeleteHashEntry(Jim_HashTable *ht, const void *key)
         prevHe = he;
         he = he->next;
     }
-    return JIM_ERR;             /* not found */
+    return JIM_ERR;             
 }
 
-/* Destroy an entire hash table */
+
 int Jim_FreeHashTable(Jim_HashTable *ht)
 {
     unsigned int i;
 
-    /* Free all the elements */
-    for (i = 0; i < ht->size && ht->used > 0; i++) {
+    
+    for (i = 0; ht->used > 0; i++) {
         Jim_HashEntry *he, *nextHe;
 
         if ((he = ht->table[i]) == NULL)
@@ -7204,11 +6079,11 @@ int Jim_FreeHashTable(Jim_HashTable *ht)
             he = nextHe;
         }
     }
-    /* Free the table and the allocated cache structure */
+    
     Jim_Free(ht->table);
-    /* Re-initialize the table */
+    
     JimResetHashTable(ht);
-    return JIM_OK;              /* never fails */
+    return JIM_OK;              
 }
 
 Jim_HashEntry *Jim_FindHashEntry(Jim_HashTable *ht, const void *key)
@@ -7216,7 +6091,7 @@ Jim_HashEntry *Jim_FindHashEntry(Jim_HashTable *ht, const void *key)
     Jim_HashEntry *he;
     unsigned int h;
 
-    if (ht->size == 0)
+    if (ht->used == 0)
         return NULL;
     h = Jim_HashKey(ht, key) & ht->sizemask;
     he = ht->table[h];
@@ -7252,8 +6127,6 @@ Jim_HashEntry *Jim_NextHashEntry(Jim_HashTableIterator *iter)
             iter->entry = iter->nextEntry;
         }
         if (iter->entry) {
-            /* We need to save the 'next' here, the iterator user
-             * may delete the entry we are returning. */
             iter->nextEntry = iter->entry->next;
             return iter->entry;
         }
@@ -7261,13 +6134,11 @@ Jim_HashEntry *Jim_NextHashEntry(Jim_HashTableIterator *iter)
     return NULL;
 }
 
-/* ------------------------- private functions ------------------------------ */
 
-/* Expand the hash table if needed */
+
+
 static int JimExpandHashTableIfNeeded(Jim_HashTable *ht)
 {
-    /* If the hash table is empty expand it to the intial size,
-     * if the table is "full" dobule its size. */
     if (ht->size == 0)
         return Jim_ExpandHashTable(ht, JIM_HT_INITIAL_SIZE);
     if (ht->size == ht->used)
@@ -7275,7 +6146,7 @@ static int JimExpandHashTableIfNeeded(Jim_HashTable *ht)
     return JIM_OK;
 }
 
-/* Our hash table capability is a power of two */
+
 static unsigned int JimHashTableNextPower(unsigned int size)
 {
     unsigned int i = JIM_HT_INITIAL_SIZE;
@@ -7289,20 +6160,17 @@ static unsigned int JimHashTableNextPower(unsigned int size)
     }
 }
 
-/* Returns the index of a free slot that can be populated with
- * an hash entry for the given 'key'.
- * If the key already exists, -1 is returned. */
 static int JimInsertHashEntry(Jim_HashTable *ht, const void *key)
 {
     unsigned int h;
     Jim_HashEntry *he;
 
-    /* Expand the hashtable if needed */
+    
     if (JimExpandHashTableIfNeeded(ht) == JIM_ERR)
         return -1;
-    /* Compute the key hash value */
+    
     h = Jim_HashKey(ht, key) & ht->sizemask;
-    /* Search if this slot does not already contain the given key */
+    
     he = ht->table[h];
     while (he) {
         if (Jim_CompareHashKeys(ht, key, he->key))
@@ -7312,7 +6180,7 @@ static int JimInsertHashEntry(Jim_HashTable *ht, const void *key)
     return h;
 }
 
-/* ----------------------- StringCopy Hash Table Type ------------------------*/
+
 
 static unsigned int JimStringCopyHTHashFunction(const void *key)
 {
@@ -7354,47 +6222,43 @@ static void JimStringCopyHTKeyDestructor(void *privdata, const void *key)
 {
     JIM_NOTUSED(privdata);
 
-    Jim_Free((void *)key);      /* ATTENTION: const cast */
+    Jim_Free((void *)key);      
 }
 
 static void JimStringKeyValCopyHTValDestructor(void *privdata, void *val)
 {
     JIM_NOTUSED(privdata);
 
-    Jim_Free((void *)val);      /* ATTENTION: const cast */
+    Jim_Free((void *)val);      
 }
 
 #if 0
 static Jim_HashTableType JimStringCopyHashTableType = {
-    JimStringCopyHTHashFunction,        /* hash function */
-    JimStringCopyHTKeyDup,      /* key dup */
-    NULL,                       /* val dup */
-    JimStringCopyHTKeyCompare,  /* key compare */
-    JimStringCopyHTKeyDestructor,       /* key destructor */
-    NULL                        /* val destructor */
+    JimStringCopyHTHashFunction,        
+    JimStringCopyHTKeyDup,      
+    NULL,                       
+    JimStringCopyHTKeyCompare,  
+    JimStringCopyHTKeyDestructor,       
+    NULL                        
 };
 #endif
 
-/* This is like StringCopy but does not auto-duplicate the key.
- * It's used for intepreter's shared strings. */
 static const Jim_HashTableType JimSharedStringsHashTableType = {
-    JimStringCopyHTHashFunction,        /* hash function */
-    NULL,                       /* key dup */
-    NULL,                       /* val dup */
-    JimStringCopyHTKeyCompare,  /* key compare */
-    JimStringCopyHTKeyDestructor,       /* key destructor */
-    NULL                        /* val destructor */
+    JimStringCopyHTHashFunction,        
+    NULL,                       
+    NULL,                       
+    JimStringCopyHTKeyCompare,  
+    JimStringCopyHTKeyDestructor,       
+    NULL                        
 };
 
-/* This is like StringCopy but also automatically handle dynamic
- * allocated C strings as values. */
 static const Jim_HashTableType JimStringKeyValCopyHashTableType = {
-    JimStringCopyHTHashFunction,        /* hash function */
-    JimStringCopyHTKeyDup,      /* key dup */
-    JimStringKeyValCopyHTValDup,        /* val dup */
-    JimStringCopyHTKeyCompare,  /* key compare */
-    JimStringCopyHTKeyDestructor,       /* key destructor */
-    JimStringKeyValCopyHTValDestructor, /* val destructor */
+    JimStringCopyHTHashFunction,        
+    JimStringCopyHTKeyDup,      
+    JimStringKeyValCopyHTValDup,        
+    JimStringCopyHTKeyCompare,  
+    JimStringCopyHTKeyDestructor,       
+    JimStringKeyValCopyHTValDestructor, 
 };
 
 typedef struct AssocDataValue
@@ -7413,18 +6277,14 @@ static void JimAssocDataHashTableValueDestructor(void *privdata, void *data)
 }
 
 static const Jim_HashTableType JimAssocDataHashTableType = {
-    JimStringCopyHTHashFunction,        /* hash function */
-    JimStringCopyHTKeyDup,      /* key dup */
-    NULL,                       /* val dup */
-    JimStringCopyHTKeyCompare,  /* key compare */
-    JimStringCopyHTKeyDestructor,       /* key destructor */
-    JimAssocDataHashTableValueDestructor        /* val destructor */
+    JimStringCopyHTHashFunction,        
+    JimStringCopyHTKeyDup,      
+    NULL,                       
+    JimStringCopyHTKeyCompare,  
+    JimStringCopyHTKeyDestructor,       
+    JimAssocDataHashTableValueDestructor        
 };
 
-/* -----------------------------------------------------------------------------
- * Stack - This is a simple generic stack implementation. It is used for
- * example in the 'expr' expression compiler.
- * ---------------------------------------------------------------------------*/
 void Jim_InitStack(Jim_Stack *stack)
 {
     stack->len = 0;
@@ -7477,67 +6337,59 @@ void Jim_FreeStackElements(Jim_Stack *stack, void (*freeFunc) (void *ptr))
         freeFunc(stack->vector[i]);
 }
 
-/* -----------------------------------------------------------------------------
- * Parser
- * ---------------------------------------------------------------------------*/
 
-/* Token types */
-#define JIM_TT_NONE    0           /* No token returned */
-#define JIM_TT_STR     1          /* simple string */
-#define JIM_TT_ESC     2          /* string that needs escape chars conversion */
-#define JIM_TT_VAR     3          /* var substitution */
-#define JIM_TT_DICTSUGAR   4      /* Syntax sugar for [dict get], $foo(bar) */
-#define JIM_TT_CMD     5          /* command substitution */
-/* Note: Keep these three together for TOKEN_IS_SEP() */
-#define JIM_TT_SEP     6          /* word separator. arg is # of tokens. -ve if {*} */
-#define JIM_TT_EOL     7          /* line separator */
-#define JIM_TT_EOF     8          /* end of script */
 
-#define JIM_TT_LINE    9          /* special 'start-of-line' token. arg is # of arguments to the command. -ve if {*} */
-#define JIM_TT_WORD   10          /* special 'start-of-word' token. arg is # of tokens to combine. -ve if {*} */
+#define JIM_TT_NONE    0           
+#define JIM_TT_STR     1          
+#define JIM_TT_ESC     2          
+#define JIM_TT_VAR     3          
+#define JIM_TT_DICTSUGAR   4      
+#define JIM_TT_CMD     5          
+
+#define JIM_TT_SEP     6          
+#define JIM_TT_EOL     7          
+#define JIM_TT_EOF     8          
+
+#define JIM_TT_LINE    9          
+#define JIM_TT_WORD   10          
+
 
-/* Additional token types needed for expressions */
 #define JIM_TT_SUBEXPR_START  11
 #define JIM_TT_SUBEXPR_END    12
 #define JIM_TT_EXPR_INT       13
 #define JIM_TT_EXPR_DOUBLE    14
 
-#define JIM_TT_EXPRSUGAR      15  /* $(expression) */
+#define JIM_TT_EXPRSUGAR      15  
+
 
-/* Operator token types start here */
 #define JIM_TT_EXPR_OP        20
 
 #define TOKEN_IS_SEP(type) (type >= JIM_TT_SEP && type <= JIM_TT_EOF)
 
-/* Parser states */
-#define JIM_PS_DEF 0            /* Default state */
-#define JIM_PS_QUOTE 1          /* Inside "" */
-#define JIM_PS_DICTSUGAR 2      /* Tokenising abc(def) into 4 separate tokens */
 
-/* Parser context structure. The same context is used both to parse
- * Tcl scripts and lists. */
+#define JIM_PS_DEF 0            
+#define JIM_PS_QUOTE 1          
+#define JIM_PS_DICTSUGAR 2      
+
 struct JimParserCtx
 {
-    const char *p;              /* Pointer to the point of the program we are parsing */
-    int len;                    /* Remaining length */
-    int linenr;                 /* Current line number */
+    const char *p;              
+    int len;                    
+    int linenr;                 
     const char *tstart;
-    const char *tend;           /* Returned token is at tstart-tend in 'prg'. */
-    int tline;                  /* Line number of the returned token */
-    int tt;                     /* Token type */
-    int eof;                    /* Non zero if EOF condition is true. */
-    int state;                  /* Parser state */
-    int comment;                /* Non zero if the next chars may be a comment. */
-    char missing;               /* At end of parse, ' ' if complete, '{' if braces incomplete, '"' if quotes incomplete */
-    int missingline;            /* Line number starting the missing token */
+    const char *tend;           
+    int tline;                  
+    int tt;                     
+    int eof;                    
+    int state;                  
+    int comment;                
+    char missing;               
+    int missingline;            
 };
 
-/**
- * Results of missing quotes, braces, etc. from parsing.
- */
 struct JimParseResult {
-    char missing;               /* From JimParserCtx.missing */
-    int line;                   /* From JimParserCtx.missingline */
+    char missing;               
+    int line;                   
 };
 
 static int JimParseScript(struct JimParserCtx *pc);
@@ -7554,9 +6406,6 @@ static int JimParseSubQuote(struct JimParserCtx *pc);
 static void JimParseSubCmd(struct JimParserCtx *pc);
 static Jim_Obj *JimParserGetTokenObj(Jim_Interp *interp, struct JimParserCtx *pc);
 
-/* Initialize a parser context.
- * 'prg' is a pointer to the program text, linenr is the line
- * number of the first line contained in the program. */
 static void JimParserInit(struct JimParserCtx *pc, const char *prg, int len, int linenr)
 {
     pc->p = prg;
@@ -7575,7 +6424,7 @@ static void JimParserInit(struct JimParserCtx *pc, const char *prg, int len, int
 
 static int JimParseScript(struct JimParserCtx *pc)
 {
-    while (1) {                 /* the while is used to reiterate with continue if needed */
+    while (1) {                 
         if (!pc->len) {
             pc->tstart = pc->p;
             pc->tend = pc->p - 1;
@@ -7679,39 +6528,12 @@ static int JimParseEol(struct JimParserCtx *pc)
     return JIM_OK;
 }
 
-/*
-** Here are the rules for parsing:
-** {braced expression}
-** - Count open and closing braces
-** - Backslash escapes meaning of braces
-**
-** "quoted expression"
-** - First double quote at start of word terminates the expression
-** - Backslash escapes quote and bracket
-** - [commands brackets] are counted/nested
-** - command rules apply within [brackets], not quoting rules (i.e. quotes have their own rules)
-** 
-** [command expression]
-** - Count open and closing brackets
-** - Backslash escapes quote, bracket and brace
-** - [commands brackets] are counted/nested
-** - "quoted expressions" are parsed according to quoting rules
-** - {braced expressions} are parsed according to brace rules
-**
-** For everything, backslash escapes the next char, newline increments current line
-*/
-
-/**
- * Parses a braced expression starting at pc->p.
- * 
- * Positions the parser at the end of the braced expression,
- * sets pc->tend and possibly pc->missing.
- */
+
 static void JimParseSubBrace(struct JimParserCtx *pc)
 {
     int level = 1;
 
-    /* Skip the brace */
+    
     pc->p++;
     pc->len--;
     while (pc->len) {
@@ -7750,22 +6572,12 @@ static void JimParseSubBrace(struct JimParserCtx *pc)
     pc->tend = pc->p - 1;
 }
 
-/**
- * Parses a quoted expression starting at pc->p.
- * 
- * Positions the parser at the end of the quoted expression,
- * sets pc->tend and possibly pc->missing.
- *
- * Returns the type of the token of the string,
- * either JIM_TT_ESC (if it contains values which need to be [subst]ed)
- * or JIM_TT_STR.
- */
 static int JimParseSubQuote(struct JimParserCtx *pc)
 {
     int tt = JIM_TT_STR;
     int line = pc->tline;
 
-    /* Skip the quote */
+    
     pc->p++;
     pc->len--;
     while (pc->len) {
@@ -7808,19 +6620,13 @@ static int JimParseSubQuote(struct JimParserCtx *pc)
     return tt;
 }
 
-/**
- * Parses a [command] expression starting at pc->p.
- * 
- * Positions the parser at the end of the command expression,
- * sets pc->tend and possibly pc->missing.
- */
 static void JimParseSubCmd(struct JimParserCtx *pc)
 {
     int level = 1;
     int startofword = 1;
     int line = pc->tline;
 
-    /* Skip the bracket */
+    
     pc->p++;
     pc->len--;
     while (pc->len) {
@@ -7900,13 +6706,13 @@ static int JimParseQuote(struct JimParserCtx *pc)
 
 static int JimParseVar(struct JimParserCtx *pc)
 {
-    /* skip the $ */
+    
     pc->p++;
     pc->len--;
 
 #ifdef EXPRSUGAR_BRACKET
     if (*pc->p == '[') {
-        /* Parse $[...] expr shorthand syntax */
+        
         JimParseCmd(pc);
         pc->tt = JIM_TT_EXPRSUGAR;
         return JIM_OK;
@@ -7936,7 +6742,7 @@ static int JimParseVar(struct JimParserCtx *pc)
     }
     else {
         while (1) {
-            /* Skip double colon, but not single colon! */
+            
             if (pc->p[0] == ':' && pc->p[1] == ':') {
                 pc->p += 2;
                 pc->len -= 2;
@@ -7949,7 +6755,7 @@ static int JimParseVar(struct JimParserCtx *pc)
             }
             break;
         }
-        /* Parse [dict get] syntax sugar. */
+        
         if (*pc->p == '(') {
             int count = 1;
             const char *paren = NULL;
@@ -7976,7 +6782,7 @@ static int JimParseVar(struct JimParserCtx *pc)
                 pc->len--;
             }
             else if (paren) {
-                /* Did not find a matching paren. Back up */
+                
                 paren++;
                 pc->len += (pc->p - paren);
                 pc->p = paren;
@@ -7989,10 +6795,6 @@ static int JimParseVar(struct JimParserCtx *pc)
         }
         pc->tend = pc->p - 1;
     }
-    /* Check if we parsed just the '$' character.
-     * That's not a variable so an error is returned
-     * to tell the state machine to consider this '$' just
-     * a string. */
     if (pc->tstart == pc->p) {
         pc->p--;
         pc->len++;
@@ -8012,7 +6814,7 @@ static int JimParseStr(struct JimParserCtx *pc)
         pc->state = JIM_PS_QUOTE;
         pc->p++;
         pc->len--;
-        /* In case the end quote is missing */
+        
         pc->missingline = pc->tline;
     }
     pc->tstart = pc->p;
@@ -8042,15 +6844,15 @@ static int JimParseStr(struct JimParserCtx *pc)
                 }
                 break;
             case '(':
-                /* If the following token is not '$' just keep going */
+                
                 if (pc->len > 1 && pc->p[1] != '$') {
                     break;
                 }
             case ')':
-                /* Only need a separate ')' token if the previous was a var */
+                
                 if (*pc->p == '(' || pc->tt == JIM_TT_VAR) {
                     if (pc->p == pc->tstart) {
-                        /* At the start of the token, so just return this char */
+                        
                         pc->p++;
                         pc->len--;
                     }
@@ -8093,7 +6895,7 @@ static int JimParseStr(struct JimParserCtx *pc)
         pc->p++;
         pc->len--;
     }
-    return JIM_OK;              /* unreached */
+    return JIM_OK;              
 }
 
 static int JimParseComment(struct JimParserCtx *pc)
@@ -8113,7 +6915,7 @@ static int JimParseComment(struct JimParserCtx *pc)
     return JIM_OK;
 }
 
-/* xdigitval and odigitval are helper functions for JimEscape() */
+
 static int xdigitval(int c)
 {
     if (c >= '0' && c <= '9')
@@ -8132,13 +6934,6 @@ static int odigitval(int c)
     return -1;
 }
 
-/* Perform Tcl escape substitution of 's', storing the result
- * string into 'dest'. The escaped string is guaranteed to
- * be the same length or shorted than the source string.
- * Slen is the length of the string at 's', if it's -1 the string
- * length will be calculated by the function.
- *
- * The function returns the length of the resulting string. */
 static int JimEscape(char *dest, const char *s, int slen)
 {
     char *p = dest;
@@ -8177,11 +6972,6 @@ static int JimEscape(char *dest, const char *s, int slen)
                         break;
                     case 'u':
                     case 'x':
-                        /* A unicode or hex sequence.
-                         * \u Expect 1-4 hex chars and convert to utf-8.
-                         * \x Expect 1-2 hex chars and convert to hex.
-                         * An invalid sequence means simply the escaped char.
-                         */
                         {
                             int val = 0;
                             int k;
@@ -8196,7 +6986,7 @@ static int JimEscape(char *dest, const char *s, int slen)
                                 val = (val << 4) | c;
                             }
                             if (k) {
-                                /* Got a valid sequence, so convert */
+                                
                                 if (s[i] == 'u') {
                                     p += utf8_fromunicode(p, val);
                                 }
@@ -8206,7 +6996,7 @@ static int JimEscape(char *dest, const char *s, int slen)
                                 i += k;
                                 break;
                             }
-                            /* Not a valid codepoint, just an escaped char */
+                            
                             *p++ = s[i];
                         }
                         break;
@@ -8219,7 +7009,7 @@ static int JimEscape(char *dest, const char *s, int slen)
                         i++;
                         break;
                     case '\n':
-                        /* Replace all spaces and tabs after backslash newline with a single space*/
+                        
                         *p++ = ' ';
                         do {
                             i++;
@@ -8233,7 +7023,7 @@ static int JimEscape(char *dest, const char *s, int slen)
                     case '5':
                     case '6':
                     case '7':
-                        /* octal escape */
+                        
                         {
                             int val = 0;
                             int c = odigitval(s[i + 1]);
@@ -8273,26 +7063,6 @@ static int JimEscape(char *dest, const char *s, int slen)
     return len;
 }
 
-/* Returns a dynamically allocated copy of the current token in the
- * parser context. The function performs conversion of escapes if
- * the token is of type JIM_TT_ESC.
- *
- * Note that after the conversion, tokens that are grouped with
- * braces in the source code, are always recognizable from the
- * identical string obtained in a different way from the type.
- *
- * For example the string:
- *
- * {*}$a
- *
- * will return as first token "*", of type JIM_TT_STR
- *
- * While the string:
- *
- * *$a
- *
- * will return as first token "*", of type JIM_TT_ESC
- */
 static Jim_Obj *JimParserGetTokenObj(Jim_Interp *interp, struct JimParserCtx *pc)
 {
     const char *start, *end;
@@ -8310,12 +7080,12 @@ static Jim_Obj *JimParserGetTokenObj(Jim_Interp *interp, struct JimParserCtx *pc
         len = (end - start) + 1;
         token = Jim_Alloc(len + 1);
         if (pc->tt != JIM_TT_ESC) {
-            /* No escape conversion needed? Just copy it. */
+            
             memcpy(token, start, len);
             token[len] = '\0';
         }
         else {
-            /* Else convert the escape chars. */
+            
             len = JimEscape(token, start, len);
         }
     }
@@ -8323,17 +7093,6 @@ static Jim_Obj *JimParserGetTokenObj(Jim_Interp *interp, struct JimParserCtx *pc
     return Jim_NewStringObjNoAlloc(interp, token, len);
 }
 
-/* Parses the given string to determine if it represents a complete script.
- *
- * This is useful for interactive shells implementation, for [info complete].
- *
- * If 'stateCharPtr' != NULL, the function stores ' ' on complete script,
- * '{' on scripts incomplete missing one or more '}' to be balanced.
- * '[' on scripts incomplete missing one or more ']' to be balanced.
- * '"' on scripts incomplete missing a '"' char.
- *
- * If the script is complete, 1 is returned, otherwise 0.
- */
 int Jim_ScriptIsComplete(const char *s, int len, char *stateCharPtr)
 {
     struct JimParserCtx parser;
@@ -8348,9 +7107,6 @@ int Jim_ScriptIsComplete(const char *s, int len, char *stateCharPtr)
     return parser.missing == ' ';
 }
 
-/* -----------------------------------------------------------------------------
- * Tcl Lists parsing
- * ---------------------------------------------------------------------------*/
 static int JimParseListSep(struct JimParserCtx *pc);
 static int JimParseListStr(struct JimParserCtx *pc);
 static int JimParseListQuote(struct JimParserCtx *pc);
@@ -8414,7 +7170,7 @@ static int JimParseListQuote(struct JimParserCtx *pc)
             case '\\':
                 pc->tt = JIM_TT_ESC;
                 if (--pc->len == 0) {
-                    /* Trailing backslash */
+                    
                     pc->tend = pc->p;
                     return JIM_OK;
                 }
@@ -8447,7 +7203,7 @@ static int JimParseListStr(struct JimParserCtx *pc)
         switch (*pc->p) {
             case '\\':
                 if (--pc->len == 0) {
-                    /* Trailing backslash */
+                    
                     pc->tend = pc->p;
                     return JIM_OK;
                 }
@@ -8468,35 +7224,26 @@ static int JimParseListStr(struct JimParserCtx *pc)
     return JIM_OK;
 }
 
-/* -----------------------------------------------------------------------------
- * Jim_Obj related functions
- * ---------------------------------------------------------------------------*/
 
-/* Return a new initialized object. */
+
 Jim_Obj *Jim_NewObj(Jim_Interp *interp)
 {
     Jim_Obj *objPtr;
 
-    /* -- Check if there are objects in the free list -- */
+    
     if (interp->freeList != NULL) {
-        /* -- Unlink the object from the free list -- */
+        
         objPtr = interp->freeList;
         interp->freeList = objPtr->nextObjPtr;
     }
     else {
-        /* -- No ready to use objects: allocate a new one -- */
+        
         objPtr = Jim_Alloc(sizeof(*objPtr));
     }
 
-    /* Object is returned with refCount of 0. Every
-     * kind of GC implemented should take care to don't try
-     * to scan objects with refCount == 0. */
     objPtr->refCount = 0;
-    /* All the other fields are left not initialized to save time.
-     * The caller will probably want to set them to the right
-     * value anyway. */
 
-    /* -- Put the object into the live list -- */
+    
     objPtr->prevObjPtr = NULL;
     objPtr->nextObjPtr = interp->liveList;
     if (interp->liveList)
@@ -8506,30 +7253,27 @@ Jim_Obj *Jim_NewObj(Jim_Interp *interp)
     return objPtr;
 }
 
-/* Free an object. Actually objects are never freed, but
- * just moved to the free objects list, where they will be
- * reused by Jim_NewObj(). */
 void Jim_FreeObj(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-    /* Check if the object was already freed, panic. */
-    JimPanic((objPtr->refCount != 0, interp, "!!!Object %p freed with bad refcount %d, type=%s", objPtr,
+    
+    JimPanic((objPtr->refCount != 0, "!!!Object %p freed with bad refcount %d, type=%s", objPtr,
         objPtr->refCount, objPtr->typePtr ? objPtr->typePtr->name : "<none>"));
 
-    /* Free the internal representation */
+    
     Jim_FreeIntRep(interp, objPtr);
-    /* Free the string representation */
+    
     if (objPtr->bytes != NULL) {
         if (objPtr->bytes != JimEmptyStringRep)
             Jim_Free(objPtr->bytes);
     }
-    /* Unlink the object from the live objects list */
+    
     if (objPtr->prevObjPtr)
         objPtr->prevObjPtr->nextObjPtr = objPtr->nextObjPtr;
     if (objPtr->nextObjPtr)
         objPtr->nextObjPtr->prevObjPtr = objPtr->prevObjPtr;
     if (interp->liveList == objPtr)
         interp->liveList = objPtr->nextObjPtr;
-    /* Link the object into the free objects list */
+    
     objPtr->prevObjPtr = NULL;
     objPtr->nextObjPtr = interp->freeList;
     if (interp->freeList)
@@ -8538,7 +7282,7 @@ void Jim_FreeObj(Jim_Interp *interp, Jim_Obj *objPtr)
     objPtr->refCount = -1;
 }
 
-/* Invalidate the string representation of an object. */
+
 void Jim_InvalidateStringRep(Jim_Obj *objPtr)
 {
     if (objPtr->bytes != NULL) {
@@ -8551,8 +7295,6 @@ void Jim_InvalidateStringRep(Jim_Obj *objPtr)
 #define Jim_SetStringRep(o, b, l) \
     do { (o)->bytes = b; (o)->length = l; } while (0)
 
-/* Set the initial string representation for an object.
- * Does not try to free an old one. */
 void Jim_InitStringRep(Jim_Obj *objPtr, const char *bytes, int length)
 {
     if (length == 0) {
@@ -8567,42 +7309,39 @@ void Jim_InitStringRep(Jim_Obj *objPtr, const char *bytes, int length)
     }
 }
 
-/* Duplicate an object. The returned object has refcount = 0. */
+
 Jim_Obj *Jim_DuplicateObj(Jim_Interp *interp, Jim_Obj *objPtr)
 {
     Jim_Obj *dupPtr;
 
     dupPtr = Jim_NewObj(interp);
     if (objPtr->bytes == NULL) {
-        /* Object does not have a valid string representation. */
+        
         dupPtr->bytes = NULL;
     }
     else {
         Jim_InitStringRep(dupPtr, objPtr->bytes, objPtr->length);
     }
 
-    /* By default, the new object has the same type as the old object */
+    
     dupPtr->typePtr = objPtr->typePtr;
     if (objPtr->typePtr != NULL) {
         if (objPtr->typePtr->dupIntRepProc == NULL) {
             dupPtr->internalRep = objPtr->internalRep;
         }
         else {
-            /* The dup proc may set a different type, e.g. NULL */
+            
             objPtr->typePtr->dupIntRepProc(interp, objPtr, dupPtr);
         }
     }
     return dupPtr;
 }
 
-/* Return the string representation for objPtr. If the object
- * string representation is invalid, calls the method to create
- * a new one starting from the internal representation of the object. */
 const char *Jim_GetString(Jim_Obj *objPtr, int *lenPtr)
 {
     if (objPtr->bytes == NULL) {
-        /* Invalid string repr. Generate it. */
-        JimPanic((objPtr->typePtr->updateStringProc == NULL, NULL, "UpdateStringProc called against '%s' type.", objPtr->typePtr->name));
+        
+        JimPanic((objPtr->typePtr->updateStringProc == NULL, "UpdateStringProc called against '%s' type.", objPtr->typePtr->name));
         objPtr->typePtr->updateStringProc(objPtr);
     }
     if (lenPtr)
@@ -8610,7 +7349,7 @@ const char *Jim_GetString(Jim_Obj *objPtr, int *lenPtr)
     return objPtr->bytes;
 }
 
-/* Just returns the length of the object's string rep */
+
 int Jim_Length(Jim_Obj *objPtr)
 {
     int len;
@@ -8643,9 +7382,6 @@ static const Jim_ObjType interpolatedObjType = {
     JIM_TYPE_NONE,
 };
 
-/* -----------------------------------------------------------------------------
- * String Object
- * ---------------------------------------------------------------------------*/
 static void DupStringInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
 static int SetStringFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
@@ -8661,11 +7397,6 @@ static void DupStringInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *d
 {
     JIM_NOTUSED(interp);
 
-    /* This is a bit subtle: the only caller of this function
-     * should be Jim_DuplicateObj(), that will copy the
-     * string representaion. After the copy, the duplicated
-     * object will not have more room in teh buffer than
-     * srcPtr->length bytes. So we just set it to length. */
     dupPtr->internalRep.strValue.maxLength = srcPtr->length;
 
     dupPtr->internalRep.strValue.charLength = srcPtr->internalRep.strValue.charLength;
@@ -8673,23 +7404,18 @@ static void DupStringInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *d
 
 static int SetStringFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-    /* Get a fresh string representation. */
+    
     (void)Jim_String(objPtr);
-    /* Free any other internal representation. */
+    
     Jim_FreeIntRep(interp, objPtr);
-    /* Set it as string, i.e. just set the maxLength field. */
+    
     objPtr->typePtr = &stringObjType;
     objPtr->internalRep.strValue.maxLength = objPtr->length;
-    /* Don't know the utf-8 length yet */
+    
     objPtr->internalRep.strValue.charLength = -1;
     return JIM_OK;
 }
 
-/**
- * Returns the length of the object string in chars, not bytes.
- *
- * These may be different for a utf-8 string.
- */
 int Jim_Utf8Length(Jim_Interp *interp, Jim_Obj *objPtr)
 {
 #ifdef JIM_UTF8
@@ -8705,15 +7431,15 @@ int Jim_Utf8Length(Jim_Interp *interp, Jim_Obj *objPtr)
 #endif
 }
 
-/* len is in bytes -- see also Jim_NewStringObjUtf8() */
+
 Jim_Obj *Jim_NewStringObj(Jim_Interp *interp, const char *s, int len)
 {
     Jim_Obj *objPtr = Jim_NewObj(interp);
 
-    /* Need to find out how many bytes the string requires */
+    
     if (len == -1)
         len = strlen(s);
-    /* Alloc/Set the string rep. */
+    
     if (len == 0) {
         objPtr->bytes = JimEmptyStringRep;
         objPtr->length = 0;
@@ -8725,21 +7451,21 @@ Jim_Obj *Jim_NewStringObj(Jim_Interp *interp, const char *s, int len)
         objPtr->bytes[len] = '\0';
     }
 
-    /* No typePtr field for the vanilla string object. */
+    
     objPtr->typePtr = NULL;
     return objPtr;
 }
 
-/* charlen is in characters -- see also Jim_NewStringObj() */
+
 Jim_Obj *Jim_NewStringObjUtf8(Jim_Interp *interp, const char *s, int charlen)
 {
 #ifdef JIM_UTF8
-    /* Need to find out how many bytes the string requires */
+    
     int bytelen = utf8_index(s, charlen);
 
     Jim_Obj *objPtr = Jim_NewStringObj(interp, s, bytelen);
 
-    /* Remember the utf8 length, so set the type */
+    
     objPtr->typePtr = &stringObjType;
     objPtr->internalRep.strValue.maxLength = bytelen;
     objPtr->internalRep.strValue.charLength = charlen;
@@ -8750,8 +7476,6 @@ Jim_Obj *Jim_NewStringObjUtf8(Jim_Interp *interp, const char *s, int charlen)
 #endif
 }
 
-/* This version does not try to duplicate the 's' pointer, but
- * use it directly. */
 Jim_Obj *Jim_NewStringObjNoAlloc(Jim_Interp *interp, char *s, int len)
 {
     Jim_Obj *objPtr = Jim_NewObj(interp);
@@ -8763,8 +7487,6 @@ Jim_Obj *Jim_NewStringObjNoAlloc(Jim_Interp *interp, char *s, int len)
     return objPtr;
 }
 
-/* Low-level string append. Use it only against objects
- * of type "string". */
 static void StringAppendString(Jim_Obj *objPtr, const char *str, int len)
 {
     int needlen;
@@ -8775,7 +7497,7 @@ static void StringAppendString(Jim_Obj *objPtr, const char *str, int len)
     if (objPtr->internalRep.strValue.maxLength < needlen ||
         objPtr->internalRep.strValue.maxLength == 0) {
         needlen *= 2;
-        /* Inefficient to malloc() for less than 8 bytes */
+        
         if (needlen < 7) {
             needlen = 7;
         }
@@ -8790,16 +7512,16 @@ static void StringAppendString(Jim_Obj *objPtr, const char *str, int len)
     memcpy(objPtr->bytes + objPtr->length, str, len);
     objPtr->bytes[objPtr->length + len] = '\0';
     if (objPtr->internalRep.strValue.charLength >= 0) {
-        /* Update the utf-8 char length */
+        
         objPtr->internalRep.strValue.charLength += utf8_strlen(objPtr->bytes + objPtr->length, len);
     }
     objPtr->length += len;
 }
 
-/* Higher level API to append strings to objects. */
+
 void Jim_AppendString(Jim_Interp *interp, Jim_Obj *objPtr, const char *str, int len)
 {
-    JimPanic((Jim_IsShared(objPtr), interp, "Jim_AppendString called with shared object"));
+    JimPanic((Jim_IsShared(objPtr), "Jim_AppendString called with shared object"));
     if (objPtr->typePtr != &stringObjType)
         SetStringFromAny(interp, objPtr);
     StringAppendString(objPtr, str, len);
@@ -8864,11 +7586,6 @@ int Jim_StringCompareObj(Jim_Interp *interp, Jim_Obj *firstObjPtr, Jim_Obj *seco
     return JimStringCompare(s1, l1, s2, l2);
 }
 
-/* Convert a range, as returned by Jim_GetRange(), into
- * an absolute index into an object of the specified length.
- * This function may return negative values, or values
- * bigger or equal to the length of the list if the index
- * is out of range. */
 static int JimRelToAbsIndex(int len, int idx)
 {
     if (idx < 0)
@@ -8876,12 +7593,6 @@ static int JimRelToAbsIndex(int len, int idx)
     return idx;
 }
 
-/* Convert a pair of index as normalize by JimRelToAbsIndex(),
- * into a range stored in *firstPtr, *lastPtr, *rangeLenPtr, suitable
- * for implementation of commands like [string range] and [lrange].
- *
- * The resulting range is guaranteed to address valid elements of
- * the structure. */
 static void JimRelToAbsRange(int len, int first, int last,
     int *firstPtr, int *lastPtr, int *rangeLenPtr)
 {
@@ -8953,7 +7664,7 @@ Jim_Obj *Jim_StringRangeObj(Jim_Interp *interp,
         return strObjPtr;
     }
     if (len == bytelen) {
-        /* ASCII optimisation */
+        
         return Jim_NewStringObj(interp, str + first, rangeLen);
     }
     return Jim_NewStringObjUtf8(interp, str + utf8_index(str, first), rangeLen);
@@ -9006,10 +7717,6 @@ static Jim_Obj *JimStringToUpper(Jim_Interp *interp, Jim_Obj *strObjPtr)
     return Jim_NewStringObjNoAlloc(interp, buf, len);
 }
 
-/* Similar to memchr() except searches a UTF-8 string 'str' of byte length 'len'
- * for unicode character 'c'.
- * Returns the position if found or NULL if not
- */
 static const char *utf8_memchr(const char *str, int len, int c)
 {
 #ifdef JIM_UTF8
@@ -9028,13 +7735,6 @@ static const char *utf8_memchr(const char *str, int len, int c)
 #endif
 }
 
-/**
- * Searches for the first non-trim char in string (str, len)
- *
- * If none is found, returns just past the last char.
- *
- * Lengths are in bytes.
- */
 static const char *JimFindTrimLeft(const char *str, int len, const char *trimchars, int trimlen)
 {
     while (len) {
@@ -9042,7 +7742,7 @@ static const char *JimFindTrimLeft(const char *str, int len, const char *trimcha
         int n = utf8_tounicode(str, &c);
 
         if (utf8_memchr(trimchars, trimlen, c) == NULL) {
-            /* Not a trim char, so stop */
+            
             break;
         }
         str += n;
@@ -9051,13 +7751,6 @@ static const char *JimFindTrimLeft(const char *str, int len, const char *trimcha
     return str;
 }
 
-/**
- * Searches backwards for a non-trim char in string (str, len).
- *
- * Returns a pointer to just after the non-trim char, or NULL if not found.
- *
- * Lengths are in bytes.
- */
 static const char *JimFindTrimRight(const char *str, int len, const char *trimchars, int trimlen)
 {
     str += len;
@@ -9080,7 +7773,7 @@ static const char *JimFindTrimRight(const char *str, int len, const char *trimch
 }
 
 static const char default_trim_chars[] = " \t\n\r";
-/* sizeof() here includes the null byte */
+
 static int default_trim_chars_len = sizeof(default_trim_chars);
 
 static Jim_Obj *JimStringTrimLeft(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
@@ -9121,7 +7814,7 @@ static Jim_Obj *JimStringTrimRight(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_O
     nontrim = JimFindTrimRight(strObjPtr->bytes, len, trimchars, trimcharslen);
 
     if (nontrim == NULL) {
-        /* All trim, so return a zero-length string */
+        
         return Jim_NewEmptyStringObj(interp);
     }
     if (nontrim == strObjPtr->bytes + len) {
@@ -9132,7 +7825,7 @@ static Jim_Obj *JimStringTrimRight(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_O
         strObjPtr = Jim_NewStringObj(interp, strObjPtr->bytes, (nontrim - strObjPtr->bytes));
     }
     else {
-        /* Can modify this string in place */
+        
         strObjPtr->bytes[nontrim - strObjPtr->bytes] = 0;
         strObjPtr->length = (nontrim - strObjPtr->bytes);
     }
@@ -9142,14 +7835,14 @@ static Jim_Obj *JimStringTrimRight(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_O
 
 static Jim_Obj *JimStringTrim(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr)
 {
-    /* First trim left. */
+    
     Jim_Obj *objPtr = JimStringTrimLeft(interp, strObjPtr, trimcharsObjPtr);
 
-    /* Now trim right */
+    
     strObjPtr = JimStringTrimRight(interp, objPtr, trimcharsObjPtr);
 
     if (objPtr != strObjPtr) {
-        /* Note that we don't want this object to be leaked */
+        
         Jim_IncrRefCount(objPtr);
         Jim_DecrRefCount(interp, objPtr);
     }
@@ -9228,20 +7921,7 @@ static int JimStringIs(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *strClass
     return JIM_OK;
 }
 
-/* -----------------------------------------------------------------------------
- * Compared String Object
- * ---------------------------------------------------------------------------*/
 
-/* This is strange object that allows to compare a C literal string
- * with a Jim object in very short time if the same comparison is done
- * multiple times. For example every time the [if] command is executed,
- * Jim has to check if a given argument is "else". This comparions if
- * the code has no errors are true most of the times, so we can cache
- * inside the object the pointer of the string of the last matching
- * comparison. Because most C compilers perform literal sharing,
- * so that: char *x = "foo", char *y = "foo", will lead to x == y,
- * this works pretty well even if comparisons are at different places
- * inside the C code. */
 
 static const Jim_ObjType comparedStringObjType = {
     "compared-string",
@@ -9251,11 +7931,6 @@ static const Jim_ObjType comparedStringObjType = {
     JIM_TYPE_REFERENCES,
 };
 
-/* The only way this object is exposed to the API is via the following
- * function. Returns true if the string and the object string repr.
- * are the same, otherwise zero is returned.
- *
- * Note: this isn't binary safe, but it hardly needs to be.*/
 int Jim_CompareStringImmediate(Jim_Interp *interp, Jim_Obj *objPtr, const char *str)
 {
     if (objPtr->typePtr == &comparedStringObjType && objPtr->internalRep.ptr == str)
@@ -9269,7 +7944,7 @@ int Jim_CompareStringImmediate(Jim_Interp *interp, Jim_Obj *objPtr, const char *
             Jim_FreeIntRep(interp, objPtr);
             objPtr->typePtr = &comparedStringObjType;
         }
-        objPtr->internalRep.ptr = (char *)str;  /*ATTENTION: const cast */
+        objPtr->internalRep.ptr = (char *)str;  
         return 1;
     }
 }
@@ -9283,27 +7958,6 @@ static int qsortCompareStringPointers(const void *a, const void *b)
 }
 
 
-/* -----------------------------------------------------------------------------
- * Source Object
- *
- * This object is just a string from the language point of view, but
- * in the internal representation it contains the filename and line number
- * where this given token was read. This information is used by
- * Jim_EvalObj() if the object passed happens to be of type "source".
- *
- * This allows to propagate the information about line numbers and file
- * names and give error messages with absolute line numbers.
- *
- * Note that this object uses shared strings for filenames, and the
- * pointer to the filename together with the line number is taken into
- * the space for the "inline" internal representation of the Jim_Object,
- * so there is almost memory zero-overhead.
- *
- * Also the object will be converted to something else if the given
- * token it represents in the source file is not something to be
- * evaluated (not a script), and will be specialized in some other way,
- * so the time overhead is also null.
- * ---------------------------------------------------------------------------*/
 
 static void FreeSourceInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
 static void DupSourceInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
@@ -9318,32 +7972,26 @@ static const Jim_ObjType sourceObjType = {
 
 void FreeSourceInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-    Jim_ReleaseSharedString(interp, objPtr->internalRep.sourceValue.fileName);
+    Jim_DecrRefCount(interp, objPtr->internalRep.sourceValue.fileNameObj);
 }
 
 void DupSourceInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
 {
-    dupPtr->internalRep.sourceValue.fileName =
-        Jim_GetSharedString(interp, srcPtr->internalRep.sourceValue.fileName);
-    dupPtr->internalRep.sourceValue.lineNumber = dupPtr->internalRep.sourceValue.lineNumber;
-    dupPtr->typePtr = &sourceObjType;
+    dupPtr->internalRep = srcPtr->internalRep;
+    Jim_IncrRefCount(dupPtr->internalRep.sourceValue.fileNameObj);
 }
 
 static void JimSetSourceInfo(Jim_Interp *interp, Jim_Obj *objPtr,
-    const char *fileName, int lineNumber)
+    Jim_Obj *fileNameObj, int lineNumber)
 {
-    if (fileName) {
-        JimPanic((Jim_IsShared(objPtr), interp, "JimSetSourceInfo called with shared object"));
-        JimPanic((objPtr->typePtr != NULL, interp, "JimSetSourceInfo called with typePtr != NULL"));
-        objPtr->internalRep.sourceValue.fileName = Jim_GetSharedString(interp, fileName);
-        objPtr->internalRep.sourceValue.lineNumber = lineNumber;
-        objPtr->typePtr = &sourceObjType;
-    }
+    JimPanic((Jim_IsShared(objPtr), "JimSetSourceInfo called with shared object"));
+    JimPanic((objPtr->typePtr != NULL, "JimSetSourceInfo called with typePtr != NULL"));
+    Jim_IncrRefCount(fileNameObj);
+    objPtr->internalRep.sourceValue.fileNameObj = fileNameObj;
+    objPtr->internalRep.sourceValue.lineNumber = lineNumber;
+    objPtr->typePtr = &sourceObjType;
 }
 
-/* -----------------------------------------------------------------------------
- * Script Object
- * ---------------------------------------------------------------------------*/
 
 static const Jim_ObjType scriptLineObjType = {
     "scriptline",
@@ -9385,94 +8033,22 @@ static const Jim_ObjType scriptObjType = {
     JIM_TYPE_REFERENCES,
 };
 
-/* The ScriptToken structure represents every token into a scriptObj.
- * Every token contains an associated Jim_Obj that can be specialized
- * by commands operating on it. */
 typedef struct ScriptToken
 {
     int type;
     Jim_Obj *objPtr;
 } ScriptToken;
 
-/* This is the script object internal representation. An array of
- * ScriptToken structures, including a pre-computed representation of the
- * command length and arguments.
- *
- * For example the script:
- *
- * puts hello
- * set $i $x$y [foo]BAR
- *
- * will produce a ScriptObj with the following Tokens:
- *
- * LIN 2
- * ESC puts
- * ESC hello
- * LIN 4
- * ESC set
- * VAR i
- * WRD 2
- * VAR x
- * VAR y
- * WRD 2
- * CMD foo
- * ESC BAR
- *
- * "puts hello" has two args (LIN 2), composed of single tokens.
- * (Note that the WRD token is omitted for the common case of a single token.)
- *
- * "set $i $x$y [foo]BAR" has four (LIN 4) args, the first word
- * has 1 token (ESC SET), and the last has two tokens (WRD 2 CMD foo ESC BAR)
- *
- * The precomputation of the command structure makes Jim_Eval() faster,
- * and simpler because there aren't dynamic lengths / allocations.
- *
- * -- {expand}/{*} handling --
- *
- * Expand is handled in a special way.
- *
- *   If a "word" begins with {*}, the word token count is -ve.
- *
- * For example the command:
- *
- * list {*}{a b}
- *
- * Will produce the following cmdstruct array:
- *
- * LIN 2
- * ESC list
- * WRD -1
- * STR a b
- *
- * Note that the 'LIN' token also contains the source information for the
- * first word of the line for error reporting purposes
- *
- * -- the substFlags field of the structure --
- *
- * The scriptObj structure is used to represent both "script" objects
- * and "subst" objects. In the second case, the there are no LIN and WRD
- * tokens. Instead SEP and EOL tokens are added as-is.
- * In addition, the field 'substFlags' is used to represent the flags used to turn
- * the string into the internal representation used to perform the
- * substitution. If this flags are not what the application requires
- * the scriptObj is created again. For example the script:
- *
- * subst -nocommands $string
- * subst -novariables $string
- *
- * Will recreate the internal representation of the $string object
- * two times.
- */
 typedef struct ScriptObj
 {
-    int len;                    /* Length as number of tokens. */
-    ScriptToken *token;         /* Tokens array. */
-    int substFlags;             /* flags used for the compilation of "subst" objects */
+    int len;                    
+    ScriptToken *token;         
+    int substFlags;             
     int inUse;                  /* Used to share a ScriptObj. Currently
                                    only used by Jim_EvalObj() as protection against
                                    shimmering of the currently evaluated object. */
-    const char *fileName;
-    int line;                   /* Line number of the first line */
+    Jim_Obj *fileNameObj;
+    int line;                   
 } ScriptObj;
 
 void FreeScriptInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
@@ -9487,9 +8063,7 @@ void FreeScriptInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
         Jim_DecrRefCount(interp, script->token[i].objPtr);
     }
     Jim_Free(script->token);
-    if (script->fileName) {
-        Jim_ReleaseSharedString(interp, script->fileName);
-    }
+    Jim_DecrRefCount(interp, script->fileNameObj);
     Jim_Free(script);
 }
 
@@ -9498,32 +8072,25 @@ void DupScriptInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
     JIM_NOTUSED(interp);
     JIM_NOTUSED(srcPtr);
 
-    /* Just returns an simple string. */
+    
     dupPtr->typePtr = NULL;
 }
 
-/* A simple parser token.
- * All the simple tokens for the script point into the same script string rep.
- */
 typedef struct
 {
-    const char *token;          /* Pointer to the start of the token */
-    int len;                    /* Length of this token */
-    int type;                   /* Token type */
-    int line;                   /* Line number */
+    const char *token;          
+    int len;                    
+    int type;                   
+    int line;                   
 } ParseToken;
 
-/* A list of parsed tokens representing a script.
- * Tokens are added to this list as the script is parsed.
- * It grows as needed.
- */
 typedef struct
 {
-    /* Start with a statically allocated list of tokens which will be expanded with realloc if needed */
-    ParseToken *list;           /* Array of tokens */
-    int size;                   /* Current size of the list */
-    int count;                  /* Number of entries used */
-    ParseToken static_list[20]; /* Small initial token space to avoid allocation */
+    
+    ParseToken *list;           
+    int size;                   
+    int count;                  
+    ParseToken static_list[20]; 
 } ParseTokenList;
 
 static void ScriptTokenListInit(ParseTokenList *tokenlist)
@@ -9540,25 +8107,20 @@ static void ScriptTokenListFree(ParseTokenList *tokenlist)
     }
 }
 
-/**
- * Adds the new token to the tokenlist.
- * The token has the given length, type and line number.
- * The token list is resized as necessary.
- */
 static void ScriptAddToken(ParseTokenList *tokenlist, const char *token, int len, int type,
     int line)
 {
     ParseToken *t;
 
     if (tokenlist->count == tokenlist->size) {
-        /* Resize the list */
+        
         tokenlist->size *= 2;
         if (tokenlist->list != tokenlist->static_list) {
             tokenlist->list =
                 Jim_Realloc(tokenlist->list, tokenlist->size * sizeof(*tokenlist->list));
         }
         else {
-            /* The list needs to become allocated */
+            
             tokenlist->list = Jim_Alloc(tokenlist->size * sizeof(*tokenlist->list));
             memcpy(tokenlist->list, tokenlist->static_list,
                 tokenlist->count * sizeof(*tokenlist->list));
@@ -9571,27 +8133,21 @@ static void ScriptAddToken(ParseTokenList *tokenlist, const char *token, int len
     t->line = line;
 }
 
-/* Counts the number of adjoining non-separator.
- *
- * Returns -ve if the first token is the expansion
- * operator (in which case the count doesn't include
- * that token).
- */
 static int JimCountWordTokens(ParseToken *t)
 {
     int expand = 1;
     int count = 0;
 
-    /* Is the first word {*} or {expand}? */
+    
     if (t->type == JIM_TT_STR && !TOKEN_IS_SEP(t[1].type)) {
         if ((t->len == 1 && *t->token == '*') || (t->len == 6 && strncmp(t->token, "expand", 6) == 0)) {
-            /* Create an expand token */
+            
             expand = -1;
             t++;
         }
     }
 
-    /* Now count non-separator words */
+    
     while (!TOKEN_IS_SEP(t->type)) {
         t++;
         count++;
@@ -9600,46 +8156,31 @@ static int JimCountWordTokens(ParseToken *t)
     return count * expand;
 }
 
-/**
- * Create a script/subst object from the given token.
- */
 static Jim_Obj *JimMakeScriptObj(Jim_Interp *interp, const ParseToken *t)
 {
     Jim_Obj *objPtr;
 
     if (t->type == JIM_TT_ESC && memchr(t->token, '\\', t->len) != NULL) {
-        /* Convert the backlash escapes . */
+        
         int len = t->len;
         char *str = Jim_Alloc(len + 1);
         len = JimEscape(str, t->token, len);
         objPtr = Jim_NewStringObjNoAlloc(interp, str, len);
     }
     else {
-        /* REVIST: Strictly, JIM_TT_STR should replace <backslash><newline><whitespace>
-         *         with a single space. This is currently not done.
-         */
         objPtr = Jim_NewStringObj(interp, t->token, t->len);
     }
     return objPtr;
 }
 
-/**
- * Takes a tokenlist and creates the allocated list of script tokens
- * in script->token, of length script->len.
- *
- * Unnecessary tokens are discarded, and LINE and WORD tokens are inserted
- * as required.
- *
- * Also sets script->line to the line number of the first token
- */
 static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
     ParseTokenList *tokenlist)
 {
     int i;
     struct ScriptToken *token;
-    /* Number of tokens so far for the current command */
+    
     int lineargs = 0;
-    /* This is the first token for the current command */
+    
     ScriptToken *linefirst;
     int count;
     int linenr;
@@ -9652,7 +8193,7 @@ static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
     }
 #endif
 
-    /* May need up to one extra script token for each EOL in the worst case */
+    
     count = tokenlist->count;
     for (i = 0; i < tokenlist->count; i++) {
         if (tokenlist->list[i].type == JIM_TT_EOL) {
@@ -9663,14 +8204,14 @@ static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
 
     token = script->token = Jim_Alloc(sizeof(ScriptToken) * count);
 
-    /* This is the first token for the current command */
+    
     linefirst = token++;
 
     for (i = 0; i < tokenlist->count; ) {
-        /* Look ahead to find out how many tokens make up the next word */
+        
         int wordtokens;
 
-        /* Skip any leading separators */
+        
         while (tokenlist->list[i].type == JIM_TT_SEP) {
             i++;
         }
@@ -9678,13 +8219,13 @@ static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
         wordtokens = JimCountWordTokens(tokenlist->list + i);
 
         if (wordtokens == 0) {
-            /* None, so at end of line */
+            
             if (lineargs) {
                 linefirst->type = JIM_TT_LINE;
                 linefirst->objPtr = JimNewScriptLineObj(interp, lineargs, linenr);
                 Jim_IncrRefCount(linefirst->objPtr);
 
-                /* Reset for new line */
+                
                 lineargs = 0;
                 linefirst = token++;
             }
@@ -9692,13 +8233,13 @@ static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
             continue;
         }
         else if (wordtokens != 1) {
-            /* More than 1, or {expand}, so insert a WORD token */
+            
             token->type = JIM_TT_WORD;
             token->objPtr = Jim_NewIntObj(interp, wordtokens);
             Jim_IncrRefCount(token->objPtr);
             token++;
             if (wordtokens < 0) {
-                /* Skip the expand token */
+                
                 i++;
                 wordtokens = -wordtokens - 1;
                 lineargs--;
@@ -9706,12 +8247,12 @@ static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
         }
 
         if (lineargs == 0) {
-            /* First real token on the line, so record the line number */
+            
             linenr = tokenlist->list[i].line;
         }
         lineargs++;
 
-        /* Add each non-separator word token to the line */
+        
         while (wordtokens--) {
             const ParseToken *t = &tokenlist->list[i++];
 
@@ -9719,10 +8260,7 @@ static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
             token->objPtr = JimMakeScriptObj(interp, t);
             Jim_IncrRefCount(token->objPtr);
 
-            /* Every object is initially a string, but the
-             * internal type may be specialized during execution of the
-             * script. */
-            JimSetSourceInfo(interp, token->objPtr, script->fileName, t->line);
+            JimSetSourceInfo(interp, token->objPtr, script->fileNameObj, t->line);
             token++;
         }
     }
@@ -9736,7 +8274,7 @@ static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
     assert(script->len < count);
 
 #ifdef DEBUG_SHOW_SCRIPT
-    printf("==== Script (%s) ====\n", script->fileName);
+    printf("==== Script (%s) ====\n", Jim_String(script->fileNameObj));
     for (i = 0; i < script->len; i++) {
         const ScriptToken *t = &script->token[i];
         printf("[%2d] %s %s\n", i, jim_tt_name(t->type), Jim_String(t->objPtr));
@@ -9745,9 +8283,6 @@ static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
 
 }
 
-/**
- * Similar to ScriptObjAddTokens(), but for subst objects.
- */
 static void SubstObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
     ParseTokenList *tokenlist)
 {
@@ -9759,7 +8294,7 @@ static void SubstObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
     for (i = 0; i < tokenlist->count; i++) {
         const ParseToken *t = &tokenlist->list[i];
 
-        /* Create a token for 't' */
+        
         token->type = t->type;
         token->objPtr = JimMakeScriptObj(interp, t);
         Jim_IncrRefCount(token->objPtr);
@@ -9769,9 +8304,6 @@ static void SubstObjAddTokens(Jim_Interp *interp, struct ScriptObj *script,
     script->len = i;
 }
 
-/* This method takes the string representation of an object
- * as a Tcl script, and generates the pre-parsed internal representation
- * of the script. */
 static int SetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr, struct JimParseResult *result)
 {
     int scriptTextLen;
@@ -9781,12 +8313,12 @@ static int SetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr, struct J
     ParseTokenList tokenlist;
     int line = 1;
 
-    /* Try to get information about filename / line number */
+    
     if (objPtr->typePtr == &sourceObjType) {
         line = objPtr->internalRep.sourceValue.lineNumber;
     }
 
-    /* Initially parse the script into tokens (in tokenlist) */
+    
     ScriptTokenListInit(&tokenlist);
 
     JimParserInit(&parser, scriptText, scriptTextLen, line);
@@ -9802,28 +8334,28 @@ static int SetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr, struct J
         return JIM_ERR;
     }
 
-    /* Add a final EOF token */
+    
     ScriptAddToken(&tokenlist, scriptText + scriptTextLen, 0, JIM_TT_EOF, 0);
 
-    /* Create the "real" script tokens from the initial token list */
+    
     script = Jim_Alloc(sizeof(*script));
     memset(script, 0, sizeof(*script));
     script->inUse = 1;
     script->line = line;
     if (objPtr->typePtr == &sourceObjType) {
-        script->fileName = Jim_GetSharedString(interp, objPtr->internalRep.sourceValue.fileName);
+        script->fileNameObj = objPtr->internalRep.sourceValue.fileNameObj;
+    }
+    else {
+        script->fileNameObj = interp->emptyObj;
     }
+    Jim_IncrRefCount(script->fileNameObj);
 
     ScriptObjAddTokens(interp, script, &tokenlist);
 
-    /* No longer need the token list */
+    
     ScriptTokenListFree(&tokenlist);
 
-    if (!script->fileName) {
-        script->fileName = Jim_GetSharedString(interp, "");
-    }
-
-    /* Free the old internal rep and set the new one. */
+    
     Jim_FreeIntRep(interp, objPtr);
     Jim_SetIntRepPtr(objPtr, script);
     objPtr->typePtr = &scriptObjType;
@@ -9841,9 +8373,6 @@ ScriptObj *Jim_GetScript(Jim_Interp *interp, Jim_Obj *objPtr)
     return (ScriptObj *) Jim_GetIntRepPtr(objPtr);
 }
 
-/* -----------------------------------------------------------------------------
- * Commands
- * ---------------------------------------------------------------------------*/
 static void JimIncrCmdRefCount(Jim_Cmd *cmdPtr)
 {
     cmdPtr->inUse++;
@@ -9860,12 +8389,12 @@ static void JimDecrCmdRefCount(Jim_Interp *interp, Jim_Cmd *cmdPtr)
                 Jim_Free(cmdPtr->u.proc.staticVars);
             }
             if (cmdPtr->u.proc.prevCmd) {
-                /* Delete any pushed command too */
+                
                 JimDecrCmdRefCount(interp, cmdPtr->u.proc.prevCmd);
             }
         }
         else {
-            /* native (C) */
+            
             if (cmdPtr->u.native.delProc) {
                 cmdPtr->u.native.delProc(interp, cmdPtr->u.native.privData);
             }
@@ -9874,24 +8403,21 @@ static void JimDecrCmdRefCount(Jim_Interp *interp, Jim_Cmd *cmdPtr)
     }
 }
 
-/* Commands HashTable Type.
- *
- * Keys are dynamic allocated strings, Values are Jim_Cmd structures. */
 static void JimCommandsHT_ValDestructor(void *interp, void *val)
 {
     JimDecrCmdRefCount(interp, val);
 }
 
 static const Jim_HashTableType JimCommandsHashTableType = {
-    JimStringCopyHTHashFunction,        /* hash function */
-    JimStringCopyHTKeyDup,      /* key dup */
-    NULL,                       /* val dup */
-    JimStringCopyHTKeyCompare,  /* key compare */
-    JimStringCopyHTKeyDestructor,       /* key destructor */
-    JimCommandsHT_ValDestructor        /* val destructor */
+    JimStringCopyHTHashFunction,        
+    JimStringCopyHTKeyDup,      
+    NULL,                       
+    JimStringCopyHTKeyCompare,  
+    JimStringCopyHTKeyDestructor,       
+    JimCommandsHT_ValDestructor        
 };
 
-/* ------------------------- Commands related functions --------------------- */
+
 
 int Jim_CreateCommand(Jim_Interp *interp, const char *cmdName,
     Jim_CmdProc cmdProc, void *privData, Jim_DelCmdProc delProc)
@@ -9899,13 +8425,13 @@ int Jim_CreateCommand(Jim_Interp *interp, const char *cmdName,
     Jim_Cmd *cmdPtr;
 
     if (Jim_DeleteHashEntry(&interp->commands, cmdName) != JIM_ERR) {
-        /* Command existed so incr proc epoch */
+        
         Jim_InterpIncrProcEpoch(interp);
     }
 
     cmdPtr = Jim_Alloc(sizeof(*cmdPtr));
 
-    /* Store the new details for this proc */
+    
     memset(cmdPtr, 0, sizeof(*cmdPtr));
     cmdPtr->inUse = 1;
     cmdPtr->u.native.delProc = delProc;
@@ -9914,9 +8440,6 @@ int Jim_CreateCommand(Jim_Interp *interp, const char *cmdName,
 
     Jim_AddHashEntry(&interp->commands, cmdName, cmdPtr);
 
-    /* There is no need to increment the 'proc epoch' because
-     * creation of a new procedure can never affect existing
-     * cached commands. We don't do negative caching. */
     return JIM_OK;
 }
 
@@ -9934,7 +8457,7 @@ static int JimCreateProcedure(Jim_Interp *interp, Jim_Obj *cmdName,
 
     argListLen = Jim_ListLength(interp, argListObjPtr);
 
-    /* Allocate space for both the command pointer and the arg list */
+    
     cmdPtr = Jim_Alloc(sizeof(*cmdPtr) + sizeof(struct Jim_ProcArg) * argListLen);
     memset(cmdPtr, 0, sizeof(*cmdPtr));
     cmdPtr->inUse = 1;
@@ -9947,7 +8470,7 @@ static int JimCreateProcedure(Jim_Interp *interp, Jim_Obj *cmdName,
     Jim_IncrRefCount(argListObjPtr);
     Jim_IncrRefCount(bodyObjPtr);
 
-    /* Create the statics hash table. */
+    
     if (staticsListObjPtr) {
         int len, i;
 
@@ -9961,11 +8484,9 @@ static int JimCreateProcedure(Jim_Interp *interp, Jim_Obj *cmdName,
                 int subLen;
 
                 Jim_ListIndex(interp, staticsListObjPtr, i, &objPtr, JIM_NONE);
-                /* Check if it's composed of two elements. */
+                
                 subLen = Jim_ListLength(interp, objPtr);
                 if (subLen == 1 || subLen == 2) {
-                    /* Try to get the variable value from the current
-                     * environment. */
                     Jim_ListIndex(interp, objPtr, 0, &nameObjPtr, JIM_NONE);
                     if (subLen == 1) {
                         initObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_NONE);
@@ -10005,8 +8526,8 @@ static int JimCreateProcedure(Jim_Interp *interp, Jim_Obj *cmdName,
         }
     }
 
-    /* Parse the args out into arglist, validating as we go */
-    /* Examine the argument list for default parameters and 'args' */
+    
+    
     for (i = 0; i < argListLen; i++) {
         Jim_Obj *argPtr;
         Jim_Obj *nameObjPtr;
@@ -10014,7 +8535,7 @@ static int JimCreateProcedure(Jim_Interp *interp, Jim_Obj *cmdName,
         int len;
         int n = 1;
 
-        /* Examine a parameter */
+        
         Jim_ListIndex(interp, argListObjPtr, i, &argPtr, JIM_NONE);
         len = Jim_ListLength(interp, argPtr);
         if (len == 0) {
@@ -10027,12 +8548,12 @@ static int JimCreateProcedure(Jim_Interp *interp, Jim_Obj *cmdName,
         }
 
         if (len == 2) {
-            /* Optional parameter */
+            
             Jim_ListIndex(interp, argPtr, 0, &nameObjPtr, JIM_NONE);
             Jim_ListIndex(interp, argPtr, 1, &defaultObjPtr, JIM_NONE);
         }
         else {
-            /* Required parameter */
+            
             nameObjPtr = argPtr;
             defaultObjPtr = NULL;
         }
@@ -10058,42 +8579,29 @@ static int JimCreateProcedure(Jim_Interp *interp, Jim_Obj *cmdName,
         cmdPtr->u.proc.arglist[i].defaultObjPtr = defaultObjPtr;
     }
 
-    /* Add the new command */
+    
 
-    /* It may already exist, so we try to delete the old one.
-     * Note that reference count means that it won't be deleted yet if
-     * it exists in the call stack.
-     *
-     * BUT, if 'local' is in force, instead of deleting the existing
-     * proc, we stash a reference to the old proc here.
-     */
     he = Jim_FindHashEntry(&interp->commands, Jim_String(cmdName));
     if (he) {
-        /* There was an old procedure with the same name, this requires
-         * a 'proc epoch' update. */
 
-        /* If a procedure with the same name didn't existed there is no need
-         * to increment the 'proc epoch' because creation of a new procedure
-         * can never affect existing cached commands. We don't do
-         * negative caching. */
         Jim_InterpIncrProcEpoch(interp);
     }
 
     if (he && interp->local) {
-        /* Just push this proc over the top of the previous one */
+        
         cmdPtr->u.proc.prevCmd = he->u.val;
         he->u.val = cmdPtr;
     }
     else {
         if (he) {
-            /* Replace the existing proc */
+            
             Jim_DeleteHashEntry(&interp->commands, Jim_String(cmdName));
         }
 
         Jim_AddHashEntry(&interp->commands, Jim_String(cmdName), cmdPtr);
     }
 
-    /* Unlike Tcl, set the name of the proc as the result */
+    
     Jim_SetResult(interp, cmdName);
     return JIM_OK;
 
@@ -10120,7 +8628,7 @@ int Jim_RenameCommand(Jim_Interp *interp, const char *oldName, const char *newNa
 {
     Jim_HashEntry *he;
 
-    /* Does it exist? */
+    
     he = Jim_FindHashEntry(&interp->commands, oldName);
     if (he == NULL) {
         Jim_SetResultFormatted(interp, "can't %s \"%s\": command doesn't exist",
@@ -10128,30 +8636,27 @@ int Jim_RenameCommand(Jim_Interp *interp, const char *oldName, const char *newNa
         return JIM_ERR;
     }
 
-    if (newName[0] == '\0')     /* Delete! */
+    if (newName[0] == '\0')     
         return Jim_DeleteCommand(interp, oldName);
 
-    /* rename */
+    
     if (Jim_FindHashEntry(&interp->commands, newName)) {
         Jim_SetResultFormatted(interp, "can't rename to \"%s\": command already exists", newName);
         return JIM_ERR;
     }
 
-    /* Add the new name first */
+    
     JimIncrCmdRefCount(he->u.val);
     Jim_AddHashEntry(&interp->commands, newName, he->u.val);
 
-    /* Now remove the old name */
+    
     Jim_DeleteHashEntry(&interp->commands, oldName);
 
-    /* Increment the epoch */
+    
     Jim_InterpIncrProcEpoch(interp);
     return JIM_OK;
 }
 
-/* -----------------------------------------------------------------------------
- * Command object
- * ---------------------------------------------------------------------------*/
 
 static int SetCommandFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
@@ -10168,14 +8673,14 @@ int SetCommandFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
     Jim_HashEntry *he;
     const char *cmdName;
 
-    /* Get the string representation */
+    
     cmdName = Jim_String(objPtr);
-    /* Lookup this name into the commands hash table */
+    
     he = Jim_FindHashEntry(&interp->commands, cmdName);
     if (he == NULL)
         return JIM_ERR;
 
-    /* Free the old internal repr and set the new one. */
+    
     Jim_FreeIntRep(interp, objPtr);
     objPtr->typePtr = &commandObjType;
     objPtr->internalRep.cmdValue.procEpoch = interp->procEpoch;
@@ -10183,14 +8688,6 @@ int SetCommandFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
     return JIM_OK;
 }
 
-/* This function returns the command structure for the command name
- * stored in objPtr. It tries to specialize the objPtr to contain
- * a cached info instead to perform the lookup into the hash table
- * every time. The information cached may not be uptodate, in such
- * a case the lookup is performed and the cache updated.
- *
- * Respects the 'upcall' setting
- */
 Jim_Cmd *Jim_GetCommand(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
 {
     Jim_Cmd *cmd;
@@ -10210,13 +8707,7 @@ Jim_Cmd *Jim_GetCommand(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
     return cmd;
 }
 
-/* -----------------------------------------------------------------------------
- * Variables
- * ---------------------------------------------------------------------------*/
 
-/* Variables HashTable Type.
- *
- * Keys are dynamic allocated strings, Values are Jim_Var structures. */
 static void JimVariablesHTValDestructor(void *interp, void *val)
 {
     Jim_Var *varPtr = (void *)val;
@@ -10226,19 +8717,16 @@ static void JimVariablesHTValDestructor(void *interp, void *val)
 }
 
 static const Jim_HashTableType JimVariablesHashTableType = {
-    JimStringCopyHTHashFunction,        /* hash function */
-    JimStringCopyHTKeyDup,      /* key dup */
-    NULL,                       /* val dup */
-    JimStringCopyHTKeyCompare,  /* key compare */
-    JimStringCopyHTKeyDestructor,       /* key destructor */
-    JimVariablesHTValDestructor /* val destructor */
+    JimStringCopyHTHashFunction,        
+    JimStringCopyHTKeyDup,      
+    NULL,                       
+    JimStringCopyHTKeyCompare,  
+    JimStringCopyHTKeyDestructor,       
+    JimVariablesHTValDestructor 
 };
 
-/* -----------------------------------------------------------------------------
- * Variable object
- * ---------------------------------------------------------------------------*/
 
-#define JIM_DICT_SUGAR 100      /* Only returned by SetVariableFromAny() */
+#define JIM_DICT_SUGAR 100      
 
 static int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
@@ -10250,8 +8738,6 @@ static const Jim_ObjType variableObjType = {
     JIM_TYPE_REFERENCES,
 };
 
-/* Return true if the string "str" looks like syntax sugar for [dict]. I.e.
- * is in the form "varname(key)". */
 static int JimNameIsDictSugar(const char *str, int len)
 {
     if (len && str[len - 1] == ')' && strchr(str, '(') != NULL)
@@ -10259,15 +8745,9 @@ static int JimNameIsDictSugar(const char *str, int len)
     return 0;
 }
 
-/**
- * Check that the name does not contain embedded nulls.
- *
- * Variable and procedure names are maniplated as null terminated strings, so
- * don't allow names with embedded nulls.
- */
 static int JimValidName(Jim_Interp *interp, const char *type, Jim_Obj *nameObjPtr)
 {
-    /* Variable names and proc names can't contain embedded nulls */
+    
     if (nameObjPtr->typePtr != &variableObjType) {
         int len;
         const char *str = Jim_GetString(nameObjPtr, &len);
@@ -10279,11 +8759,6 @@ static int JimValidName(Jim_Interp *interp, const char *type, Jim_Obj *nameObjPt
     return JIM_OK;
 }
 
-/* This method should be called only by the variable API.
- * It returns JIM_OK on success (variable already exists),
- * JIM_ERR if it does not exists, JIM_DICT_SUGAR if it's not
- * a variable name, but syntax glue for [dict] i.e. the last
- * character is ')' */
 static int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
 {
     Jim_HashEntry *he;
@@ -10291,10 +8766,10 @@ static int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
     int len;
     Jim_CallFrame *framePtr = interp->framePtr;
 
-    /* Check if the object is already an uptodate variable */
+    
     if (objPtr->typePtr == &variableObjType &&
         objPtr->internalRep.varValue.callFrameId == framePtr->id) {
-        return JIM_OK;          /* nothing to do */
+        return JIM_OK;          
     }
 
     if (objPtr->typePtr == &dictSubstObjType) {
@@ -10305,10 +8780,10 @@ static int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
         return JIM_ERR;
     }
 
-    /* Get the string representation */
+    
     varName = Jim_GetString(objPtr, &len);
 
-    /* Make sure it's not syntax glue to get/set dict. */
+    
     if (JimNameIsDictSugar(varName, len)) {
         return JIM_DICT_SUGAR;
     }
@@ -10321,17 +8796,17 @@ static int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
         }
     }
     else {
-        /* Lookup this name into the variables hash table */
+        
         he = Jim_FindHashEntry(&framePtr->vars, varName);
         if (he == NULL) {
-            /* Try with static vars. */
+            
             if (framePtr->staticVars == NULL)
                 return JIM_ERR;
             if (!(he = Jim_FindHashEntry(framePtr->staticVars, varName)))
                 return JIM_ERR;
         }
     }
-    /* Free the old internal repr and set the new one. */
+    
     Jim_FreeIntRep(interp, objPtr);
     objPtr->typePtr = &variableObjType;
     objPtr->internalRep.varValue.callFrameId = framePtr->id;
@@ -10339,15 +8814,10 @@ static int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
     return JIM_OK;
 }
 
-/* -------------------- Variables related functions ------------------------- */
+
 static int JimDictSugarSet(Jim_Interp *interp, Jim_Obj *ObjPtr, Jim_Obj *valObjPtr);
 static Jim_Obj *JimDictSugarGet(Jim_Interp *interp, Jim_Obj *ObjPtr, int flags);
 
-/* For now that's dummy. Variables lookup should be optimized
- * in many ways, with caching of lookups, and possibly with
- * a table of pre-allocated vars in every CallFrame for local vars.
- * All the caching should also have an 'epoch' mechanism similar
- * to the one used by Tcl for procedures lookup caching. */
 
 int Jim_SetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr)
 {
@@ -10358,7 +8828,7 @@ int Jim_SetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr)
     if ((err = SetVariableFromAny(interp, nameObjPtr)) != JIM_OK) {
         Jim_CallFrame *framePtr = interp->framePtr;
 
-        /* Check for [dict] syntax sugar. */
+        
         if (err == JIM_DICT_SUGAR)
             return JimDictSugarSet(interp, nameObjPtr, valObjPtr);
 
@@ -10366,23 +8836,23 @@ int Jim_SetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr)
             return JIM_ERR;
         }
 
-        /* New variable to create */
+        
         name = Jim_String(nameObjPtr);
 
         var = Jim_Alloc(sizeof(*var));
         var->objPtr = valObjPtr;
         Jim_IncrRefCount(valObjPtr);
         var->linkFramePtr = NULL;
-        /* Insert the new variable */
+        
         if (name[0] == ':' && name[1] == ':') {
-            /* Into the top level frame */
+            
             framePtr = interp->topFramePtr;
             Jim_AddHashEntry(&framePtr->vars, name + 2, var);
         }
         else {
             Jim_AddHashEntry(&framePtr->vars, name, var);
         }
-        /* Make the object int rep a variable */
+        
         Jim_FreeIntRep(interp, nameObjPtr);
         nameObjPtr->typePtr = &variableObjType;
         nameObjPtr->internalRep.varValue.callFrameId = framePtr->id;
@@ -10395,7 +8865,7 @@ int Jim_SetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr)
             Jim_DecrRefCount(interp, var->objPtr);
             var->objPtr = valObjPtr;
         }
-        else {                  /* Else handle the link */
+        else {                  
             Jim_CallFrame *savedCallFrame;
 
             savedCallFrame = interp->framePtr;
@@ -10457,7 +8927,7 @@ int Jim_SetVariableLink(Jim_Interp *interp, Jim_Obj *nameObjPtr,
     varName = Jim_GetString(nameObjPtr, &len);
 
     if (varName[0] == ':' && varName[1] == ':') {
-        /* Linking a global var does nothing */
+        
         return JIM_OK;
     }
 
@@ -10466,7 +8936,7 @@ int Jim_SetVariableLink(Jim_Interp *interp, Jim_Obj *nameObjPtr,
         return JIM_ERR;
     }
 
-    /* Check for an existing variable or link */
+    
     if (SetVariableFromAny(interp, nameObjPtr) == JIM_OK) {
         Jim_Var *varPtr = nameObjPtr->internalRep.varValue.varPtr;
 
@@ -10475,16 +8945,16 @@ int Jim_SetVariableLink(Jim_Interp *interp, Jim_Obj *nameObjPtr,
             return JIM_ERR;
         }
 
-        /* It exists, but is a link, so delete the link */
+        
         varPtr->linkFramePtr = NULL;
     }
 
-    /* Check for cycles. */
+    
     if (interp->framePtr == targetCallFrame) {
         Jim_Obj *objPtr = targetNameObjPtr;
         Jim_Var *varPtr;
 
-        /* Cycles are only possible with 'uplevel 0' */
+        
         while (1) {
             if (Jim_StringEqObj(objPtr, nameObjPtr)) {
                 Jim_SetResultString(interp, "can't upvar from variable to itself", -1);
@@ -10499,23 +8969,13 @@ int Jim_SetVariableLink(Jim_Interp *interp, Jim_Obj *nameObjPtr,
         }
     }
 
-    /* Perform the binding */
+    
     Jim_SetVariable(interp, nameObjPtr, targetNameObjPtr);
-    /* We are now sure 'nameObjPtr' type is variableObjType */
+    
     nameObjPtr->internalRep.varValue.varPtr->linkFramePtr = targetCallFrame;
     return JIM_OK;
 }
 
-/* Return the Jim_Obj pointer associated with a variable name,
- * or NULL if the variable was not found in the current context.
- * The same optimization discussed in the comment to the
- * 'SetVariable' function should apply here.
- *
- * If JIM_UNSHARED is set and the variable is an array element (dict sugar)
- * in a dictionary which is shared, the array variable value is duplicated first.
- * This allows the array element to be updated (e.g. append, lappend) without
- * affecting other references to the dictionary.
- */
 Jim_Obj *Jim_GetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
 {
     switch (SetVariableFromAny(interp, nameObjPtr)) {
@@ -10528,7 +8988,7 @@ Jim_Obj *Jim_GetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
                 else {
                     Jim_Obj *objPtr;
 
-                    /* The variable is a link? Resolve it. */
+                    
                     Jim_CallFrame *savedCallFrame = interp->framePtr;
 
                     interp->framePtr = varPtr->linkFramePtr;
@@ -10537,13 +8997,13 @@ Jim_Obj *Jim_GetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
                     if (objPtr) {
                         return objPtr;
                     }
-                    /* Error, so fall through to the error message */
+                    
                 }
             }
             break;
 
         case JIM_DICT_SUGAR:
-            /* [dict] syntax sugar. */
+            
             return JimDictSugarGet(interp, nameObjPtr, flags);
     }
     if (flags & JIM_ERRMSG) {
@@ -10589,9 +9049,6 @@ Jim_Obj *Jim_GetGlobalVariableStr(Jim_Interp *interp, const char *name, int flag
     return objPtr;
 }
 
-/* Unset a variable.
- * Note: On success unset invalidates all the variable objects created
- * in the current call frame incrementing. */
 int Jim_UnsetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
 {
     const char *name;
@@ -10600,13 +9057,13 @@ int Jim_UnsetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
 
     retval = SetVariableFromAny(interp, nameObjPtr);
     if (retval == JIM_DICT_SUGAR) {
-        /* [dict] syntax sugar. */
+        
         return JimDictSugarSet(interp, nameObjPtr, NULL);
     }
     else if (retval == JIM_OK) {
         varPtr = nameObjPtr->internalRep.varValue.varPtr;
 
-        /* If it's a link call UnsetVariable recursively */
+        
         if (varPtr->linkFramePtr) {
             Jim_CallFrame *savedCallFrame;
 
@@ -10625,7 +9082,7 @@ int Jim_UnsetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
             }
             retval = Jim_DeleteHashEntry(&framePtr->vars, name);
             if (retval == JIM_OK) {
-                /* Change the callframe id, invalidating var lookup caching */
+                
                 JimChangeCallFrameId(interp, framePtr);
             }
         }
@@ -10636,15 +9093,8 @@ int Jim_UnsetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
     return retval;
 }
 
-/* ----------  Dict syntax sugar (similar to array Tcl syntax) -------------- */
 
-/* Given a variable name for [dict] operation syntax sugar,
- * this function returns two objects, the first with the name
- * of the variable to set, and the second with the rispective key.
- * For example "foo(bar)" will return objects with string repr. of
- * "foo" and "bar".
- *
- * The returned objects have refcount = 1. The function can't fail. */
+
 static void JimDictSugarParseVarKey(Jim_Interp *interp, Jim_Obj *objPtr,
     Jim_Obj **varPtrPtr, Jim_Obj **keyPtrPtr)
 {
@@ -10655,7 +9105,7 @@ static void JimDictSugarParseVarKey(Jim_Interp *interp, Jim_Obj *objPtr,
     str = Jim_GetString(objPtr, &len);
 
     p = strchr(str, '(');
-    JimPanic((p == NULL, interp, "JimDictSugarParseVarKey() called for non-dict-sugar (%s)", str));
+    JimPanic((p == NULL, "JimDictSugarParseVarKey() called for non-dict-sugar (%s)", str));
 
     varObjPtr = Jim_NewStringObj(interp, str, p - str);
 
@@ -10665,7 +9115,7 @@ static void JimDictSugarParseVarKey(Jim_Interp *interp, Jim_Obj *objPtr,
         keyLen--;
     }
 
-    /* Create the objects with the variable name and key. */
+    
     keyObjPtr = Jim_NewStringObj(interp, p, keyLen);
 
     Jim_IncrRefCount(varObjPtr);
@@ -10674,8 +9124,6 @@ static void JimDictSugarParseVarKey(Jim_Interp *interp, Jim_Obj *objPtr,
     *keyPtrPtr = keyObjPtr;
 }
 
-/* Helper of Jim_SetVariable() to deal with dict-syntax variable names.
- * Also used by Jim_UnsetVariable() with valObjPtr = NULL. */
 static int JimDictSugarSet(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *valObjPtr)
 {
     int err;
@@ -10683,34 +9131,28 @@ static int JimDictSugarSet(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *valObjP
     SetDictSubstFromAny(interp, objPtr);
 
     err = Jim_SetDictKeysVector(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr,
-        &objPtr->internalRep.dictSubstValue.indexObjPtr, 1, valObjPtr);
+        &objPtr->internalRep.dictSubstValue.indexObjPtr, 1, valObjPtr, JIM_ERRMSG);
 
     if (err == JIM_OK) {
-        /* Don't keep an extra ref to the result */
+        
         Jim_SetEmptyResult(interp);
     }
     else {
         if (!valObjPtr) {
-            /* Better error message for unset a(2) where a exists but a(2) doesn't */
+            
             if (Jim_GetVariable(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr, JIM_NONE)) {
                 Jim_SetResultFormatted(interp, "can't unset \"%#s\": no such element in array",
                     objPtr);
                 return err;
             }
         }
-        /* Make the error more informative and Tcl-compatible */
+        
         Jim_SetResultFormatted(interp, "can't %s \"%#s\": variable isn't array",
             (valObjPtr ? "set" : "unset"), objPtr);
     }
     return err;
 }
 
-/**
- * Expands the array variable (dict sugar) and returns the result, or NULL on error.
- *
- * If JIM_UNSHARED is set and the dictionary is shared, it will be duplicated
- * and stored back to the variable before expansion.
- */
 static Jim_Obj *JimDictExpandArrayVariable(Jim_Interp *interp, Jim_Obj *varObjPtr,
     Jim_Obj *keyObjPtr, int flags)
 {
@@ -10738,17 +9180,17 @@ static Jim_Obj *JimDictExpandArrayVariable(Jim_Interp *interp, Jim_Obj *varObjPt
     else if ((flags & JIM_UNSHARED) && Jim_IsShared(dictObjPtr)) {
         dictObjPtr = Jim_DuplicateObj(interp, dictObjPtr);
         if (Jim_SetVariable(interp, varObjPtr, dictObjPtr) != JIM_OK) {
-            /* This can probably never happen */
-            JimPanic((1, interp, "SetVariable failed for JIM_UNSHARED"));
+            
+            JimPanic((1, "SetVariable failed for JIM_UNSHARED"));
         }
-        /* We know that the key exists. Get the result in the now-unshared dictionary */
+        
         Jim_DictKey(interp, dictObjPtr, keyObjPtr, &resObjPtr, JIM_NONE);
     }
 
     return resObjPtr;
 }
 
-/* Helper of Jim_GetVariable() to deal with dict-syntax variable names */
+
 static Jim_Obj *JimDictSugarGet(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
 {
     SetDictSubstFromAny(interp, objPtr);
@@ -10758,7 +9200,7 @@ static Jim_Obj *JimDictSugarGet(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
         objPtr->internalRep.dictSubstValue.indexObjPtr, flags);
 }
 
-/* --------- $var(INDEX) substitution, using a specialized object ----------- */
+
 
 void FreeDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
 {
@@ -10776,14 +9218,14 @@ void DupDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPt
     dupPtr->typePtr = &dictSubstObjType;
 }
 
-/* Note: The object *must* be in dict-sugar format */
+
 static void SetDictSubstFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 {
     if (objPtr->typePtr != &dictSubstObjType) {
         Jim_Obj *varObjPtr, *keyObjPtr;
 
         if (objPtr->typePtr == &interpolatedObjType) {
-            /* An interpolated object in dict-sugar form */
+            
 
             const ScriptToken *token = objPtr->internalRep.twoPtrValue.ptr1;
 
@@ -10804,12 +9246,6 @@ static void SetDictSubstFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
     }
 }
 
-/* This function is used to expand [dict get] sugar in the form
- * of $var(INDEX). The function is mainly used by Jim_EvalObj()
- * to deal with tokens of type JIM_TT_DICTSUGAR. objPtr points to an
- * object that is *guaranteed* to be in the form VARNAME(INDEX).
- * The 'index' part is [subst]ituted, and is used to lookup a key inside
- * the [dict]ionary contained in variable VARNAME. */
 static Jim_Obj *JimExpandDictSugar(Jim_Interp *interp, Jim_Obj *objPtr)
 {
     Jim_Obj *resObjPtr = NULL;
@@ -10836,16 +9272,13 @@ static Jim_Obj *JimExpandExprSugar(Jim_Interp *interp, Jim_Obj *objPtr)
     Jim_Obj *resultObjPtr;
 
     if (Jim_EvalExpression(interp, objPtr, &resultObjPtr) == JIM_OK) {
-        /* Note that the result has a ref count of 1, but we need a ref count of 0 */
+        
         resultObjPtr->refCount--;
         return resultObjPtr;
     }
     return NULL;
 }
 
-/* -----------------------------------------------------------------------------
- * CallFrame
- * ---------------------------------------------------------------------------*/
 
 static Jim_CallFrame *JimCreateCallFrame(Jim_Interp *interp, Jim_CallFrame *parent)
 {
@@ -10874,14 +9307,14 @@ static Jim_CallFrame *JimCreateCallFrame(Jim_Interp *interp, Jim_CallFrame *pare
     return cf;
 }
 
-/* Used to invalidate every caching related to callframe stability. */
+
 static void JimChangeCallFrameId(Jim_Interp *interp, Jim_CallFrame *cf)
 {
     cf->id = interp->callFrameEpoch++;
 }
 
-#define JIM_FCF_NONE 0          /* no flags */
-#define JIM_FCF_NOHT 1          /* don't free the hash table */
+#define JIM_FCF_NONE 0          
+#define JIM_FCF_NOHT 1          
 static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int flags)
 {
     if (cf->procArgsObjPtr)
@@ -10902,7 +9335,7 @@ static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int flags)
 
                 Jim_DecrRefCount(interp, varPtr->objPtr);
                 Jim_Free(he->u.val);
-                Jim_Free((void *)he->key);      /* ATTENTION: const cast */
+                Jim_Free((void *)he->key);      
                 Jim_Free(he);
                 table[i] = NULL;
                 he = nextEntry;
@@ -10914,16 +9347,8 @@ static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int flags)
     interp->freeFramesList = cf;
 }
 
-/* -----------------------------------------------------------------------------
- * References
- * ---------------------------------------------------------------------------*/
 #ifdef JIM_REFERENCES
 
-/* References HashTable Type.
- *
- * Keys are jim_wide integers, dynamically allocated for now but in the
- * future it's worth to cache this 8 bytes objects. Values are poitners
- * to Jim_References. */
 static void JimReferencesHTValDestructor(void *interp, void *val)
 {
     Jim_Reference *refPtr = (void *)val;
@@ -10937,7 +9362,7 @@ static void JimReferencesHTValDestructor(void *interp, void *val)
 
 static unsigned int JimReferencesHTHashFunction(const void *key)
 {
-    /* Only the least significant bits are used. */
+    
     const jim_wide *widePtr = key;
     unsigned int intValue = (unsigned int)*widePtr;
 
@@ -10969,24 +9394,15 @@ static void JimReferencesHTKeyDestructor(void *privdata, const void *key)
 }
 
 static const Jim_HashTableType JimReferencesHashTableType = {
-    JimReferencesHTHashFunction,        /* hash function */
-    JimReferencesHTKeyDup,      /* key dup */
-    NULL,                       /* val dup */
-    JimReferencesHTKeyCompare,  /* key compare */
-    JimReferencesHTKeyDestructor,       /* key destructor */
-    JimReferencesHTValDestructor        /* val destructor */
+    JimReferencesHTHashFunction,        
+    JimReferencesHTKeyDup,      
+    NULL,                       
+    JimReferencesHTKeyCompare,  
+    JimReferencesHTKeyDestructor,       
+    JimReferencesHTValDestructor        
 };
 
-/* -----------------------------------------------------------------------------
- * Reference object type and References API
- * ---------------------------------------------------------------------------*/
 
-/* The string representation of references has two features in order
- * to make the GC faster. The first is that every reference starts
- * with a non common character '<', in order to make the string matching
- * faster. The second is that the reference string rep is 42 characters
- * in length, this allows to avoid to check every object with a string
- * repr < 42, and usually there aren't many of these objects. */
 
 #define JIM_REFERENCE_SPACE (35+JIM_REFERENCE_TAGLEN)
 
@@ -11021,8 +9437,6 @@ void UpdateStringOfReference(struct Jim_Obj *objPtr)
     objPtr->length = len;
 }
 
-/* returns true if 'c' is a valid reference tag character.
- * i.e. inside the range [_a-zA-Z0-9] */
 static int isrefchar(int c)
 {
     return (c == '_' || isalnum(c));
@@ -11037,12 +9451,12 @@ static int SetReferenceFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
     Jim_Reference *refPtr;
     Jim_HashEntry *he;
 
-    /* Get the string representation */
+    
     str = Jim_GetString(objPtr, &len);
-    /* Check if it looks like a reference */
+    
     if (len < JIM_REFERENCE_SPACE)
         goto badformat;
-    /* Trim spaces */
+    
     start = str;
     end = str + len - 1;
     while (*start == ' ')
@@ -11051,30 +9465,30 @@ static int SetReferenceFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
         end--;
     if (end - start + 1 != JIM_REFERENCE_SPACE)
         goto badformat;
-    /* <reference.<1234567>.%020> */
+    
     if (memcmp(start, "<reference.<", 12) != 0)
         goto badformat;
     if (start[12 + JIM_REFERENCE_TAGLEN] != '>' || end[0] != '>')
         goto badformat;
-    /* The tag can't contain chars other than a-zA-Z0-9 + '_'. */
+    
     for (i = 0; i < JIM_REFERENCE_TAGLEN; i++) {
         if (!isrefchar(start[12 + i]))
             goto badformat;
     }
-    /* Extract info from the reference. */
+    
     memcpy(refId, start + 14 + JIM_REFERENCE_TAGLEN, 20);
     refId[20] = '\0';
-    /* Try to convert the ID into a jim_wide */
+    
     if (Jim_StringToWide(refId, &wideValue, 10) != JIM_OK)
         goto badformat;
-    /* Check if the reference really exists! */
+    
     he = Jim_FindHashEntry(&interp->references, &wideValue);
     if (he == NULL) {
         Jim_SetResultFormatted(interp, "invalid reference id \"%#s\"", objPtr);
         return JIM_ERR;
     }
     refPtr = he->u.val;
-    /* Free the old internal repr and set the new one. */
+    
     Jim_FreeIntRep(interp, objPtr);
     objPtr->typePtr = &referenceObjType;
     objPtr->internalRep.refValue.id = wideValue;
@@ -11086,9 +9500,6 @@ static int SetReferenceFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
     return JIM_ERR;
 }
 
-/* Returns a new reference pointing to objPtr, having cmdNamePtr
- * as finalizer command (or NULL if there is no finalizer).
- * The returned reference object has refcount = 0. */
 Jim_Obj *Jim_NewReference(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *tagPtr, Jim_Obj *cmdNamePtr)
 {
     struct Jim_Reference *refPtr;
@@ -11097,7 +9508,7 @@ Jim_Obj *Jim_NewReference(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *tagPtr,
     const char *tag;
     int tagLen, i;
 
-    /* Perform the Garbage Collection if needed. */
+    
     Jim_CollectIfNeeded(interp);
 
     refPtr = Jim_Alloc(sizeof(*refPtr));
@@ -11113,8 +9524,6 @@ Jim_Obj *Jim_NewReference(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *tagPtr,
     refObjPtr->internalRep.refValue.id = interp->referenceNextId;
     refObjPtr->internalRep.refValue.refPtr = refPtr;
     interp->referenceNextId++;
-    /* Set the tag. Trimmed at JIM_REFERENCE_TAGLEN. Everything
-     * that does not pass the 'isrefchar' test is replaced with '_' */
     tag = Jim_GetString(tagPtr, &tagLen);
     if (tagLen > JIM_REFERENCE_TAGLEN)
         tagLen = JIM_REFERENCE_TAGLEN;
@@ -11158,152 +9567,21 @@ int Jim_GetFinalizer(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj **cmdNamePtrPt
     return JIM_OK;
 }
 
-/* -----------------------------------------------------------------------------
- * References Garbage Collection
- * ---------------------------------------------------------------------------*/
 
-/* This the hash table type for the "MARK" phase of the GC */
+
 static const Jim_HashTableType JimRefMarkHashTableType = {
-    JimReferencesHTHashFunction,        /* hash function */
-    JimReferencesHTKeyDup,      /* key dup */
-    NULL,                       /* val dup */
-    JimReferencesHTKeyCompare,  /* key compare */
-    JimReferencesHTKeyDestructor,       /* key destructor */
-    NULL                        /* val destructor */
+    JimReferencesHTHashFunction,        
+    JimReferencesHTKeyDup,      
+    NULL,                       
+    JimReferencesHTKeyCompare,  
+    JimReferencesHTKeyDestructor,       
+    NULL                        
 };
 
-/* Performs the garbage collection. */
+
 int Jim_Collect(Jim_Interp *interp)
 {
-    Jim_HashTable marks;
-    Jim_HashTableIterator *htiter;
-    Jim_HashEntry *he;
-    Jim_Obj *objPtr;
     int collected = 0;
-
-    /* Avoid recursive calls */
-    if (interp->lastCollectId == -1) {
-        /* Jim_Collect() already running. Return just now. */
-        return 0;
-    }
-    interp->lastCollectId = -1;
-
-    /* Mark all the references found into the 'mark' hash table.
-     * The references are searched in every live object that
-     * is of a type that can contain references. */
-    Jim_InitHashTable(&marks, &JimRefMarkHashTableType, NULL);
-    objPtr = interp->liveList;
-    while (objPtr) {
-        if (objPtr->typePtr == NULL || objPtr->typePtr->flags & JIM_TYPE_REFERENCES) {
-            const char *str, *p;
-            int len;
-
-            /* If the object is of type reference, to get the
-             * Id is simple... */
-            if (objPtr->typePtr == &referenceObjType) {
-                Jim_AddHashEntry(&marks, &objPtr->internalRep.refValue.id, NULL);
-#ifdef JIM_DEBUG_GC
-                printf("MARK (reference): %d refcount: %d" JIM_NL,
-                    (int)objPtr->internalRep.refValue.id, objPtr->refCount);
-#endif
-                objPtr = objPtr->nextObjPtr;
-                continue;
-            }
-            /* Get the string repr of the object we want
-             * to scan for references. */
-            p = str = Jim_GetString(objPtr, &len);
-            /* Skip objects too little to contain references. */
-            if (len < JIM_REFERENCE_SPACE) {
-                objPtr = objPtr->nextObjPtr;
-                continue;
-            }
-            /* Extract references from the object string repr. */
-            while (1) {
-                int i;
-                jim_wide id;
-                char buf[21];
-
-                if ((p = strstr(p, "<reference.<")) == NULL)
-                    break;
-                /* Check if it's a valid reference. */
-                if (len - (p - str) < JIM_REFERENCE_SPACE)
-                    break;
-                if (p[41] != '>' || p[19] != '>' || p[20] != '.')
-                    break;
-                for (i = 21; i <= 40; i++)
-                    if (!isdigit(UCHAR(p[i])))
-                        break;
-                /* Get the ID */
-                memcpy(buf, p + 21, 20);
-                buf[20] = '\0';
-                Jim_StringToWide(buf, &id, 10);
-
-                /* Ok, a reference for the given ID
-                 * was found. Mark it. */
-                Jim_AddHashEntry(&marks, &id, NULL);
-#ifdef JIM_DEBUG_GC
-                printf("MARK: %d" JIM_NL, (int)id);
-#endif
-                p += JIM_REFERENCE_SPACE;
-            }
-        }
-        objPtr = objPtr->nextObjPtr;
-    }
-
-    /* Run the references hash table to destroy every reference that
-     * is not referenced outside (not present in the mark HT). */
-    htiter = Jim_GetHashTableIterator(&interp->references);
-    while ((he = Jim_NextHashEntry(htiter)) != NULL) {
-        const jim_wide *refId;
-        Jim_Reference *refPtr;
-
-        refId = he->key;
-        /* Check if in the mark phase we encountered
-         * this reference. */
-        if (Jim_FindHashEntry(&marks, refId) == NULL) {
-#ifdef JIM_DEBUG_GC
-            printf("COLLECTING %d" JIM_NL, (int)*refId);
-#endif
-            collected++;
-            /* Drop the reference, but call the
-             * finalizer first if registered. */
-            refPtr = he->u.val;
-            if (refPtr->finalizerCmdNamePtr) {
-                char *refstr = Jim_Alloc(JIM_REFERENCE_SPACE + 1);
-                Jim_Obj *objv[3], *oldResult;
-
-                JimFormatReference(refstr, refPtr, *refId);
-
-                objv[0] = refPtr->finalizerCmdNamePtr;
-                objv[1] = Jim_NewStringObjNoAlloc(interp, refstr, 32);
-                objv[2] = refPtr->objPtr;
-                Jim_IncrRefCount(objv[0]);
-                Jim_IncrRefCount(objv[1]);
-                Jim_IncrRefCount(objv[2]);
-
-                /* Drop the reference itself */
-                Jim_DeleteHashEntry(&interp->references, refId);
-
-                /* Call the finalizer. Errors ignored. */
-                oldResult = interp->result;
-                Jim_IncrRefCount(oldResult);
-                Jim_EvalObjVector(interp, 3, objv);
-                Jim_SetResult(interp, oldResult);
-                Jim_DecrRefCount(interp, oldResult);
-
-                Jim_DecrRefCount(interp, objv[0]);
-                Jim_DecrRefCount(interp, objv[1]);
-                Jim_DecrRefCount(interp, objv[2]);
-            }
-            else {
-                Jim_DeleteHashEntry(&interp->references, refId);
-            }
-        }
-    }
-    Jim_FreeHashTableIterator(htiter);
-    Jim_FreeHashTable(&marks);
-    interp->lastCollectId = interp->referenceNextId;
-    interp->lastCollectTime = time(NULL);
     return collected;
 }
 
@@ -11335,9 +9613,6 @@ static int JimIsBigEndian(void)
     return uval.c[0] == 1;
 }
 
-/* -----------------------------------------------------------------------------
- * Interpreter related functions
- * ---------------------------------------------------------------------------*/
 
 Jim_Interp *Jim_CreateInterp(void)
 {
@@ -11345,30 +9620,27 @@ Jim_Interp *Jim_CreateInterp(void)
 
     memset(i, 0, sizeof(*i));
 
-    i->errorFileName = Jim_StrDup("");
     i->maxNestingDepth = JIM_MAX_NESTING_DEPTH;
     i->lastCollectTime = time(NULL);
 
-    /* Note that we can create objects only after the
-     * interpreter liveList and freeList pointers are
-     * initialized to NULL. */
     Jim_InitHashTable(&i->commands, &JimCommandsHashTableType, i);
 #ifdef JIM_REFERENCES
     Jim_InitHashTable(&i->references, &JimReferencesHashTableType, i);
 #endif
-    Jim_InitHashTable(&i->sharedStrings, &JimSharedStringsHashTableType, NULL);
     Jim_InitHashTable(&i->assocData, &JimAssocDataHashTableType, i);
     Jim_InitHashTable(&i->packages, &JimStringKeyValCopyHashTableType, NULL);
     i->framePtr = i->topFramePtr = JimCreateCallFrame(i, NULL);
     i->emptyObj = Jim_NewEmptyStringObj(i);
     i->trueObj = Jim_NewIntObj(i, 1);
     i->falseObj = Jim_NewIntObj(i, 0);
+    i->errorFileNameObj = i->emptyObj;
     i->result = i->emptyObj;
     i->stackTrace = Jim_NewListObj(i, NULL, 0);
     i->unknown = Jim_NewStringObj(i, "unknown", -1);
     i->errorProc = i->emptyObj;
     i->currentScriptObj = Jim_NewEmptyStringObj(i);
     Jim_IncrRefCount(i->emptyObj);
+    Jim_IncrRefCount(i->errorFileNameObj);
     Jim_IncrRefCount(i->result);
     Jim_IncrRefCount(i->stackTrace);
     Jim_IncrRefCount(i->unknown);
@@ -11377,7 +9649,7 @@ Jim_Interp *Jim_CreateInterp(void)
     Jim_IncrRefCount(i->trueObj);
     Jim_IncrRefCount(i->falseObj);
 
-    /* Initialize key variables every interpreter should contain */
+    
     Jim_SetVariableStrWithStr(i, JIM_LIBPATH, TCL_LIBRARY);
     Jim_SetVariableStrWithStr(i, JIM_INTERACTIVE, "0");
 
@@ -11404,7 +9676,7 @@ void Jim_FreeInterp(Jim_Interp *i)
     Jim_DecrRefCount(i, i->stackTrace);
     Jim_DecrRefCount(i, i->errorProc);
     Jim_DecrRefCount(i, i->unknown);
-    Jim_Free((void *)i->errorFileName);
+    Jim_DecrRefCount(i, i->errorFileNameObj);
     Jim_DecrRefCount(i, i->currentScriptObj);
     Jim_FreeHashTable(&i->commands);
 #ifdef JIM_REFERENCES
@@ -11415,14 +9687,12 @@ void Jim_FreeInterp(Jim_Interp *i)
     Jim_FreeHashTable(&i->assocData);
     JimDeleteLocalProcs(i);
 
-    /* Free the call frames list */
+    
     while (cf) {
         prevcf = cf->parentCallFrame;
         JimFreeCallFrame(i, cf, JIM_FCF_NONE);
         cf = prevcf;
     }
-    /* Check that the live object list is empty, otherwise
-     * there is a memory leak. */
     if (i->liveList != NULL) {
         objPtr = i->liveList;
 
@@ -11435,22 +9705,22 @@ void Jim_FreeInterp(Jim_Interp *i)
                 (void *)objPtr, objPtr->refCount, type, objPtr->bytes ? objPtr->bytes : "(null)");
             if (objPtr->typePtr == &sourceObjType) {
                 printf("FILE %s LINE %d" JIM_NL,
-                    objPtr->internalRep.sourceValue.fileName,
+                    Jim_String(objPtr->internalRep.sourceValue.fileNameObj),
                     objPtr->internalRep.sourceValue.lineNumber);
             }
             objPtr = objPtr->nextObjPtr;
         }
         printf("-------------------------------------" JIM_NL JIM_NL);
-        JimPanic((1, i, "Live list non empty freeing the interpreter! Leak?"));
+        JimPanic((1, "Live list non empty freeing the interpreter! Leak?"));
     }
-    /* Free all the freed objects. */
+    
     objPtr = i->freeList;
     while (objPtr) {
         nextObjPtr = objPtr->nextObjPtr;
         Jim_Free(objPtr);
         objPtr = nextObjPtr;
     }
-    /* Free cached CallFrame structures */
+    
     cf = i->freeFramesList;
     while (cf) {
         nextcf = cf->nextFramePtr;
@@ -11463,25 +9733,10 @@ void Jim_FreeInterp(Jim_Interp *i)
     Jim_FreeLoadHandles(i);
 #endif
 
-    /* Free the sharedString hash table. Make sure to free it
-     * after every other Jim_Object was freed. */
-    Jim_FreeHashTable(&i->sharedStrings);
-    /* Free the interpreter structure. */
+    
     Jim_Free(i);
 }
 
-/* Returns the call frame relative to the level represented by
- * levelObjPtr. If levelObjPtr == NULL, the * level is assumed to be '1'.
- *
- * This function accepts the 'level' argument in the form
- * of the commands [uplevel] and [upvar].
- *
- * For a function accepting a relative integer as level suitable
- * for implementation of [info level ?level?] check the
- * JimGetCallFrameByInteger() function.
- *
- * Returns NULL on error.
- */
 Jim_CallFrame *Jim_GetCallFrameByLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr)
 {
     long level;
@@ -11503,13 +9758,13 @@ Jim_CallFrame *Jim_GetCallFrameByLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr)
                 level = -1;
             }
             else {
-                /* Convert from a relative to an absolute level */
+                
                 level = interp->framePtr->level - level;
             }
         }
     }
     else {
-        str = "1";              /* Needed to format the error message. */
+        str = "1";              
         level = interp->framePtr->level - 1;
     }
 
@@ -11517,7 +9772,7 @@ Jim_CallFrame *Jim_GetCallFrameByLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr)
         return interp->topFramePtr;
     }
     if (level > 0) {
-        /* Lookup */
+        
         for (framePtr = interp->framePtr; framePtr; framePtr = framePtr->parentCallFrame) {
             if (framePtr->level == level) {
                 return framePtr;
@@ -11529,9 +9784,6 @@ Jim_CallFrame *Jim_GetCallFrameByLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr)
     return NULL;
 }
 
-/* Similar to Jim_GetCallFrameByLevel() but the level is specified
- * as a relative integer like in the [info level ?level?] command.
- **/
 static Jim_CallFrame *JimGetCallFrameByInteger(Jim_Interp *interp, Jim_Obj *levelObjPtr)
 {
     long level;
@@ -11539,7 +9791,7 @@ static Jim_CallFrame *JimGetCallFrameByInteger(Jim_Interp *interp, Jim_Obj *leve
 
     if (Jim_GetLong(interp, levelObjPtr, &level) == JIM_OK) {
         if (level <= 0) {
-            /* Convert from a relative to an absolute level */
+            
             level = interp->framePtr->level + level;
         }
 
@@ -11547,7 +9799,7 @@ static Jim_CallFrame *JimGetCallFrameByInteger(Jim_Interp *interp, Jim_Obj *leve
             return interp->topFramePtr;
         }
 
-        /* Lookup */
+        
         for (framePtr = interp->framePtr; framePtr; framePtr = framePtr->parentCallFrame) {
             if (framePtr->level == level) {
                 return framePtr;
@@ -11559,17 +9811,6 @@ static Jim_CallFrame *JimGetCallFrameByInteger(Jim_Interp *interp, Jim_Obj *leve
     return NULL;
 }
 
-static void JimSetErrorFileName(Jim_Interp *interp, const char *filename)
-{
-    Jim_Free((void *)interp->errorFileName);
-    interp->errorFileName = Jim_StrDup(filename);
-}
-
-static void JimSetErrorLineNumber(Jim_Interp *interp, int linenr)
-{
-    interp->errorLine = linenr;
-}
-
 static void JimResetStackTrace(Jim_Interp *interp)
 {
     Jim_DecrRefCount(interp, interp->stackTrace);
@@ -11581,16 +9822,12 @@ static void JimSetStackTrace(Jim_Interp *interp, Jim_Obj *stackTraceObj)
 {
     int len;
 
-    /* Increment reference first in case these are the same object */
+    
     Jim_IncrRefCount(stackTraceObj);
     Jim_DecrRefCount(interp, interp->stackTrace);
     interp->stackTrace = stackTraceObj;
     interp->errorFlag = 1;
 
-    /* This is a bit ugly.
-     * If the filename of the last entry of the stack trace is empty,
-     * the next stack level should be added.
-     */
     len = Jim_ListLength(interp, interp->stackTrace);
     if (len >= 3) {
         Jim_Obj *filenameObj;
@@ -11605,15 +9842,15 @@ static void JimSetStackTrace(Jim_Interp *interp, Jim_Obj *stackTraceObj)
     }
 }
 
-/* Returns 1 if the stack trace information was used or 0 if not */
+
 static void JimAppendStackTrace(Jim_Interp *interp, const char *procname,
-    const char *filename, int linenr)
+    Jim_Obj *fileNameObj, int linenr)
 {
     if (strcmp(procname, "unknown") == 0) {
         procname = "";
     }
-    if (!*procname && !*filename) {
-        /* No useful info here */
+    if (!*procname && !Jim_Length(fileNameObj)) {
+        
         return;
     }
 
@@ -11623,27 +9860,19 @@ static void JimAppendStackTrace(Jim_Interp *interp, const char *procname,
         Jim_IncrRefCount(interp->stackTrace);
     }
 
-    /* If we have no procname but the previous element did, merge with that frame */
-    if (!*procname && *filename) {
-        /* Just a filename. Check the previous entry */
+    
+    if (!*procname && Jim_Length(fileNameObj)) {
+        
         int len = Jim_ListLength(interp, interp->stackTrace);
 
         if (len >= 3) {
-            Jim_Obj *procnameObj;
-            Jim_Obj *filenameObj;
-
-            if (Jim_ListIndex(interp, interp->stackTrace, len - 3, &procnameObj, JIM_NONE) == JIM_OK
-                && Jim_ListIndex(interp, interp->stackTrace, len - 2, &filenameObj,
-                    JIM_NONE) == JIM_OK) {
-
-                const char *prev_procname = Jim_String(procnameObj);
-                const char *prev_filename = Jim_String(filenameObj);
-
-                if (*prev_procname && !*prev_filename) {
-                    ListSetIndex(interp, interp->stackTrace, len - 2, Jim_NewStringObj(interp,
-                            filename, -1), 0);
-                    ListSetIndex(interp, interp->stackTrace, len - 1, Jim_NewIntObj(interp, linenr),
-                        0);
+            Jim_Obj *objPtr;
+            if (Jim_ListIndex(interp, interp->stackTrace, len - 3, &objPtr, JIM_NONE) == JIM_OK && Jim_Length(objPtr)) {
+                
+                if (Jim_ListIndex(interp, interp->stackTrace, len - 2, &objPtr, JIM_NONE) == JIM_OK && !Jim_Length(objPtr)) {
+                    
+                    ListSetIndex(interp, interp->stackTrace, len - 2, fileNameObj, 0);
+                    ListSetIndex(interp, interp->stackTrace, len - 1, Jim_NewIntObj(interp, linenr), 0);
                     return;
                 }
             }
@@ -11651,7 +9880,7 @@ static void JimAppendStackTrace(Jim_Interp *interp, const char *procname,
     }
 
     Jim_ListAppendElement(interp, interp->stackTrace, Jim_NewStringObj(interp, procname, -1));
-    Jim_ListAppendElement(interp, interp->stackTrace, Jim_NewStringObj(interp, filename, -1));
+    Jim_ListAppendElement(interp, interp->stackTrace, fileNameObj);
     Jim_ListAppendElement(interp, interp->stackTrace, Jim_NewIntObj(interp, linenr));
 }
 
@@ -11687,53 +9916,6 @@ int Jim_GetExitCode(Jim_Interp *interp)
     return interp->exitCode;
 }
 
-/* -----------------------------------------------------------------------------
- * Shared strings.
- * Every interpreter has an hash table where to put shared dynamically
- * allocate strings that are likely to be used a lot of times.
- * For example, in the 'source' object type, there is a pointer to
- * the filename associated with that object. Every script has a lot
- * of this objects with the identical file name, so it is wise to share
- * this info.
- *
- * The API is trivial: Jim_GetSharedString(interp, "foobar")
- * returns the pointer to the shared string. Every time a reference
- * to the string is no longer used, the user should call
- * Jim_ReleaseSharedString(interp, stringPointer). Once no one is using
- * a given string, it is removed from the hash table.
- * ---------------------------------------------------------------------------*/
-const char *Jim_GetSharedString(Jim_Interp *interp, const char *str)
-{
-    Jim_HashEntry *he = Jim_FindHashEntry(&interp->sharedStrings, str);
-
-    if (he == NULL) {
-        char *strCopy = Jim_StrDup(str);
-
-        Jim_AddHashEntry(&interp->sharedStrings, strCopy, NULL);
-	he = Jim_FindHashEntry(&interp->sharedStrings, strCopy);
-	he->u.intval = 1;
-        return strCopy;
-    }
-    else {
-        he->u.intval++;
-        return he->key;
-    }
-}
-
-void Jim_ReleaseSharedString(Jim_Interp *interp, const char *str)
-{
-    Jim_HashEntry *he = Jim_FindHashEntry(&interp->sharedStrings, str);
-
-    JimPanic((he == NULL, interp, "Jim_ReleaseSharedString called with " "unknown shared string '%s'", str));
-
-    if (--he->u.intval == 0) {
-        Jim_DeleteHashEntry(&interp->sharedStrings, str);
-    }
-}
-
-/* -----------------------------------------------------------------------------
- * Integer object
- * ---------------------------------------------------------------------------*/
 #define JIM_INTEGER_SPACE 24
 
 static void UpdateStringOfInt(struct Jim_Obj *objPtr);
@@ -11747,11 +9929,6 @@ static const Jim_ObjType intObjType = {
     JIM_TYPE_NONE,
 };
 
-/* A coerced double is closer to an int than a double.
- * It is an int value temporarily masquerading as a double value.
- * i.e. it has the same string value as an int and Jim_GetWide()
- * succeeds, but also Jim_GetDouble() returns the value directly.
- */
 static const Jim_ObjType coercedDoubleObjType = {
     "coerced-double",
     NULL,
@@ -11778,14 +9955,14 @@ int SetIntFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
     const char *str;
 
     if (objPtr->typePtr == &coercedDoubleObjType) {
-        /* Simple switcheroo */
+        
         objPtr->typePtr = &intObjType;
         return JIM_OK;
     }
 
-    /* Get the string representation */
+    
     str = Jim_String(objPtr);
-    /* Try to convert into a jim_wide */
+    
     if (Jim_StringToWide(str, &wideValue, 0) != JIM_OK) {
         if (flags & JIM_ERRMSG) {
             Jim_SetResultFormatted(interp, "expected integer but got \"%#s\"", objPtr);
@@ -11796,7 +9973,7 @@ int SetIntFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
         Jim_SetResultString(interp, "Integer value too big to be represented", -1);
         return JIM_ERR;
     }
-    /* Free the old internal repr and set the new one. */
+    
     Jim_FreeIntRep(interp, objPtr);
     objPtr->typePtr = &intObjType;
     objPtr->internalRep.wideValue = wideValue;
@@ -11818,7 +9995,7 @@ int Jim_GetWide(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide * widePtr)
     return JIM_OK;
 }
 
-/* Get a wide but does not set an error if the format is bad. */
+
 static int JimGetWideNoErr(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide * widePtr)
 {
     if (objPtr->typePtr != &intObjType && SetIntFromAny(interp, objPtr, JIM_NONE) == JIM_ERR)
@@ -11851,9 +10028,6 @@ Jim_Obj *Jim_NewIntObj(Jim_Interp *interp, jim_wide wideValue)
     return objPtr;
 }
 
-/* -----------------------------------------------------------------------------
- * Double object
- * ---------------------------------------------------------------------------*/
 #define JIM_DOUBLE_SPACE 30
 
 static void UpdateStringOfDouble(struct Jim_Obj *objPtr);
@@ -11884,13 +10058,10 @@ int SetDoubleFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
     jim_wide wideValue;
     const char *str;
 
-    /* Preserve the string representation.
-     * Needed so we can convert back to int without loss
-     */
     str = Jim_String(objPtr);
 
 #ifdef HAVE_LONG_LONG
-    /* Assume a 53 bit mantissa */
+    
 #define MIN_INT_IN_DOUBLE -(1LL << 53)
 #define MAX_INT_IN_DOUBLE -(MIN_INT_IN_DOUBLE + 1)
 
@@ -11898,26 +10069,26 @@ int SetDoubleFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
         && JimWideValue(objPtr) >= MIN_INT_IN_DOUBLE
         && JimWideValue(objPtr) <= MAX_INT_IN_DOUBLE) {
 
-        /* Direct conversion to coerced double */
+        
         objPtr->typePtr = &coercedDoubleObjType;
         return JIM_OK;
     }
     else
 #endif
     if (Jim_StringToWide(str, &wideValue, 10) == JIM_OK) {
-        /* Managed to convert to an int, so we can use this as a cooerced double */
+        
         Jim_FreeIntRep(interp, objPtr);
         objPtr->typePtr = &coercedDoubleObjType;
         objPtr->internalRep.wideValue = wideValue;
         return JIM_OK;
     }
     else {
-        /* Try to convert into a double */
+        
         if (Jim_StringToDouble(str, &doubleValue) != JIM_OK) {
             Jim_SetResultFormatted(interp, "expected number but got \"%#s\"", objPtr);
             return JIM_ERR;
         }
-        /* Free the old internal repr and set the new one. */
+        
         Jim_FreeIntRep(interp, objPtr);
     }
     objPtr->typePtr = &doubleObjType;
@@ -11954,19 +10125,12 @@ Jim_Obj *Jim_NewDoubleObj(Jim_Interp *interp, double doubleValue)
     return objPtr;
 }
 
-/* -----------------------------------------------------------------------------
- * List object
- * ---------------------------------------------------------------------------*/
 static void ListAppendElement(Jim_Obj *listPtr, Jim_Obj *objPtr);
 static void FreeListInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
 static void DupListInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
 static void UpdateStringOfList(struct Jim_Obj *objPtr);
 static int SetListFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
-/* Note that while the elements of the list may contain references,
- * the list object itself can't. This basically means that the
- * list object string representation as a whole can't contain references
- * that are not presents in the single elements. */
 static const Jim_ObjType listObjType = {
     "list",
     FreeListInternalRep,
@@ -12003,9 +10167,6 @@ void DupListInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
     dupPtr->typePtr = &listObjType;
 }
 
-/* The following function checks if a given string can be encoded
- * into a list element without any kind of quoting, surrounded by braces,
- * or using escapes to quote. */
 #define JIM_ELESTR_SIMPLE 0
 #define JIM_ELESTR_BRACE 1
 #define JIM_ELESTR_QUOTE 2
@@ -12013,7 +10174,7 @@ static int ListElementQuotingType(const char *s, int len)
 {
     int i, level, blevel, trySimple = 1;
 
-    /* Try with the SIMPLE case */
+    
     if (len == 0)
         return JIM_ELESTR_BRACE;
     if (s[0] == '#')
@@ -12045,7 +10206,7 @@ static int ListElementQuotingType(const char *s, int len)
     return JIM_ELESTR_SIMPLE;
 
   testbrace:
-    /* Test if it's possible to do with braces */
+    
     if (s[len - 1] == '\\')
         return JIM_ELESTR_QUOTE;
     level = 0;
@@ -12104,8 +10265,6 @@ static int ListElementQuotingType(const char *s, int len)
     return JIM_ELESTR_QUOTE;
 }
 
-/* Returns the malloc-ed representation of a string
- * using backslash to quote special chars. */
 static char *BackslashQuoteString(const char *s, int len, int *qlenPtr)
 {
     char *q = Jim_Alloc(len * 2 + 1), *p;
@@ -12168,7 +10327,7 @@ static void UpdateStringOfList(struct Jim_Obj *objPtr)
     int *quotingType;
     Jim_Obj **ele = objPtr->internalRep.listValue.ele;
 
-    /* (Over) Estimate the space needed. */
+    
     quotingType = Jim_Alloc(sizeof(int) * objPtr->internalRep.listValue.len + 1);
     bufLen = 0;
     for (i = 0; i < objPtr->internalRep.listValue.len; i++) {
@@ -12187,11 +10346,11 @@ static void UpdateStringOfList(struct Jim_Obj *objPtr)
                 bufLen += len * 2;
                 break;
         }
-        bufLen++;               /* elements separator. */
+        bufLen++;               
     }
     bufLen++;
 
-    /* Generate the string rep. */
+    
     p = objPtr->bytes = Jim_Alloc(bufLen + 1);
     realLength = 0;
     for (i = 0; i < objPtr->internalRep.listValue.len; i++) {
@@ -12221,13 +10380,13 @@ static void UpdateStringOfList(struct Jim_Obj *objPtr)
                 realLength += qlen;
                 break;
         }
-        /* Add a separating space */
+        
         if (i + 1 != objPtr->internalRep.listValue.len) {
             *p++ = ' ';
             realLength++;
         }
     }
-    *p = '\0';                  /* nul term. */
+    *p = '\0';                  
     objPtr->length = realLength;
     Jim_Free(quotingType);
 }
@@ -12237,27 +10396,30 @@ int SetListFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
     struct JimParserCtx parser;
     const char *str;
     int strLen;
-    const char *filename = NULL;
-    int linenr = 1;
+    Jim_Obj *fileNameObj;
+    int linenr;
 
-    /* Try to preserve information about filename / line number */
+    
     if (objPtr->typePtr == &sourceObjType) {
-        filename = Jim_GetSharedString(interp, objPtr->internalRep.sourceValue.fileName);
+        fileNameObj = objPtr->internalRep.sourceValue.fileNameObj;
         linenr = objPtr->internalRep.sourceValue.lineNumber;
     }
+    else {
+        fileNameObj = interp->emptyObj;
+        linenr = 1;
+    }
+    Jim_IncrRefCount(fileNameObj);
 
-    /* Get the string representation */
+    
     str = Jim_GetString(objPtr, &strLen);
 
-    /* Free the old internal repr just now and initialize the
-     * new one just now. The string->list conversion can't fail. */
     Jim_FreeIntRep(interp, objPtr);
     objPtr->typePtr = &listObjType;
     objPtr->internalRep.listValue.len = 0;
     objPtr->internalRep.listValue.maxLen = 0;
     objPtr->internalRep.listValue.ele = NULL;
 
-    /* Convert into a list */
+    
     JimParserInit(&parser, str, strLen, linenr);
     while (!parser.eof) {
         Jim_Obj *elementPtr;
@@ -12266,12 +10428,10 @@ int SetListFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
         if (parser.tt != JIM_TT_STR && parser.tt != JIM_TT_ESC)
             continue;
         elementPtr = JimParserGetTokenObj(interp, &parser);
-        JimSetSourceInfo(interp, elementPtr, filename, parser.tline);
+        JimSetSourceInfo(interp, elementPtr, fileNameObj, parser.tline);
         ListAppendElement(objPtr, elementPtr);
     }
-    if (filename) {
-        Jim_ReleaseSharedString(interp, filename);
-    }
+    Jim_DecrRefCount(interp, fileNameObj);
     return JIM_OK;
 }
 
@@ -12292,12 +10452,6 @@ Jim_Obj *Jim_NewListObj(Jim_Interp *interp, Jim_Obj *const *elements, int len)
     return objPtr;
 }
 
-/* Return a vector of Jim_Obj with the elements of a Jim list, and the
- * length of the vector. Note that the user of this function should make
- * sure that the list object can't shimmer while the vector returned
- * is in use, this vector is the one stored inside the internal representation
- * of the list object. This function is not exported, extensions should
- * always access to the List object elements using Jim_ListIndex(). */
 static void JimListGetElements(Jim_Interp *interp, Jim_Obj *listObj, int *listLen,
     Jim_Obj ***listVec)
 {
@@ -12305,7 +10459,7 @@ static void JimListGetElements(Jim_Interp *interp, Jim_Obj *listObj, int *listLe
     *listVec = listObj->internalRep.listValue.ele;
 }
 
-/* Sorting uses ints, but commands may return wide */
+
 static int JimSign(jim_wide w)
 {
     if (w == 0) {
@@ -12317,7 +10471,7 @@ static int JimSign(jim_wide w)
     return 1;
 }
 
-/* ListSortElements type values */
+
 struct lsort_info {
     jmp_buf jmpbuf;
     Jim_Obj *command;
@@ -12347,7 +10501,7 @@ static int ListSortIndexHelper(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
     return sort_info->subfn(&lObj, &rObj);
 }
 
-/* Sort the internal rep of a list. */
+
 static int ListSortString(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
 {
     return Jim_StringCompareObj(sort_info->interp, *lhsObj, *rhsObj, 0) * sort_info->order;
@@ -12377,7 +10531,7 @@ static int ListSortCommand(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
 
     jim_wide ret = 0;
 
-    /* This must be a valid list */
+    
     compare_script = Jim_DuplicateObj(sort_info->interp, sort_info->command);
     Jim_ListAppendElement(sort_info->interp, compare_script, *lhsObj);
     Jim_ListAppendElement(sort_info->interp, compare_script, *rhsObj);
@@ -12391,7 +10545,7 @@ static int ListSortCommand(Jim_Obj **lhsObj, Jim_Obj **rhsObj)
     return JimSign(ret) * sort_info->order;
 }
 
-/* Sort a list *in place*. MUST be called with non-shared objects. */
+
 static int ListSortElements(Jim_Interp *interp, Jim_Obj *listObjPtr, struct lsort_info *info)
 {
     struct lsort_info *prev_info;
@@ -12402,11 +10556,11 @@ static int ListSortElements(Jim_Interp *interp, Jim_Obj *listObjPtr, struct lsor
     int len;
     int rc;
 
-    JimPanic((Jim_IsShared(listObjPtr), interp, "Jim_ListSortElements called with shared object"));
+    JimPanic((Jim_IsShared(listObjPtr), "Jim_ListSortElements called with shared object"));
     if (!Jim_IsList(listObjPtr))
         SetListFromAny(interp, listObjPtr);
 
-    /* Allow lsort to be called reentrantly */
+    
     prev_info = sort_info;
     sort_info = info;
 
@@ -12426,12 +10580,12 @@ static int ListSortElements(Jim_Interp *interp, Jim_Obj *listObjPtr, struct lsor
             fn = ListSortCommand;
             break;
         default:
-            fn = NULL;          /* avoid warning */
-            JimPanic((1, interp, "ListSort called with invalid sort type"));
+            fn = NULL;          
+            JimPanic((1, "ListSort called with invalid sort type"));
     }
 
     if (info->indexed) {
-        /* Need to interpose a "list index" function */
+        
         info->subfn = fn;
         fn = ListSortIndexHelper;
     }
@@ -12445,13 +10599,6 @@ static int ListSortElements(Jim_Interp *interp, Jim_Obj *listObjPtr, struct lsor
     return rc;
 }
 
-/* This is the low-level function to insert elements into a list.
- * The higher-level Jim_ListInsertElements() performs shared object
- * check and invalidate the string repr. This version is used
- * in the internals of the List Object and is not exported.
- *
- * NOTE: this function can be called only against objects
- * with internal type of List. */
 static void ListInsertElements(Jim_Obj *listPtr, int idx, int elemc, Jim_Obj *const *elemVec)
 {
     int currentLen = listPtr->internalRep.listValue.len;
@@ -12475,18 +10622,12 @@ static void ListInsertElements(Jim_Obj *listPtr, int idx, int elemc, Jim_Obj *co
     listPtr->internalRep.listValue.len += elemc;
 }
 
-/* Convenience call to ListInsertElements() to append a single element.
- */
 static void ListAppendElement(Jim_Obj *listPtr, Jim_Obj *objPtr)
 {
     ListInsertElements(listPtr, listPtr->internalRep.listValue.len, 1, &objPtr);
 }
 
 
-/* Appends every element of appendListPtr into listPtr.
- * Both have to be of the list type.
- * Convenience call to ListInsertElements()
- */
 static void ListAppendList(Jim_Obj *listPtr, Jim_Obj *appendListPtr)
 {
     ListInsertElements(listPtr, listPtr->internalRep.listValue.len,
@@ -12495,7 +10636,7 @@ static void ListAppendList(Jim_Obj *listPtr, Jim_Obj *appendListPtr)
 
 void Jim_ListAppendElement(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *objPtr)
 {
-    JimPanic((Jim_IsShared(listPtr), interp, "Jim_ListAppendElement called with shared object"));
+    JimPanic((Jim_IsShared(listPtr), "Jim_ListAppendElement called with shared object"));
     if (!Jim_IsList(listPtr))
         SetListFromAny(interp, listPtr);
     Jim_InvalidateStringRep(listPtr);
@@ -12504,7 +10645,7 @@ void Jim_ListAppendElement(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *objPtr
 
 void Jim_ListAppendList(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *appendListPtr)
 {
-    JimPanic((Jim_IsShared(listPtr), interp, "Jim_ListAppendList called with shared object"));
+    JimPanic((Jim_IsShared(listPtr), "Jim_ListAppendList called with shared object"));
     if (!Jim_IsList(listPtr))
         SetListFromAny(interp, listPtr);
     Jim_InvalidateStringRep(listPtr);
@@ -12521,7 +10662,7 @@ int Jim_ListLength(Jim_Interp *interp, Jim_Obj *objPtr)
 void Jim_ListInsertElements(Jim_Interp *interp, Jim_Obj *listPtr, int idx,
     int objc, Jim_Obj *const *objVec)
 {
-    JimPanic((Jim_IsShared(listPtr), interp, "Jim_ListInsertElement called with shared object"));
+    JimPanic((Jim_IsShared(listPtr), "Jim_ListInsertElement called with shared object"));
     if (!Jim_IsList(listPtr))
         SetListFromAny(interp, listPtr);
     if (idx >= 0 && idx > listPtr->internalRep.listValue.len)
@@ -12570,9 +10711,6 @@ static int ListSetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int idx,
     return JIM_OK;
 }
 
-/* Modify the list stored into the variable named 'varNamePtr'
- * setting the element specified by the 'indexc' indexes objects in 'indexv',
- * with the new element 'newObjptr'. */
 int Jim_SetListIndex(Jim_Interp *interp, Jim_Obj *varNamePtr,
     Jim_Obj *const *indexv, int indexc, Jim_Obj *newObjPtr)
 {
@@ -12618,9 +10756,6 @@ Jim_Obj *Jim_ConcatObj(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
 {
     int i;
 
-    /* If all the objects in objv are lists,
-     * it's possible to return a list as result, that's the
-     * concatenation of all the lists. */
     for (i = 0; i < objc; i++) {
         if (!Jim_IsList(objv[i]))
             break;
@@ -12633,32 +10768,32 @@ Jim_Obj *Jim_ConcatObj(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
         return objPtr;
     }
     else {
-        /* Else... we have to glue strings together */
+        
         int len = 0, objLen;
         char *bytes, *p;
 
-        /* Compute the length */
+        
         for (i = 0; i < objc; i++) {
             Jim_GetString(objv[i], &objLen);
             len += objLen;
         }
         if (objc)
             len += objc - 1;
-        /* Create the string rep, and a string object holding it. */
+        
         p = bytes = Jim_Alloc(len + 1);
         for (i = 0; i < objc; i++) {
             const char *s = Jim_GetString(objv[i], &objLen);
 
-            /* Remove leading space */
+            
             while (objLen && (*s == ' ' || *s == '\t' || *s == '\n')) {
                 s++;
                 objLen--;
                 len--;
             }
-            /* And trailing space */
+            
             while (objLen && (s[objLen - 1] == ' ' ||
                     s[objLen - 1] == '\n' || s[objLen - 1] == '\t')) {
-                /* Handle trailing backslash-space case */
+                
                 if (objLen > 1 && s[objLen - 2] == '\\') {
                     break;
                 }
@@ -12671,8 +10806,6 @@ Jim_Obj *Jim_ConcatObj(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
                 *p++ = ' ';
             }
             else if (i + 1 != objc) {
-                /* Drop the space calcuated for this
-                 * element that is instead null. */
                 len--;
             }
         }
@@ -12681,9 +10814,6 @@ Jim_Obj *Jim_ConcatObj(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
     }
 }
 
-/* Returns a list composed of the elements in the specified range.
- * first and start are directly accepted as Jim_Objects and
- * processed for the end?-index? case. */
 Jim_Obj *Jim_ListRange(Jim_Interp *interp, Jim_Obj *listObjPtr, Jim_Obj *firstObjPtr,
     Jim_Obj *lastObjPtr)
 {
@@ -12693,7 +10823,7 @@ Jim_Obj *Jim_ListRange(Jim_Interp *interp, Jim_Obj *listObjPtr, Jim_Obj *firstOb
     if (Jim_GetIndex(interp, firstObjPtr, &first) != JIM_OK ||
         Jim_GetIndex(interp, lastObjPtr, &last) != JIM_OK)
         return NULL;
-    len = Jim_ListLength(interp, listObjPtr);   /* will convert into list */
+    len = Jim_ListLength(interp, listObjPtr);   
     first = JimRelToAbsIndex(len, first);
     last = JimRelToAbsIndex(len, last);
     JimRelToAbsRange(len, first, last, &first, &last, &rangeLen);
@@ -12703,17 +10833,11 @@ Jim_Obj *Jim_ListRange(Jim_Interp *interp, Jim_Obj *listObjPtr, Jim_Obj *firstOb
     return Jim_NewListObj(interp, listObjPtr->internalRep.listValue.ele + first, rangeLen);
 }
 
-/* -----------------------------------------------------------------------------
- * Dict object
- * ---------------------------------------------------------------------------*/
 static void FreeDictInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
 static void DupDictInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
 static void UpdateStringOfDict(struct Jim_Obj *objPtr);
 static int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
-/* Dict HashTable Type.
- *
- * Keys and Values are Jim objects. */
 
 static unsigned int JimObjectHTHashFunction(const void *key)
 {
@@ -12741,19 +10865,15 @@ static void JimObjectHTKeyValDestructor(void *interp, void *val)
 }
 
 static const Jim_HashTableType JimDictHashTableType = {
-    JimObjectHTHashFunction,    /* hash function */
-    NULL,                       /* key dup */
-    NULL,                       /* val dup */
-    JimObjectHTKeyCompare,      /* key compare */
-    (void (*)(void *, const void *))    /* ATTENTION: const cast */
-        JimObjectHTKeyValDestructor,    /* key destructor */
-    JimObjectHTKeyValDestructor /* val destructor */
+    JimObjectHTHashFunction,    
+    NULL,                       
+    NULL,                       
+    JimObjectHTKeyCompare,      
+    (void (*)(void *, const void *))    
+        JimObjectHTKeyValDestructor,    
+    JimObjectHTKeyValDestructor 
 };
 
-/* Note that while the elements of the dict may contain references,
- * the list object itself can't. This basically means that the
- * dict object string representation as a whole can't contain references
- * that are not presents in the single elements. */
 static const Jim_ObjType dictObjType = {
     "dict",
     FreeDictInternalRep,
@@ -12776,19 +10896,19 @@ void DupDictInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
     Jim_HashTableIterator *htiter;
     Jim_HashEntry *he;
 
-    /* Create a new hash table */
+    
     ht = srcPtr->internalRep.ptr;
     dupHt = Jim_Alloc(sizeof(*dupHt));
     Jim_InitHashTable(dupHt, &JimDictHashTableType, interp);
     if (ht->size != 0)
         Jim_ExpandHashTable(dupHt, ht->size);
-    /* Copy every element from the source to the dup hash table */
+    
     htiter = Jim_GetHashTableIterator(ht);
     while ((he = Jim_NextHashEntry(htiter)) != NULL) {
         const Jim_Obj *keyObjPtr = he->key;
         Jim_Obj *valObjPtr = he->u.val;
 
-        Jim_IncrRefCount((Jim_Obj *)keyObjPtr); /* ATTENTION: const cast */
+        Jim_IncrRefCount((Jim_Obj *)keyObjPtr); 
         Jim_IncrRefCount(valObjPtr);
         Jim_AddHashEntry(dupHt, keyObjPtr, valObjPtr);
     }
@@ -12809,18 +10929,18 @@ void UpdateStringOfDict(struct Jim_Obj *objPtr)
     Jim_HashEntry *he;
     Jim_Obj **objv;
 
-    /* Trun the hash table into a flat vector of Jim_Objects. */
+    
     ht = objPtr->internalRep.ptr;
     objc = ht->used * 2;
     objv = Jim_Alloc(objc * sizeof(Jim_Obj *));
     htiter = Jim_GetHashTableIterator(ht);
     i = 0;
     while ((he = Jim_NextHashEntry(htiter)) != NULL) {
-        objv[i++] = (Jim_Obj *)he->key; /* ATTENTION: const cast */
+        objv[i++] = (Jim_Obj *)he->key; 
         objv[i++] = he->u.val;
     }
     Jim_FreeHashTableIterator(htiter);
-    /* (Over) Estimate the space needed. */
+    
     quotingType = Jim_Alloc(sizeof(int) * objc);
     bufLen = 0;
     for (i = 0; i < objc; i++) {
@@ -12839,11 +10959,11 @@ void UpdateStringOfDict(struct Jim_Obj *objPtr)
                 bufLen += len * 2;
                 break;
         }
-        bufLen++;               /* elements separator. */
+        bufLen++;               
     }
     bufLen++;
 
-    /* Generate the string rep. */
+    
     p = objPtr->bytes = Jim_Alloc(bufLen + 1);
     realLength = 0;
     for (i = 0; i < objc; i++) {
@@ -12873,13 +10993,13 @@ void UpdateStringOfDict(struct Jim_Obj *objPtr)
                 realLength += qlen;
                 break;
         }
-        /* Add a separating space */
+        
         if (i + 1 != objc) {
             *p++ = ' ';
             realLength++;
         }
     }
-    *p = '\0';                  /* nul term. */
+    *p = '\0';                  
     objPtr->length = realLength;
     Jim_Free(quotingType);
     Jim_Free(objv);
@@ -12889,12 +11009,9 @@ static int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
 {
     int listlen;
 
-    /* Get the string representation. Do this first so we don't
-     * change order in case of fast conversion to dict.
-     */
     Jim_String(objPtr);
 
-    /* For simplicity, convert a non-list object to a list and then to a dict */
+    
     listlen = Jim_ListLength(interp, objPtr);
     if (listlen % 2) {
         Jim_SetResultString(interp,
@@ -12902,7 +11019,7 @@ static int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
         return JIM_ERR;
     }
     else {
-        /* Now it is easy to convert to a dict from a list, and it can't fail */
+        
         Jim_HashTable *ht;
         int i;
 
@@ -12924,7 +11041,7 @@ static int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
 
                 he = Jim_FindHashEntry(ht, keyObjPtr);
                 Jim_DecrRefCount(interp, keyObjPtr);
-                /* ATTENTION: const cast */
+                
                 Jim_DecrRefCount(interp, (Jim_Obj *)he->u.val);
                 he->u.val = valObjPtr;
             }
@@ -12938,20 +11055,14 @@ static int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
     }
 }
 
-/* Dict object API */
 
-/* Add an element to a dict. objPtr must be of the "dict" type.
- * The higer-level exported function is Jim_DictAddElement().
- * If an element with the specified key already exists, the value
- * associated is replaced with the new one.
- *
- * if valueObjPtr == NULL, the key is instead removed if it exists. */
+
 static int DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
     Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr)
 {
     Jim_HashTable *ht = objPtr->internalRep.ptr;
 
-    if (valueObjPtr == NULL) {  /* unset */
+    if (valueObjPtr == NULL) {  
         return Jim_DeleteHashEntry(ht, keyObjPtr);
     }
     Jim_IncrRefCount(keyObjPtr);
@@ -12960,21 +11071,19 @@ static int DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
         Jim_HashEntry *he = Jim_FindHashEntry(ht, keyObjPtr);
 
         Jim_DecrRefCount(interp, keyObjPtr);
-        /* ATTENTION: const cast */
+        
         Jim_DecrRefCount(interp, (Jim_Obj *)he->u.val);
         he->u.val = valueObjPtr;
     }
     return JIM_OK;
 }
 
-/* Add an element, higher-level interface for DictAddElement().
- * If valueObjPtr == NULL, the key is removed if it exists. */
 int Jim_DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
     Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr)
 {
     int retcode;
 
-    JimPanic((Jim_IsShared(objPtr), interp, "Jim_DictAddElement called with shared object"));
+    JimPanic((Jim_IsShared(objPtr), "Jim_DictAddElement called with shared object"));
     if (objPtr->typePtr != &dictObjType) {
         if (SetDictFromAny(interp, objPtr) != JIM_OK)
             return JIM_ERR;
@@ -12989,7 +11098,7 @@ Jim_Obj *Jim_NewDictObj(Jim_Interp *interp, Jim_Obj *const *elements, int len)
     Jim_Obj *objPtr;
     int i;
 
-    JimPanic((len % 2, interp, "Jim_NewDictObj() 'len' argument must be even"));
+    JimPanic((len % 2, "Jim_NewDictObj() 'len' argument must be even"));
 
     objPtr = Jim_NewObj(interp);
     objPtr->typePtr = &dictObjType;
@@ -13001,9 +11110,6 @@ Jim_Obj *Jim_NewDictObj(Jim_Interp *interp, Jim_Obj *const *elements, int len)
     return objPtr;
 }
 
-/* Return the value associated to the specified dict key
- * Note: Returns JIM_OK if OK, JIM_ERR if entry not found or -1 if can't create dict value
- */
 int Jim_DictKey(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj *keyPtr,
     Jim_Obj **objPtrPtr, int flags)
 {
@@ -13025,7 +11131,7 @@ int Jim_DictKey(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj *keyPtr,
     return JIM_OK;
 }
 
-/* Return an allocated array of key/value pairs for the dictionary. Stores the length in *len */
+
 int Jim_DictPairs(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj ***objPtrPtr, int *len)
 {
     Jim_HashTable *ht;
@@ -13040,12 +11146,12 @@ int Jim_DictPairs(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj ***objPtrPtr, in
     }
     ht = dictPtr->internalRep.ptr;
 
-    /* Turn the hash table into a flat vector of Jim_Objects. */
+    
     objv = Jim_Alloc((ht->used * 2) * sizeof(Jim_Obj *));
     htiter = Jim_GetHashTableIterator(ht);
     i = 0;
     while ((he = Jim_NextHashEntry(htiter)) != NULL) {
-        objv[i++] = (Jim_Obj *)he->key; /* ATTENTION: const cast */
+        objv[i++] = (Jim_Obj *)he->key; 
         objv[i++] = he->u.val;
     }
     *len = i;
@@ -13055,7 +11161,7 @@ int Jim_DictPairs(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj ***objPtrPtr, in
 }
 
 
-/* Return the value associated to the specified dict keys */
+
 int Jim_DictKeysVector(Jim_Interp *interp, Jim_Obj *dictPtr,
     Jim_Obj *const *keyv, int keyc, Jim_Obj **objPtrPtr, int flags)
 {
@@ -13078,14 +11184,8 @@ int Jim_DictKeysVector(Jim_Interp *interp, Jim_Obj *dictPtr,
     return JIM_OK;
 }
 
-/* Modify the dict stored into the variable named 'varNamePtr'
- * setting the element specified by the 'keyc' keys objects in 'keyv',
- * with the new value of the element 'newObjPtr'.
- *
- * If newObjPtr == NULL the operation is to remove the given key
- * from the dictionary. */
 int Jim_SetDictKeysVector(Jim_Interp *interp, Jim_Obj *varNamePtr,
-    Jim_Obj *const *keyv, int keyc, Jim_Obj *newObjPtr)
+    Jim_Obj *const *keyv, int keyc, Jim_Obj *newObjPtr, int flags)
 {
     Jim_Obj *varObjPtr, *objPtr, *dictObjPtr;
     int shared, i;
@@ -13093,8 +11193,9 @@ int Jim_SetDictKeysVector(Jim_Interp *interp, Jim_Obj *varNamePtr,
     varObjPtr = objPtr =
         Jim_GetVariable(interp, varNamePtr, newObjPtr == NULL ? JIM_ERRMSG : JIM_NONE);
     if (objPtr == NULL) {
-        if (newObjPtr == NULL)  /* Cannot remove a key from non existing var */
+        if (newObjPtr == NULL)   {
             return JIM_ERR;
+        }
         varObjPtr = objPtr = Jim_NewDictObj(interp, NULL, 0);
         if (Jim_SetVariable(interp, varNamePtr, objPtr) != JIM_OK) {
             Jim_FreeNewObj(interp, varObjPtr);
@@ -13106,41 +11207,40 @@ int Jim_SetDictKeysVector(Jim_Interp *interp, Jim_Obj *varNamePtr,
     for (i = 0; i < keyc - 1; i++) {
         dictObjPtr = objPtr;
 
-        /* Check if it's a valid dictionary */
+        
         if (dictObjPtr->typePtr != &dictObjType) {
-            if (SetDictFromAny(interp, dictObjPtr) != JIM_OK)
+            if (SetDictFromAny(interp, dictObjPtr) != JIM_OK) {
                 goto err;
+            }
         }
-        /* Check if the given key exists. */
+        
         Jim_InvalidateStringRep(dictObjPtr);
         if (Jim_DictKey(interp, dictObjPtr, keyv[i], &objPtr,
                 newObjPtr ? JIM_NONE : JIM_ERRMSG) == JIM_OK) {
-            /* This key exists at the current level.
-             * Make sure it's not shared!. */
             if (Jim_IsShared(objPtr)) {
                 objPtr = Jim_DuplicateObj(interp, objPtr);
                 DictAddElement(interp, dictObjPtr, keyv[i], objPtr);
             }
         }
         else {
-            /* Key not found. If it's an [unset] operation
-             * this is an error. Only the last key may not
-             * exist. */
-            if (newObjPtr == NULL)
+            if (newObjPtr == NULL) {
                 goto err;
-            /* Otherwise set an empty dictionary
-             * as key's value. */
+            }
             objPtr = Jim_NewDictObj(interp, NULL, 0);
             DictAddElement(interp, dictObjPtr, keyv[i], objPtr);
         }
     }
+    
     if (Jim_DictAddElement(interp, objPtr, keyv[keyc - 1], newObjPtr) != JIM_OK) {
-        goto err;
+        if (newObjPtr || (flags & JIM_ERRMSG)) {
+            goto err;
+        }
     }
     Jim_InvalidateStringRep(objPtr);
     Jim_InvalidateStringRep(varObjPtr);
-    if (Jim_SetVariable(interp, varNamePtr, varObjPtr) != JIM_OK)
+    if (Jim_SetVariable(interp, varNamePtr, varObjPtr) != JIM_OK) {
         goto err;
+    }
     Jim_SetResult(interp, varObjPtr);
     return JIM_OK;
   err:
@@ -13150,9 +11250,6 @@ int Jim_SetDictKeysVector(Jim_Interp *interp, Jim_Obj *varNamePtr,
     return JIM_ERR;
 }
 
-/* -----------------------------------------------------------------------------
- * Index object
- * ---------------------------------------------------------------------------*/
 static void UpdateStringOfIndex(struct Jim_Obj *objPtr);
 static int SetIndexFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
@@ -13187,10 +11284,10 @@ int SetIndexFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
     const char *str;
     char *endptr;
 
-    /* Get the string representation */
+    
     str = Jim_String(objPtr);
 
-    /* Try to convert into an index */
+    
     if (strncmp(str, "end", 3) == 0) {
         end = 1;
         str += 3;
@@ -13205,7 +11302,7 @@ int SetIndexFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
         str = endptr;
     }
 
-    /* Now str may include or +<num> or -<num> */
+    
     if (*str == '+' || *str == '-') {
         int sign = (*str == '+' ? 1 : -1);
 
@@ -13215,7 +11312,7 @@ int SetIndexFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
         }
         str = endptr;
     }
-    /* The only thing left should be spaces */
+    
     while (isspace(UCHAR(*str))) {
         str++;
     }
@@ -13227,7 +11324,7 @@ int SetIndexFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
             idx = INT_MAX;
         }
         else {
-            /* end-1 is repesented as -2 */
+            
             idx--;
         }
     }
@@ -13235,7 +11332,7 @@ int SetIndexFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
         idx = -INT_MAX;
     }
 
-    /* Free the old internal repr and set the new one. */
+    
     Jim_FreeIntRep(interp, objPtr);
     objPtr->typePtr = &indexObjType;
     objPtr->internalRep.indexValue = idx;
@@ -13249,7 +11346,7 @@ int SetIndexFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 
 int Jim_GetIndex(Jim_Interp *interp, Jim_Obj *objPtr, int *indexPtr)
 {
-    /* Avoid shimmering if the object is an integer. */
+    
     if (objPtr->typePtr == &intObjType) {
         jim_wide val = JimWideValue(objPtr);
 
@@ -13264,11 +11361,8 @@ int Jim_GetIndex(Jim_Interp *interp, Jim_Obj *objPtr, int *indexPtr)
     return JIM_OK;
 }
 
-/* -----------------------------------------------------------------------------
- * Return Code Object.
- * ---------------------------------------------------------------------------*/
 
-/* NOTE: These must be kept in the same order as JIM_OK, JIM_ERR, ... */
+
 static const char * const jimReturnCodes[] = {
     [JIM_OK] = "ok",
     [JIM_ERR] = "error",
@@ -13293,9 +11387,6 @@ static const Jim_ObjType returnCodeObjType = {
     JIM_TYPE_NONE,
 };
 
-/* Converts a (standard) return code to a string. Returns "?" for
- * non-standard return codes.
- */
 const char *Jim_ReturnCode(int code)
 {
     if (code < 0 || code >= (int)jimReturnCodesSize) {
@@ -13311,14 +11402,14 @@ int SetReturnCodeFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
     int returnCode;
     jim_wide wideValue;
 
-    /* Try to convert into an integer */
+    
     if (JimGetWideNoErr(interp, objPtr, &wideValue) != JIM_ERR)
         returnCode = (int)wideValue;
     else if (Jim_GetEnum(interp, objPtr, jimReturnCodes, &returnCode, NULL, JIM_NONE) != JIM_OK) {
         Jim_SetResultFormatted(interp, "expected return code but got \"%#s\"", objPtr);
         return JIM_ERR;
     }
-    /* Free the old internal repr and set the new one. */
+    
     Jim_FreeIntRep(interp, objPtr);
     objPtr->typePtr = &returnCodeObjType;
     objPtr->internalRep.returnCode = returnCode;
@@ -13333,21 +11424,18 @@ int Jim_GetReturnCode(Jim_Interp *interp, Jim_Obj *objPtr, int *intPtr)
     return JIM_OK;
 }
 
-/* -----------------------------------------------------------------------------
- * Expression Parsing
- * ---------------------------------------------------------------------------*/
 static int JimParseExprOperator(struct JimParserCtx *pc);
 static int JimParseExprNumber(struct JimParserCtx *pc);
 static int JimParseExprIrrational(struct JimParserCtx *pc);
 
-/* Exrp's Stack machine operators opcodes. */
 
-/* Binary operators (numbers) */
+
+
 enum
 {
-    /* Continues on from the JIM_TT_ space */
-    /* Operations */
-    JIM_EXPROP_MUL = JIM_TT_EXPR_OP,    /* 15 */
+    
+    
+    JIM_EXPROP_MUL = JIM_TT_EXPR_OP,    
     JIM_EXPROP_DIV,
     JIM_EXPROP_MOD,
     JIM_EXPROP_SUB,
@@ -13362,46 +11450,46 @@ enum
     JIM_EXPROP_GTE,
     JIM_EXPROP_NUMEQ,
     JIM_EXPROP_NUMNE,
-    JIM_EXPROP_BITAND,          /* 30 */
+    JIM_EXPROP_BITAND,          
     JIM_EXPROP_BITXOR,
     JIM_EXPROP_BITOR,
 
-    /* Note must keep these together */
-    JIM_EXPROP_LOGICAND,        /* 33 */
+    
+    JIM_EXPROP_LOGICAND,        
     JIM_EXPROP_LOGICAND_LEFT,
     JIM_EXPROP_LOGICAND_RIGHT,
 
-    /* and these */
-    JIM_EXPROP_LOGICOR,         /* 36 */
+    
+    JIM_EXPROP_LOGICOR,         
     JIM_EXPROP_LOGICOR_LEFT,
     JIM_EXPROP_LOGICOR_RIGHT,
 
-    /* and these */
-    /* Ternary operators */
-    JIM_EXPROP_TERNARY,         /* 39 */
+    
+    
+    JIM_EXPROP_TERNARY,         
     JIM_EXPROP_TERNARY_LEFT,
     JIM_EXPROP_TERNARY_RIGHT,
 
-    /* and these */
-    JIM_EXPROP_COLON,           /* 42 */
+    
+    JIM_EXPROP_COLON,           
     JIM_EXPROP_COLON_LEFT,
     JIM_EXPROP_COLON_RIGHT,
 
-    JIM_EXPROP_POW,             /* 45 */
+    JIM_EXPROP_POW,             
+
 
-/* Binary operators (strings) */
     JIM_EXPROP_STREQ,
     JIM_EXPROP_STRNE,
     JIM_EXPROP_STRIN,
     JIM_EXPROP_STRNI,
 
-/* Unary operators (numbers) */
+
     JIM_EXPROP_NOT,
     JIM_EXPROP_BITNOT,
     JIM_EXPROP_UNARYMINUS,
     JIM_EXPROP_UNARYPLUS,
 
-    /* Functions */
+    
     JIM_EXPROP_FUNC_FIRST,
     JIM_EXPROP_FUNC_INT = JIM_EXPROP_FUNC_FIRST,
     JIM_EXPROP_FUNC_ABS,
@@ -13411,7 +11499,7 @@ enum
     JIM_EXPROP_FUNC_SRAND,
 
 #ifdef JIM_MATH_FUNCTIONS
-    /* math functions from libm */
+    
     JIM_EXPROP_FUNC_SIN,
     JIM_EXPROP_FUNC_COS,
     JIM_EXPROP_FUNC_TAN,
@@ -13438,7 +11526,7 @@ struct JimExprState
     int skip;
 };
 
-/* Operators table */
+
 typedef struct Jim_ExprOperator
 {
     const char *name;
@@ -13577,7 +11665,7 @@ static int JimExprOpIntUnary(Jim_Interp *interp, struct JimExprState *e)
 
 static int JimExprOpNone(Jim_Interp *interp, struct JimExprState *e)
 {
-    JimPanic((e->opcode != JIM_EXPROP_FUNC_RAND));
+    JimPanic((e->opcode != JIM_EXPROP_FUNC_RAND, "JimExprOpNone only support rand()"));
 
     ExprPush(e, Jim_NewDoubleObj(interp, JimRandDouble(interp)));
 
@@ -13651,7 +11739,7 @@ static int JimExprOpDoubleUnary(Jim_Interp *interp, struct JimExprState *e)
 }
 #endif
 
-/* A binary operation on two ints */
+
 static int JimExprOpIntBin(Jim_Interp *interp, struct JimExprState *e)
 {
     Jim_Obj *B = ExprPop(e);
@@ -13687,14 +11775,6 @@ static int JimExprOpIntBin(Jim_Interp *interp, struct JimExprState *e)
                     rc = JIM_ERR;
                 }
                 else {
-                    /*
-                     * From Tcl 8.x
-                     *
-                     * This code is tricky: C doesn't guarantee much
-                     * about the quotient or remainder, but Tcl does.
-                     * The remainder always has the same sign as the
-                     * divisor and a smaller absolute value.
-                     */
                     int negative = 0;
 
                     if (wB < 0) {
@@ -13713,12 +11793,12 @@ static int JimExprOpIntBin(Jim_Interp *interp, struct JimExprState *e)
                 break;
             case JIM_EXPROP_ROTL:
             case JIM_EXPROP_ROTR:{
-                    /* uint32_t would be better. But not everyone has inttypes.h? */
+                    
                     unsigned long uA = (unsigned long)wA;
                     unsigned long uB = (unsigned long)wB;
                     const unsigned int S = sizeof(unsigned long) * 8;
 
-                    /* Shift left by the word size or more is undefined. */
+                    
                     uB %= S;
 
                     if (e->opcode == JIM_EXPROP_ROTR) {
@@ -13741,7 +11821,7 @@ static int JimExprOpIntBin(Jim_Interp *interp, struct JimExprState *e)
 }
 
 
-/* A binary operation on two ints or two doubles (or two strings for some ops) */
+
 static int JimExprOpBin(Jim_Interp *interp, struct JimExprState *e)
 {
     int intresult = 0;
@@ -13756,7 +11836,7 @@ static int JimExprOpBin(Jim_Interp *interp, struct JimExprState *e)
         (B->typePtr != &doubleObjType || B->bytes) &&
         JimGetWideNoErr(interp, A, &wA) == JIM_OK && JimGetWideNoErr(interp, B, &wB) == JIM_OK) {
 
-        /* Both are ints */
+        
 
         intresult = 1;
 
@@ -13779,14 +11859,6 @@ static int JimExprOpBin(Jim_Interp *interp, struct JimExprState *e)
                     rc = JIM_ERR;
                 }
                 else {
-                    /*
-                     * From Tcl 8.x
-                     *
-                     * This code is tricky: C doesn't guarantee much
-                     * about the quotient or remainder, but Tcl does.
-                     * The remainder always has the same sign as the
-                     * divisor and a smaller absolute value.
-                     */
                     if (wB < 0) {
                         wB = -wB;
                         wA = -wA;
@@ -13879,9 +11951,9 @@ static int JimExprOpBin(Jim_Interp *interp, struct JimExprState *e)
         }
     }
     else {
-        /* Handle the string case */
+        
 
-        /* REVISIT: Could optimise the eq/ne case by checking lengths */
+        
         int i = Jim_StringCompareObj(interp, A, B, 0);
 
         intresult = 1;
@@ -14005,17 +12077,17 @@ static int JimExprOpAndLeft(Jim_Interp *interp, struct JimExprState *e)
 
     switch (ExprBool(interp, A)) {
         case 0:
-            /* false, so skip RHS opcodes with a 0 result */
+            
             e->skip = JimWideValue(skip);
             ExprPush(e, Jim_NewIntObj(interp, 0));
             break;
 
         case 1:
-            /* true so continue */
+            
             break;
 
         case -1:
-            /* Invalid */
+            
             rc = JIM_ERR;
     }
     Jim_DecrRefCount(interp, A);
@@ -14032,17 +12104,17 @@ static int JimExprOpOrLeft(Jim_Interp *interp, struct JimExprState *e)
 
     switch (ExprBool(interp, A)) {
         case 0:
-            /* false, so do nothing */
+            
             break;
 
         case 1:
-            /* true so skip RHS opcodes with a 1 result */
+            
             e->skip = JimWideValue(skip);
             ExprPush(e, Jim_NewIntObj(interp, 1));
             break;
 
         case -1:
-            /* Invalid */
+            
             rc = JIM_ERR;
             break;
     }
@@ -14067,7 +12139,7 @@ static int JimExprOpAndOrRight(Jim_Interp *interp, struct JimExprState *e)
             break;
 
         case -1:
-            /* Invalid */
+            
             rc = JIM_ERR;
             break;
     }
@@ -14082,23 +12154,23 @@ static int JimExprOpTernaryLeft(Jim_Interp *interp, struct JimExprState *e)
     Jim_Obj *A = ExprPop(e);
     int rc = JIM_OK;
 
-    /* Repush A */
+    
     ExprPush(e, A);
 
     switch (ExprBool(interp, A)) {
         case 0:
-            /* false, skip RHS opcodes */
+            
             e->skip = JimWideValue(skip);
-            /* Push a dummy value */
+            
             ExprPush(e, Jim_NewIntObj(interp, 0));
             break;
 
         case 1:
-            /* true so do nothing */
+            
             break;
 
         case -1:
-            /* Invalid */
+            
             rc = JIM_ERR;
             break;
     }
@@ -14114,11 +12186,11 @@ static int JimExprOpColonLeft(Jim_Interp *interp, struct JimExprState *e)
     Jim_Obj *B = ExprPop(e);
     Jim_Obj *A = ExprPop(e);
 
-    /* No need to check for A as non-boolean */
+    
     if (ExprBool(interp, A)) {
-        /* true, so skip RHS opcodes */
+        
         e->skip = JimWideValue(skip);
-        /* Repush B as the answer */
+        
         ExprPush(e, B);
     }
 
@@ -14141,7 +12213,7 @@ enum
     LAZY_RIGHT
 };
 
-/* name - precedence - arity - opcode */
+
 static const struct Jim_ExprOperator Jim_ExprOperators[] = {
     [JIM_EXPROP_FUNC_INT] = {"int", 400, 1, JimExprOpNumUnary, LAZY_NONE},
     [JIM_EXPROP_FUNC_DOUBLE] = {"double", 400, 1, JimExprOpNumUnary, LAZY_NONE},
@@ -14211,7 +12283,7 @@ static const struct Jim_ExprOperator Jim_ExprOperators[] = {
     [JIM_EXPROP_TERNARY] = {"?", 5, 2, JimExprOpNull, LAZY_OP},
     [JIM_EXPROP_COLON] = {":", 5, 2, JimExprOpNull, LAZY_OP},
 
-    /* private operators */
+    
     [JIM_EXPROP_TERNARY_LEFT] = {NULL, 5, 2, JimExprOpTernaryLeft, LAZY_LEFT},
     [JIM_EXPROP_TERNARY_RIGHT] = {NULL, 5, 2, JimExprOpNull, LAZY_RIGHT},
     [JIM_EXPROP_COLON_LEFT] = {NULL, 5, 2, JimExprOpColonLeft, LAZY_LEFT},
@@ -14227,8 +12299,11 @@ static const struct Jim_ExprOperator Jim_ExprOperators[] = {
 
 static int JimParseExpression(struct JimParserCtx *pc)
 {
-    /* Discard spaces and quoted newline */
+    
     while (isspace(UCHAR(*pc->p)) || (*(pc->p) == '\\' && *(pc->p + 1) == '\n')) {
+        if (*pc->p == '\n') {
+            pc->linenr++;
+        }
         pc->p++;
         pc->len--;
     }
@@ -14261,7 +12336,7 @@ static int JimParseExpression(struct JimParserCtx *pc)
             if (JimParseVar(pc) == JIM_ERR)
                 return JimParseExprOperator(pc);
             else {
-                /* Don't allow expr sugar in expressions */
+                
                 if (pc->tt == JIM_TT_EXPRSUGAR) {
                     return JIM_ERR;
                 }
@@ -14304,7 +12379,7 @@ static int JimParseExprNumber(struct JimParserCtx *pc)
     int allowdot = 1;
     int allowhex = 0;
 
-    /* Assume an integer for now */
+    
     pc->tt = JIM_TT_EXPR_INT;
     pc->tstart = pc->p;
     pc->tline = pc->linenr;
@@ -14360,7 +12435,7 @@ static int JimParseExprOperator(struct JimParserCtx *pc)
     int i;
     int bestIdx = -1, bestLen = 0;
 
-    /* Try to get the longest match. */
+    
     for (i = JIM_TT_EXPR_OP; i < (signed)JIM_EXPR_OPERATORS_NUM; i++) {
         const char *opname;
         int oplen;
@@ -14380,7 +12455,7 @@ static int JimParseExprOperator(struct JimParserCtx *pc)
         return JIM_ERR;
     }
 
-    /* Validate paretheses around function arguments */
+    
     if (bestIdx >= JIM_EXPROP_FUNC_FIRST) {
         const char *p = pc->p + bestLen;
         int len = pc->len - bestLen;
@@ -14428,9 +12503,6 @@ const char *jim_tt_name(int type)
     }
 }
 
-/* -----------------------------------------------------------------------------
- * Expression Object
- * ---------------------------------------------------------------------------*/
 static void FreeExprInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
 static void DupExprInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
 static int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
@@ -14443,12 +12515,12 @@ static const Jim_ObjType exprObjType = {
     JIM_TYPE_REFERENCES,
 };
 
-/* Expr bytecode structure */
+
 typedef struct ExprByteCode
 {
-    int len;                    /* Length as number of tokens. */
-    ScriptToken *token;         /* Tokens array. */
-    int inUse;                  /* Used for sharing. */
+    int len;                    
+    ScriptToken *token;         
+    int inUse;                  
 } ExprByteCode;
 
 static void ExprFreeByteCode(Jim_Interp *interp, ExprByteCode * expr)
@@ -14480,20 +12552,17 @@ static void DupExprInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dup
     JIM_NOTUSED(interp);
     JIM_NOTUSED(srcPtr);
 
-    /* Just returns an simple string. */
+    
     dupPtr->typePtr = NULL;
 }
 
-/* Check if an expr program looks correct. */
+
 static int ExprCheckCorrectness(ExprByteCode * expr)
 {
     int i;
     int stacklen = 0;
     int ternary = 0;
 
-    /* Try to check if there are stack underflows,
-     * and make sure at the end of the program there is
-     * a single result on the stack. */
     for (i = 0; i < expr->len; i++) {
         ScriptToken *t = &expr->token[i];
         const struct Jim_ExprOperator *op = JimExprOperatorInfoByOpcode(t->type);
@@ -14511,7 +12580,7 @@ static int ExprCheckCorrectness(ExprByteCode * expr)
             }
         }
 
-        /* All operations and operands add one to the stack */
+        
         stacklen++;
     }
     if (stacklen != 1 || ternary != 0) {
@@ -14520,38 +12589,13 @@ static int ExprCheckCorrectness(ExprByteCode * expr)
     return JIM_OK;
 }
 
-/* This procedure converts every occurrence of || and && opereators
- * in lazy unary versions.
- *
- * a b || is converted into:
- *
- * a <offset> |L b |R
- *
- * a b && is converted into:
- *
- * a <offset> &L b &R
- *
- * "|L" checks if 'a' is true:
- *   1) if it is true pushes 1 and skips <offset> instructions to reach
- *      the opcode just after |R.
- *   2) if it is false does nothing.
- * "|R" checks if 'b' is true:
- *   1) if it is true pushes 1, otherwise pushes 0.
- *
- * "&L" checks if 'a' is true:
- *   1) if it is true does nothing.
- *   2) If it is false pushes 0 and skips <offset> instructions to reach
- *      the opcode just after &R
- * "&R" checks if 'a' is true:
- *      if it is true pushes 1, otherwise pushes 0.
- */
 static int ExprAddLazyOperator(Jim_Interp *interp, ExprByteCode * expr, ParseToken *t)
 {
     int i;
 
     int leftindex, arity, offset;
 
-    /* Search for the end of the first operator */
+    
     leftindex = expr->len - 1;
 
     arity = 1;
@@ -14568,27 +12612,24 @@ static int ExprAddLazyOperator(Jim_Interp *interp, ExprByteCode * expr, ParseTok
     }
     leftindex++;
 
-    /* Move them up */
+    
     memmove(&expr->token[leftindex + 2], &expr->token[leftindex],
         sizeof(*expr->token) * (expr->len - leftindex));
     expr->len += 2;
     offset = (expr->len - leftindex) - 1;
 
-    /* Now we rely on the fact the the left and right version have opcodes
-     * 1 and 2 after the main opcode respectively
-     */
     expr->token[leftindex + 1].type = t->type + 1;
     expr->token[leftindex + 1].objPtr = interp->emptyObj;
 
     expr->token[leftindex].type = JIM_TT_EXPR_INT;
     expr->token[leftindex].objPtr = Jim_NewIntObj(interp, offset);
 
-    /* Now add the 'R' operator */
+    
     expr->token[expr->len].objPtr = interp->emptyObj;
     expr->token[expr->len].type = t->type + 2;
     expr->len++;
 
-    /* Do we need to adjust the skip count for any &L, |L, ?L or :L in the left operand? */
+    
     for (i = leftindex - 1; i > 0; i--) {
         if (JimExprOperatorInfoByOpcode(expr->token[i].type)->lazy == LAZY_LEFT) {
             if (JimWideValue(expr->token[i - 1].objPtr) + i - 1 >= leftindex) {
@@ -14618,12 +12659,6 @@ static int ExprAddOperator(Jim_Interp *interp, ExprByteCode * expr, ParseToken *
     return JIM_OK;
 }
 
-/**
- * Returns the index of the COLON_LEFT to the left of 'right_index'
- * taking into account nesting.
- *
- * The expression *must* be well formed, thus a COLON_LEFT will always be found.
- */
 static int ExprTernaryGetColonLeftIndex(ExprByteCode *expr, int right_index)
 {
     int ternary_count = 1;
@@ -14643,16 +12678,10 @@ static int ExprTernaryGetColonLeftIndex(ExprByteCode *expr, int right_index)
         right_index--;
     }
 
-    /*notreached*/
+    
     return -1;
 }
 
-/**
- * Find the left/right indices for the ternary expression to the left of 'right_index'.
- *
- * Returns 1 if found, and fills in *prev_right_index and *prev_left_index.
- * Otherwise returns 0.
- */
 static int ExprTernaryGetMoveIndices(ExprByteCode *expr, int right_index, int *prev_right_index, int *prev_left_index)
 {
     int i = right_index - 1;
@@ -14677,51 +12706,6 @@ static int ExprTernaryGetMoveIndices(ExprByteCode *expr, int right_index, int *p
     return 0;
 }
 
-/*
-* ExprTernaryReorderExpression description
-* ========================================
-*
-* ?: is right-to-left associative which doesn't work with the stack-based
-* expression engine. The fix is to reorder the bytecode.
-*
-* The expression:
-*
-*    expr 1?2:0?3:4
-*
-* Has initial bytecode:
-*
-*    '1' '2' (40=TERNARY_LEFT) '2' (41=TERNARY_RIGHT) '2' (43=COLON_LEFT) '0' (44=COLON_RIGHT)
-*    '2' (40=TERNARY_LEFT) '3' (41=TERNARY_RIGHT) '2' (43=COLON_LEFT) '4' (44=COLON_RIGHT)
-*
-* The fix involves simulating this expression instead:
-*
-*    expr 1?2:(0?3:4)
-*
-* With the following bytecode:
-*
-*    '1' '2' (40=TERNARY_LEFT) '2' (41=TERNARY_RIGHT) '10' (43=COLON_LEFT) '0' '2' (40=TERNARY_LEFT)
-*    '3' (41=TERNARY_RIGHT) '2' (43=COLON_LEFT) '4' (44=COLON_RIGHT) (44=COLON_RIGHT)
-*
-* i.e. The token COLON_RIGHT at index 8 is moved towards the end of the stack, all tokens above 8
-*      are shifted down and the skip count of the token JIM_EXPROP_COLON_LEFT at index 5 is
-*      incremented by the amount tokens shifted down. The token JIM_EXPROP_COLON_RIGHT that is moved
-*      is identified as immediately preceeding a token JIM_EXPROP_TERNARY_LEFT
-*
-* ExprTernaryReorderExpression works thus as follows :
-* - start from the end of the stack
-* - while walking towards the beginning of the stack
-*     if token=JIM_EXPROP_COLON_RIGHT then
-*        find the associated token JIM_EXPROP_TERNARY_LEFT, which allows to
-*            find the associated token previous(JIM_EXPROP_COLON_RIGHT)
-*            find the associated token previous(JIM_EXPROP_LEFT_RIGHT)
-*        if all found then
-*            perform the rotation
-*            update the skip count of the token previous(JIM_EXPROP_LEFT_RIGHT)
-*        end if
-*    end if
-*
-* Note: care has to be taken for nested ternary constructs!!!
-*/
 static void ExprTernaryReorderExpression(Jim_Interp *interp, ExprByteCode *expr)
 {
     int i;
@@ -14736,47 +12720,25 @@ static void ExprTernaryReorderExpression(Jim_Interp *interp, ExprByteCode *expr)
             continue;
         }
 
-        /* COLON_RIGHT found: get the indexes needed to move the tokens in the stack (if any) */
+        
         if (ExprTernaryGetMoveIndices(expr, i, &prev_right_index, &prev_left_index) == 0) {
             continue;
         }
 
-        /*
-        ** rotate tokens down
-        **
-        ** +->  [i]                         : JIM_EXPROP_COLON_RIGHT
-        ** |     |                             |
-        ** |     V                             V
-        ** |   [...]                        : ...
-        ** |     |                             |
-        ** |     V                             V
-        ** |   [...]                        : ...
-        ** |     |                             |
-        ** |     V                             V
-        ** +-  [prev_right_index]           : JIM_EXPROP_COLON_RIGHT
-        */
         tmp = expr->token[prev_right_index];
         for (j = prev_right_index; j < i; j++) {
             expr->token[j] = expr->token[j + 1];
         }
         expr->token[i] = tmp;
 
-        /* Increment the 'skip' count associated to the previous JIM_EXPROP_COLON_LEFT token
-         *
-         * This is 'colon left increment' = i - prev_right_index
-         *
-         * [prev_left_index]      : JIM_EXPROP_LEFT_RIGHT
-         * [prev_left_index-1]    : skip_count
-         *
-         */
         JimWideValue(expr->token[prev_left_index-1].objPtr) += (i - prev_right_index);
 
-        /* Adjust for i-- in the loop */
+        
         i++;
     }
 }
 
-static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList *tokenlist)
+static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList *tokenlist, Jim_Obj *fileNameObj)
 {
     Jim_Stack stack;
     ExprByteCode *expr;
@@ -14785,7 +12747,7 @@ static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList
     int prevtt = JIM_TT_NONE;
     int have_ternary = 0;
 
-    /* -1 for EOL */
+    
     int count = tokenlist->count - 1;
 
     expr = Jim_Alloc(sizeof(*expr));
@@ -14794,15 +12756,12 @@ static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList
 
     Jim_InitStack(&stack);
 
-    /* Need extra bytecodes for lazy operators.
-     * Also check for the ternary operator
-     */
     for (i = 0; i < tokenlist->count; i++) {
         ParseToken *t = &tokenlist->list[i];
 
         if (JimExprOperatorInfoByOpcode(t->type)->lazy == LAZY_OP) {
             count += 2;
-            /* Ternary is a lazy op but also needs reordering */
+            
             if (t->type == JIM_EXPROP_TERNARY) {
                 have_ternary = 1;
             }
@@ -14814,7 +12773,7 @@ static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList
     for (i = 0; i < tokenlist->count && ok; i++) {
         ParseToken *t = &tokenlist->list[i];
 
-        /* Next token will be stored here */
+        
         struct ScriptToken *token = &expr->token[expr->len];
 
         if (t->type == JIM_TT_EOL) {
@@ -14830,6 +12789,10 @@ static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList
             case JIM_TT_CMD:
                 token->objPtr = Jim_NewStringObj(interp, t->token, t->len);
                 token->type = t->type;
+                if (t->type == JIM_TT_CMD) {
+                    
+                    JimSetSourceInfo(interp, token->objPtr, fileNameObj, t->line);
+                }
                 expr->len++;
                 break;
 
@@ -14872,11 +12835,11 @@ static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList
 
 
             default:{
-                    /* Must be an operator */
+                    
                     const struct Jim_ExprOperator *op;
                     ParseToken *tt;
 
-                    /* Convert -/+ to unary minus or unary plus if necessary */
+                    
                     if (prevtt == JIM_TT_NONE || prevtt >= JIM_TT_EXPR_OP) {
                         if (t->type == JIM_EXPROP_SUB) {
                             t->type = JIM_EXPROP_UNARYMINUS;
@@ -14888,12 +12851,12 @@ static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList
 
                     op = JimExprOperatorInfoByOpcode(t->type);
 
-                    /* Now handle precedence */
+                    
                     while ((tt = Jim_StackPeek(&stack)) != NULL) {
                         const struct Jim_ExprOperator *tt_op =
                             JimExprOperatorInfoByOpcode(tt->type);
 
-                        /* Note that right-to-left associativity of ?: operator is handled later */
+                        
 
                         if (op->arity != 1 && tt_op->precedence >= op->precedence) {
                             if (ExprAddOperator(interp, expr, tt) != JIM_OK) {
@@ -14913,7 +12876,7 @@ static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList
         prevtt = t->type;
     }
 
-    /* Reduce any remaining subexpr */
+    
     while (Jim_StackLen(&stack)) {
         ParseToken *tt = Jim_StackPop(&stack);
 
@@ -14933,7 +12896,7 @@ static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList
     }
 
   err:
-    /* Free the stack used for the compilation. */
+    
     Jim_FreeStack(&stack);
 
     for (i = 0; i < expr->len; i++) {
@@ -14949,26 +12912,31 @@ static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList
 }
 
 
-/* This method takes the string representation of an expression
- * and generates a program for the Expr's stack-based VM. */
-int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
+static int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
 {
     int exprTextLen;
     const char *exprText;
     struct JimParserCtx parser;
     struct ExprByteCode *expr;
     ParseTokenList tokenlist;
+    int line;
+    Jim_Obj *fileNameObj;
     int rc = JIM_ERR;
-    int line = 1;
 
-    /* Try to get information about filename / line number */
+    
     if (objPtr->typePtr == &sourceObjType) {
+        fileNameObj = objPtr->internalRep.sourceValue.fileNameObj;
         line = objPtr->internalRep.sourceValue.lineNumber;
     }
+    else {
+        fileNameObj = interp->emptyObj;
+        line = 1;
+    }
+    Jim_IncrRefCount(fileNameObj);
 
     exprText = Jim_GetString(objPtr, &exprTextLen);
 
-    /* Initially tokenise the expression into tokenlist */
+    
     ScriptTokenListInit(&tokenlist);
 
     JimParserInit(&parser, exprText, exprTextLen, line);
@@ -14996,10 +12964,10 @@ int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
     }
 #endif
 
-    /* Now create the expression bytecode from the tokenlist */
-    expr = ExprCreateByteCode(interp, &tokenlist);
+    
+    expr = ExprCreateByteCode(interp, &tokenlist, fileNameObj);
 
-    /* No longer need the token list */
+    
     ScriptTokenListFree(&tokenlist);
 
     if (!expr) {
@@ -15019,7 +12987,7 @@ int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
     }
 #endif
 
-    /* Check program correctness. */
+    
     if (ExprCheckCorrectness(expr) != JIM_OK) {
         ExprFreeByteCode(interp, expr);
         goto invalidexpr;
@@ -15028,7 +12996,8 @@ int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
     rc = JIM_OK;
 
   err:
-    /* Free the old internal rep and set the new one. */
+    
+    Jim_DecrRefCount(interp, fileNameObj);
     Jim_FreeIntRep(interp, objPtr);
     Jim_SetIntRepPtr(objPtr, expr);
     objPtr->typePtr = &exprObjType;
@@ -15045,21 +13014,6 @@ static ExprByteCode *JimGetExpression(Jim_Interp *interp, Jim_Obj *objPtr)
     return (ExprByteCode *) Jim_GetIntRepPtr(objPtr);
 }
 
-/* -----------------------------------------------------------------------------
- * Expressions evaluation.
- * Jim uses a specialized stack-based virtual machine for expressions,
- * that takes advantage of the fact that expr's operators
- * can't be redefined.
- *
- * Jim_EvalExpression() uses the bytecode compiled by
- * SetExprFromAny() method of the "expression" object.
- *
- * On success a Tcl Object containing the result of the evaluation
- * is stored into expResultPtrPtr (having refcount of 1), and JIM_OK is
- * returned.
- * On error the function returns a retcode != to JIM_OK and set a suitable
- * error on the interp.
- * ---------------------------------------------------------------------------*/
 #define JIM_EE_STATICSTACK_LEN 10
 
 int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr, Jim_Obj **exprResultPtrPtr)
@@ -15072,27 +13026,13 @@ int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr, Jim_Obj **exprRe
 
     expr = JimGetExpression(interp, exprObjPtr);
     if (!expr) {
-        return JIM_ERR;         /* error in expression. */
+        return JIM_ERR;         
     }
 
 #ifdef JIM_OPTIMIZATION
-    /* Check for one of the following common expressions used by while/for
-     *
-     *   CONST
-     *   $a
-     *   !$a
-     *   $a < CONST, $a < $b
-     *   $a <= CONST, $a <= $b
-     *   $a > CONST, $a > $b
-     *   $a >= CONST, $a >= $b
-     *   $a != CONST, $a != $b
-     *   $a == CONST, $a == $b
-     */
     {
         Jim_Obj *objPtr;
 
-        /* STEP 1 -- Check if there are the conditions to run the specialized
-         * version of while */
 
         switch (expr->len) {
             case 1:
@@ -15135,7 +13075,7 @@ int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr, Jim_Obj **exprRe
                         case JIM_EXPROP_GTE:
                         case JIM_EXPROP_NUMEQ:
                         case JIM_EXPROP_NUMNE:{
-                                /* optimise ok */
+                                
                                 jim_wide wideValueA;
                                 jim_wide wideValueB;
 
@@ -15173,7 +13113,7 @@ int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr, Jim_Obj **exprRe
                                             case JIM_EXPROP_NUMNE:
                                                 cmpRes = wideValueA != wideValueB;
                                                 break;
-                                            default:   /*notreached */
+                                            default:   
                                                 cmpRes = 0;
                                         }
                                         *exprResultPtrPtr =
@@ -15190,16 +13130,10 @@ int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr, Jim_Obj **exprRe
     }
 #endif
 
-    /* In order to avoid that the internal repr gets freed due to
-     * shimmering of the exprObjPtr's object, we make the internal rep
-     * shared. */
     expr->inUse++;
 
-    /* The stack-based expr VM itself */
+    
 
-    /* Stack allocation. Expr programs have the feature that
-     * a program of length N can't require a stack longer than
-     * N. */
     if (expr->len > JIM_EE_STATICSTACK_LEN)
         e.stack = Jim_Alloc(sizeof(Jim_Obj *) * expr->len);
     else
@@ -15207,7 +13141,7 @@ int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr, Jim_Obj **exprRe
 
     e.stacklen = 0;
 
-    /* Execute every instruction */
+    
     for (i = 0; i < expr->len && retcode == JIM_OK; i++) {
         Jim_Obj *objPtr;
 
@@ -15253,12 +13187,12 @@ int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr, Jim_Obj **exprRe
                 break;
 
             default:{
-                    /* Find and execute the operation */
+                    
                     e.skip = 0;
                     e.opcode = expr->token[i].type;
 
                     retcode = JimExprOperatorInfoByOpcode(e.opcode)->funcop(interp, &e);
-                    /* Skip some opcodes if necessary */
+                    
                     i += e.skip;
                     continue;
                 }
@@ -15309,57 +13243,30 @@ int Jim_GetBoolFromExpr(Jim_Interp *interp, Jim_Obj *exprObjPtr, int *boolPtr)
     return JIM_OK;
 }
 
-/* -----------------------------------------------------------------------------
- * ScanFormat String Object
- * ---------------------------------------------------------------------------*/
 
-/* This Jim_Obj will held a parsed representation of a format string passed to
- * the Jim_ScanString command. For error diagnostics, the scanformat string has
- * to be parsed in its entirely first and then, if correct, can be used for
- * scanning. To avoid endless re-parsing, the parsed representation will be
- * stored in an internal representation and re-used for performance reason. */
 
-/* A ScanFmtPartDescr will held the information of /one/ part of the whole
- * scanformat string. This part will later be used to extract information
- * out from the string to be parsed by Jim_ScanString */
 
 typedef struct ScanFmtPartDescr
 {
-    char type;                  /* Type of conversion (e.g. c, d, f) */
-    char modifier;              /* Modify type (e.g. l - long, h - short */
-    size_t width;               /* Maximal width of input to be converted */
-    int pos;                    /* -1 - no assign, 0 - natural pos, >0 - XPG3 pos */
-    char *arg;                  /* Specification of a CHARSET conversion */
-    char *prefix;               /* Prefix to be scanned literally before conversion */
+    char type;                  
+    char modifier;              
+    size_t width;               
+    int pos;                    
+    char *arg;                  
+    char *prefix;               
 } ScanFmtPartDescr;
 
-/* The ScanFmtStringObj will hold the internal representation of a scanformat
- * string parsed and separated in part descriptions. Furthermore it contains
- * the original string representation of the scanformat string to allow for
- * fast update of the Jim_Obj's string representation part.
- *
- * As an add-on the internal object representation adds some scratch pad area
- * for usage by Jim_ScanString to avoid endless allocating and freeing of
- * memory for purpose of string scanning.
- *
- * The error member points to a static allocated string in case of a mal-
- * formed scanformat string or it contains '0' (NULL) in case of a valid
- * parse representation.
- *
- * The whole memory of the internal representation is allocated as a single
- * area of memory that will be internally separated. So freeing and duplicating
- * of such an object is cheap */
 
 typedef struct ScanFmtStringObj
 {
-    jim_wide size;              /* Size of internal repr in bytes */
-    char *stringRep;            /* Original string representation */
-    size_t count;               /* Number of ScanFmtPartDescr contained */
-    size_t convCount;           /* Number of conversions that will assign */
-    size_t maxPos;              /* Max position index if XPG3 is used */
-    const char *error;          /* Ptr to error text (NULL if no error */
-    char *scratch;              /* Some scratch pad used by Jim_ScanString */
-    ScanFmtPartDescr descr[1];  /* The vector of partial descriptions */
+    jim_wide size;              
+    char *stringRep;            
+    size_t count;               
+    size_t convCount;           
+    size_t maxPos;              
+    const char *error;          
+    char *scratch;              
+    ScanFmtPartDescr descr[1];  
 } ScanFmtStringObj;
 
 
@@ -15401,12 +13308,6 @@ void UpdateStringOfScanFmt(Jim_Obj *objPtr)
     objPtr->length = strlen(bytes);
 }
 
-/* SetScanFmtFromAny will parse a given string and create the internal
- * representation of the format specification. In case of an error
- * the error data member of the internal representation will be set
- * to an descriptive error text and the function will be left with
- * JIM_ERR to indicate unsucessful parsing (aka. malformed scanformat
- * specification */
 
 static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 {
@@ -15419,18 +13320,18 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
     int curr;
 
     Jim_FreeIntRep(interp, objPtr);
-    /* Count how many conversions could take place maximally */
+    
     for (i = 0, maxCount = 0; i < maxFmtLen; ++i)
         if (fmt[i] == '%')
             ++maxCount;
-    /* Calculate an approximation of the memory necessary */
-    approxSize = sizeof(ScanFmtStringObj)       /* Size of the container */
-        +(maxCount + 1) * sizeof(ScanFmtPartDescr)      /* Size of all partials */
-        +maxFmtLen * sizeof(char) + 3 + 1       /* Scratch + "%n" + '\0' */
-        + maxFmtLen * sizeof(char) + 1  /* Original stringrep */
-        + maxFmtLen * sizeof(char)      /* Arg for CHARSETs */
-        +(maxCount + 1) * sizeof(char)  /* '\0' for every partial */
-        +1;                     /* safety byte */
+    
+    approxSize = sizeof(ScanFmtStringObj)       
+        +(maxCount + 1) * sizeof(ScanFmtPartDescr)      
+        +maxFmtLen * sizeof(char) + 3 + 1       
+        + maxFmtLen * sizeof(char) + 1  
+        + maxFmtLen * sizeof(char)      
+        +(maxCount + 1) * sizeof(char)  
+        +1;                     
     fmtObj = (ScanFmtStringObj *) Jim_Alloc(approxSize);
     memset(fmtObj, 0, approxSize);
     fmtObj->size = approxSize;
@@ -15446,8 +13347,8 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
         ScanFmtPartDescr *descr = &fmtObj->descr[curr];
 
         fmtObj->count++;
-        descr->width = 0;       /* Assume width unspecified */
-        /* Overread and store any "literal" prefix */
+        descr->width = 0;       
+        
         if (*fmt != '%' || fmt[1] == '%') {
             descr->type = 0;
             descr->prefix = &buffer[i];
@@ -15461,35 +13362,35 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
             }
             buffer[i++] = 0;
         }
-        /* Skip the conversion introducing '%' sign */
+        
         ++fmt;
-        /* End reached due to non-conversion literal only? */
+        
         if (fmt >= fmtEnd)
             goto done;
-        descr->pos = 0;         /* Assume "natural" positioning */
+        descr->pos = 0;         
         if (*fmt == '*') {
-            descr->pos = -1;    /* Okay, conversion will not be assigned */
+            descr->pos = -1;    
             ++fmt;
         }
         else
-            fmtObj->convCount++;        /* Otherwise count as assign-conversion */
-        /* Check if next token is a number (could be width or pos */
+            fmtObj->convCount++;        
+        
         if (sscanf(fmt, "%d%n", &width, &skip) == 1) {
             fmt += skip;
-            /* Was the number a XPG3 position specifier? */
+            
             if (descr->pos != -1 && *fmt == '$') {
                 int prev;
 
                 ++fmt;
                 descr->pos = width;
                 width = 0;
-                /* Look if "natural" postioning and XPG3 one was mixed */
+                
                 if ((lastPos == 0 && descr->pos > 0)
                     || (lastPos > 0 && descr->pos == 0)) {
                     fmtObj->error = "cannot mix \"%\" and \"%n$\" conversion specifiers";
                     return JIM_ERR;
                 }
-                /* Look if this position was already used */
+                
                 for (prev = 0; prev < curr; ++prev) {
                     if (fmtObj->descr[prev].pos == -1)
                         continue;
@@ -15499,7 +13400,7 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
                         return JIM_ERR;
                     }
                 }
-                /* Try to find a width after the XPG3 specifier */
+                
                 if (sscanf(fmt, "%d%n", &width, &skip) == 1) {
                     descr->width = width;
                     fmt += skip;
@@ -15508,14 +13409,14 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
                     fmtObj->maxPos = descr->pos;
             }
             else {
-                /* Number was not a XPG3, so it has to be a width */
+                
                 descr->width = width;
             }
         }
-        /* If positioning mode was undetermined yet, fix this */
+        
         if (lastPos == -1)
             lastPos = descr->pos;
-        /* Handle CHARSET conversion type ... */
+        
         if (*fmt == '[') {
             int swapped = 1, beg = i, end, j;
 
@@ -15534,7 +13435,7 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
             }
             end = i;
             buffer[i++] = 0;
-            /* In case a range fence was given "backwards", swap it */
+            
             while (swapped) {
                 swapped = 0;
                 for (j = beg + 1; j < end - 1; ++j) {
@@ -15549,7 +13450,7 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
             }
         }
         else {
-            /* Remember any valid modifier if given */
+            
             if (strchr("hlL", *fmt) != 0)
                 descr->modifier = tolower((int)*fmt++);
 
@@ -15573,7 +13474,7 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
     return JIM_OK;
 }
 
-/* Some accessor macros to allow lowlevel access to fields of internal repr */
+
 
 #define FormatGetCnvCount(_fo_) \
     ((ScanFmtStringObj*)((_fo_)->internalRep.ptr))->convCount
@@ -15582,10 +13483,6 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 #define FormatGetError(_fo_) \
     ((ScanFmtStringObj*)((_fo_)->internalRep.ptr))->error
 
-/* JimScanAString is used to scan an unspecified string that ends with
- * next WS, or a string that is specified via a charset.
- *
- */
 static Jim_Obj *JimScanAString(Jim_Interp *interp, const char *sdescr, const char *str)
 {
     char *buffer = Jim_StrDup(str);
@@ -15596,7 +13493,7 @@ static Jim_Obj *JimScanAString(Jim_Interp *interp, const char *sdescr, const cha
         int n;
 
         if (!sdescr && isspace(UCHAR(*str)))
-            break;              /* EOS via WS if unspecified */
+            break;              
 
         n = utf8_tounicode(str, &c);
         if (sdescr && !JimCharsetMatch(sdescr, c, JIM_CHARSET_SCAN))
@@ -15608,11 +13505,6 @@ static Jim_Obj *JimScanAString(Jim_Interp *interp, const char *sdescr, const cha
     return Jim_NewStringObjNoAlloc(interp, buffer, p - buffer);
 }
 
-/* ScanOneEntry will scan one entry out of the string passed as argument.
- * It use the sscanf() function for this task. After extracting and
- * converting of the value, the count of scanned characters will be
- * returned of -1 in case of no conversion tool place and string was
- * already scanned thru */
 
 static int ScanOneEntry(Jim_Interp *interp, const char *str, int pos, int strLen,
     ScanFmtStringObj * fmtObj, long idx, Jim_Obj **valObjPtr)
@@ -15624,42 +13516,40 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, int pos, int strLen
     int i;
     Jim_Obj *tmpObj = NULL;
 
-    /* First pessimistically assume, we will not scan anything :-) */
+    
     *valObjPtr = 0;
     if (descr->prefix) {
-        /* There was a prefix given before the conversion, skip it and adjust
-         * the string-to-be-parsed accordingly */
-        /* XXX: Should be checking strLen, not str[pos] */
+        
         for (i = 0; pos < strLen && descr->prefix[i]; ++i) {
-            /* If prefix require, skip WS */
+            
             if (isspace(UCHAR(descr->prefix[i])))
                 while (pos < strLen && isspace(UCHAR(str[pos])))
                     ++pos;
             else if (descr->prefix[i] != str[pos])
-                break;          /* Prefix do not match here, leave the loop */
+                break;          
             else
-                ++pos;          /* Prefix matched so far, next round */
+                ++pos;          
         }
         if (pos >= strLen) {
-            return -1;          /* All of str consumed: EOF condition */
+            return -1;          
         }
         else if (descr->prefix[i] != 0)
-            return 0;           /* Not whole prefix consumed, no conversion possible */
+            return 0;           
     }
-    /* For all but following conversion, skip leading WS */
+    
     if (descr->type != 'c' && descr->type != '[' && descr->type != 'n')
         while (isspace(UCHAR(str[pos])))
             ++pos;
-    /* Determine how much skipped/scanned so far */
+    
     scanned = pos - anchor;
 
-    /* %c is a special, simple case. no width */
+    
     if (descr->type == 'n') {
-        /* Return pseudo conversion means: how much scanned so far? */
+        
         *valObjPtr = Jim_NewIntObj(interp, anchor + scanned);
     }
     else if (pos >= strLen) {
-        /* Cannot scan anything, as str is totally consumed */
+        
         return -1;
     }
     else if (descr->type == 'c') {
@@ -15669,10 +13559,8 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, int pos, int strLen
             return scanned;
     }
     else {
-        /* Processing of conversions follows ... */
+        
         if (descr->width > 0) {
-            /* Do not try to scan as fas as possible but only the given width.
-             * To ensure this, we copy the part that should be scanned. */
             size_t sLen = utf8_strlen(&str[pos], strLen - pos);
             size_t tLen = descr->width > sLen ? sLen : descr->width;
 
@@ -15680,7 +13568,7 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, int pos, int strLen
             tok = tmpObj->bytes;
         }
         else {
-            /* As no width was given, simply refer to the original string */
+            
             tok = &str[pos];
         }
         switch (descr->type) {
@@ -15689,34 +13577,26 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, int pos, int strLen
             case 'x':
             case 'u':
             case 'i':{
-                    char *endp; /* Position where the number finished */
+                    char *endp; 
                     jim_wide w;
 
                     int base = descr->type == 'o' ? 8
                         : descr->type == 'x' ? 16 : descr->type == 'i' ? 0 : 10;
 
-                    /* Try to scan a number with the given base */
+                    
                     w = strtoull(tok, &endp, base);
                     if (endp == tok && base == 0) {
-                        /* If scanning failed, and base was undetermined, simply
-                         * put it to 10 and try once more. This should catch the
-                         * case where %i begin to parse a number prefix (e.g.
-                         * '0x' but no further digits follows. This will be
-                         * handled as a ZERO followed by a char 'x' by Tcl */
                         w = strtoull(tok, &endp, 10);
                     }
 
                     if (endp != tok) {
-                        /* There was some number sucessfully scanned! */
+                        
                         *valObjPtr = Jim_NewIntObj(interp, w);
 
-                        /* Adjust the number-of-chars scanned so far */
+                        
                         scanned += endp - tok;
                     }
                     else {
-                        /* Nothing was scanned. We have to determine if this
-                         * happened due to e.g. prefix mismatch or input str
-                         * exhausted */
                         scanned = *tok ? 0 : -1;
                     }
                     break;
@@ -15734,22 +13614,17 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, int pos, int strLen
                     double value = strtod(tok, &endp);
 
                     if (endp != tok) {
-                        /* There was some number sucessfully scanned! */
+                        
                         *valObjPtr = Jim_NewDoubleObj(interp, value);
-                        /* Adjust the number-of-chars scanned so far */
+                        
                         scanned += endp - tok;
                     }
                     else {
-                        /* Nothing was scanned. We have to determine if this
-                         * happened due to e.g. prefix mismatch or input str
-                         * exhausted */
                         scanned = *tok ? 0 : -1;
                     }
                     break;
                 }
         }
-        /* If a substring was allocated (due to pre-defined width) do not
-         * forget to free it */
         if (tmpObj) {
             Jim_FreeNewObj(interp, tmpObj);
         }
@@ -15757,9 +13632,6 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, int pos, int strLen
     return scanned;
 }
 
-/* Jim_ScanString is the workhorse of string scanning. It will scan a given
- * string and returns all converted (and not ignored) values in a list back
- * to the caller. If an error occured, a NULL pointer will be returned */
 
 Jim_Obj *Jim_ScanString(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *fmtObjPtr, int flags)
 {
@@ -15773,61 +13645,61 @@ Jim_Obj *Jim_ScanString(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *fmtObjP
     Jim_Obj *emptyStr = 0;
     ScanFmtStringObj *fmtObj;
 
-    /* This should never happen. The format object should already be of the correct type */
-    JimPanic((fmtObjPtr->typePtr != &scanFmtStringObjType, interp, "Jim_ScanString() for non-scan format"));
+    
+    JimPanic((fmtObjPtr->typePtr != &scanFmtStringObjType, "Jim_ScanString() for non-scan format"));
 
     fmtObj = (ScanFmtStringObj *) fmtObjPtr->internalRep.ptr;
-    /* Check if format specification was valid */
+    
     if (fmtObj->error != 0) {
         if (flags & JIM_ERRMSG)
             Jim_SetResultString(interp, fmtObj->error, -1);
         return 0;
     }
-    /* Allocate a new "shared" empty string for all unassigned conversions */
+    
     emptyStr = Jim_NewEmptyStringObj(interp);
     Jim_IncrRefCount(emptyStr);
-    /* Create a list and fill it with empty strings up to max specified XPG3 */
+    
     resultList = Jim_NewListObj(interp, 0, 0);
     if (fmtObj->maxPos > 0) {
         for (i = 0; i < fmtObj->maxPos; ++i)
             Jim_ListAppendElement(interp, resultList, emptyStr);
         JimListGetElements(interp, resultList, &resultc, &resultVec);
     }
-    /* Now handle every partial format description */
+    
     for (i = 0, pos = 0; i < fmtObj->count; ++i) {
         ScanFmtPartDescr *descr = &(fmtObj->descr[i]);
         Jim_Obj *value = 0;
 
-        /* Only last type may be "literal" w/o conversion - skip it! */
+        
         if (descr->type == 0)
             continue;
-        /* As long as any conversion could be done, we will proceed */
+        
         if (scanned > 0)
             scanned = ScanOneEntry(interp, str, pos, strLen, fmtObj, i, &value);
-        /* In case our first try results in EOF, we will leave */
+        
         if (scanned == -1 && i == 0)
             goto eof;
-        /* Advance next pos-to-be-scanned for the amount scanned already */
+        
         pos += scanned;
 
-        /* value == 0 means no conversion took place so take empty string */
+        
         if (value == 0)
             value = Jim_NewEmptyStringObj(interp);
-        /* If value is a non-assignable one, skip it */
+        
         if (descr->pos == -1) {
             Jim_FreeNewObj(interp, value);
         }
         else if (descr->pos == 0)
-            /* Otherwise append it to the result list if no XPG3 was given */
+            
             Jim_ListAppendElement(interp, resultList, value);
         else if (resultVec[descr->pos - 1] == emptyStr) {
-            /* But due to given XPG3, put the value into the corr. slot */
+            
             Jim_DecrRefCount(interp, resultVec[descr->pos - 1]);
             Jim_IncrRefCount(value);
             resultVec[descr->pos - 1] = value;
         }
         else {
-            /* Otherwise, the slot was already used - free obj and ERROR */
+            
             Jim_FreeNewObj(interp, value);
             goto err;
         }
@@ -15844,10 +13716,7 @@ Jim_Obj *Jim_ScanString(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *fmtObjP
     return 0;
 }
 
-/* -----------------------------------------------------------------------------
- * Pseudo Random Number Generation
- * ---------------------------------------------------------------------------*/
-/* Initialize the sbox with the numbers from 0 to 255 */
+
 static void JimPrngInit(Jim_Interp *interp)
 {
 #define PRNG_SEED_SIZE 256
@@ -15865,18 +13734,18 @@ static void JimPrngInit(Jim_Interp *interp)
     Jim_Free(seed);
 }
 
-/* Generates N bytes of random data */
+
 static void JimRandomBytes(Jim_Interp *interp, void *dest, unsigned int len)
 {
     Jim_PrngState *prng;
     unsigned char *destByte = (unsigned char *)dest;
     unsigned int si, sj, x;
 
-    /* initialization, only needed the first time */
+    
     if (interp->prngState == NULL)
         JimPrngInit(interp);
     prng = interp->prngState;
-    /* generates 'len' bytes of pseudo-random numbers */
+    
     for (x = 0; x < len; x++) {
         prng->i = (prng->i + 1) & 0xff;
         si = prng->sbox[prng->i];
@@ -15888,21 +13757,21 @@ static void JimRandomBytes(Jim_Interp *interp, void *dest, unsigned int len)
     }
 }
 
-/* Re-seed the generator with user-provided bytes */
+
 static void JimPrngSeed(Jim_Interp *interp, unsigned char *seed, int seedLen)
 {
     int i;
     Jim_PrngState *prng;
 
-    /* initialization, only needed the first time */
+    
     if (interp->prngState == NULL)
         JimPrngInit(interp);
     prng = interp->prngState;
 
-    /* Set the sbox[i] with i */
+    
     for (i = 0; i < 256; i++)
         prng->sbox[i] = i;
-    /* Now use the seed to perform a random permutation of the sbox */
+    
     for (i = 0; i < seedLen; i++) {
         unsigned char t;
 
@@ -15912,15 +13781,12 @@ static void JimPrngSeed(Jim_Interp *interp, unsigned char *seed, int seedLen)
     }
     prng->i = prng->j = 0;
 
-    /* discard at least the first 256 bytes of stream.
-     * borrow the seed buffer for this
-     */
     for (i = 0; i < 256; i += seedLen) {
         JimRandomBytes(interp, seed, seedLen);
     }
 }
 
-/* [incr] */
+
 static int Jim_IncrCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     jim_wide wideValue, increment = 1;
@@ -15936,7 +13802,7 @@ static int Jim_IncrCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     }
     intObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED);
     if (!intObjPtr) {
-        /* Set missing variable to 0 */
+        
         wideValue = 0;
     }
     else if (Jim_GetWide(interp, intObjPtr, &wideValue) != JIM_OK) {
@@ -15950,14 +13816,12 @@ static int Jim_IncrCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
         }
     }
     else {
-        /* Can do it the quick way */
+        
         Jim_InvalidateStringRep(intObjPtr);
         JimWideValue(intObjPtr) = wideValue + increment;
 
-        /* The following step is required in order to invalidate the
-         * string repr of "FOO" if the var name is on the form of "FOO(IDX)" */
         if (argv[1]->typePtr != &variableObjType) {
-            /* Note that this can't fail since GetVariable already succeeded */
+            
             Jim_SetVariable(interp, argv[1], intObjPtr);
         }
     }
@@ -15966,85 +13830,60 @@ static int Jim_IncrCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
 }
 
 
-/* -----------------------------------------------------------------------------
- * Eval
- * ---------------------------------------------------------------------------*/
-#define JIM_EVAL_SARGV_LEN 8    /* static arguments vector length */
-#define JIM_EVAL_SINTV_LEN 8    /* static interpolation vector length */
+#define JIM_EVAL_SARGV_LEN 8    
+#define JIM_EVAL_SINTV_LEN 8    
+
 
-/* Handle calls to the [unknown] command */
-static int JimUnknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv, const char *filename,
+static int JimUnknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv, Jim_Obj *fileNameObj,
     int linenr)
 {
     Jim_Obj **v, *sv[JIM_EVAL_SARGV_LEN];
     int retCode;
 
-    /* If JimUnknown() is recursively called too many times...
-     * done here
-     */
     if (interp->unknown_called > 50) {
         return JIM_ERR;
     }
 
-    /* If the [unknown] command does not exists returns
-     * just now */
     if (Jim_GetCommand(interp, interp->unknown, JIM_NONE) == NULL)
         return JIM_ERR;
 
-    /* The object interp->unknown just contains
-     * the "unknown" string, it is used in order to
-     * avoid to lookup the unknown command every time
-     * but instread to cache the result. */
     if (argc + 1 <= JIM_EVAL_SARGV_LEN)
         v = sv;
     else
         v = Jim_Alloc(sizeof(Jim_Obj *) * (argc + 1));
-    /* Make a copy of the arguments vector, but shifted on
-     * the right of one position. The command name of the
-     * command will be instead the first argument of the
-     * [unknown] call. */
     memcpy(v + 1, argv, sizeof(Jim_Obj *) * argc);
     v[0] = interp->unknown;
-    /* Call it */
+    
     interp->unknown_called++;
-    retCode = JimEvalObjVector(interp, argc + 1, v, filename, linenr);
+    retCode = JimEvalObjVector(interp, argc + 1, v, fileNameObj, linenr);
     interp->unknown_called--;
 
-    /* Clean up */
+    
     if (v != sv)
         Jim_Free(v);
     return retCode;
 }
 
-/* Eval the object vector 'objv' composed of 'objc' elements.
- * Every element is used as single argument.
- * Jim_EvalObj() will call this function every time its object
- * argument is of "list" type, with no string representation.
- *
- * This is possible because the string representation of a
- * list object generated by the UpdateStringOfList is made
- * in a way that ensures that every list element is a different
- * command argument. */
 static int JimEvalObjVector(Jim_Interp *interp, int objc, Jim_Obj *const *objv,
-    const char *filename, int linenr)
+    Jim_Obj *fileNameObj, int linenr)
 {
     int i, retcode;
     Jim_Cmd *cmdPtr;
 
-    /* Incr refcount of arguments. */
+    
     for (i = 0; i < objc; i++)
         Jim_IncrRefCount(objv[i]);
-    /* Command lookup */
+    
     cmdPtr = Jim_GetCommand(interp, objv[0], JIM_ERRMSG);
     if (cmdPtr == NULL) {
-        retcode = JimUnknown(interp, objc, objv, filename, linenr);
+        retcode = JimUnknown(interp, objc, objv, fileNameObj, linenr);
     }
     else {
-        /* Call it -- Make sure result is an empty object. */
+        
         JimIncrCmdRefCount(cmdPtr);
         Jim_SetEmptyResult(interp);
         if (cmdPtr->isproc) {
-            retcode = JimCallProcedure(interp, cmdPtr, filename, linenr, objc, objv);
+            retcode = JimCallProcedure(interp, cmdPtr, fileNameObj, linenr, objc, objv);
         }
         else {
             interp->cmdPrivData = cmdPtr->u.native.privData;
@@ -16052,7 +13891,7 @@ static int JimEvalObjVector(Jim_Interp *interp, int objc, Jim_Obj *const *objv,
         }
         JimDecrCmdRefCount(interp, cmdPtr);
     }
-    /* Decr refcount of arguments and return the retcode */
+    
     for (i = 0; i < objc; i++)
         Jim_DecrRefCount(interp, objv[i]);
 
@@ -16061,19 +13900,16 @@ static int JimEvalObjVector(Jim_Interp *interp, int objc, Jim_Obj *const *objv,
 
 int Jim_EvalObjVector(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
 {
-    return JimEvalObjVector(interp, objc, objv, NULL, 0);
+    return JimEvalObjVector(interp, objc, objv, interp->emptyObj, 1);
 }
 
-/**
- * Invokes 'prefix' as a command with the objv array as arguments.
- */
-int Jim_EvalObjPrefix(Jim_Interp *interp, const char *prefix, int objc, Jim_Obj *const *objv)
+int Jim_EvalObjPrefix(Jim_Interp *interp, Jim_Obj *prefix, int objc, Jim_Obj *const *objv)
 {
     int i;
     int ret;
     Jim_Obj **nargv = Jim_Alloc((objc + 1) * sizeof(*nargv));
 
-    nargv[0] = Jim_NewStringObj(interp, prefix, -1);
+    nargv[0] = prefix;
     for (i = 0; i < objc; i++) {
         nargv[i + 1] = objv[i];
     }
@@ -16082,32 +13918,30 @@ int Jim_EvalObjPrefix(Jim_Interp *interp, const char *prefix, int objc, Jim_Obj
     return ret;
 }
 
-static void JimAddErrorToStack(Jim_Interp *interp, int retcode, const char *filename, int line)
+static void JimAddErrorToStack(Jim_Interp *interp, int retcode, Jim_Obj *fileNameObj, int line)
 {
     int rc = retcode;
 
     if (rc == JIM_ERR && !interp->errorFlag) {
-        /* This is the first error, so save the file/line information and reset the stack */
+        
         interp->errorFlag = 1;
-        JimSetErrorFileName(interp, filename);
-        JimSetErrorLineNumber(interp, line);
+        Jim_IncrRefCount(fileNameObj);
+        Jim_DecrRefCount(interp, interp->errorFileNameObj);
+        interp->errorFileNameObj = fileNameObj;
+        interp->errorLine = line;
 
         JimResetStackTrace(interp);
-        /* Always add a level where the error first occurs */
+        
         interp->addStackTrace++;
     }
 
-    /* Now if this is an "interesting" level, add it to the stack trace */
+    
     if (rc == JIM_ERR && interp->addStackTrace > 0) {
-        /* Add the stack info for the current level */
+        
 
-        JimAppendStackTrace(interp, Jim_String(interp->errorProc), filename, line);
+        JimAppendStackTrace(interp, Jim_String(interp->errorProc), fileNameObj, line);
 
-        /* Note: if we didn't have a filename for this level,
-         * don't clear the addStackTrace flag
-         * so we can pick it up at the next level
-         */
-        if (*filename) {
+        if (Jim_Length(fileNameObj)) {
             interp->addStackTrace = 0;
         }
 
@@ -16116,21 +13950,21 @@ static void JimAddErrorToStack(Jim_Interp *interp, int retcode, const char *file
         Jim_IncrRefCount(interp->errorProc);
     }
     else if (rc == JIM_RETURN && interp->returnCode == JIM_ERR) {
-        /* Propagate the addStackTrace value through 'return -code error' */
+        
     }
     else {
         interp->addStackTrace = 0;
     }
 }
 
-/* And delete any local procs */
+
 static void JimDeleteLocalProcs(Jim_Interp *interp)
 {
     if (interp->localProcs) {
         char *procname;
 
         while ((procname = Jim_StackPop(interp->localProcs)) != NULL) {
-            /* If there is a pushed command, find it */
+            
             Jim_Cmd *prevCmd = NULL;
             Jim_HashEntry *he = Jim_FindHashEntry(&interp->commands, procname);
             if (he) {
@@ -16141,11 +13975,11 @@ static void JimDeleteLocalProcs(Jim_Interp *interp)
                 }
             }
 
-            /* Delete the local proc */
+            
             Jim_DeleteCommand(interp, procname);
 
             if (prevCmd) {
-                /* And restore the pushed command */
+                
                 Jim_AddHashEntry(&interp->commands, procname, prevCmd);
             }
             Jim_Free(procname);
@@ -16181,17 +14015,17 @@ static int JimSubstOneToken(Jim_Interp *interp, const ScriptToken *token, Jim_Ob
                     objPtr = interp->result;
                     break;
                 case JIM_BREAK:
-                    /* Stop substituting */
+                    
                     return JIM_BREAK;
                 case JIM_CONTINUE:
-                    /* just skip this one */
+                    
                     return JIM_CONTINUE;
                 default:
                     return JIM_ERR;
             }
             break;
         default:
-            JimPanic((1, interp,
+            JimPanic((1,
                 "default token type (%d) reached " "in Jim_SubstObj().", token->type));
             objPtr = NULL;
             break;
@@ -16203,10 +14037,6 @@ static int JimSubstOneToken(Jim_Interp *interp, const ScriptToken *token, Jim_Ob
     return JIM_ERR;
 }
 
-/* Interpolate the given tokens into a unique Jim_Obj returned by reference
- * via *objPtrPtr. This function is only called by Jim_EvalObj() and Jim_SubstObj()
- * The returned object has refcount = 0.
- */
 static Jim_Obj *JimInterpolateTokens(Jim_Interp *interp, const ScriptToken * token, int tokens, int flags)
 {
     int totlen = 0, i;
@@ -16220,8 +14050,6 @@ static Jim_Obj *JimInterpolateTokens(Jim_Interp *interp, const ScriptToken * tok
     else
         intv = Jim_Alloc(sizeof(Jim_Obj *) * tokens);
 
-    /* Compute every token forming the argument
-     * in the intv objects vector. */
     for (i = 0; i < tokens; i++) {
         switch (JimSubstOneToken(interp, &token[i], &intv[i])) {
             case JIM_OK:
@@ -16229,19 +14057,19 @@ static Jim_Obj *JimInterpolateTokens(Jim_Interp *interp, const ScriptToken * tok
                 break;
             case JIM_BREAK:
                 if (flags & JIM_SUBST_FLAG) {
-                    /* Stop here */
+                    
                     tokens = i;
                     continue;
                 }
-                /* XXX: Should probably set an error about break outside loop */
-                /* fall through to error */
+                
+                
             case JIM_CONTINUE:
                 if (flags & JIM_SUBST_FLAG) {
                     intv[i] = NULL;
                     continue;
                 }
-                /* XXX: Ditto continue outside loop */
-                /* fall through to error */
+                
+                
             default:
                 while (i--) {
                     Jim_DecrRefCount(interp, intv[i]);
@@ -16256,19 +14084,17 @@ static Jim_Obj *JimInterpolateTokens(Jim_Interp *interp, const ScriptToken * tok
         totlen += intv[i]->length;
     }
 
-    /* Fast path return for a single token */
+    
     if (tokens == 1 && intv[0] && intv == sintv) {
         Jim_DecrRefCount(interp, intv[0]);
         return intv[0];
     }
 
-    /* Concatenate every token in an unique
-     * object. */
     objPtr = Jim_NewStringObjNoAlloc(interp, NULL, 0);
 
     if (tokens == 4 && token[0].type == JIM_TT_ESC && token[1].type == JIM_TT_ESC
         && token[2].type == JIM_TT_VAR) {
-        /* May be able to do fast interpolated object -> dictSubst */
+        
         objPtr->typePtr = &interpolatedObjType;
         objPtr->internalRep.twoPtrValue.ptr1 = (void *)token;
         objPtr->internalRep.twoPtrValue.ptr2 = intv[2];
@@ -16285,7 +14111,7 @@ static Jim_Obj *JimInterpolateTokens(Jim_Interp *interp, const ScriptToken * tok
         }
     }
     objPtr->bytes[totlen] = '\0';
-    /* Free the intv vector if not static. */
+    
     if (intv != sintv) {
         Jim_Free(intv);
     }
@@ -16294,10 +14120,7 @@ static Jim_Obj *JimInterpolateTokens(Jim_Interp *interp, const ScriptToken * tok
 }
 
 
-/* If listPtr is a list, call JimEvalObjVector() with the given source info.
- * Otherwise eval with Jim_EvalObj()
- */
-int Jim_EvalObjList(Jim_Interp *interp, Jim_Obj *listPtr, const char *filename, int linenr)
+static int JimEvalObjList(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *fileNameObj, int linenr)
 {
     if (!Jim_IsList(listPtr)) {
         return Jim_EvalObj(interp, listPtr);
@@ -16309,7 +14132,7 @@ int Jim_EvalObjList(Jim_Interp *interp, Jim_Obj *listPtr, const char *filename,
             Jim_IncrRefCount(listPtr);
             retcode = JimEvalObjVector(interp,
                 listPtr->internalRep.listValue.len,
-                listPtr->internalRep.listValue.ele, filename, linenr);
+                listPtr->internalRep.listValue.ele, fileNameObj, linenr);
             Jim_DecrRefCount(interp, listPtr);
         }
         return retcode;
@@ -16327,25 +14150,16 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
 
     interp->errorFlag = 0;
 
-    /* If the object is of type "list", we can call
-     * a specialized version of Jim_EvalObj() */
     if (Jim_IsList(scriptObjPtr)) {
-        return Jim_EvalObjList(interp, scriptObjPtr, NULL, 0);
+        return JimEvalObjList(interp, scriptObjPtr, interp->emptyObj, 1);
     }
 
-    Jim_IncrRefCount(scriptObjPtr);     /* Make sure it's shared. */
+    Jim_IncrRefCount(scriptObjPtr);     
     script = Jim_GetScript(interp, scriptObjPtr);
 
-    /* Reset the interpreter result. This is useful to
-     * return the empty result in the case of empty program. */
     Jim_SetEmptyResult(interp);
 
 #ifdef JIM_OPTIMIZATION
-    /* Check for one of the following common scripts used by for, while
-     *
-     *   {}
-     *   incr a
-     */
     if (script->len == 0) {
         Jim_DecrRefCount(interp, scriptObjPtr);
         return JIM_OK;
@@ -16368,43 +14182,27 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
     }
 #endif
 
-    /* Now we have to make sure the internal repr will not be
-     * freed on shimmering.
-     *
-     * Think for example to this:
-     *
-     * set x {llength $x; ... some more code ...}; eval $x
-     *
-     * In order to preserve the internal rep, we increment the
-     * inUse field of the script internal rep structure. */
     script->inUse++;
 
     token = script->token;
     argv = sargv;
 
-    /* Execute every command sequentially until the end of the script
-     * or an error occurs.
-     */
     for (i = 0; i < script->len && retcode == JIM_OK; ) {
         int argc;
         int j;
         Jim_Cmd *cmd;
 
-        /* First token of the line is always JIM_TT_LINE */
+        
         argc = token[i].objPtr->internalRep.scriptLineValue.argc;
         linenr = token[i].objPtr->internalRep.scriptLineValue.line;
 
-        /* Allocate the arguments vector if required */
+        
         if (argc > JIM_EVAL_SARGV_LEN)
             argv = Jim_Alloc(sizeof(Jim_Obj *) * argc);
 
-        /* Skip the JIM_TT_LINE token */
+        
         i++;
 
-        /* Populate the arguments objects.
-         * If an error occurs, retcode will be set and
-         * 'j' will be set to the number of args expanded
-         */
         for (j = 0; j < argc; j++) {
             long wordtokens = 1;
             int expand = 0;
@@ -16419,8 +14217,6 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
             }
 
             if (wordtokens == 1) {
-                /* Fast path if the token does not
-                 * need interpolation */
 
                 switch (token[i].type) {
                     case JIM_TT_ESC:
@@ -16443,12 +14239,10 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
                         }
                         break;
                     default:
-                        JimPanic((1, interp, "default token type reached " "in Jim_EvalObj()."));
+                        JimPanic((1, "default token type reached " "in Jim_EvalObj()."));
                 }
             }
             else {
-                /* For interpolation we call a helper
-                 * function to do the work for us. */
                 wordObjPtr = JimInterpolateTokens(interp, token + i, wordtokens, JIM_NONE);
             }
 
@@ -16466,7 +14260,7 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
                 argv[j] = wordObjPtr;
             }
             else {
-                /* Need to expand wordObjPtr into multiple args from argv[j] ... */
+                
                 int len = Jim_ListLength(interp, wordObjPtr);
                 int newargc = argc + len - 1;
                 int k;
@@ -16479,39 +14273,35 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
                         }
                     }
                     else {
-                        /* Need to realloc to make room for (len - 1) more entries */
+                        
                         argv = Jim_Realloc(argv, sizeof(*argv) * newargc);
                     }
                 }
 
-                /* Now copy in the expanded version */
+                
                 for (k = 0; k < len; k++) {
                     argv[j++] = wordObjPtr->internalRep.listValue.ele[k];
                     Jim_IncrRefCount(wordObjPtr->internalRep.listValue.ele[k]);
                 }
 
-                /* The original object reference is no longer needed,
-                 * after the expansion it is no longer present on
-                 * the argument vector, but the single elements are
-                 * in its place. */
                 Jim_DecrRefCount(interp, wordObjPtr);
 
-                /* And update the indexes */
+                
                 j--;
                 argc += len - 1;
             }
         }
 
         if (retcode == JIM_OK && argc) {
-            /* Lookup the command to call */
+            
             cmd = Jim_GetCommand(interp, argv[0], JIM_ERRMSG);
             if (cmd != NULL) {
-                /* Call it -- Make sure result is an empty object. */
+                
                 JimIncrCmdRefCount(cmd);
                 Jim_SetEmptyResult(interp);
                 if (cmd->isproc) {
                     retcode =
-                        JimCallProcedure(interp, cmd, script->fileName, linenr, argc, argv);
+                        JimCallProcedure(interp, cmd, script->fileNameObj, linenr, argc, argv);
                 } else {
                     interp->cmdPrivData = cmd->u.native.privData;
                     retcode = cmd->u.native.cmdProc(interp, argc, argv);
@@ -16519,16 +14309,16 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
                 JimDecrCmdRefCount(interp, cmd);
             }
             else {
-                /* Call [unknown] */
-                retcode = JimUnknown(interp, argc, argv, script->fileName, linenr);
+                
+                retcode = JimUnknown(interp, argc, argv, script->fileNameObj, linenr);
             }
             if (interp->signal_level && interp->sigmask) {
-                /* Check for a signal after each command */
+                
                 retcode = JIM_SIGNAL;
             }
         }
 
-        /* Finished with the command, so decrement ref counts of each argument */
+        
         while (j-- > 0) {
             Jim_DecrRefCount(interp, argv[j]);
         }
@@ -16539,12 +14329,9 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
         }
     }
 
-    /* Possibly add to the error stack trace */
-    JimAddErrorToStack(interp, retcode, script->fileName, linenr);
+    
+    JimAddErrorToStack(interp, retcode, script->fileNameObj, linenr);
 
-    /* Note that we don't have to decrement inUse, because the
-     * following code transfers our use of the reference again to
-     * the script object. */
     Jim_FreeIntRep(interp, scriptObjPtr);
     scriptObjPtr->typePtr = &scriptObjType;
     Jim_SetIntRepPtr(scriptObjPtr, script);
@@ -16556,10 +14343,10 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
 static int JimSetProcArg(Jim_Interp *interp, Jim_Obj *argNameObj, Jim_Obj *argValObj)
 {
     int retcode;
-    /* If argObjPtr begins with '&', do an automatic upvar */
+    
     const char *varname = Jim_String(argNameObj);
     if (*varname == '&') {
-        /* First check that the target variable exists */
+        
         Jim_Obj *objPtr;
         Jim_CallFrame *savedCallFrame = interp->framePtr;
 
@@ -16570,7 +14357,7 @@ static int JimSetProcArg(Jim_Interp *interp, Jim_Obj *argNameObj, Jim_Obj *argVa
             return JIM_ERR;
         }
 
-        /* It exists, so perform the binding. */
+        
         objPtr = Jim_NewStringObj(interp, varname + 1, -1);
         Jim_IncrRefCount(objPtr);
         retcode = Jim_SetVariableLink(interp, objPtr, argValObj, interp->framePtr->parentCallFrame);
@@ -16582,12 +14369,9 @@ static int JimSetProcArg(Jim_Interp *interp, Jim_Obj *argNameObj, Jim_Obj *argVa
     return retcode;
 }
 
-/**
- * Sets the interp result to be an error message indicating the required proc args.
- */
 static void JimSetProcWrongArgs(Jim_Interp *interp, Jim_Obj *procNameObj, Jim_Cmd *cmd)
 {
-    /* Create a nice error message, consistent with Tcl 8.5 */
+    
     Jim_Obj *argmsg = Jim_NewStringObj(interp, "", 0);
     int i;
 
@@ -16596,13 +14380,13 @@ static void JimSetProcWrongArgs(Jim_Interp *interp, Jim_Obj *procNameObj, Jim_Cm
 
         if (i == cmd->u.proc.argsPos) {
             if (cmd->u.proc.arglist[i].defaultObjPtr) {
-                /* Renamed args */
+                
                 Jim_AppendString(interp, argmsg, "?", 1);
                 Jim_AppendObj(interp, argmsg, cmd->u.proc.arglist[i].defaultObjPtr);
                 Jim_AppendString(interp, argmsg, " ...?", -1);
             }
             else {
-                /* We have plain args */
+                
                 Jim_AppendString(interp, argmsg, "?argument ...?", -1);
             }
         }
@@ -16621,56 +14405,48 @@ static void JimSetProcWrongArgs(Jim_Interp *interp, Jim_Obj *procNameObj, Jim_Cm
     Jim_FreeNewObj(interp, argmsg);
 }
 
-/* Call a procedure implemented in Tcl.
- * It's possible to speed-up a lot this function, currently
- * the callframes are not cached, but allocated and
- * destroied every time. What is expecially costly is
- * to create/destroy the local vars hash table every time.
- *
- * This can be fixed just implementing callframes caching
- * in JimCreateCallFrame() and JimFreeCallFrame(). */
-static int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, const char *filename, int linenr, int argc,
+static int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, Jim_Obj *fileNameObj, int linenr, int argc,
     Jim_Obj *const *argv)
 {
     Jim_CallFrame *callFramePtr;
     Jim_Stack *prevLocalProcs;
     int i, d, retcode, optargs;
 
-    /* Check arity */
+    
     if (argc - 1 < cmd->u.proc.reqArity ||
         (cmd->u.proc.argsPos < 0 && argc - 1 > cmd->u.proc.reqArity + cmd->u.proc.optArity)) {
         JimSetProcWrongArgs(interp, argv[0], cmd);
         return JIM_ERR;
     }
 
-    /* Check if there are too nested calls */
+    
     if (interp->framePtr->level == interp->maxNestingDepth) {
         Jim_SetResultString(interp, "Too many nested calls. Infinite recursion?", -1);
         return JIM_ERR;
     }
 
-    /* Create a new callframe */
+    
     callFramePtr = JimCreateCallFrame(interp, interp->framePtr);
     callFramePtr->argv = argv;
     callFramePtr->argc = argc;
     callFramePtr->procArgsObjPtr = cmd->u.proc.argListObjPtr;
     callFramePtr->procBodyObjPtr = cmd->u.proc.bodyObjPtr;
     callFramePtr->staticVars = cmd->u.proc.staticVars;
-    callFramePtr->filename = filename;
+    callFramePtr->fileNameObj = fileNameObj;
     callFramePtr->line = linenr;
     Jim_IncrRefCount(cmd->u.proc.argListObjPtr);
     Jim_IncrRefCount(cmd->u.proc.bodyObjPtr);
     interp->framePtr = callFramePtr;
 
-    /* How many optional args are available */
+    
     optargs = (argc - 1 - cmd->u.proc.reqArity);
 
-    /* Step 'i' along the actual args, and step 'd' along the formal args */
+    
     i = 1;
     for (d = 0; d < cmd->u.proc.argListLen; d++) {
         Jim_Obj *nameObjPtr = cmd->u.proc.arglist[d].nameObjPtr;
         if (d == cmd->u.proc.argsPos) {
-            /* assign $args */
+            
             Jim_Obj *listObjPtr;
             int argsLen = 0;
             if (cmd->u.proc.reqArity + cmd->u.proc.optArity < argc - 1) {
@@ -16678,7 +14454,7 @@ static int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, const char *filena
             }
             listObjPtr = Jim_NewListObj(interp, &argv[i], argsLen);
 
-            /* It is possible to rename args. */
+            
             if (cmd->u.proc.arglist[d].defaultObjPtr) {
                 nameObjPtr =cmd->u.proc.arglist[d].defaultObjPtr;
             }
@@ -16691,12 +14467,12 @@ static int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, const char *filena
             continue;
         }
 
-        /* Optional or required? */
+        
         if (cmd->u.proc.arglist[d].defaultObjPtr == NULL || optargs-- > 0) {
             retcode = JimSetProcArg(interp, nameObjPtr, argv[i++]);
         }
         else {
-            /* Ran out, so use the default */
+            
             retcode = Jim_SetVariable(interp, nameObjPtr, cmd->u.proc.arglist[d].defaultObjPtr);
         }
         if (retcode != JIM_OK) {
@@ -16704,19 +14480,19 @@ static int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, const char *filena
         }
     }
 
-    /* Install a new stack for local procs */
+    
     prevLocalProcs = interp->localProcs;
     interp->localProcs = NULL;
 
-    /* Eval the body */
+    
     retcode = Jim_EvalObj(interp, cmd->u.proc.bodyObjPtr);
 
-    /* Delete any local procs */
+    
     JimDeleteLocalProcs(interp);
     interp->localProcs = prevLocalProcs;
 
 badargset:
-    /* Destroy the callframe */
+    
     interp->framePtr = interp->framePtr->parentCallFrame;
     if (callFramePtr->vars.size != JIM_HT_INITIAL_SIZE) {
         JimFreeCallFrame(interp, callFramePtr, JIM_FCF_NONE);
@@ -16724,16 +14500,16 @@ badargset:
     else {
         JimFreeCallFrame(interp, callFramePtr, JIM_FCF_NOHT);
     }
-    /* Handle the JIM_EVAL return code */
+    
     while (retcode == JIM_EVAL) {
         Jim_Obj *resultScriptObjPtr = Jim_GetResult(interp);
 
         Jim_IncrRefCount(resultScriptObjPtr);
-        /* Should be a list! */
-        retcode = Jim_EvalObjList(interp, resultScriptObjPtr, filename, linenr);
+        
+        retcode = JimEvalObjList(interp, resultScriptObjPtr, fileNameObj, linenr);
         Jim_DecrRefCount(interp, resultScriptObjPtr);
     }
-    /* Handle the JIM_RETURN return code */
+    
     if (retcode == JIM_RETURN) {
         if (--interp->returnLevel <= 0) {
             retcode = interp->returnCode;
@@ -16750,7 +14526,7 @@ badargset:
     return retcode;
 }
 
-int Jim_Eval_Named(Jim_Interp *interp, const char *script, const char *filename, int lineno)
+int Jim_EvalSource(Jim_Interp *interp, const char *filename, int lineno, const char *script)
 {
     int retval;
     Jim_Obj *scriptObjPtr;
@@ -16758,11 +14534,10 @@ int Jim_Eval_Named(Jim_Interp *interp, const char *script, const char *filename,
     scriptObjPtr = Jim_NewStringObj(interp, script, -1);
     Jim_IncrRefCount(scriptObjPtr);
 
-
     if (filename) {
         Jim_Obj *prevScriptObj;
 
-        JimSetSourceInfo(interp, scriptObjPtr, filename, lineno);
+        JimSetSourceInfo(interp, scriptObjPtr, Jim_NewStringObj(interp, filename, -1), lineno);
 
         prevScriptObj = interp->currentScriptObj;
         interp->currentScriptObj = scriptObjPtr;
@@ -16780,10 +14555,10 @@ int Jim_Eval_Named(Jim_Interp *interp, const char *script, const char *filename,
 
 int Jim_Eval(Jim_Interp *interp, const char *script)
 {
-    return Jim_Eval_Named(interp, script, NULL, 0);
+    return Jim_EvalObj(interp, Jim_NewStringObj(interp, script, -1));
 }
 
-/* Execute script in the scope of the global level */
+
 int Jim_EvalGlobal(Jim_Interp *interp, const char *script)
 {
     int retval;
@@ -16842,10 +14617,10 @@ int Jim_EvalFile(Jim_Interp *interp, const char *filename)
     buf[readlen] = 0;
 
     scriptObjPtr = Jim_NewStringObjNoAlloc(interp, buf, readlen);
-    JimSetSourceInfo(interp, scriptObjPtr, filename, 1);
+    JimSetSourceInfo(interp, scriptObjPtr, Jim_NewStringObj(interp, filename, -1), 1);
     Jim_IncrRefCount(scriptObjPtr);
 
-    /* Now check the script for unmatched braces, etc. */
+    
     if (SetScriptFromAny(interp, scriptObjPtr, &result) == JIM_ERR) {
         const char *msg;
         char linebuf[20];
@@ -16876,7 +14651,7 @@ int Jim_EvalFile(Jim_Interp *interp, const char *filename)
 
     retcode = Jim_EvalObj(interp, scriptObjPtr);
 
-    /* Handle the JIM_RETURN return code */
+    
     if (retcode == JIM_RETURN) {
         if (--interp->returnLevel <= 0) {
             retcode = interp->returnCode;
@@ -16885,7 +14660,7 @@ int Jim_EvalFile(Jim_Interp *interp, const char *filename)
         }
     }
     if (retcode == JIM_ERR) {
-        /* EvalFile changes context, so add a stack frame here */
+        
         interp->addStackTrace++;
     }
 
@@ -16896,9 +14671,6 @@ int Jim_EvalFile(Jim_Interp *interp, const char *filename)
     return retcode;
 }
 
-/* -----------------------------------------------------------------------------
- * Subst
- * ---------------------------------------------------------------------------*/
 static int JimParseSubstStr(struct JimParserCtx *pc)
 {
     pc->tstart = pc->p;
@@ -16969,15 +14741,7 @@ static int JimParseSubst(struct JimParserCtx *pc, int flags)
     return JIM_OK;
 }
 
-/* The subst object type reuses most of the data structures and functions
- * of the script object. Script's data structures are a bit more complex
- * for what is needed for [subst]itution tasks, but the reuse helps to
- * deal with a single data structure at the cost of some more memory
- * usage for substitutions. */
 
-/* This method takes the string representation of an object
- * as a Tcl string where to perform [subst]itution, and generates
- * the pre-parsed internal representation. */
 static int SetSubstFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr, int flags)
 {
     int scriptTextLen;
@@ -16986,27 +14750,28 @@ static int SetSubstFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr, int flags
     struct ScriptObj *script = Jim_Alloc(sizeof(*script));
     ParseTokenList tokenlist;
 
-    /* Initially parse the subst into tokens (in tokenlist) */
+    
     ScriptTokenListInit(&tokenlist);
 
     JimParserInit(&parser, scriptText, scriptTextLen, 1);
     while (1) {
         JimParseSubst(&parser, flags);
         if (parser.eof) {
-            /* Note that subst doesn't need the EOL token */
+            
             break;
         }
         ScriptAddToken(&tokenlist, parser.tstart, parser.tend - parser.tstart + 1, parser.tt,
             parser.tline);
     }
 
-    /* Create the "real" subst/script tokens from the initial token list */
+    
     script->inUse = 1;
     script->substFlags = flags;
-    script->fileName = NULL;
+    script->fileNameObj = interp->emptyObj;
+    Jim_IncrRefCount(script->fileNameObj);
     SubstObjAddTokens(interp, script, &tokenlist);
 
-    /* No longer need the token list */
+    
     ScriptTokenListFree(&tokenlist);
 
 #ifdef DEBUG_SHOW_SUBST
@@ -17021,7 +14786,7 @@ static int SetSubstFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr, int flags
     }
 #endif
 
-    /* Free the old internal rep and set the new one. */
+    
     Jim_FreeIntRep(interp, objPtr);
     Jim_SetIntRepPtr(objPtr, script);
     objPtr->typePtr = &scriptObjType;
@@ -17035,16 +14800,11 @@ static ScriptObj *Jim_GetSubst(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
     return (ScriptObj *) Jim_GetIntRepPtr(objPtr);
 }
 
-/* Performs commands,variables,blackslashes substitution,
- * storing the result object (with refcount 0) into
- * resObjPtrPtr. */
 int Jim_SubstObj(Jim_Interp *interp, Jim_Obj *substObjPtr, Jim_Obj **resObjPtrPtr, int flags)
 {
     ScriptObj *script = Jim_GetSubst(interp, substObjPtr, flags);
 
-    Jim_IncrRefCount(substObjPtr);      /* Make sure it's shared. */
-    /* In order to preserve the internal rep, we increment the
-     * inUse field of the script internal rep structure. */
+    Jim_IncrRefCount(substObjPtr);      
     script->inUse++;
 
     *resObjPtrPtr = JimInterpolateTokens(interp, script->token, script->len, flags);
@@ -17057,9 +14817,6 @@ int Jim_SubstObj(Jim_Interp *interp, Jim_Obj *substObjPtr, Jim_Obj **resObjPtrPt
     return JIM_OK;
 }
 
-/* -----------------------------------------------------------------------------
- * Core commands utility functions
- * ---------------------------------------------------------------------------*/
 void Jim_WrongNumArgs(Jim_Interp *interp, int argc, Jim_Obj *const *argv, const char *msg)
 {
     int i;
@@ -17078,22 +14835,22 @@ void Jim_WrongNumArgs(Jim_Interp *interp, int argc, Jim_Obj *const *argv, const
 
 #define JimTrivialMatch(pattern)	(strpbrk((pattern), "*[?\\") == NULL)
 
-/* type is: 0=commands, 1=procs, 2=channels */
+
 static Jim_Obj *JimCommandsList(Jim_Interp *interp, Jim_Obj *patternObjPtr, int type)
 {
     Jim_HashTableIterator *htiter;
     Jim_HashEntry *he;
     Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);
 
-    /* Check for the non-pattern case. We can do this much more efficiently. */
+    
     if (patternObjPtr && JimTrivialMatch(Jim_String(patternObjPtr))) {
         Jim_Cmd *cmdPtr = Jim_GetCommand(interp, patternObjPtr, JIM_NONE);
         if (cmdPtr) {
             if (type == 1 && !cmdPtr->isproc) {
-                /* not a proc */
+                
             }
             else if (type == 2 && !Jim_AioFilehandle(interp, patternObjPtr)) {
-                /* not a channel */
+                
             }
             else {
                 Jim_ListAppendElement(interp, listObjPtr, patternObjPtr);
@@ -17108,7 +14865,7 @@ static Jim_Obj *JimCommandsList(Jim_Interp *interp, Jim_Obj *patternObjPtr, int
         Jim_Obj *cmdNameObj;
 
         if (type == 1 && !cmdPtr->isproc) {
-            /* not a proc */
+            
             continue;
         }
         if (patternObjPtr && !JimStringMatch(interp, patternObjPtr, he->key, 0))
@@ -17116,7 +14873,7 @@ static Jim_Obj *JimCommandsList(Jim_Interp *interp, Jim_Obj *patternObjPtr, int
 
         cmdNameObj = Jim_NewStringObj(interp, he->key, -1);
 
-        /* Is it a channel? */
+        
         if (type == 2 && !Jim_AioFilehandle(interp, cmdNameObj)) {
             Jim_FreeNewObj(interp, cmdNameObj);
             continue;
@@ -17128,7 +14885,7 @@ static Jim_Obj *JimCommandsList(Jim_Interp *interp, Jim_Obj *patternObjPtr, int
     return listObjPtr;
 }
 
-/* Keep this in order */
+
 #define JIM_VARLIST_GLOBALS 0
 #define JIM_VARLIST_LOCALS 1
 #define JIM_VARLIST_VARS 2
@@ -17143,8 +14900,6 @@ static Jim_Obj *JimVariablesList(Jim_Interp *interp, Jim_Obj *patternObjPtr, int
         htiter = Jim_GetHashTableIterator(&interp->topFramePtr->vars);
     }
     else {
-        /* For [info locals], if we are at top level an emtpy list
-         * is returned. I don't agree, but we aim at compatibility (SS) */
         if (mode == JIM_VARLIST_LOCALS && interp->framePtr == interp->topFramePtr)
             return listObjPtr;
         htiter = Jim_GetHashTableIterator(&interp->framePtr->vars);
@@ -17173,7 +14928,7 @@ static int JimInfoLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr,
     if (targetCallFrame == NULL) {
         return JIM_ERR;
     }
-    /* No proc call at toplevel callframe */
+    
     if (targetCallFrame == interp->topFramePtr) {
         Jim_SetResultFormatted(interp, "bad level \"%#s\"", levelObjPtr);
         return JIM_ERR;
@@ -17185,19 +14940,15 @@ static int JimInfoLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr,
         Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
 
         Jim_ListAppendElement(interp, listObj, targetCallFrame->argv[0]);
-        Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp,
-                targetCallFrame->filename ? targetCallFrame->filename : "", -1));
+        Jim_ListAppendElement(interp, listObj, targetCallFrame->fileNameObj);
         Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, targetCallFrame->line));
         *objPtrPtr = listObj;
     }
     return JIM_OK;
 }
 
-/* -----------------------------------------------------------------------------
- * Core commands
- * ---------------------------------------------------------------------------*/
 
-/* fake [puts] -- not the real puts, just for debugging. */
+
 static int Jim_PutsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 2 && argc != 3) {
@@ -17219,7 +14970,7 @@ static int Jim_PutsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return JIM_OK;
 }
 
-/* Helper for [+] and [*] */
+
 static int JimAddMulHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int op)
 {
     jim_wide wideValue, res;
@@ -17252,7 +15003,7 @@ static int JimAddMulHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, i
     return JIM_OK;
 }
 
-/* Helper for [-] and [/] */
+
 static int JimSubDivHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int op)
 {
     jim_wide wideValue, res = 0;
@@ -17264,8 +15015,6 @@ static int JimSubDivHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, i
         return JIM_ERR;
     }
     else if (argc == 2) {
-        /* The arity = 2 case is different. For [- x] returns -x,
-         * while [/ x] returns 1/x. */
         if (Jim_GetWide(interp, argv[1], &wideValue) != JIM_OK) {
             if (Jim_GetDouble(interp, argv[1], &doubleValue) != JIM_OK) {
                 return JIM_ERR;
@@ -17326,31 +15075,31 @@ static int JimSubDivHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, i
 }
 
 
-/* [+] */
+
 static int Jim_AddCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     return JimAddMulHelper(interp, argc, argv, JIM_EXPROP_ADD);
 }
 
-/* [*] */
+
 static int Jim_MulCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     return JimAddMulHelper(interp, argc, argv, JIM_EXPROP_MUL);
 }
 
-/* [-] */
+
 static int Jim_SubCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     return JimSubDivHelper(interp, argc, argv, JIM_EXPROP_SUB);
 }
 
-/* [/] */
+
 static int Jim_DivCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     return JimSubDivHelper(interp, argc, argv, JIM_EXPROP_DIV);
 }
 
-/* [set] */
+
 static int Jim_SetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 2 && argc != 3) {
@@ -17366,17 +15115,13 @@ static int Jim_SetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
         Jim_SetResult(interp, objPtr);
         return JIM_OK;
     }
-    /* argc == 3 case. */
+    
     if (Jim_SetVariable(interp, argv[1], argv[2]) != JIM_OK)
         return JIM_ERR;
     Jim_SetResult(interp, argv[2]);
     return JIM_OK;
 }
 
-/* [unset]
- *
- * unset ?-nocomplain? ?--? ?varName ...?
- */
 static int Jim_UnsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int i = 1;
@@ -17405,7 +15150,7 @@ static int Jim_UnsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     return JIM_OK;
 }
 
-/* [while] */
+
 static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 3) {
@@ -17413,7 +15158,7 @@ static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
         return JIM_ERR;
     }
 
-    /* The general purpose implementation of while starts here */
+    
     while (1) {
         int boolean, retval;
 
@@ -17440,7 +15185,7 @@ static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     return JIM_OK;
 }
 
-/* [for] */
+
 static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int retval;
@@ -17453,29 +15198,15 @@ static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
         return JIM_ERR;
     }
 
-    /* Do the initialisation */
+    
     if ((retval = Jim_EvalObj(interp, argv[1])) != JIM_OK) {
         return retval;
     }
 
-    /* And do the first test now. Better for optimisation
-     * if we can do next/test at the bottom of the loop
-     */
     retval = Jim_GetBoolFromExpr(interp, argv[2], &boolean);
 
-    /* Ready to do the body as follows:
-     * while (1) {
-     *     body // check retcode
-     *     next // check retcode
-     *     test // check retcode/test bool
-     * }
-     */
 
 #ifdef JIM_OPTIMIZATION
-    /* Check if the for is on the form:
-     *      for ... {$i < CONST} {incr i}
-     *      for ... {$i < $j} {incr i}
-     */
     if (retval == JIM_OK && boolean) {
         ScriptObj *incrScript;
         ExprByteCode *expr;
@@ -17484,15 +15215,15 @@ static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
         Jim_Obj *objPtr;
         int cmpOffset;
 
-        /* Do it only if there aren't shared arguments */
+        
         expr = JimGetExpression(interp, argv[2]);
         incrScript = Jim_GetScript(interp, argv[3]);
 
-        /* Ensure proper lengths to start */
+        
         if (incrScript->len != 3 || !expr || expr->len != 3) {
             goto evalstart;
         }
-        /* Ensure proper token types. */
+        
         if (incrScript->token[1].type != JIM_TT_ESC ||
             expr->token[0].type != JIM_TT_VAR ||
             (expr->token[1].type != JIM_TT_EXPR_INT && expr->token[1].type != JIM_TT_VAR)) {
@@ -17509,17 +15240,17 @@ static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
             goto evalstart;
         }
 
-        /* Update command must be incr */
+        
         if (!Jim_CompareStringImmediate(interp, incrScript->token[1].objPtr, "incr")) {
             goto evalstart;
         }
 
-        /* incr, expression must be about the same variable */
+        
         if (!Jim_StringEqObj(incrScript->token[2].objPtr, expr->token[0].objPtr)) {
             goto evalstart;
         }
 
-        /* Get the stop condition (must be a variable or integer) */
+        
         if (expr->token[1].type == JIM_TT_EXPR_INT) {
             if (Jim_GetWide(interp, expr->token[1].objPtr, &stop) == JIM_ERR) {
                 goto evalstart;
@@ -17528,11 +15259,11 @@ static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
         else {
             stopVarNamePtr = expr->token[1].objPtr;
             Jim_IncrRefCount(stopVarNamePtr);
-            /* Keep the compiler happy */
+            
             stop = 0;
         }
 
-        /* Initialization */
+        
         procEpoch = interp->procEpoch;
         varNamePtr = expr->token[0].objPtr;
         Jim_IncrRefCount(varNamePtr);
@@ -17542,12 +15273,12 @@ static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
             goto testcond;
         }
 
-        /* --- OPTIMIZED FOR --- */
+        
         while (retval == JIM_OK) {
-            /* === Check condition === */
-            /* Note that currentVal is already set here */
+            
+            
 
-            /* Immediate or Variable? get the 'stop' value if the latter. */
+            
             if (stopVarNamePtr) {
                 objPtr = Jim_GetVariable(interp, stopVarNamePtr, JIM_NONE);
                 if (objPtr == NULL || Jim_GetWide(interp, objPtr, &stop) != JIM_OK) {
@@ -17559,19 +15290,17 @@ static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
                 break;
             }
 
-            /* Eval body */
+            
             retval = Jim_EvalObj(interp, argv[4]);
             if (retval == JIM_OK || retval == JIM_CONTINUE) {
                 retval = JIM_OK;
-                /* If there was a change in procedures/command continue
-                 * with the usual [for] command implementation */
                 if (procEpoch != interp->procEpoch) {
                     goto evalnext;
                 }
 
                 objPtr = Jim_GetVariable(interp, varNamePtr, JIM_ERRMSG);
 
-                /* Increment */
+                
                 if (objPtr == NULL) {
                     retval = JIM_ERR;
                     goto out;
@@ -17595,15 +15324,15 @@ static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
 #endif
 
     while (boolean && (retval == JIM_OK || retval == JIM_CONTINUE)) {
-        /* Body */
+        
         retval = Jim_EvalObj(interp, argv[4]);
 
         if (retval == JIM_OK || retval == JIM_CONTINUE) {
-            /* increment */
+            
           evalnext:
             retval = Jim_EvalObj(interp, argv[3]);
             if (retval == JIM_OK || retval == JIM_CONTINUE) {
-                /* test */
+                
               testcond:
                 retval = Jim_GetBoolFromExpr(interp, argv[2], &boolean);
             }
@@ -17625,7 +15354,7 @@ static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
     return retval;
 }
 
-/* [loop] */
+
 static int Jim_LoopCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int retval;
@@ -17655,7 +15384,7 @@ static int Jim_LoopCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
 
             retval = JIM_OK;
 
-            /* Increment */
+            
             i += incr;
 
             if (objPtr && !Jim_IsShared(objPtr) && objPtr->typePtr == &intObjType) {
@@ -17667,8 +15396,6 @@ static int Jim_LoopCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
                 JimWideValue(objPtr) = i;
                 Jim_InvalidateStringRep(objPtr);
 
-                /* The following step is required in order to invalidate the
-                 * string repr of "FOO" if the var name is of the form of "FOO(IDX)" */
                 if (argv[1]->typePtr != &variableObjType) {
                     if (Jim_SetVariable(interp, argv[1], objPtr) != JIM_OK) {
                         retval = JIM_ERR;
@@ -17693,7 +15420,7 @@ static int Jim_LoopCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return retval;
 }
 
-/* foreach + lmap implementation. */
+
 static int JimForeachMapHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int doMap)
 {
     int result = JIM_ERR, i, nbrOfLists, *listsIdx, *listsEnd;
@@ -17710,13 +15437,13 @@ static int JimForeachMapHelper(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     }
     emptyStr = Jim_NewEmptyStringObj(interp);
     Jim_IncrRefCount(emptyStr);
-    script = argv[argc - 1];    /* Last argument is a script */
-    nbrOfLists = (argc - 1 - 1) / 2;    /* argc - 'foreach' - script */
+    script = argv[argc - 1];    
+    nbrOfLists = (argc - 1 - 1) / 2;    
     listsIdx = (int *)Jim_Alloc(nbrOfLists * sizeof(int));
     listsEnd = (int *)Jim_Alloc(nbrOfLists * 2 * sizeof(int));
-    /* Initialize iterators and remember max nbr elements each list */
+    
     memset(listsIdx, 0, nbrOfLists * sizeof(int));
-    /* Remember lengths of all lists and calculate how much rounds to loop */
+    
     for (i = 0; i < nbrOfLists * 2; i += 2) {
         div_t cnt;
         int count;
@@ -17740,22 +15467,22 @@ static int JimForeachMapHelper(Jim_Interp *interp, int argc, Jim_Obj *const *arg
                 Jim_Obj *varName, *ele;
                 int lst = i * 2 + 1;
 
-                /* List index operations below can't fail */
+                
                 Jim_ListIndex(interp, argv[var + 1], varIdx, &varName, JIM_NONE);
                 if (listsIdx[i] < listsEnd[lst]) {
                     Jim_ListIndex(interp, argv[lst + 1], listsIdx[i], &ele, JIM_NONE);
-                    /* Avoid shimmering */
+                    
                     Jim_IncrRefCount(ele);
                     result = Jim_SetVariable(interp, varName, ele);
                     Jim_DecrRefCount(interp, ele);
                     if (result == JIM_OK) {
-                        ++listsIdx[i];  /* Remember next iterator of current list */
-                        ++varIdx;       /* Next variable */
+                        ++listsIdx[i];  
+                        ++varIdx;       
                         continue;
                     }
                 }
                 else if (Jim_SetVariable(interp, varName, emptyStr) == JIM_OK) {
-                    ++varIdx;   /* Next variable */
+                    ++varIdx;   
                     continue;
                 }
                 goto err;
@@ -17790,58 +15517,56 @@ static int JimForeachMapHelper(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return result;
 }
 
-/* [foreach] */
+
 static int Jim_ForeachCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     return JimForeachMapHelper(interp, argc, argv, 0);
 }
 
-/* [lmap] */
+
 static int Jim_LmapCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     return JimForeachMapHelper(interp, argc, argv, 1);
 }
 
-/* [if] */
+
 static int Jim_IfCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int boolean, retval, current = 1, falsebody = 0;
 
     if (argc >= 3) {
         while (1) {
-            /* Far not enough arguments given! */
+            
             if (current >= argc)
                 goto err;
             if ((retval = Jim_GetBoolFromExpr(interp, argv[current++], &boolean))
                 != JIM_OK)
                 return retval;
-            /* There lacks something, isn't it? */
+            
             if (current >= argc)
                 goto err;
             if (Jim_CompareStringImmediate(interp, argv[current], "then"))
                 current++;
-            /* Tsk tsk, no then-clause? */
+            
             if (current >= argc)
                 goto err;
             if (boolean)
                 return Jim_EvalObj(interp, argv[current]);
-            /* Ok: no else-clause follows */
+            
             if (++current >= argc) {
                 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
                 return JIM_OK;
             }
             falsebody = current++;
             if (Jim_CompareStringImmediate(interp, argv[falsebody], "else")) {
-                /* IIICKS - else-clause isn't last cmd? */
+                
                 if (current != argc - 1)
                     goto err;
                 return Jim_EvalObj(interp, argv[current]);
             }
             else if (Jim_CompareStringImmediate(interp, argv[falsebody], "elseif"))
-                /* Ok: elseif follows meaning all the stuff
-                 * again (how boring...) */
                 continue;
-            /* OOPS - else-clause is not last cmd? */
+            
             else if (falsebody != argc - 1)
                 goto err;
             return Jim_EvalObj(interp, argv[falsebody]);
@@ -17854,7 +15579,7 @@ static int Jim_IfCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 }
 
 
-/* Returns 1 if match, 0 if no match or -<error> on error (e.g. -JIM_ERR, -JIM_BREAK)*/
+
 int Jim_CommandMatchObj(Jim_Interp *interp, Jim_Obj *commandObj, Jim_Obj *patternObj,
     Jim_Obj *stringObj, int nocase)
 {
@@ -17882,7 +15607,7 @@ int Jim_CommandMatchObj(Jim_Interp *interp, Jim_Obj *commandObj, Jim_Obj *patter
 enum
 { SWITCH_EXACT, SWITCH_GLOB, SWITCH_RE, SWITCH_CMD };
 
-/* [switch] */
+
 static int Jim_SwitchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int matchOpt = SWITCH_EXACT, opt = 1, patCount, i;
@@ -17953,20 +15678,17 @@ static int Jim_SwitchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
                     break;
                 case SWITCH_RE:
                     command = Jim_NewStringObj(interp, "regexp", -1);
-                    /* Fall thru intentionally */
+                    
                 case SWITCH_CMD:{
                         int rc = Jim_CommandMatchObj(interp, command, patObj, strObj, 0);
 
-                        /* After the execution of a command we need to
-                         * make sure to reconvert the object into a list
-                         * again. Only for the single-list style [switch]. */
                         if (argc - opt == 1) {
                             Jim_Obj **vector;
 
                             JimListGetElements(interp, argv[opt], &patCount, &vector);
                             caseList = vector;
                         }
-                        /* command is here already decref'd */
+                        
                         if (rc < 0) {
                             return -rc;
                         }
@@ -17993,7 +15715,7 @@ static int Jim_SwitchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_OK;
 }
 
-/* [list] */
+
 static int Jim_ListCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *listObjPtr;
@@ -18003,7 +15725,7 @@ static int Jim_ListCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return JIM_OK;
 }
 
-/* [lindex] */
+
 static int Jim_LindexCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *objPtr, *listObjPtr;
@@ -18023,8 +15745,6 @@ static int Jim_LindexCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
             return JIM_ERR;
         }
         if (Jim_ListIndex(interp, listObjPtr, idx, &objPtr, JIM_NONE) != JIM_OK) {
-            /* Returns an empty object if the index
-             * is out of range. */
             Jim_DecrRefCount(interp, listObjPtr);
             Jim_SetEmptyResult(interp);
             return JIM_OK;
@@ -18037,7 +15757,7 @@ static int Jim_LindexCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_OK;
 }
 
-/* [llength] */
+
 static int Jim_LlengthCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 2) {
@@ -18048,7 +15768,7 @@ static int Jim_LlengthCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
     return JIM_OK;
 }
 
-/* [lsearch] */
+
 static int Jim_LsearchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     static const char * const options[] = {
@@ -18106,7 +15826,7 @@ static int Jim_LsearchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
                     goto wrongargs;
                 }
                 commandObj = argv[++i];
-                /* fallthru */
+                
             case OPT_EXACT:
             case OPT_GLOB:
             case OPT_REGEXP:
@@ -18155,13 +15875,13 @@ static int Jim_LsearchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
                 break;
         }
 
-        /* If we have a non-match with opt_bool, opt_not, !opt_all, can't exit early */
+        
         if (!eq && opt_bool && opt_not && !opt_all) {
             continue;
         }
 
         if ((!opt_bool && eq == !opt_not) || (opt_bool && (eq || opt_all))) {
-            /* Got a match (or non-match for opt_not), or (opt_bool && opt_all) */
+            
             Jim_Obj *resultObj;
 
             if (opt_bool) {
@@ -18188,7 +15908,7 @@ static int Jim_LsearchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
         Jim_SetResult(interp, listObjPtr);
     }
     else {
-        /* No match */
+        
         if (opt_bool) {
             Jim_SetResultBool(interp, opt_not);
         }
@@ -18204,7 +15924,7 @@ static int Jim_LsearchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
     return rc;
 }
 
-/* [lappend] */
+
 static int Jim_LappendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *listObjPtr;
@@ -18216,7 +15936,7 @@ static int Jim_LappendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
     }
     listObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED);
     if (!listObjPtr) {
-        /* Create the list if it does not exists */
+        
         listObjPtr = Jim_NewListObj(interp, NULL, 0);
         if (Jim_SetVariable(interp, argv[1], listObjPtr) != JIM_OK) {
             Jim_FreeNewObj(interp, listObjPtr);
@@ -18237,7 +15957,7 @@ static int Jim_LappendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
     return JIM_OK;
 }
 
-/* [linsert] */
+
 static int Jim_LinsertCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int idx, len;
@@ -18267,7 +15987,7 @@ static int Jim_LinsertCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
     return JIM_ERR;
 }
 
-/* [lreplace] */
+
 static int Jim_LreplaceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int first, last, len, rangeLen;
@@ -18292,16 +16012,13 @@ static int Jim_LreplaceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const
     last = JimRelToAbsIndex(len, last);
     JimRelToAbsRange(len, first, last, &first, &last, &rangeLen);
 
-    /* Now construct a new list which consists of:
-     * <elements before first> <supplied elements> <elements after last>
-     */
 
-    /* Check to see if trying to replace past the end of the list */
+    
     if (first < len) {
-        /* OK. Not past the end */
+        
     }
     else if (len == 0) {
-        /* Special for empty list, adjust first to 0 */
+        
         first = 0;
     }
     else {
@@ -18317,17 +16034,17 @@ static int Jim_LreplaceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const
         listObj = Jim_DuplicateObj(interp, listObj);
     }
 
-    /* Add the first set of elements */
+    
     for (i = 0; i < first; i++) {
         Jim_ListAppendElement(interp, newListObj, listObj->internalRep.listValue.ele[i]);
     }
 
-    /* Add supplied elements */
+    
     for (i = 4; i < argc; i++) {
         Jim_ListAppendElement(interp, newListObj, argv[i]);
     }
 
-    /* Add the remaining elements */
+    
     for (i = first + rangeLen; i < len; i++) {
         Jim_ListAppendElement(interp, newListObj, listObj->internalRep.listValue.ele[i]);
     }
@@ -18338,7 +16055,7 @@ static int Jim_LreplaceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const
     return JIM_OK;
 }
 
-/* [lset] */
+
 static int Jim_LsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc < 3) {
@@ -18357,7 +16074,7 @@ static int Jim_LsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return JIM_OK;
 }
 
-/* [lsort] */
+
 static int Jim_LsortCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const argv[])
 {
     static const char * const options[] = {
@@ -18437,7 +16154,7 @@ static int Jim_LsortCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const arg
     return retCode;
 }
 
-/* [append] */
+
 static int Jim_AppendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *stringObjPtr;
@@ -18456,7 +16173,7 @@ static int Jim_AppendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
         int freeobj = 0;
         stringObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED);
         if (!stringObjPtr) {
-            /* Create the string if it doesn't exist */
+            
             stringObjPtr = Jim_NewEmptyStringObj(interp);
             freeobj = 1;
         }
@@ -18478,212 +16195,16 @@ static int Jim_AppendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_OK;
 }
 
-/* [debug] */
+
 static int Jim_DebugCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-#ifdef JIM_DEBUG_COMMAND
-    static const char * const options[] = {
-        "refcount", "objcount", "objects", "invstr", "scriptlen", "exprlen",
-        "exprbc", "show",
-        NULL
-    };
-    enum
-    {
-        OPT_REFCOUNT, OPT_OBJCOUNT, OPT_OBJECTS, OPT_INVSTR, OPT_SCRIPTLEN,
-        OPT_EXPRLEN, OPT_EXPRBC, OPT_SHOW,
-    };
-    int option;
-
-    if (argc < 2) {
-        Jim_WrongNumArgs(interp, 1, argv, "subcommand ?...?");
-        return JIM_ERR;
-    }
-    if (Jim_GetEnum(interp, argv[1], options, &option, "subcommand", JIM_ERRMSG) != JIM_OK)
-        return JIM_ERR;
-    if (option == OPT_REFCOUNT) {
-        if (argc != 3) {
-            Jim_WrongNumArgs(interp, 2, argv, "object");
-            return JIM_ERR;
-        }
-        Jim_SetResultInt(interp, argv[2]->refCount);
-        return JIM_OK;
-    }
-    else if (option == OPT_OBJCOUNT) {
-        int freeobj = 0, liveobj = 0;
-        char buf[256];
-        Jim_Obj *objPtr;
-
-        if (argc != 2) {
-            Jim_WrongNumArgs(interp, 2, argv, "");
-            return JIM_ERR;
-        }
-        /* Count the number of free objects. */
-        objPtr = interp->freeList;
-        while (objPtr) {
-            freeobj++;
-            objPtr = objPtr->nextObjPtr;
-        }
-        /* Count the number of live objects. */
-        objPtr = interp->liveList;
-        while (objPtr) {
-            liveobj++;
-            objPtr = objPtr->nextObjPtr;
-        }
-        /* Set the result string and return. */
-        sprintf(buf, "free %d used %d", freeobj, liveobj);
-        Jim_SetResultString(interp, buf, -1);
-        return JIM_OK;
-    }
-    else if (option == OPT_OBJECTS) {
-        Jim_Obj *objPtr, *listObjPtr, *subListObjPtr;
-
-        /* Count the number of live objects. */
-        objPtr = interp->liveList;
-        listObjPtr = Jim_NewListObj(interp, NULL, 0);
-        while (objPtr) {
-            char buf[128];
-            const char *type = objPtr->typePtr ? objPtr->typePtr->name : "";
-
-            subListObjPtr = Jim_NewListObj(interp, NULL, 0);
-            sprintf(buf, "%p", objPtr);
-            Jim_ListAppendElement(interp, subListObjPtr, Jim_NewStringObj(interp, buf, -1));
-            Jim_ListAppendElement(interp, subListObjPtr, Jim_NewStringObj(interp, type, -1));
-            Jim_ListAppendElement(interp, subListObjPtr, Jim_NewIntObj(interp, objPtr->refCount));
-            Jim_ListAppendElement(interp, subListObjPtr, objPtr);
-            Jim_ListAppendElement(interp, listObjPtr, subListObjPtr);
-            objPtr = objPtr->nextObjPtr;
-        }
-        Jim_SetResult(interp, listObjPtr);
-        return JIM_OK;
-    }
-    else if (option == OPT_INVSTR) {
-        Jim_Obj *objPtr;
-
-        if (argc != 3) {
-            Jim_WrongNumArgs(interp, 2, argv, "object");
-            return JIM_ERR;
-        }
-        objPtr = argv[2];
-        if (objPtr->typePtr != NULL)
-            Jim_InvalidateStringRep(objPtr);
-        Jim_SetEmptyResult(interp);
-        return JIM_OK;
-    }
-    else if (option == OPT_SHOW) {
-        const char *s;
-        int len, charlen;
-
-        if (argc != 3) {
-            Jim_WrongNumArgs(interp, 2, argv, "object");
-            return JIM_ERR;
-        }
-        s = Jim_GetString(argv[2], &len);
-        charlen = Jim_Utf8Length(interp, argv[2]);
-        printf("chars (%d): <<%s>>\n", charlen, s);
-        printf("bytes (%d):", len);
-        while (len--) {
-            printf(" %02x", (unsigned char)*s++);
-        }
-        printf("\n");
-        return JIM_OK;
-    }
-    else if (option == OPT_SCRIPTLEN) {
-        ScriptObj *script;
-
-        if (argc != 3) {
-            Jim_WrongNumArgs(interp, 2, argv, "script");
-            return JIM_ERR;
-        }
-        script = Jim_GetScript(interp, argv[2]);
-        Jim_SetResultInt(interp, script->len);
-        return JIM_OK;
-    }
-    else if (option == OPT_EXPRLEN) {
-        ExprByteCode *expr;
-
-        if (argc != 3) {
-            Jim_WrongNumArgs(interp, 2, argv, "expression");
-            return JIM_ERR;
-        }
-        expr = JimGetExpression(interp, argv[2]);
-        if (expr == NULL)
-            return JIM_ERR;
-        Jim_SetResultInt(interp, expr->len);
-        return JIM_OK;
-    }
-    else if (option == OPT_EXPRBC) {
-        Jim_Obj *objPtr;
-        ExprByteCode *expr;
-        int i;
-
-        if (argc != 3) {
-            Jim_WrongNumArgs(interp, 2, argv, "expression");
-            return JIM_ERR;
-        }
-        expr = JimGetExpression(interp, argv[2]);
-        if (expr == NULL)
-            return JIM_ERR;
-        objPtr = Jim_NewListObj(interp, NULL, 0);
-        for (i = 0; i < expr->len; i++) {
-            const char *type;
-            const Jim_ExprOperator *op;
-            Jim_Obj *obj = expr->token[i].objPtr;
-
-            switch (expr->token[i].type) {
-                case JIM_TT_EXPR_INT:
-                    type = "int";
-                    break;
-                case JIM_TT_EXPR_DOUBLE:
-                    type = "double";
-                    break;
-                case JIM_TT_CMD:
-                    type = "command";
-                    break;
-                case JIM_TT_VAR:
-                    type = "variable";
-                    break;
-                case JIM_TT_DICTSUGAR:
-                    type = "dictsugar";
-                    break;
-                case JIM_TT_EXPRSUGAR:
-                    type = "exprsugar";
-                    break;
-                case JIM_TT_ESC:
-                    type = "subst";
-                    break;
-                case JIM_TT_STR:
-                    type = "string";
-                    break;
-                default:
-                    op = JimExprOperatorInfoByOpcode(expr->token[i].type);
-                    if (op == NULL) {
-                        type = "private";
-                    }
-                    else {
-                        type = "operator";
-                    }
-                    obj = Jim_NewStringObj(interp, op ? op->name : "", -1);
-                    break;
-            }
-            Jim_ListAppendElement(interp, objPtr, Jim_NewStringObj(interp, type, -1));
-            Jim_ListAppendElement(interp, objPtr, obj);
-        }
-        Jim_SetResult(interp, objPtr);
-        return JIM_OK;
-    }
-    else {
-        Jim_SetResultString(interp,
-            "bad option. Valid options are refcount, " "objcount, objects, invstr", -1);
-        return JIM_ERR;
-    }
-    /* unreached */
-#else
+#if !defined(JIM_DEBUG_COMMAND)
     Jim_SetResultString(interp, "unsupported", -1);
     return JIM_ERR;
 #endif
 }
 
-/* [eval] */
+
 static int Jim_EvalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int rc;
@@ -18701,13 +16222,13 @@ static int Jim_EvalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     }
 
     if (rc == JIM_ERR) {
-        /* eval is "interesting", so add a stack frame here */
+        
         interp->addStackTrace++;
     }
     return rc;
 }
 
-/* [uplevel] */
+
 static int Jim_UplevelCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc >= 2) {
@@ -18716,10 +16237,10 @@ static int Jim_UplevelCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
         Jim_Obj *objPtr;
         const char *str;
 
-        /* Save the old callframe pointer */
+        
         savedCallFrame = interp->framePtr;
 
-        /* Lookup the target frame pointer */
+        
         str = Jim_String(argv[1]);
         if ((str[0] >= '0' && str[0] <= '9') || str[0] == '#') {
             targetCallFrame =Jim_GetCallFrameByLevel(interp, argv[1]);
@@ -18737,7 +16258,7 @@ static int Jim_UplevelCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
             Jim_WrongNumArgs(interp, 1, argv, "?level? command ?arg ...?");
             return JIM_ERR;
         }
-        /* Eval the code in the target callframe. */
+        
         interp->framePtr = targetCallFrame;
         if (argc == 2) {
             retcode = Jim_EvalObj(interp, argv[1]);
@@ -18757,7 +16278,7 @@ static int Jim_UplevelCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
     }
 }
 
-/* [expr] */
+
 static int Jim_ExprCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *exprResultPtr;
@@ -18785,7 +16306,7 @@ static int Jim_ExprCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return JIM_OK;
 }
 
-/* [break] */
+
 static int Jim_BreakCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 1) {
@@ -18795,7 +16316,7 @@ static int Jim_BreakCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     return JIM_BREAK;
 }
 
-/* [continue] */
+
 static int Jim_ContinueCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 1) {
@@ -18805,7 +16326,7 @@ static int Jim_ContinueCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const
     return JIM_CONTINUE;
 }
 
-/* [return] */
+
 static int Jim_ReturnCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int i;
@@ -18842,11 +16363,11 @@ static int Jim_ReturnCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
             "?-code code? ?-errorinfo stacktrace? ?-level level? ?result?");
     }
 
-    /* If a stack trace is supplied and code is error, set the stack trace */
+    
     if (stackTraceObj && returnCode == JIM_ERR) {
         JimSetStackTrace(interp, stackTraceObj);
     }
-    /* If an error code list is supplied, set the global $errorCode */
+    
     if (errorCodeObj && returnCode == JIM_ERR) {
         Jim_SetGlobalVariableStr(interp, "errorCode", errorCodeObj);
     }
@@ -18859,7 +16380,7 @@ static int Jim_ReturnCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_RETURN;
 }
 
-/* [tailcall] */
+
 static int Jim_TailcallCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *objPtr;
@@ -18869,7 +16390,7 @@ static int Jim_TailcallCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const
     return JIM_EVAL;
 }
 
-/* [proc] */
+
 static int Jim_ProcCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 4 && argc != 5) {
@@ -18885,18 +16406,18 @@ static int Jim_ProcCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     }
 }
 
-/* [local] */
+
 static int Jim_LocalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int retcode;
 
-    /* Evaluate the arguments with 'local' in force */
+    
     interp->local++;
     retcode = Jim_EvalObjVector(interp, argc - 1, argv + 1);
     interp->local--;
 
 
-    /* If OK, and the result is a proc, add it to the list of local procs */
+    
     if (retcode == 0) {
         const char *procname = Jim_String(Jim_GetResult(interp));
 
@@ -18914,7 +16435,7 @@ static int Jim_LocalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     return retcode;
 }
 
-/* [upcall] */
+
 static int Jim_UpcallCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc < 2) {
@@ -18929,14 +16450,14 @@ static int Jim_UpcallCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
             Jim_SetResultFormatted(interp, "no previous proc: \"%#s\"", argv[1]);
             return JIM_ERR;
         }
-        /* OK. Mark this command as being in an upcall */
+        
         cmdPtr->u.proc.upcall++;
         JimIncrCmdRefCount(cmdPtr);
 
-        /* Invoke the command as normal */
+        
         retcode = Jim_EvalObjVector(interp, argc - 1, argv + 1);
 
-        /* No longer in an upcall */
+        
         cmdPtr->u.proc.upcall--;
         JimDecrCmdRefCount(interp, cmdPtr);
 
@@ -18944,20 +16465,20 @@ static int Jim_UpcallCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     }
 }
 
-/* [concat] */
+
 static int Jim_ConcatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_SetResult(interp, Jim_ConcatObj(interp, argc - 1, argv + 1));
     return JIM_OK;
 }
 
-/* [upvar] */
+
 static int Jim_UpvarCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int i;
     Jim_CallFrame *targetCallFrame;
 
-    /* Lookup the target frame pointer */
+    
     if (argc > 3 && (argc % 2 == 0)) {
         targetCallFrame = Jim_GetCallFrameByLevel(interp, argv[1]);
         argc--;
@@ -18970,13 +16491,13 @@ static int Jim_UpvarCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
         return JIM_ERR;
     }
 
-    /* Check for arity */
+    
     if (argc < 3) {
         Jim_WrongNumArgs(interp, 1, argv, "?level? otherVar localVar ?otherVar localVar ...?");
         return JIM_ERR;
     }
 
-    /* Now... for every other/local couple: */
+    
     for (i = 1; i < argc; i += 2) {
         if (Jim_SetVariableLink(interp, argv[i + 1], argv[i], targetCallFrame) != JIM_OK)
             return JIM_ERR;
@@ -18984,7 +16505,7 @@ static int Jim_UpvarCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     return JIM_OK;
 }
 
-/* [global] */
+
 static int Jim_GlobalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int i;
@@ -18993,9 +16514,9 @@ static int Jim_GlobalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
         Jim_WrongNumArgs(interp, 1, argv, "varName ?varName ...?");
         return JIM_ERR;
     }
-    /* Link every var to the toplevel having the same name */
+    
     if (interp->framePtr->level == 0)
-        return JIM_OK;          /* global at toplevel... */
+        return JIM_OK;          
     for (i = 1; i < argc; i++) {
         if (Jim_SetVariableLink(interp, argv[i], argv[i], interp->topFramePtr) != JIM_OK)
             return JIM_ERR;
@@ -19003,9 +16524,6 @@ static int Jim_GlobalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_OK;
 }
 
-/* does the [string map] operation. On error NULL is returned,
- * otherwise a new string object with the result, having refcount = 0,
- * is returned. */
 static Jim_Obj *JimStringMap(Jim_Interp *interp, Jim_Obj *mapListObjPtr,
     Jim_Obj *objPtr, int nocase)
 {
@@ -19023,7 +16541,7 @@ static Jim_Obj *JimStringMap(Jim_Interp *interp, Jim_Obj *mapListObjPtr,
     str = Jim_String(objPtr);
     strLen = Jim_Utf8Length(interp, objPtr);
 
-    /* Map it */
+    
     resultObjPtr = Jim_NewStringObj(interp, "", 0);
     while (strLen) {
         for (i = 0; i < numMaps; i += 2) {
@@ -19056,7 +16574,7 @@ static Jim_Obj *JimStringMap(Jim_Interp *interp, Jim_Obj *mapListObjPtr,
                 }
             }
         }
-        if (i == numMaps) {     /* no match */
+        if (i == numMaps) {     
             int c;
             if (noMatchStart == NULL)
                 noMatchStart = str;
@@ -19070,7 +16588,7 @@ static Jim_Obj *JimStringMap(Jim_Interp *interp, Jim_Obj *mapListObjPtr,
     return resultObjPtr;
 }
 
-/* [string] */
+
 static int Jim_StringCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int len;
@@ -19266,7 +16784,7 @@ static int Jim_StringCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
                     Jim_SetResultString(interp, "", 0);
                 }
                 else if (len == Jim_Length(argv[2])) {
-                    /* ASCII optimisation */
+                    
                     Jim_SetResultString(interp, str + idx, 1);
                 }
                 else {
@@ -19358,7 +16876,7 @@ static int Jim_StringCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_OK;
 }
 
-/* [time] */
+
 static int Jim_TimeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     long i, count = 1;
@@ -19392,7 +16910,7 @@ static int Jim_TimeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return JIM_OK;
 }
 
-/* [exit] */
+
 static int Jim_ExitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     long exitCode = 0;
@@ -19409,28 +16927,25 @@ static int Jim_ExitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return JIM_EXIT;
 }
 
-/* [catch] */
+
 static int Jim_CatchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int exitCode = 0;
     int i;
     int sig = 0;
 
-    /* Which return codes are caught? These are the defaults */
-    jim_wide mask =
-        (1 << JIM_OK | 1 << JIM_ERR | 1 << JIM_BREAK | 1 << JIM_CONTINUE | 1 << JIM_RETURN);
+    
+    jim_wide ignore_mask = (1 << JIM_EXIT) | (1 << JIM_EVAL) | (1 << JIM_SIGNAL);
+    static const int max_ignore_code = sizeof(ignore_mask) * 8;
 
-    /* Reset the error code before catch.
-     * Note that this is not strictly correct.
-     */
     Jim_SetGlobalVariableStr(interp, "errorCode", Jim_NewStringObj(interp, "NONE", -1));
 
     for (i = 1; i < argc - 1; i++) {
         const char *arg = Jim_String(argv[i]);
         jim_wide option;
-        int add;
+        int ignore;
 
-        /* It's a pity we can't use Jim_GetEnum here :-( */
+        
         if (strcmp(arg, "--") == 0) {
             i++;
             break;
@@ -19441,11 +16956,11 @@ static int Jim_CatchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
 
         if (strncmp(arg, "-no", 3) == 0) {
             arg += 3;
-            add = 0;
+            ignore = 1;
         }
         else {
             arg++;
-            add = 1;
+            ignore = 0;
         }
 
         if (Jim_StringToWide(arg, &option, 10) != JIM_OK) {
@@ -19458,11 +16973,11 @@ static int Jim_CatchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
             goto wrongargs;
         }
 
-        if (add) {
-            mask |= (1 << option);
+        if (ignore) {
+            ignore_mask |= (1 << option);
         }
         else {
-            mask &= ~(1 << option);
+            ignore_mask &= ~(1 << option);
         }
     }
 
@@ -19475,13 +16990,13 @@ static int Jim_CatchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     }
     argv += i;
 
-    if (mask & (1 << JIM_SIGNAL)) {
+    if ((ignore_mask & (1 << JIM_SIGNAL)) == 0) {
         sig++;
     }
 
     interp->signal_level += sig;
     if (interp->signal_level && interp->sigmask) {
-        /* If a signal is set, don't even try to execute the body */
+        
         exitCode = JIM_SIGNAL;
     }
     else {
@@ -19489,14 +17004,14 @@ static int Jim_CatchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     }
     interp->signal_level -= sig;
 
-    /* Catch or pass through? Only the first 32/64 codes can be passed through */
-    if (exitCode >= 0 && exitCode < (int)sizeof(mask) * 8 && ((1 << exitCode) & mask) == 0) {
-        /* Not caught, pass it up */
+    
+    if (exitCode >= 0 && exitCode < max_ignore_code && ((1 << exitCode) & ignore_mask)) {
+        
         return exitCode;
     }
 
     if (sig && exitCode == JIM_SIGNAL) {
-        /* Catch the signal at this level */
+        
         if (interp->signal_set_result) {
             interp->signal_set_result(interp, interp->sigmask);
         }
@@ -19541,7 +17056,7 @@ static int Jim_CatchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
 
 #ifdef JIM_REFERENCES
 
-/* [ref] */
+
 static int Jim_RefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 3 && argc != 4) {
@@ -19557,7 +17072,7 @@ static int Jim_RefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
     return JIM_OK;
 }
 
-/* [getref] */
+
 static int Jim_GetrefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Reference *refPtr;
@@ -19572,7 +17087,7 @@ static int Jim_GetrefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_OK;
 }
 
-/* [setref] */
+
 static int Jim_SetrefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Reference *refPtr;
@@ -19590,7 +17105,7 @@ static int Jim_SetrefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_OK;
 }
 
-/* [collect] */
+
 static int Jim_CollectCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 1) {
@@ -19599,7 +17114,7 @@ static int Jim_CollectCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
     }
     Jim_SetResultInt(interp, Jim_Collect(interp));
 
-    /* Free all the freed objects. */
+    
     while (interp->freeList) {
         Jim_Obj *nextObjPtr = interp->freeList->nextObjPtr;
         Jim_Free(interp->freeList);
@@ -19609,7 +17124,7 @@ static int Jim_CollectCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *
     return JIM_OK;
 }
 
-/* [finalize] reference ?newValue? */
+
 static int Jim_FinalizeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 2 && argc != 3) {
@@ -19621,7 +17136,7 @@ static int Jim_FinalizeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const
 
         if (Jim_GetFinalizer(interp, argv[1], &cmdNamePtr) != JIM_OK)
             return JIM_ERR;
-        if (cmdNamePtr != NULL) /* otherwise the null string is returned. */
+        if (cmdNamePtr != NULL) 
             Jim_SetResult(interp, cmdNamePtr);
     }
     else {
@@ -19632,7 +17147,7 @@ static int Jim_FinalizeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const
     return JIM_OK;
 }
 
-/* [info references] */
+
 static int JimInfoReferences(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *listObjPtr;
@@ -19656,7 +17171,7 @@ static int JimInfoReferences(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 }
 #endif
 
-/* [rename] */
+
 static int Jim_RenameCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     const char *oldName, *newName;
@@ -19687,14 +17202,11 @@ int Jim_DictKeys(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *patternObj)
         return JIM_ERR;
     }
 
-    /* XXX: Could make the exact-match case much more efficient here.
-     *      See JimCommandsList()
-     */
     if (Jim_DictPairs(interp, dictObj, &dictValuesObj, &len) != JIM_OK) {
         return JIM_ERR;
     }
 
-    /* Only return the matching values */
+    
     resultObj = Jim_NewListObj(interp, NULL, 0);
 
     for (i = 0; i < len; i += 2) {
@@ -19716,7 +17228,7 @@ int Jim_DictSize(Jim_Interp *interp, Jim_Obj *objPtr)
     return ((Jim_HashTable *)objPtr->internalRep.ptr)->used;
 }
 
-/* [dict] */
+
 static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *objPtr;
@@ -19756,7 +17268,7 @@ static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
                 Jim_WrongNumArgs(interp, 2, argv, "varName key ?key ...? value");
                 return JIM_ERR;
             }
-            return Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc - 4, argv[argc - 1]);
+            return Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc - 4, argv[argc - 1], JIM_ERRMSG);
 
         case OPT_EXIST:
             if (argc < 3) {
@@ -19772,7 +17284,7 @@ static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
                 Jim_WrongNumArgs(interp, 2, argv, "varName key ?key ...?");
                 return JIM_ERR;
             }
-            return Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc - 3, NULL);
+            return Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc - 3, NULL, JIM_NONE);
 
         case OPT_KEYS:
             if (argc != 3 && argc != 4) {
@@ -19805,7 +17317,7 @@ static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
                 return JIM_ERR;
             }
             else {
-                return Jim_EvalObjPrefix(interp, "dict merge", argc - 2, argv + 2);
+                return Jim_EvalPrefix(interp, "dict merge", argc - 2, argv + 2);
             }
 
         case OPT_WITH:
@@ -19817,7 +17329,7 @@ static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
                 return JIM_ERR;
             }
             else {
-                return Jim_EvalObjPrefix(interp, "dict with", argc - 2, argv + 2);
+                return Jim_EvalPrefix(interp, "dict with", argc - 2, argv + 2);
             }
 
         case OPT_CREATE:
@@ -19834,7 +17346,7 @@ static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     }
 }
 
-/* [subst] */
+
 static int Jim_SubstCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     static const char * const options[] = {
@@ -19876,7 +17388,7 @@ static int Jim_SubstCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     return JIM_OK;
 }
 
-/* [info] */
+
 static int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int cmd;
@@ -19905,7 +17417,7 @@ static int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
         return JIM_ERR;
     }
 
-    /* Test for the the most common commands first, just in case it makes a difference */
+    
     switch (cmd) {
         case INFO_EXISTS:{
                 if (argc != 3) {
@@ -19932,11 +17444,11 @@ static int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
             break;
 
         case INFO_VARS:
-            mode++;             /* JIM_VARLIST_VARS */
+            mode++;             
         case INFO_LOCALS:
-            mode++;             /* JIM_VARLIST_LOCALS */
+            mode++;             
         case INFO_GLOBALS:
-            /* mode 0 => JIM_VARLIST_GLOBALS */
+            
             if (argc != 2 && argc != 3) {
                 Jim_WrongNumArgs(interp, 2, argv, "?pattern?");
                 return JIM_ERR;
@@ -19949,30 +17461,33 @@ static int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
                 Jim_WrongNumArgs(interp, 2, argv, "");
                 return JIM_ERR;
             }
-            Jim_SetResultString(interp, Jim_GetScript(interp, interp->currentScriptObj)->fileName,
-                -1);
+            Jim_SetResult(interp, Jim_GetScript(interp, interp->currentScriptObj)->fileNameObj);
             break;
 
         case INFO_SOURCE:{
-                const char *filename = "";
-                int line = 0;
+                int line;
                 Jim_Obj *resObjPtr;
+                Jim_Obj *fileNameObj;
 
                 if (argc != 3) {
                     Jim_WrongNumArgs(interp, 2, argv, "source");
                     return JIM_ERR;
                 }
                 if (argv[2]->typePtr == &sourceObjType) {
-                    filename = argv[2]->internalRep.sourceValue.fileName;
+                    fileNameObj = argv[2]->internalRep.sourceValue.fileNameObj;
                     line = argv[2]->internalRep.sourceValue.lineNumber;
                 }
                 else if (argv[2]->typePtr == &scriptObjType) {
                     ScriptObj *script = Jim_GetScript(interp, argv[2]);
-                    filename = script->fileName;
+                    fileNameObj = script->fileNameObj;
                     line = script->line;
                 }
+                else {
+                    fileNameObj = interp->emptyObj;
+                    line = 1;
+                }
                 resObjPtr = Jim_NewListObj(interp, NULL, 0);
-                Jim_ListAppendElement(interp, resObjPtr, Jim_NewStringObj(interp, filename, -1));
+                Jim_ListAppendElement(interp, resObjPtr, fileNameObj);
                 Jim_ListAppendElement(interp, resObjPtr, Jim_NewIntObj(interp, line));
                 Jim_SetResult(interp, resObjPtr);
                 break;
@@ -20049,11 +17564,11 @@ static int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
             break;
 
         case INFO_HOSTNAME:
-            /* Redirect to os.gethostname if it exists */
+            
             return Jim_Eval(interp, "os.gethostname");
 
         case INFO_NAMEOFEXECUTABLE:
-            /* Redirect to Tcl proc */
+            
             return Jim_Eval(interp, "{info nameofexecutable}");
 
         case INFO_RETURNCODES:
@@ -20100,7 +17615,7 @@ static int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return JIM_OK;
 }
 
-/* [exists] */
+
 static int Jim_ExistsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *objPtr;
@@ -20129,7 +17644,7 @@ static int Jim_ExistsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
         return JIM_ERR;
     }
 
-    /* Test for the the most common commands first, just in case it makes a difference */
+    
     switch (option) {
         case OPT_VAR:
             Jim_SetResultBool(interp, Jim_GetVariable(interp, objPtr, 0) != NULL);
@@ -20145,7 +17660,7 @@ static int Jim_ExistsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_OK;
 }
 
-/* [split] */
+
 static int Jim_SplitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     const char *str, *splitChars, *noMatchStart;
@@ -20165,7 +17680,7 @@ static int Jim_SplitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     }
     strLen = Jim_Utf8Length(interp, argv[1]);
 
-    /* Init */
+    
     if (argc == 2) {
         splitChars = " \n\t\r";
         splitLen = 4;
@@ -20178,7 +17693,7 @@ static int Jim_SplitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     noMatchStart = str;
     resObjPtr = Jim_NewListObj(interp, NULL, 0);
 
-    /* Split */
+    
     if (splitLen) {
         Jim_Obj *objPtr;
         while (strLen--) {
@@ -20201,16 +17716,13 @@ static int Jim_SplitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
         Jim_ListAppendElement(interp, resObjPtr, objPtr);
     }
     else {
-        /* This handles the special case of splitchars eq {}
-         * Optimise by sharing common (ASCII) characters
-         */
         Jim_Obj **commonObj = NULL;
 #define NUM_COMMON (128 - 9)
         while (strLen--) {
             int n = utf8_tounicode(str, &c);
 #ifdef JIM_OPTIMIZATION
             if (c >= 9 && c < 128) {
-                /* Common ASCII char. Note that 9 is the tab character */
+                
                 c -= 9;
                 if (!commonObj) {
                     commonObj = Jim_Alloc(sizeof(*commonObj) * NUM_COMMON);
@@ -20234,7 +17746,7 @@ static int Jim_SplitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     return JIM_OK;
 }
 
-/* [join] */
+
 static int Jim_JoinCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     const char *joinStr;
@@ -20245,7 +17757,7 @@ static int Jim_JoinCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
         Jim_WrongNumArgs(interp, 1, argv, "list ?joinString?");
         return JIM_ERR;
     }
-    /* Init */
+    
     if (argc == 2) {
         joinStr = " ";
         joinStrLen = 1;
@@ -20255,7 +17767,7 @@ static int Jim_JoinCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     }
     listLen = Jim_ListLength(interp, argv[1]);
     resObjPtr = Jim_NewStringObj(interp, NULL, 0);
-    /* Split */
+    
     for (i = 0; i < listLen; i++) {
         Jim_Obj *objPtr = 0;
 
@@ -20269,7 +17781,7 @@ static int Jim_JoinCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return JIM_OK;
 }
 
-/* [format] */
+
 static int Jim_FormatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *objPtr;
@@ -20285,7 +17797,7 @@ static int Jim_FormatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_OK;
 }
 
-/* [scan] */
+
 static int Jim_ScanCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *listPtr, **outVec;
@@ -20361,7 +17873,7 @@ static int Jim_ScanCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *arg
     return JIM_OK;
 }
 
-/* [error] */
+
 static int Jim_ErrorCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     if (argc != 2 && argc != 3) {
@@ -20377,7 +17889,7 @@ static int Jim_ErrorCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     return JIM_ERR;
 }
 
-/* [lrange] */
+
 static int Jim_LrangeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *objPtr;
@@ -20392,7 +17904,7 @@ static int Jim_LrangeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return JIM_OK;
 }
 
-/* [lrepeat] */
+
 static int Jim_LrepeatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *objPtr;
@@ -20449,7 +17961,7 @@ void Jim_SetEnviron(char **env)
 #endif
 }
 
-/* [env] */
+
 static int Jim_EnvCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     const char *key;
@@ -20492,7 +18004,7 @@ static int Jim_EnvCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv
     return JIM_OK;
 }
 
-/* [source] */
+
 static int Jim_SourceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     int retval;
@@ -20507,7 +18019,7 @@ static int Jim_SourceCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *a
     return retval;
 }
 
-/* [lreverse] */
+
 static int Jim_LreverseCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     Jim_Obj *revObjPtr, **ele;
@@ -20540,19 +18052,16 @@ static int JimRangeLen(jim_wide start, jim_wide end, jim_wide step)
         return -1;
     len = end - start;
     if (len < 0)
-        len = -len;             /* abs(len) */
+        len = -len;             
     if (step < 0)
-        step = -step;           /* abs(step) */
+        step = -step;           
     len = 1 + ((len - 1) / step);
-    /* We can truncate safely to INT_MAX, the range command
-     * will always return an error for a such long range
-     * because Tcl lists can't be so long. */
     if (len > INT_MAX)
         len = INT_MAX;
     return (int)((len < 0) ? -1 : len);
 }
 
-/* [range] */
+
 static int Jim_RangeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     jim_wide start = 0, end, step = 1;
@@ -20585,7 +18094,7 @@ static int Jim_RangeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *ar
     return JIM_OK;
 }
 
-/* [rand] */
+
 static int Jim_RandCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
     jim_wide min = 0, max = 0, len, maxMul;
@@ -20706,9 +18215,6 @@ void Jim_RegisterCoreCommands(Jim_Interp *interp)
     }
 }
 
-/* -----------------------------------------------------------------------------
- * Interactive prompt
- * ---------------------------------------------------------------------------*/
 void Jim_MakeErrorMessage(Jim_Interp *interp)
 {
     Jim_Obj *argv[2];
@@ -20763,14 +18269,11 @@ int Jim_GetEnum(Jim_Interp *interp, Jim_Obj *objPtr,
 
     for (entryPtr = tablePtr, i = 0; *entryPtr != NULL; entryPtr++, i++) {
         if (Jim_CompareStringImmediate(interp, objPtr, *entryPtr)) {
-            /* Found an exact match */
+            
             *indexPtr = i;
             return JIM_OK;
         }
         if (flags & JIM_ENUM_ABBREV) {
-            /* Accept an unambiguous abbreviation.
-             * Note that '-' doesnt' consitute a valid abbreviation
-             */
             if (strncmp(arg, *entryPtr, arglen) == 0) {
                 if (*arg == '-' && arglen == 1) {
                     break;
@@ -20784,7 +18287,7 @@ int Jim_GetEnum(Jim_Interp *interp, Jim_Obj *objPtr,
         }
     }
 
-    /* If we had an unambiguous partial match */
+    
     if (match >= 0) {
         *indexPtr = match;
         return JIM_OK;
@@ -20819,23 +18322,9 @@ int Jim_IsList(Jim_Obj *objPtr)
     return objPtr->typePtr == &listObjType;
 }
 
-/**
- * Very simple printf-like formatting, designed for error messages.
- *
- * The format may contain up to 5 '%s' or '%#s', corresponding to variable arguments.
- * The resulting string is created and set as the result.
- *
- * Each '%s' should correspond to a regular string parameter.
- * Each '%#s' should correspond to a (Jim_Obj *) parameter.
- * Any other printf specifier is not allowed (but %% is allowed for the % character).
- *
- * e.g. Jim_SetResultFormatted(interp, "Bad option \"%#s\" in proc \"%#s\"", optionObjPtr, procNamePtr);
- *
- * Note: We take advantage of the fact that printf has the same behaviour for both %s and %#s
- */
 void Jim_SetResultFormatted(Jim_Interp *interp, const char *format, ...)
 {
-    /* Initial space needed */
+    
     int len = strlen(format);
     int extra = 0;
     int n = 0;
@@ -20876,7 +18365,7 @@ void Jim_SetResultFormatted(Jim_Interp *interp, const char *format, ...)
     Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, buf, len));
 }
 
-/* stubs */
+
 #ifndef jim_ext_package
 int Jim_PackageProvide(Jim_Interp *interp, const char *name, const char *ver, int flags)
 {
@@ -20892,28 +18381,16 @@ FILE *Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *fhObj)
 #endif
 
 
-/*
- * Local Variables: ***
- * c-basic-offset: 4 ***
- * tab-width: 4 ***
- * End: ***
- */
 #include <stdio.h>
 #include <string.h>
 
 
-/**
- * Implements the common 'commands' subcommand
- */
 static int subcmd_null(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-    /* Nothing to do, since the result has already been created */
+    
     return JIM_OK;
 }
 
-/**
- * Do-nothing command to support -commands and -usage
- */
 static const jim_subcmd_type dummy_subcmd = {
     .cmd = "dummy",
     .function = subcmd_null,
@@ -20967,7 +18444,7 @@ static void show_full_usage(Jim_Interp *interp, const jim_subcmd_type * ct, int
     Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
     for (; ct->cmd; ct++) {
         if (!(ct->flags & JIM_MODFLAG_HIDDEN)) {
-            /* subcmd */
+            
             add_cmd_usage(interp, ct, argv[0]);
             if (ct->description) {
                 Jim_AppendStrings(interp, Jim_GetResult(interp), "\n\n    ", ct->description, NULL);
@@ -21009,27 +18486,27 @@ const jim_subcmd_type *Jim_ParseSubCmd(Jim_Interp *interp, const jim_subcmd_type
     cmd = argv[1];
 
     if (argc == 2 && Jim_CompareStringImmediate(interp, cmd, "-usage")) {
-        /* Show full usage */
+        
         show_full_usage(interp, command_table, argc, argv);
         return &dummy_subcmd;
     }
 
-    /* Check for the help command */
+    
     if (Jim_CompareStringImmediate(interp, cmd, "-help")) {
         if (argc == 2) {
-            /* Usage for the command, not the subcommand */
+            
             show_cmd_usage(interp, command_table, argc, argv);
             return &dummy_subcmd;
         }
         help = 1;
 
-        /* Skip the 'help' command */
+        
         cmd = argv[2];
     }
 
-    /* Check for special builtin '-commands' command first */
+    
     if (Jim_CompareStringImmediate(interp, cmd, "-commands")) {
-        /* Build the result here */
+        
         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
         add_commands(interp, command_table, " ");
         return &dummy_subcmd;
@@ -21039,14 +18516,14 @@ const jim_subcmd_type *Jim_ParseSubCmd(Jim_Interp *interp, const jim_subcmd_type
 
     for (ct = command_table; ct->cmd; ct++) {
         if (Jim_CompareStringImmediate(interp, cmd, ct->cmd)) {
-            /* Found an exact match */
+            
             break;
         }
         if (strncmp(cmdstr, ct->cmd, cmdlen) == 0) {
             if (partial) {
-                /* Ambiguous */
+                
                 if (help) {
-                    /* Just show the top level help here */
+                    
                     show_cmd_usage(interp, command_table, argc, argv);
                     return &dummy_subcmd;
                 }
@@ -21058,15 +18535,15 @@ const jim_subcmd_type *Jim_ParseSubCmd(Jim_Interp *interp, const jim_subcmd_type
         continue;
     }
 
-    /* If we had an unambiguous partial match */
+    
     if (partial && !ct->cmd) {
         ct = partial;
     }
 
     if (!ct->cmd) {
-        /* No matching command */
+        
         if (help) {
-            /* Just show the top level help here */
+            
             show_cmd_usage(interp, command_table, argc, argv);
             return &dummy_subcmd;
         }
@@ -21076,7 +18553,7 @@ const jim_subcmd_type *Jim_ParseSubCmd(Jim_Interp *interp, const jim_subcmd_type
 
     if (help) {
         Jim_SetResultString(interp, "Usage: ", -1);
-        /* subcmd */
+        
         add_cmd_usage(interp, ct, argv[0]);
         if (ct->description) {
             Jim_AppendStrings(interp, Jim_GetResult(interp), "\n\n", ct->description, NULL);
@@ -21084,17 +18561,17 @@ const jim_subcmd_type *Jim_ParseSubCmd(Jim_Interp *interp, const jim_subcmd_type
         return &dummy_subcmd;
     }
 
-    /* Check the number of args */
+    
     if (argc - 2 < ct->minargs || (ct->maxargs >= 0 && argc - 2 > ct->maxargs)) {
         Jim_SetResultString(interp, "wrong # args: must be \"", -1);
-        /* subcmd */
+        
         add_cmd_usage(interp, ct, argv[0]);
         Jim_AppendStrings(interp, Jim_GetResult(interp), "\"", NULL);
 
         return 0;
     }
 
-    /* Good command */
+    
     return ct;
 }
 
@@ -21125,12 +18602,12 @@ int Jim_SubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
     return Jim_CallSubCmd(interp, ct, argc, argv);
 }
 
-/* The following two functions are for normal commands */
+
 int
 Jim_CheckCmdUsage(Jim_Interp *interp, const jim_subcmd_type * command_table, int argc,
     Jim_Obj *const *argv)
 {
-    /* -usage or -help */
+    
     if (argc == 2) {
         if (Jim_CompareStringImmediate(interp, argv[1], "-usage")
             || Jim_CompareStringImmediate(interp, argv[1], "-help")) {
@@ -21144,7 +18621,7 @@ Jim_CheckCmdUsage(Jim_Interp *interp, const jim_subcmd_type * command_table, int
         }
     }
     if (argc >= 2 && command_table->function) {
-        /* This is actually a sub command table */
+        
 
         Jim_Obj *nargv[4];
         int nargc = 0;
@@ -21177,7 +18654,7 @@ Jim_CheckCmdUsage(Jim_Interp *interp, const jim_subcmd_type * command_table, int
         }
     }
 
-    /* Check the number of args */
+    
     if (argc - 1 < command_table->minargs || (command_table->maxargs >= 0
             && argc - 1 > command_table->maxargs)) {
         set_wrong_args(interp, command_table, NULL);
@@ -21186,16 +18663,9 @@ Jim_CheckCmdUsage(Jim_Interp *interp, const jim_subcmd_type * command_table, int
         return JIM_ERR;
     }
 
-    /* Not usage, but passed arg checking */
+    
     return -1;
 }
-/**
- * UTF-8 utility functions
- *
- * (c) 2010 Steve Bennett <steveb@workware.net.au>
- *
- * See LICENCE for licence details.
- */
 
 #include <ctype.h>
 #include <stdlib.h>
@@ -21203,7 +18673,7 @@ Jim_CheckCmdUsage(Jim_Interp *interp, const jim_subcmd_type * command_table, int
 #include <stdio.h>
 #include <assert.h>
 
-/* This one is always implemented */
+
 int utf8_fromunicode(char *p, unsigned short uc)
 {
     if (uc <= 0x7f) {
@@ -21223,163 +18693,6 @@ int utf8_fromunicode(char *p, unsigned short uc)
     }
 }
 
-#ifdef JIM_UTF8
-int utf8_charlen(int c)
-{
-    if ((c & 0x80) == 0) {
-        return 1;
-    }
-    if ((c & 0xe0) == 0xc0) {
-        return 2;
-    }
-    if ((c & 0xf0) == 0xe0) {
-        return 3;
-    }
-    if ((c & 0xf8) == 0xf0) {
-        return 4;
-    }
-    /* Invalid sequence */
-    return -1;
-}
-
-int utf8_strlen(const char *str, int bytelen)
-{
-    int charlen = 0;
-    if (bytelen < 0) {
-        bytelen = strlen(str);
-    }
-    while (bytelen) {
-        int c;
-        int l = utf8_tounicode(str, &c);
-        charlen++;
-        str += l;
-        bytelen -= l;
-    }
-    return charlen;
-}
-
-int utf8_index(const char *str, int index)
-{
-    const char *s = str;
-    while (index--) {
-        int c;
-        s += utf8_tounicode(s, &c);
-    }
-    return s - str;
-}
-
-int utf8_charequal(const char *s1, const char *s2)
-{
-    int c1, c2;
-
-    utf8_tounicode(s1, &c1);
-    utf8_tounicode(s2, &c2);
-
-    return c1 == c2;
-}
-
-int utf8_prev_len(const char *str, int len)
-{
-    int n = 1;
-
-    assert(len > 0);
-
-    /* Look up to len chars backward for a start-of-char byte */
-    while (--len) {
-        if ((str[-n] & 0x80) == 0) {
-            /* Start of a 1-byte char */
-            break;
-        }
-        if ((str[-n] & 0xc0) == 0xc0) {
-            /* Start of a multi-byte char */
-            break;
-        }
-        n++;
-    }
-    return n;
-}
-
-int utf8_tounicode(const char *str, int *uc)
-{
-    unsigned const char *s = (unsigned const char *)str;
-
-    if (s[0] < 0xc0) {
-        *uc = s[0];
-        return 1;
-    }
-    if (s[0] < 0xe0) {
-        if ((s[1] & 0xc0) == 0x80) {
-            *uc = ((s[0] & ~0xc0) << 6) | (s[1] & ~0x80);
-            return 2;
-        }
-    }
-    else if (s[0] < 0xf0) {
-        if (((str[1] & 0xc0) == 0x80) && ((str[2] & 0xc0) == 0x80)) {
-            *uc = ((s[0] & ~0xe0) << 12) | ((s[1] & ~0x80) << 6) | (s[2] & ~0x80);
-            return 3;
-        }
-    }
-
-    /* Invalid sequence, so just return the byte */
-    *uc = *s;
-    return 1;
-}
-
-struct casemap {
-    unsigned short code;    /* code point */
-    signed char lowerdelta; /* add for lowercase, or if -128 use the ext table */
-    signed char upperdelta; /* add for uppercase, or offset into the ext table */
-};
-
-/* Extended table for codepoints where |delta| > 127 */
-struct caseextmap {
-    unsigned short lower;
-    unsigned short upper;
-};
-
-/* Generated mapping tables */
-#include "_unicode_mapping.c"
-
-#define NUMCASEMAP sizeof(unicode_case_mapping) / sizeof(*unicode_case_mapping)
-
-static int cmp_casemap(const void *key, const void *cm)
-{
-    return *(int *)key - (int)((const struct casemap *)cm)->code;
-}
-
-static int utf8_map_case(int uc, int upper)
-{
-    const struct casemap *cm = bsearch(&uc, unicode_case_mapping, NUMCASEMAP, sizeof(*unicode_case_mapping), cmp_casemap);
-
-    if (cm) {
-        if (cm->lowerdelta == -128) {
-            uc = upper ? unicode_extmap[cm->upperdelta].upper : unicode_extmap[cm->upperdelta].lower;
-        }
-        else {
-            uc += upper ? cm->upperdelta : cm->lowerdelta;
-        }
-    }
-    return uc;
-}
-
-int utf8_upper(int uc)
-{
-    if (isascii(uc)) {
-        return toupper(uc);
-    }
-    return utf8_map_case(uc, 1);
-}
-
-int utf8_lower(int uc)
-{
-    if (isascii(uc)) {
-        return tolower(uc);
-    }
-
-    return utf8_map_case(uc, 0);
-}
-
-#endif
 #include <errno.h>
 #include <string.h>
 
@@ -21478,7 +18791,7 @@ int Jim_InteractivePrompt(Jim_Interp *interp)
         }
 #ifdef USE_LINENOISE
         if (strcmp(str, "h") == 0) {
-            /* built-in history command */
+            
             int i;
             int len;
             char **history = linenoiseHistory(&len);
@@ -21515,47 +18828,6 @@ int Jim_InteractivePrompt(Jim_Interp *interp)
     Jim_Free(history_file);
     return JIM_OK;
 }
-/* 
- * Implements the internals of the format command for jim
- *
- * The FreeBSD license
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- * The views and conclusions contained in the software and documentation
- * are those of the authors and should not be interpreted as representing
- * official policies, either expressed or implied, of the Jim Tcl Project.
- *
- * Based on code originally from Tcl 8.5:
- *
- * Copyright (c) 1995-1997 Sun Microsystems, Inc.
- * Copyright (c) 1999 by Scriptics Corporation.
- *
- * See the file "tcl.license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
- */
 #include <ctype.h>
 #include <string.h>
 
@@ -21564,27 +18836,19 @@ int Jim_InteractivePrompt(Jim_Interp *interp)
 #define JIM_INTEGER_SPACE 24
 #define MAX_FLOAT_WIDTH 320
 
-/**
- * Apply the printf-like format in fmtObjPtr with the given arguments.
- *
- * Returns a new object with zero reference count if OK, or NULL on error.
- */
 Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_Obj *const *objv)
 {
     const char *span, *format, *formatEnd, *msg;
     int numBytes = 0, objIndex = 0, gotXpg = 0, gotSequential = 0;
-    static const char *mixedXPG =
+    static const char * const mixedXPG =
 	    "cannot mix \"%\" and \"%n$\" conversion specifiers";
-    static const char *badIndex[2] = {
+    static const char * const badIndex[2] = {
 	"not enough arguments for all format specifiers",
 	"\"%n$\" argument index out of range"
     };
     int formatLen;
     Jim_Obj *resultPtr;
 
-    /* A single buffer is used to store numeric fields (with sprintf())
-     * This buffer is allocated/reallocated as necessary
-     */
     char *num_buffer = NULL;
     int num_buffer_size = 0;
 
@@ -21620,11 +18884,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    numBytes = 0;
 	}
 
-	/*
-	 * Saw a % : process the format specifier.
-	 *
-	 * Step 0. Handle special case of escaped format marker (i.e., %%).
-	 */
 
 	step = utf8_tounicode(format, &ch);
 	if (ch == '%') {
@@ -21634,9 +18893,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    continue;
 	}
 
-	/*
-	 * Step 1. XPG3 position specifier
-	 */
 
 	newXpg = 0;
 	if (isdigit(ch)) {
@@ -21666,9 +18922,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    goto errorMsg;
 	}
 
-	/*
-	 * Step 2. Set of flags. Also build up the sprintf spec.
-	 */
 	p = spec;
 	*p++ = '%';
 
@@ -21695,9 +18948,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    step = utf8_tounicode(format, &ch);
 	} while (sawFlag);
 
-	/*
-	 * Step 3. Minimum field width.
-	 */
 
 	width = 0;
 	if (isdigit(ch)) {
@@ -21724,9 +18974,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    step = utf8_tounicode(format, &ch);
 	}
 
-	/*
-	 * Step 4. Precision.
-	 */
 
 	gotPrecision = precision = 0;
 	if (ch == '.') {
@@ -21747,9 +18994,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 		goto error;
 	    }
 
-	    /*
-	     * TODO: Check this truncation logic.
-	     */
 
 	    if (precision < 0) {
 		precision = 0;
@@ -21759,9 +19003,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    step = utf8_tounicode(format, &ch);
 	}
 
-	/*
-	 * Step 5. Length modifier.
-	 */
 
 	useShort = 0;
 	if (ch == 'h') {
@@ -21769,7 +19010,7 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    format += step;
 	    step = utf8_tounicode(format, &ch);
 	} else if (ch == 'l') {
-	    /* Just for compatibility. All non-short integers are wide. */
+	    
 	    format += step;
 	    step = utf8_tounicode(format, &ch);
 	    if (ch == 'l') {
@@ -21781,9 +19022,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	format += step;
 	span = format;
 
-	/*
-	 * Step 6. The actual conversion character.
-	 */
 
 	if (ch == 'i') {
 	    ch = 'd';
@@ -21791,11 +19029,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 
 	doubleType = 0;
 
-	/* Each valid conversion will set:
-	 * formatted_buf   - the result to be added
-	 * formatted_chars - the length of formatted_buf in characters 
-	 * formatted_bytes - the length of formatted_buf in bytes
-	 */
 	switch (ch) {
 	case '\0':
 	    msg = "format string ended in middle of field specifier";
@@ -21804,7 +19037,7 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    formatted_buf = Jim_GetString(objv[objIndex], &formatted_bytes);
 	    formatted_chars = Jim_Utf8Length(interp, objv[objIndex]);
 	    if (gotPrecision && (precision < formatted_chars)) {
-		/* Need to build a (null terminated) truncated string */
+		
 		formatted_chars = precision;
 		formatted_bytes = utf8_index(formatted_buf, precision);
 	    }
@@ -21816,7 +19049,7 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    if (Jim_GetWide(interp, objv[objIndex], &code) != JIM_OK) {
 		goto error;
 	    }
-	    /* Just store the value in the 'spec' buffer */
+	    
 	    formatted_bytes = utf8_fromunicode(spec, code);
 	    formatted_buf = spec;
 	    formatted_chars = 1;
@@ -21829,7 +19062,7 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	case 'g':
 	case 'G':
 	    doubleType = 1;
-	    /* fall through */
+	    
 	case 'd':
 	case 'u':
 	case 'o':
@@ -21839,7 +19072,7 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    double d;
 	    int length;
 
-	    /* Fill in the width and precision */
+	    
 	    if (width) {
 		p += sprintf(p, "%ld", width);
 	    }
@@ -21847,7 +19080,7 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 		p += sprintf(p, ".%ld", precision);
 	    }
 
-	    /* Now the modifier, and get the actual value here */
+	    
 	    if (doubleType) {
 		if (Jim_GetDouble(interp, objv[objIndex], &d) != JIM_OK) {
 		    goto error;
@@ -21881,7 +19114,7 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	    *p++ = (char) ch;
 	    *p = '\0';
 
-	    /* Adjust length for width and precision */
+	    
 	    if (width > length) {
 		length = width;
 	    }
@@ -21889,7 +19122,7 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 		length += precision;
 	    }
 
-	    /* Increase the size of the buffer if needed */
+	    
 	    if (num_buffer_size < length + 1) {
 		num_buffer_size = length + 1;
 		num_buffer = Jim_Realloc(num_buffer, num_buffer_size);
@@ -21907,7 +19140,7 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 	}
 
 	default: {
-	    /* Just reuse the 'spec' buffer */
+	    
 	    spec[0] = ch;
 	    spec[1] = '\0';
 	    Jim_SetResultFormatted(interp, "bad field specifier \"%s\"", spec);
@@ -21945,57 +19178,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
     Jim_Free(num_buffer);
     return NULL;
 }
-/*
- * regcomp and regexec -- regsub and regerror are elsewhere
- *
- *	Copyright (c) 1986 by University of Toronto.
- *	Written by Henry Spencer.  Not derived from licensed software.
- *
- *	Permission is granted to anyone to use this software for any
- *	purpose on any computer system, and to redistribute it freely,
- *	subject to the following restrictions:
- *
- *	1. The author is not responsible for the consequences of use of
- *		this software, no matter how awful, even if they arise
- *		from defects in it.
- *
- *	2. The origin of this software must not be misrepresented, either
- *		by explicit claim or by omission.
- *
- *	3. Altered versions must be plainly marked as such, and must not
- *		be misrepresented as being the original software.
- *** THIS IS AN ALTERED VERSION.  It was altered by John Gilmore,
- *** hoptoad!gnu, on 27 Dec 1986, to add \n as an alternative to |
- *** to assist in implementing egrep.
- *** THIS IS AN ALTERED VERSION.  It was altered by John Gilmore,
- *** hoptoad!gnu, on 27 Dec 1986, to add \< and \> for word-matching
- *** as in BSD grep and ex.
- *** THIS IS AN ALTERED VERSION.  It was altered by John Gilmore,
- *** hoptoad!gnu, on 28 Dec 1986, to optimize characters quoted with \.
- *** THIS IS AN ALTERED VERSION.  It was altered by James A. Woods,
- *** ames!jaw, on 19 June 1987, to quash a regcomp() redundancy.
- *** THIS IS AN ALTERED VERSION.  It was altered by Christopher Seiwald
- *** seiwald@vix.com, on 28 August 1993, for use in jam.  Regmagic.h
- *** was moved into regexp.h, and the include of regexp.h now uses "'s
- *** to avoid conflicting with the system regexp.h.  Const, bless its
- *** soul, was removed so it can compile everywhere.  The declaration
- *** of strchr() was in conflict on AIX, so it was removed (as it is
- *** happily defined in string.h).
- *** THIS IS AN ALTERED VERSION.  It was altered by Christopher Seiwald
- *** seiwald@perforce.com, on 20 January 2000, to use function prototypes.
- *** THIS IS AN ALTERED VERSION.  It was altered by Christopher Seiwald
- *** seiwald@perforce.com, on 05 November 2002, to const string literals.
- *
- *   THIS IS AN ALTERED VERSION.  It was altered by Steve Bennett <steveb@workware.net.au>
- *   on 16 October 2010, to remove static state and add better Tcl ARE compatibility.
- *   This includes counted repetitions, UTF-8 support, character classes,
- *   shorthand character classes, increased number of parentheses to 100,
- *   backslash escape sequences. It also removes \n as an alternative to |.
- *
- * Beware that some of this code is subtly aware of the way operator
- * precedence is structured in regular expressions.  Serious changes in
- * regular-expression syntax might require a total rethink.
- */
 #include <stdio.h>
 #include <ctype.h>
 #include <stdlib.h>
@@ -22004,117 +19186,55 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_
 
 #if !defined(HAVE_REGCOMP) || defined(JIM_REGEXP)
 
-/*
- * Structure for regexp "program".  This is essentially a linear encoding
- * of a nondeterministic finite-state machine (aka syntax charts or
- * "railroad normal form" in parsing technology).  Each node is an opcode
- * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
- * all nodes except BRANCH implement concatenation; a "next" pointer with
- * a BRANCH on both ends of it is connecting two alternatives.  (Here we
- * have one of the subtle syntax dependencies:  an individual BRANCH (as
- * opposed to a collection of them) is never concatenated with anything
- * because of operator precedence.)  The operand of some types of node is
- * a literal string; for others, it is a node leading into a sub-FSM.  In
- * particular, the operand of a BRANCH node is the first node of the branch.
- * (NB this is *not* a tree structure:  the tail of the branch connects
- * to the thing following the set of BRANCHes.)  The opcodes are:
- */
-
-/* This *MUST* be less than (255-20)/2=117 */
+
+
 #define REG_MAX_PAREN 100
 
-/* definition	number	opnd?	meaning */
-#define	END	0	/* no	End of program. */
-#define	BOL	1	/* no	Match "" at beginning of line. */
-#define	EOL	2	/* no	Match "" at end of line. */
-#define	ANY	3	/* no	Match any one character. */
-#define	ANYOF	4	/* str	Match any character in this string. */
-#define	ANYBUT	5	/* str	Match any character not in this string. */
-#define	BRANCH	6	/* node	Match this alternative, or the next... */
-#define	BACK	7	/* no	Match "", "next" ptr points backward. */
-#define	EXACTLY	8	/* str	Match this string. */
-#define	NOTHING	9	/* no	Match empty string. */
-#define	REP		10	/* max,min	Match this (simple) thing [min,max] times. */
-#define	REPMIN	11	/* max,min	Match this (simple) thing [min,max] times, mininal match. */
-#define	REPX	12	/* max,min	Match this (complex) thing [min,max] times. */
-#define	REPXMIN	13	/* max,min	Match this (complex) thing [min,max] times, minimal match. */
-
-#define	WORDA	15	/* no	Match "" at wordchar, where prev is nonword */
-#define	WORDZ	16	/* no	Match "" at nonwordchar, where prev is word */
-#define	OPEN	20	/* no	Mark this point in input as start of #n. */
-			/*	OPEN+1 is number 1, etc. */
-#define	CLOSE	(OPEN+REG_MAX_PAREN)	/* no	Analogous to OPEN. */
+
+#define	END	0	
+#define	BOL	1	
+#define	EOL	2	
+#define	ANY	3	
+#define	ANYOF	4	
+#define	ANYBUT	5	
+#define	BRANCH	6	
+#define	BACK	7	
+#define	EXACTLY	8	
+#define	NOTHING	9	
+#define	REP		10	
+#define	REPMIN	11	
+#define	REPX	12	
+#define	REPXMIN	13	
+
+#define	WORDA	15	
+#define	WORDZ	16	
+#define	OPEN	20	
+			
+#define	CLOSE	(OPEN+REG_MAX_PAREN)	
 #define	CLOSE_END	(CLOSE+REG_MAX_PAREN)
 
-/*
- * The first byte of the regexp internal "program" is actually this magic
- * number; the start node begins in the second byte.
- */
 #define	REG_MAGIC	0xFADED00D
 
-/*
- * Opcode notes:
- *
- * BRANCH	The set of branches constituting a single choice are hooked
- *		together with their "next" pointers, since precedence prevents
- *		anything being concatenated to any individual branch.  The
- *		"next" pointer of the last BRANCH in a choice points to the
- *		thing following the whole choice.  This is also where the
- *		final "next" pointer of each individual branch points; each
- *		branch starts with the operand node of a BRANCH node.
- *
- * BACK		Normal "next" pointers all implicitly point forward; BACK
- *		exists to make loop structures possible.
- *
- * STAR,PLUS	'?', and complex '*' and '+', are implemented as circular
- *		BRANCH structures using BACK.  Simple cases (one character
- *		per match) are implemented with STAR and PLUS for speed
- *		and to minimize recursive plunges.
- *
- * OPEN,CLOSE	...are numbered at compile time.
- */
-
-/*
- * A node is one char of opcode followed by two chars of "next" pointer.
- * "Next" pointers are stored as two 8-bit pieces, high order first.  The
- * value is a positive offset from the opcode of the node containing it.
- * An operand, if any, simply follows the node.  (Note that much of the
- * code generation knows about this implicit relationship.)
- *
- * Using two bytes for the "next" pointer is vast overkill for most things,
- * but allows patterns to get big without disasters.
- */
+
 #define	OP(preg, p)	(preg->program[p])
 #define	NEXT(preg, p)	(preg->program[p + 1])
 #define	OPERAND(p)	((p) + 2)
 
-/*
- * See regmagic.h for one further detail of program structure.
- */
 
 
-/*
- * Utility definitions.
- */
 
 #define	FAIL(R,M)	{ (R)->err = (M); return (M); }
 #define	ISMULT(c)	((c) == '*' || (c) == '+' || (c) == '?' || (c) == '{')
 #define	META	"^$.[()|?{+*"
 
-/*
- * Flags to be passed up and down.
- */
-#define	HASWIDTH	01	/* Known never to match null string. */
-#define	SIMPLE		02	/* Simple enough to be STAR/PLUS operand. */
-#define	SPSTART		04	/* Starts with * or +. */
-#define	WORST		0	/* Worst case. */
+#define	HASWIDTH	01	
+#define	SIMPLE		02	
+#define	SPSTART		04	
+#define	WORST		0	
 
 #define MAX_REP_COUNT 1000000
 
-/*
- * Forward declarations for regcomp()'s friends.
- */
-static int reg(regex_t *preg, int paren /* Parenthesized? */, int *flagp );
+static int reg(regex_t *preg, int paren , int *flagp );
 static int regpiece(regex_t *preg, int *flagp );
 static int regbranch(regex_t *preg, int *flagp );
 static int regatom(regex_t *preg, int *flagp );
@@ -22130,7 +19250,7 @@ static int reg_range_find(const int *string, int c);
 static const char *str_find(const char *string, int c, int nocase);
 static int prefix_cmp(const int *prog, int proglen, const char *string, int nocase);
 
-/*#define DEBUG*/
+
 #ifdef DEBUG
 int regnarrate = 0;
 static void regdump(regex_t *preg);
@@ -22138,9 +19258,6 @@ static const char *regprop( int op );
 #endif
 
 
-/**
- * Returns the length of the null-terminated integer sequence.
- */
 static int str_int_len(const int *seq)
 {
 	int n = 0;
@@ -22150,21 +19267,6 @@ static int str_int_len(const int *seq)
 	return n;
 }
 
-/*
- - regcomp - compile a regular expression into internal code
- *
- * We can't allocate space until we know how big the compiled form will be,
- * but we can't compile it (and thus know how big it is) until we've got a
- * place to put the code.  So we cheat:  we compile it twice, once with code
- * generation turned off and size counting turned on, and once "for real".
- * This also means that we don't allocate space until we are sure that the
- * thing really will compile successfully, and we never have to move the
- * code and thus invalidate pointers into it.  (Note that it has to be in
- * one piece because free() must be able to free it all.)
- *
- * Beware that the optimization-preparation code in here knows about some
- * of the structure of the compiled regexp.
- */
 int regcomp(regex_t *preg, const char *exp, int cflags)
 {
 	int scan;
@@ -22180,57 +19282,46 @@ int regcomp(regex_t *preg, const char *exp, int cflags)
 	if (exp == NULL)
 		FAIL(preg, REG_ERR_NULL_ARGUMENT);
 
-	/* First pass: determine size, legality. */
+	
 	preg->cflags = cflags;
 	preg->regparse = exp;
-	/* XXX: For now, start unallocated */
+	
 	preg->program = NULL;
 	preg->proglen = 0;
 
 #if 1
-	/* Allocate space. */
+	
 	preg->proglen = (strlen(exp) + 1) * 5;
 	preg->program = malloc(preg->proglen * sizeof(int));
 	if (preg->program == NULL)
 		FAIL(preg, REG_ERR_NOMEM);
 #endif
 
-	/* Note that since we store a magic value as the first item in the program,
-	 * program offsets will never be 0
-	 */
 	regc(preg, REG_MAGIC);
 	if (reg(preg, 0, &flags) == 0) {
 		return preg->err;
 	}
 
-	/* Small enough for pointer-storage convention? */
-	if (preg->re_nsub >= REG_MAX_PAREN)		/* Probably could be 65535L. */
+	
+	if (preg->re_nsub >= REG_MAX_PAREN)		
 		FAIL(preg,REG_ERR_TOO_BIG);
 
-	/* Dig out information for optimizations. */
-	preg->regstart = 0;	/* Worst-case defaults. */
+	
+	preg->regstart = 0;	
 	preg->reganch = 0;
 	preg->regmust = 0;
 	preg->regmlen = 0;
-	scan = 1;			/* First BRANCH. */
-	if (OP(preg, regnext(preg, scan)) == END) {		/* Only one top-level choice. */
+	scan = 1;			
+	if (OP(preg, regnext(preg, scan)) == END) {		
 		scan = OPERAND(scan);
 
-		/* Starting-point info. */
+		
 		if (OP(preg, scan) == EXACTLY) {
 			preg->regstart = preg->program[OPERAND(scan)];
 		}
 		else if (OP(preg, scan) == BOL)
 			preg->reganch++;
 
-		/*
-		 * If there's something expensive in the r.e., find the
-		 * longest literal string that must appear and make it the
-		 * regmust.  Resolve ties in favor of later strings, since
-		 * the regstart check works with the beginning of the r.e.
-		 * and avoiding duplication strengthens checking.  Not a
-		 * strong reason, but sufficient in the absence of others.
-		 */
 		if (flags&SPSTART) {
 			longest = 0;
 			len = 0;
@@ -22255,16 +19346,7 @@ int regcomp(regex_t *preg, const char *exp, int cflags)
 	return 0;
 }
 
-/*
- - reg - regular expression, i.e. main body or parenthesized thing
- *
- * Caller must absorb opening parenthesis.
- *
- * Combining parenthesis handling with the base level of regular expression
- * is a trifle forced, but the need to tie the tails of the branches to what
- * follows makes it hard to avoid.
- */
-static int reg(regex_t *preg, int paren /* Parenthesized? */, int *flagp )
+static int reg(regex_t *preg, int paren , int *flagp )
 {
 	int ret;
 	int br;
@@ -22272,21 +19354,21 @@ static int reg(regex_t *preg, int paren /* Parenthesized? */, int *flagp )
 	int parno = 0;
 	int flags;
 
-	*flagp = HASWIDTH;	/* Tentatively. */
+	*flagp = HASWIDTH;	
 
-	/* Make an OPEN node, if parenthesized. */
+	
 	if (paren) {
 		parno = ++preg->re_nsub;
 		ret = regnode(preg, OPEN+parno);
 	} else
 		ret = 0;
 
-	/* Pick up the branches, linking them together. */
+	
 	br = regbranch(preg, &flags);
 	if (br == 0)
 		return 0;
 	if (ret != 0)
-		regtail(preg, ret, br);	/* OPEN -> first. */
+		regtail(preg, ret, br);	
 	else
 		ret = br;
 	if (!(flags&HASWIDTH))
@@ -22297,21 +19379,21 @@ static int reg(regex_t *preg, int paren /* Parenthesized? */, int *flagp )
 		br = regbranch(preg, &flags);
 		if (br == 0)
 			return 0;
-		regtail(preg, ret, br);	/* BRANCH -> BRANCH. */
+		regtail(preg, ret, br);	
 		if (!(flags&HASWIDTH))
 			*flagp &= ~HASWIDTH;
 		*flagp |= flags&SPSTART;
 	}
 
-	/* Make a closing node, and hook it on the end. */
+	
 	ender = regnode(preg, (paren) ? CLOSE+parno : END);
 	regtail(preg, ret, ender);
 
-	/* Hook the tails of the branches to the closing node. */
+	
 	for (br = ret; br != 0; br = regnext(preg, br))
 		regoptail(preg, br, ender);
 
-	/* Check for proper termination. */
+	
 	if (paren && *preg->regparse++ != ')') {
 		preg->err = REG_ERR_UNMATCHED_PAREN;
 		return 0;
@@ -22328,11 +19410,6 @@ static int reg(regex_t *preg, int paren /* Parenthesized? */, int *flagp )
 	return(ret);
 }
 
-/*
- - regbranch - one alternative of an | operator
- *
- * Implements the concatenation operator.
- */
 static int regbranch(regex_t *preg, int *flagp )
 {
 	int ret;
@@ -22340,7 +19417,7 @@ static int regbranch(regex_t *preg, int *flagp )
 	int latest;
 	int flags;
 
-	*flagp = WORST;		/* Tentatively. */
+	*flagp = WORST;		
 
 	ret = regnode(preg, BRANCH);
 	chain = 0;
@@ -22350,7 +19427,7 @@ static int regbranch(regex_t *preg, int *flagp )
 		if (latest == 0)
 			return 0;
 		*flagp |= flags&HASWIDTH;
-		if (chain == 0) {/* First piece. */
+		if (chain == 0) {
 			*flagp |= flags&SPSTART;
 		}
 		else {
@@ -22358,21 +19435,12 @@ static int regbranch(regex_t *preg, int *flagp )
 		}
 		chain = latest;
 	}
-	if (chain == 0)	/* Loop ran zero times. */
+	if (chain == 0)	
 		(void) regnode(preg, NOTHING);
 
 	return(ret);
 }
 
-/*
- - regpiece - something followed by possible [*+?]
- *
- * Note that the branching code sequences used for ? and the general cases
- * of * and + are somewhat optimized:  they use the same NOTHING node as
- * both the endmarker for their branch list and the body of the last branch.
- * It might seem that this node could be dispensed with entirely, but the
- * endmarker role is not redundant.
- */
 static int regpiece(regex_t *preg, int *flagp)
 {
 	int ret;
@@ -22398,7 +19466,7 @@ static int regpiece(regex_t *preg, int *flagp)
 		return 0;
 	}
 
-	/* Handle braces (counted repetition) by expansion */
+	
 	if (op == '{') {
 		char *end;
 
@@ -22465,24 +19533,16 @@ static int regpiece(regex_t *preg, int *flagp)
 	return chain ? chain : ret;
 }
 
-/**
- * Add all characters in the inclusive range between lower and upper.
- * 
- * Handles a swapped range (upper < lower).
- */
 static void reg_addrange(regex_t *preg, int lower, int upper)
 {
 	if (lower > upper) {
 		reg_addrange(preg, upper, lower);
 	}
-	/* Add a range as length, start */
+	
 	regc(preg, upper - lower + 1);
 	regc(preg, lower);
 }
 
-/**
- * Add a null-terminated literal string as a set of ranges.
- */
 static void reg_addrange_str(regex_t *preg, const char *str)
 {
 	while (*str) {
@@ -22491,11 +19551,6 @@ static void reg_addrange_str(regex_t *preg, const char *str)
 	}
 }
 
-/**
- * Extracts the next unicode char from utf8.
- * 
- * If 'upper' is set, converts the char to uppercase.
- */
 static int reg_utf8_tounicode_case(const char *s, int *uc, int upper)
 {
 	int l = utf8_tounicode(s, uc);
@@ -22505,11 +19560,6 @@ static int reg_utf8_tounicode_case(const char *s, int *uc, int upper)
 	return l;
 }
 
-/**
- * Converts a hex digit to decimal.
- * 
- * Returns -1 for an invalid hex digit.
- */
 static int hexdigitval(int c)
 {
 	if (c >= '0' && c <= '9')
@@ -22521,12 +19571,6 @@ static int hexdigitval(int c)
 	return -1;
 }
 
-/**
- * Parses up to 'n' hex digits at 's' and stores the result in *uc.
- *
- * Returns the number of hex digits parsed.
- * If there are no hex digits, returns 0 and stores nothing.
- */
 static int parse_hex(const char *s, int n, int *uc)
 {
 	int val = 0;
@@ -22545,13 +19589,6 @@ static int parse_hex(const char *s, int n, int *uc)
 	return k;
 }
 
-/**
- * Call for chars after a backlash to decode the escape sequence.
- * 
- * Stores the result in *ch.
- *
- * Returns the number of bytes consumed.
- */
 static int reg_decode_escape(const char *s, int *ch)
 {
 	int n;
@@ -22585,14 +19622,6 @@ static int reg_decode_escape(const char *s, int *ch)
 	return s - s0;
 }
 
-/*
- - regatom - the lowest level
- *
- * Optimization:  gobbles an entire sequence of ordinary characters so that
- * it can turn them into a single node, which is smaller to store and
- * faster to run.  Backslashed characters are exceptions, each becoming a
- * separate node; the code is simpler that way and it's not worth fixing.
- */
 static int regatom(regex_t *preg, int *flagp)
 {
 	int ret;
@@ -22602,11 +19631,11 @@ static int regatom(regex_t *preg, int *flagp)
 	int ch;
 	int n = reg_utf8_tounicode_case(preg->regparse, &ch, nocase);
 
-	*flagp = WORST;		/* Tentatively. */
+	*flagp = WORST;		
 
 	preg->regparse += n;
 	switch (ch) {
-	/* FIXME: these chars only have meaning at beg/end of pat? */
+	
 	case '^':
 		ret = regnode(preg, BOL);
 		break;
@@ -22620,20 +19649,20 @@ static int regatom(regex_t *preg, int *flagp)
 	case '[': {
 			const char *pattern = preg->regparse;
 
-			if (*pattern == '^') {	/* Complement of range. */
+			if (*pattern == '^') {	
 				ret = regnode(preg, ANYBUT);
 				pattern++;
 			} else
 				ret = regnode(preg, ANYOF);
 
-			/* Special case. If the first char is ']' or '-', it is part of the set */
+			
 			if (*pattern == ']' || *pattern == '-') {
 				reg_addrange(preg, *pattern, *pattern);
 				pattern++;
 			}
 
 			while (*pattern && *pattern != ']') {
-				/* Is this a range? a-z */
+				
 				int start;
 				int end;
 
@@ -22646,7 +19675,7 @@ static int regatom(regex_t *preg, int *flagp)
 					}
 				}
 				if (pattern[0] == '-' && pattern[1]) {
-					/* skip '-' */
+					
 					pattern += utf8_tounicode(pattern, &end);
 					pattern += reg_utf8_tounicode_case(pattern, &end, nocase);
 					if (end == '\\') {
@@ -22684,7 +19713,7 @@ static int regatom(regex_t *preg, int *flagp)
 						continue;
 					}
 				}
-				/* Not a range, so just add the char */
+				
 				reg_addrange(preg, start, start);
 			}
 			regc(preg, '\0');
@@ -22707,7 +19736,7 @@ static int regatom(regex_t *preg, int *flagp)
 	case '|':
 	case ')':
 		preg->err = REG_ERR_INTERNAL;
-		return 0;	/* Supposed to be caught earlier. */
+		return 0;	
 	case '?':
 	case '+':
 	case '*':
@@ -22750,47 +19779,32 @@ static int regatom(regex_t *preg, int *flagp)
 			regc(preg, '\0');
 			*flagp |= HASWIDTH|SIMPLE;
 			break;
-		/* FIXME: Someday handle \1, \2, ... */
+		
 		default:
-			/* Handle general quoted chars in exact-match routine */
-			/* Back up to include the backslash */
+			
+			
 			preg->regparse--;
 			goto de_fault;
 		}
 		break;
 	de_fault:
 	default: {
-			/*
-			 * Encode a string of characters to be matched exactly.
-			 */
 			int added = 0;
 
-			/* Back up to pick up the first char of interest */
+			
 			preg->regparse -= n;
 
 			ret = regnode(preg, EXACTLY);
 
-			/* Note that a META operator such as ? or * consumes the
-			 * preceding char.
-			 * Thus we must be careful to look ahead by 2 and add the
-			 * last char as it's own EXACTLY if necessary
-			 */
 
-			/* Until end of string or a META char is reached */
+			
 			while (*preg->regparse && strchr(META, *preg->regparse) == NULL) {
 				n = reg_utf8_tounicode_case(preg->regparse, &ch, (preg->cflags & REG_ICASE));
 				if (ch == '\\' && preg->regparse[n]) {
-					/* Non-trailing backslash.
-					 * Is this a special escape, or a regular escape?
-					 */
 					if (strchr("<>mMwds", preg->regparse[n])) {
-						/* A special escape. All done with EXACTLY */
+						
 						break;
 					}
-					/* Decode it. Note that we add the length for the escape
-					 * sequence to the length for the backlash so we can skip
-					 * the entire sequence, or not as required.
-					 */
 					n += reg_decode_escape(preg->regparse + n, &ch);
 					if (ch == 0) {
 						preg->err = REG_ERR_NULL_CHAR;
@@ -22798,24 +19812,21 @@ static int regatom(regex_t *preg, int *flagp)
 					}
 				}
 
-				/* Now we have one char 'ch' of length 'n'.
-				 * Check to see if the following char is a MULT
-				 */
 
 				if (ISMULT(preg->regparse[n])) {
-					/* Yes. But do we already have some EXACTLY chars? */
+					
 					if (added) {
-						/* Yes, so return what we have and pick up the current char next time around */
+						
 						break;
 					}
-					/* No, so add this single char and finish */
+					
 					regc(preg, ch);
 					added++;
 					preg->regparse += n;
 					break;
 				}
 
-				/* No, so just add this char normally */
+				
 				regc(preg, ch);
 				added++;
 				preg->regparse += n;
@@ -22841,10 +19852,7 @@ static void reg_grow(regex_t *preg, int n)
 	}
 }
 
-/*
- - regnode - emit a node
- */
-/* Location. */
+
 static int regnode(regex_t *preg, int op)
 {
 	reg_grow(preg, 2);
@@ -22852,32 +19860,23 @@ static int regnode(regex_t *preg, int op)
 	preg->program[preg->p++] = op;
 	preg->program[preg->p++] = 0;
 
-	/* Return the start of the node */
+	
 	return preg->p - 2;
 }
 
-/*
- - regc - emit (if appropriate) a byte of code
- */
 static void regc(regex_t *preg, int b )
 {
 	reg_grow(preg, 1);
 	preg->program[preg->p++] = b;
 }
 
-/*
- - reginsert - insert an operator in front of already-emitted operand
- *
- * Means relocating the operand.
- * Returns the new location of the original operand.
- */
 static int reginsert(regex_t *preg, int op, int size, int opnd )
 {
 	reg_grow(preg, size);
 
-	/* Move everything from opnd up */
+	
 	memmove(preg->program + opnd + size, preg->program + opnd, sizeof(int) * (preg->p - opnd));
-	/* Zero out the new space */
+	
 	memset(preg->program + opnd, 0, sizeof(int) * size);
 
 	preg->program[opnd] = op;
@@ -22887,16 +19886,13 @@ static int reginsert(regex_t *preg, int op, int size, int opnd )
 	return opnd + size;
 }
 
-/*
- - regtail - set the next-pointer at the end of a node chain
- */
 static void regtail_(regex_t *preg, int p, int val, int line )
 {
 	int scan;
 	int temp;
 	int offset;
 
-	/* Find last node. */
+	
 	scan = p;
 	for (;;) {
 		temp = regnext(preg, scan);
@@ -22913,43 +19909,31 @@ static void regtail_(regex_t *preg, int p, int val, int line )
 	preg->program[scan + 1] = offset;
 }
 
-/*
- - regoptail - regtail on operand of first argument; nop if operandless
- */
 
 static void regoptail(regex_t *preg, int p, int val )
 {
-	/* "Operandless" and "op != BRANCH" are synonymous in practice. */
+	
 	if (p != 0 && OP(preg, p) == BRANCH) {
 		regtail(preg, OPERAND(p), val);
 	}
 }
 
-/*
- * regexec and friends
- */
 
-/*
- * Forwards.
- */
 static int regtry(regex_t *preg, const char *string );
 static int regmatch(regex_t *preg, int prog);
 static int regrepeat(regex_t *preg, int p, int max);
 
-/*
- - regexec - match a regexp against a string
- */
 int regexec(regex_t  *preg,  const  char *string, size_t nmatch, regmatch_t pmatch[], int eflags)
 {
 	const char *s;
 	int scan;
 
-	/* Be paranoid... */
+	
 	if (preg == NULL || preg->program == NULL || string == NULL) {
 		return REG_ERR_NULL_ARGUMENT;
 	}
 
-	/* Check validity of program. */
+	
 	if (*preg->program != REG_MAGIC) {
 		return REG_ERR_CORRUPTED;
 	}
@@ -22962,9 +19946,9 @@ int regexec(regex_t  *preg,  const  char *string, size_t nmatch, regmatch_t pmat
 	preg->eflags = eflags;
 	preg->pmatch = pmatch;
 	preg->nmatch = nmatch;
-	preg->start = string;	/* All offsets are computed from here */
+	preg->start = string;	
 
-	/* Must clear out the embedded repeat counts */
+	
 	for (scan = OPERAND(1); scan != 0; scan = regnext(preg, scan)) {
 		switch (OP(preg, scan)) {
 		case REP:
@@ -22976,7 +19960,7 @@ int regexec(regex_t  *preg,  const  char *string, size_t nmatch, regmatch_t pmat
 		}
 	}
 
-	/* If there is a "must appear" string, look for it. */
+	
 	if (preg->regmust != 0) {
 		s = string;
 		while ((s = str_find(s, preg->program[preg->regmust], preg->cflags & REG_ICASE)) != NULL) {
@@ -22985,17 +19969,17 @@ int regexec(regex_t  *preg,  const  char *string, size_t nmatch, regmatch_t pmat
 			}
 			s++;
 		}
-		if (s == NULL)	/* Not present. */
+		if (s == NULL)	
 			return REG_NOMATCH;
 	}
 
-	/* Mark beginning of line for ^ . */
+	
 	preg->regbol = string;
 
-	/* Simplest case:  anchored match need be tried only once (maybe per line). */
+	
 	if (preg->reganch) {
 		if (eflags & REG_NOTBOL) {
-			/* This is an anchored search, but not an BOL, so possibly skip to the next line */
+			
 			goto nextline;
 		}
 		while (1) {
@@ -23006,7 +19990,7 @@ int regexec(regex_t  *preg,  const  char *string, size_t nmatch, regmatch_t pmat
 			if (*string) {
 nextline:
 				if (preg->cflags & REG_NEWLINE) {
-					/* Try the next anchor? */
+					
 					string = strchr(string, '\n');
 					if (string) {
 						preg->regbol = ++string;
@@ -23018,10 +20002,10 @@ nextline:
 		}
 	}
 
-	/* Messy cases:  unanchored match. */
+	
 	s = string;
 	if (preg->regstart != '\0') {
-		/* We know what char it must start with. */
+		
 		while ((s = str_find(s, preg->regstart, preg->cflags & REG_ICASE)) != NULL) {
 			if (regtry(preg, s))
 				return REG_NOERROR;
@@ -23029,7 +20013,7 @@ nextline:
 		}
 	}
 	else
-		/* We don't -- general case. */
+		
 		while (1) {
 			if (regtry(preg, s))
 				return REG_NOERROR;
@@ -23039,14 +20023,11 @@ nextline:
 			s += utf8_charlen(*s);
 		}
 
-	/* Failure. */
+	
 	return REG_NOMATCH;
 }
 
-/*
- - regtry - try match at specific point
- */
-			/* 0 failure, 1 success */
+			
 static int regtry( regex_t *preg, const char *string )
 {
 	int i;
@@ -23065,13 +20046,6 @@ static int regtry( regex_t *preg, const char *string )
 		return(0);
 }
 
-/**
- * Returns bytes matched if 'pattern' is a prefix of 'string'.
- *
- * If 'nocase' is non-zero, does a case-insensitive match.
- *
- * Returns -1 on not found.
- */
 static int prefix_cmp(const int *prog, int proglen, const char *string, int nocase)
 {
 	const char *s = string;
@@ -23091,15 +20065,10 @@ static int prefix_cmp(const int *prog, int proglen, const char *string, int noca
 	return -1;
 }
 
-/**
- * Searchs for 'c' in the range 'range'.
- * 
- * Returns 1 if found, or 0 if not.
- */
 static int reg_range_find(const int *range, int c)
 {
 	while (*range) {
-		/*printf("Checking %d in range [%d,%d]\n", c, range[1], (range[0] + range[1] - 1));*/
+		
 		if (c >= range[1] && c <= (range[0] + range[1] - 1)) {
 			return 1;
 		}
@@ -23108,19 +20077,10 @@ static int reg_range_find(const int *range, int c)
 	return 0;
 }
 
-/**
- * Search for the character 'c' in the utf-8 string 'string'.
- * 
- * If 'nocase' is set, the 'string' is assumed to be uppercase
- * and 'c' is converted to uppercase before matching.
- *
- * Returns the byte position in the string where the 'c' was found, or
- * NULL if not found.
- */
 static const char *str_find(const char *string, int c, int nocase)
 {
 	if (nocase) {
-		/* The "string" should already be converted to uppercase */
+		
 		c = utf8_upper(c);
 	}
 	while (*string) {
@@ -23134,12 +20094,6 @@ static const char *str_find(const char *string, int c, int nocase)
 	return NULL;
 }
 
-/**
- * Returns true if 'ch' is an end-of-line char.
- * 
- * In REG_NEWLINE mode, \n is considered EOL in
- * addition to \0
- */
 static int reg_iseol(regex_t *preg, int ch)
 {
 	if (preg->cflags & REG_NEWLINE) {
@@ -23161,10 +20115,6 @@ static int regmatchsimplerepeat(regex_t *preg, int scan, int matchmin)
 	int min = preg->program[scan + 3];
 	int next = regnext(preg, scan);
 
-	/*
-	 * Lookahead to avoid useless match attempts
-	 * when we know what character comes next.
-	 */
 	if (OP(preg, next) == EXACTLY) {
 		nextch = preg->program[OPERAND(next)];
 	}
@@ -23174,11 +20124,11 @@ static int regmatchsimplerepeat(regex_t *preg, int scan, int matchmin)
 		return 0;
 	}
 	if (matchmin) {
-		/* from min up to no */
+		
 		max = no;
 		no = min;
 	}
-	/* else from no down to min */
+	
 	while (1) {
 		if (matchmin) {
 			if (no > max) {
@@ -23192,18 +20142,18 @@ static int regmatchsimplerepeat(regex_t *preg, int scan, int matchmin)
 		}
 		preg->reginput = save + utf8_index(save, no);
 		reg_utf8_tounicode_case(preg->reginput, &c, (preg->cflags & REG_ICASE));
-		/* If it could work, try it. */
+		
 		if (reg_iseol(preg, nextch) || c == nextch) {
 			if (regmatch(preg, next)) {
 				return(1);
 			}
 		}
 		if (matchmin) {
-			/* Couldn't or didn't, add one more */
+			
 			no++;
 		}
 		else {
-			/* Couldn't or didn't -- back up. */
+			
 			no--;
 		}
 	}
@@ -23217,9 +20167,9 @@ static int regmatchrepeat(regex_t *preg, int scan, int matchmin)
 	int max = scanpt[2];
 	int min = scanpt[3];
 
-	/* Have we reached min? */
+	
 	if (scanpt[4] < min) {
-		/* No, so get another one */
+		
 		scanpt[4]++;
 		if (regmatch(preg, scan + 5)) {
 			return 1;
@@ -23232,11 +20182,11 @@ static int regmatchrepeat(regex_t *preg, int scan, int matchmin)
 	}
 
 	if (matchmin) {
-		/* minimal, so try other branch first */
+		
 		if (regmatch(preg, regnext(preg, scan))) {
 			return 1;
 		}
-		/* No, so try one more */
+		
 		scanpt[4]++;
 		if (regmatch(preg, scan + 5)) {
 			return 1;
@@ -23244,7 +20194,7 @@ static int regmatchrepeat(regex_t *preg, int scan, int matchmin)
 		scanpt[4]--;
 		return 0;
 	}
-	/* maximal, so try this branch again */
+	
 	if (scanpt[4] < max) {
 		scanpt[4]++;
 		if (regmatch(preg, scan + 5)) {
@@ -23252,25 +20202,15 @@ static int regmatchrepeat(regex_t *preg, int scan, int matchmin)
 		}
 		scanpt[4]--;
 	}
-	/* At this point we are at max with no match. Try the other branch */
+	
 	return regmatch(preg, regnext(preg, scan));
 }
 
-/*
- - regmatch - main matching routine
- *
- * Conceptually the strategy is simple:  check to see whether the current
- * node matches, call self recursively to see whether the rest matches,
- * and then act accordingly.  In practice we make some effort to avoid
- * recursion, in particular by going through "ordinary" nodes (that don't
- * need to know whether the rest of the match failed) by a loop instead of
- * by recursion.
- */
-/* 0 failure, 1 success */
+
 static int regmatch(regex_t *preg, int prog)
 {
-	int scan;	/* Current node. */
-	int next;		/* Next node. */
+	int scan;	
+	int next;		
 
 	scan = prog;
 
@@ -23283,8 +20223,7 @@ static int regmatch(regex_t *preg, int prog)
 		int c;
 #ifdef DEBUG
 		if (regnarrate) {
-			//fprintf(stderr, "%s...\n", regprop(scan));
-			fprintf(stderr, "%3d: %s...\n", scan, regprop(OP(preg, scan)));	/* Where, what. */
+			fprintf(stderr, "%3d: %s...\n", scan, regprop(OP(preg, scan)));	
 		}
 #endif
 		next = regnext(preg, scan);
@@ -23301,27 +20240,27 @@ static int regmatch(regex_t *preg, int prog)
 			}
 			break;
 		case WORDA:
-			/* Must be looking at a letter, digit, or _ */
+			
 			if ((!isalnum(UCHAR(c))) && c != '_')
 				return(0);
-			/* Prev must be BOL or nonword */
+			
 			if (preg->reginput > preg->regbol &&
 				(isalnum(UCHAR(preg->reginput[-1])) || preg->reginput[-1] == '_'))
 				return(0);
 			break;
 		case WORDZ:
-			/* Can't match at BOL */
+			
 			if (preg->reginput > preg->regbol) {
-				/* Current must be EOL or nonword */
+				
 				if (reg_iseol(preg, c) || !isalnum(UCHAR(c)) || c != '_') {
 					c = preg->reginput[-1];
-					/* Previous must be word */
+					
 					if (isalnum(UCHAR(c)) || c == '_') {
 						break;
 					}
 				}
 			}
-			/* No */
+			
 			return(0);
 
 		case ANY:
@@ -23363,8 +20302,8 @@ static int regmatch(regex_t *preg, int prog)
 		case BRANCH: {
 				const char *save;
 
-				if (OP(preg, next) != BRANCH)		/* No choice. */
-					next = OPERAND(scan);	/* Avoid recursion. */
+				if (OP(preg, next) != BRANCH)		
+					next = OPERAND(scan);	
 				else {
 					do {
 						save = preg->reginput;
@@ -23375,7 +20314,7 @@ static int regmatch(regex_t *preg, int prog)
 						scan = regnext(preg, scan);
 					} while (scan != 0 && OP(preg, scan) == BRANCH);
 					return(0);
-					/* NOTREACHED */
+					
 				}
 			}
 			break;
@@ -23388,7 +20327,7 @@ static int regmatch(regex_t *preg, int prog)
 			return regmatchrepeat(preg, scan, OP(preg, scan) == REPXMIN);
 
 		case END:
-			return(1);	/* Success! */
+			return(1);	
 			break;
 		default:
 			if (OP(preg, scan) >= OPEN+1 && OP(preg, scan) < CLOSE_END) {
@@ -23398,11 +20337,6 @@ static int regmatch(regex_t *preg, int prog)
 
 				if (regmatch(preg, next)) {
 					int no;
-					/*
-					 * Don't set startp if some later
-					 * invocation of the same parentheses
-					 * already has.
-					 */
 					if (OP(preg, scan) < CLOSE) {
 						no = OP(preg, scan) - OPEN;
 						if (no < preg->nmatch && preg->pmatch[no].rm_so == -1) {
@@ -23425,16 +20359,9 @@ static int regmatch(regex_t *preg, int prog)
 		scan = next;
 	}
 
-	/*
-	 * We get here only if there's trouble -- normally "case END" is
-	 * the terminating point.
-	 */
 	return REG_ERR_INTERNAL;
 }
 
-/*
- - regrepeat - repeatedly match something simple, report how many
- */
 static int regrepeat(regex_t *preg, int p, int max)
 {
 	int count = 0;
@@ -23447,7 +20374,7 @@ static int regrepeat(regex_t *preg, int p, int max)
 	opnd = OPERAND(p);
 	switch (OP(preg, p)) {
 	case ANY:
-		/* No need to handle utf8 specially here */
+		
 		while (!reg_iseol(preg, *scan) && count < max) {
 			count++;
 			scan++;
@@ -23483,9 +20410,9 @@ static int regrepeat(regex_t *preg, int p, int max)
 			scan += n;
 		}
 		break;
-	default:		/* Oh dear.  Called inappropriately. */
+	default:		
 		preg->err = REG_ERR_INTERNAL;
-		count = 0;	/* Best compromise. */
+		count = 0;	
 		break;
 	}
 	preg->reginput = scan;
@@ -23493,9 +20420,6 @@ static int regrepeat(regex_t *preg, int p, int max)
 	return(count);
 }
 
-/*
- - regnext - dig the "next" pointer out of a node
- */
 static int regnext(regex_t *preg, int p )
 {
 	int offset;
@@ -23511,151 +20435,6 @@ static int regnext(regex_t *preg, int p )
 		return(p+offset);
 }
 
-#ifdef DEBUG
-
-/*
- - regdump - dump a regexp onto stdout in vaguely comprehensible form
- */
-static void regdump(regex_t *preg)
-{
-	int s;
-	int op = EXACTLY;	/* Arbitrary non-END op. */
-	int next;
-	char buf[4];
-
-	int i;
-	for (i = 1; i < preg->p; i++) {
-		printf("%02x ", preg->program[i]);
-		if (i % 16 == 15) {
-			printf("\n");
-		}
-	}
-	printf("\n");
-
-	s = 1;
-	while (op != END && s < preg->p) {	/* While that wasn't END last time... */
-		op = OP(preg, s);
-		printf("%3d: %s", s, regprop(op));	/* Where, what. */
-		next = regnext(preg, s);
-		if (next == 0)		/* Next ptr. */
-			printf("(0)");
-		else
-			printf("(%d)", next);
-		s += 2;
-		if (op == REP || op == REPMIN || op == REPX || op == REPXMIN) {
-			int max = preg->program[s];
-			int min = preg->program[s + 1];
-			if (max == 65535) {
-				printf("{%d,*}", min);
-			}
-			else {
-				printf("{%d,%d}", min, max);
-			}
-			printf(" %d", preg->program[s + 2]);
-			s += 3;
-		}
-		else if (op == ANYOF || op == ANYBUT) {
-			/* set of ranges */
-
-			while (preg->program[s]) {
-				int len = preg->program[s++];
-				int first = preg->program[s++];
-				buf[utf8_fromunicode(buf, first)] = 0;
-				printf("%s", buf);
-				if (len > 1) {
-					buf[utf8_fromunicode(buf, first + len - 1)] = 0;
-					printf("-%s", buf);
-				}
-			}
-			s++;
-		}
-		else if (op == EXACTLY) {
-			/* Literal string, where present. */
-
-			while (preg->program[s]) {
-				buf[utf8_fromunicode(buf, preg->program[s])] = 0;
-				printf("%s", buf);
-				s++;
-			}
-			s++;
-		}
-		putchar('\n');
-	}
-
-	if (op == END) {
-		/* Header fields of interest. */
-		if (preg->regstart) {
-			buf[utf8_fromunicode(buf, preg->regstart)] = 0;
-			printf("start '%s' ", buf);
-		}
-		if (preg->reganch)
-			printf("anchored ");
-		if (preg->regmust != 0) {
-			int i;
-			printf("must have:");
-			for (i = 0; i < preg->regmlen; i++) {
-				putchar(preg->program[preg->regmust + i]);
-			}
-			putchar('\n');
-		}
-	}
-	printf("\n");
-}
-
-/*
- - regprop - printable representation of opcode
- */
-static const char *regprop( int op )
-{
-	static char buf[50];
-
-	switch (op) {
-	case BOL:
-		return "BOL";
-	case EOL:
-		return "EOL";
-	case ANY:
-		return "ANY";
-	case ANYOF:
-		return "ANYOF";
-	case ANYBUT:
-		return "ANYBUT";
-	case BRANCH:
-		return "BRANCH";
-	case EXACTLY:
-		return "EXACTLY";
-	case NOTHING:
-		return "NOTHING";
-	case BACK:
-		return "BACK";
-	case END:
-		return "END";
-	case REP:
-		return "REP";
-	case REPMIN:
-		return "REPMIN";
-	case REPX:
-		return "REPX";
-	case REPXMIN:
-		return "REPXMIN";
-	case WORDA:
-		return "WORDA";
-	case WORDZ:
-		return "WORDZ";
-	default:
-		if (op >= OPEN && op < CLOSE) {
-			snprintf(buf, sizeof(buf), "OPEN%d", op-OPEN);
-		}
-		else if (op >= CLOSE && op < CLOSE_END) {
-			snprintf(buf, sizeof(buf), "CLOSE%d", op-CLOSE);
-		}
-		else {
-			snprintf(buf, sizeof(buf), "?%d?\n", op);
-		}
-		return(buf);
-	}
-}
-#endif
 
 size_t regerror(int errcode, const regex_t *preg, char *errbuf,  size_t errbuf_size)
 {
@@ -23699,32 +20478,13 @@ void regfree(regex_t *preg)
 
 #endif
 
-/* Jimsh - An interactive shell for Jim
- * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
- * Copyright 2009 Steve Bennett <steveb@workware.net.au>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * A copy of the license is also included in the source distribution
- * of Jim, as a TXT file name called LICENSE.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 
-/* From initjimsh.tcl */
+
 extern int Jim_initjimshInit(Jim_Interp *interp);
 
 static void JimSetArgv(Jim_Interp *interp, int argc, char *const argv[])
@@ -23732,7 +20492,7 @@ static void JimSetArgv(Jim_Interp *interp, int argc, char *const argv[])
     int n;
     Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
 
-    /* Populate argv global var */
+    
     for (n = 0; n < argc; n++) {
         Jim_Obj *obj = Jim_NewStringObj(interp, argv[n], -1);
 
@@ -23753,11 +20513,11 @@ int main(int argc, char *const argv[])
         return 0;
     }
 
-    /* Create and initialize the interpreter */
+    
     interp = Jim_CreateInterp();
     Jim_RegisterCoreCommands(interp);
 
-    /* Register static extensions */
+    
     if (Jim_InitStaticExtensions(interp) != JIM_OK) {
         Jim_MakeErrorMessage(interp);
         fprintf(stderr, "%s\n", Jim_String(Jim_GetResult(interp)));