Indentation style changed to the new Jim standard

4 spaces. No tabs used at all.

3 files changed, 6511 insertions, 6512 deletions

diff --git a/jim-posix.c b/jim-posix.c
index ed172f0..ca4ec4e 100644
--- a/jim-posix.c
+++ b/jim-posix.c
@@ -11,102 +11,102 @@ extern int errno;
 
 static void Jim_PosixSetError(Jim_Interp *interp)
 {
-	Jim_SetResultString(interp, strerror(errno), -1);
+    Jim_SetResultString(interp, strerror(errno), -1);
 }
 
 static int Jim_PosixForkCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	pid_t pid;
-	argv = argv; /* not used */
-	
-	if (argc != 1) {
-		Jim_WrongNumArgs(interp, 1, argv, "");
-		return JIM_ERR;
-	}
-	if ((pid = fork()) == -1) {
-		Jim_SetResultString(interp, strerror(errno), -1);
-		return JIM_ERR;
-	}
-	Jim_SetResult(interp, Jim_NewIntObj(interp, (jim_wide)pid));
-	return JIM_OK;
+    pid_t pid;
+    argv = argv; /* not used */
+    
+    if (argc != 1) {
+        Jim_WrongNumArgs(interp, 1, argv, "");
+        return JIM_ERR;
+    }
+    if ((pid = fork()) == -1) {
+        Jim_SetResultString(interp, strerror(errno), -1);
+        return JIM_ERR;
+    }
+    Jim_SetResult(interp, Jim_NewIntObj(interp, (jim_wide)pid));
+    return JIM_OK;
 }
 
 static int Jim_PosixSleepCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	long longValue;
-	
-	if (argc != 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "?seconds?");
-		return JIM_ERR;
-	}
-	if (Jim_GetLong(interp, argv[1], &longValue) != JIM_OK)
-		return JIM_ERR;
-	sleep(longValue);
-	return JIM_OK;
+    long longValue;
+    
+    if (argc != 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "?seconds?");
+        return JIM_ERR;
+    }
+    if (Jim_GetLong(interp, argv[1], &longValue) != JIM_OK)
+        return JIM_ERR;
+    sleep(longValue);
+    return JIM_OK;
 }
 
 static int Jim_PosixGetidsCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	Jim_Obj *objv[8];
-	if (argc != 1) {
-		Jim_WrongNumArgs(interp, 1, argv, "");
-		return JIM_ERR;
-	}
-	objv[0] = Jim_NewStringObj(interp, "uid", -1);
-	objv[1] = Jim_NewIntObj(interp, getuid());
-	objv[2] = Jim_NewStringObj(interp, "euid", -1);
-	objv[3] = Jim_NewIntObj(interp, geteuid());
-	objv[4] = Jim_NewStringObj(interp, "gid", -1);
-	objv[5] = Jim_NewIntObj(interp, getgid());
-	objv[6] = Jim_NewStringObj(interp, "egid", -1);
-	objv[7] = Jim_NewIntObj(interp, getegid());
-	Jim_SetResult(interp, Jim_NewListObj(interp, objv, 8));
-	return JIM_OK;
+    Jim_Obj *objv[8];
+    if (argc != 1) {
+        Jim_WrongNumArgs(interp, 1, argv, "");
+        return JIM_ERR;
+    }
+    objv[0] = Jim_NewStringObj(interp, "uid", -1);
+    objv[1] = Jim_NewIntObj(interp, getuid());
+    objv[2] = Jim_NewStringObj(interp, "euid", -1);
+    objv[3] = Jim_NewIntObj(interp, geteuid());
+    objv[4] = Jim_NewStringObj(interp, "gid", -1);
+    objv[5] = Jim_NewIntObj(interp, getgid());
+    objv[6] = Jim_NewStringObj(interp, "egid", -1);
+    objv[7] = Jim_NewIntObj(interp, getegid());
+    Jim_SetResult(interp, Jim_NewListObj(interp, objv, 8));
+    return JIM_OK;
 }
 
 #define JIM_HOST_NAME_MAX 1024
 static int Jim_PosixGethostnameCommand(Jim_Interp *interp, int argc,
-		Jim_Obj **argv)
+        Jim_Obj **argv)
 {
-	char buf[JIM_HOST_NAME_MAX];
+    char buf[JIM_HOST_NAME_MAX];
 
-	if (argc != 1) {
-		Jim_WrongNumArgs(interp, 1, argv, "");
-		return JIM_ERR;
-	}
-	if (gethostname(buf, JIM_HOST_NAME_MAX) == -1) {
-		Jim_PosixSetError(interp);
-		return JIM_ERR;
-	}
-	Jim_SetResultString(interp, buf, -1);
-	return JIM_OK;
+    if (argc != 1) {
+        Jim_WrongNumArgs(interp, 1, argv, "");
+        return JIM_ERR;
+    }
+    if (gethostname(buf, JIM_HOST_NAME_MAX) == -1) {
+        Jim_PosixSetError(interp);
+        return JIM_ERR;
+    }
+    Jim_SetResultString(interp, buf, -1);
+    return JIM_OK;
 }
 
 static int Jim_PosixSethostnameCommand(Jim_Interp *interp, int argc,
-		Jim_Obj **argv)
+        Jim_Obj **argv)
 {
-	char *hostname;
-	int len;
+    char *hostname;
+    int len;
 
-	if (argc != 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "hostname");
-		return JIM_ERR;
-	}
-	hostname = Jim_GetString(argv[1], &len);
-	if (sethostname(hostname, len) == -1) {
-		Jim_PosixSetError(interp);
-		return JIM_ERR;
-	}
-	return JIM_OK;
+    if (argc != 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "hostname");
+        return JIM_ERR;
+    }
+    hostname = Jim_GetString(argv[1], &len);
+    if (sethostname(hostname, len) == -1) {
+        Jim_PosixSetError(interp);
+        return JIM_ERR;
+    }
+    return JIM_OK;
 }
 
 int Jim_OnLoad(Jim_Interp *interp)
 {
-	Jim_InitExtension(interp, "1.0");
-	Jim_CreateCommand(interp, "os.fork", Jim_PosixForkCommand, NULL);
-	Jim_CreateCommand(interp, "os.sleep", Jim_PosixSleepCommand, NULL);
-	Jim_CreateCommand(interp, "os.getids", Jim_PosixGetidsCommand, NULL);
-	Jim_CreateCommand(interp, "os.gethostname", Jim_PosixGethostnameCommand, NULL);
-	Jim_CreateCommand(interp, "os.sethostname", Jim_PosixSethostnameCommand, NULL);
-	return JIM_OK;
+    Jim_InitExtension(interp, "1.0");
+    Jim_CreateCommand(interp, "os.fork", Jim_PosixForkCommand, NULL);
+    Jim_CreateCommand(interp, "os.sleep", Jim_PosixSleepCommand, NULL);
+    Jim_CreateCommand(interp, "os.getids", Jim_PosixGetidsCommand, NULL);
+    Jim_CreateCommand(interp, "os.gethostname", Jim_PosixGethostnameCommand, NULL);
+    Jim_CreateCommand(interp, "os.sethostname", Jim_PosixSethostnameCommand, NULL);
+    return JIM_OK;
 }
diff --git a/jim.c b/jim.c
index 81a089e..167c1d7 100644
--- a/jim.c
+++ b/jim.c
@@ -74,263 +74,263 @@ static void Jim_RegisterCoreApi(Jim_Interp *interp);
 #ifdef HAVE_LONG_LONG
 static jim_wide Jim_Strtoll(const char *nptr, char **endptr, register int base)
 {
-	register const char *s;
-	register unsigned jim_wide acc;
-	register unsigned char c;
-	register unsigned jim_wide qbase, cutoff;
-	register int neg, any, cutlim;
-
-	/*
-	 * Skip white space and pick up leading +/- sign if any.
-	 * If base is 0, allow 0x for hex and 0 for octal, else
-	 * assume decimal; if base is already 16, allow 0x.
-	 */
-	s = nptr;
-	do {
-		c = *s++;
-	} while (isspace(c));
-	if (c == '-') {
-		neg = 1;
-		c = *s++;
-	} else {
-		neg = 0;
-		if (c == '+')
-			c = *s++;
-	}
-	if ((base == 0 || base == 16) &&
-	    c == '0' && (*s == 'x' || *s == 'X')) {
-		c = s[1];
-		s += 2;
-		base = 16;
-	}
-	if (base == 0)
-		base = c == '0' ? 8 : 10;
-
-	/*
-	 * Compute the cutoff value between legal numbers and illegal
-	 * numbers.  That is the largest legal value, divided by the
-	 * base.  An input number that is greater than this value, if
-	 * followed by a legal input character, is too big.  One that
-	 * is equal to this value may be valid or not; the limit
-	 * between valid and invalid numbers is then based on the last
-	 * digit.  For instance, if the range for quads is
-	 * [-9223372036854775808..9223372036854775807] and the input base
-	 * is 10, cutoff will be set to 922337203685477580 and cutlim to
-	 * either 7 (neg==0) or 8 (neg==1), meaning that if we have
-	 * accumulated a value > 922337203685477580, or equal but the
-	 * next digit is > 7 (or 8), the number is too big, and we will
-	 * return a range error.
-	 *
-	 * Set any if any `digits' consumed; make it negative to indicate
-	 * overflow.
-	 */
-	qbase = (unsigned)base;
-	cutoff = neg ? (unsigned jim_wide)-(LLONG_MIN + LLONG_MAX) + LLONG_MAX
-	    : LLONG_MAX;
-	cutlim = (int)(cutoff % qbase);
-	cutoff /= qbase;
-	for (acc = 0, any = 0;; c = *s++) {
-		if (!isascii(c))
-			break;
-		if (isdigit(c))
-			c -= '0';
-		else if (isalpha(c))
-			c -= isupper(c) ? 'A' - 10 : 'a' - 10;
-		else
-			break;
-		if (c >= base)
-			break;
-		if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
-			any = -1;
-		else {
-			any = 1;
-			acc *= qbase;
-			acc += c;
-		}
-	}
-	if (any < 0) {
-		acc = neg ? LLONG_MIN : LLONG_MAX;
-		errno = ERANGE;
-	} else if (neg)
-		acc = -acc;
-	if (endptr != 0)
-		*endptr = (char *)(any ? s - 1 : nptr);
-	return (acc);
+    register const char *s;
+    register unsigned jim_wide acc;
+    register unsigned char c;
+    register unsigned jim_wide qbase, cutoff;
+    register int neg, any, cutlim;
+
+    /*
+     * Skip white space and pick up leading +/- sign if any.
+     * If base is 0, allow 0x for hex and 0 for octal, else
+     * assume decimal; if base is already 16, allow 0x.
+     */
+    s = nptr;
+    do {
+        c = *s++;
+    } while (isspace(c));
+    if (c == '-') {
+        neg = 1;
+        c = *s++;
+    } else {
+        neg = 0;
+        if (c == '+')
+            c = *s++;
+    }
+    if ((base == 0 || base == 16) &&
+        c == '0' && (*s == 'x' || *s == 'X')) {
+        c = s[1];
+        s += 2;
+        base = 16;
+    }
+    if (base == 0)
+        base = c == '0' ? 8 : 10;
+
+    /*
+     * Compute the cutoff value between legal numbers and illegal
+     * numbers.  That is the largest legal value, divided by the
+     * base.  An input number that is greater than this value, if
+     * followed by a legal input character, is too big.  One that
+     * is equal to this value may be valid or not; the limit
+     * between valid and invalid numbers is then based on the last
+     * digit.  For instance, if the range for quads is
+     * [-9223372036854775808..9223372036854775807] and the input base
+     * is 10, cutoff will be set to 922337203685477580 and cutlim to
+     * either 7 (neg==0) or 8 (neg==1), meaning that if we have
+     * accumulated a value > 922337203685477580, or equal but the
+     * next digit is > 7 (or 8), the number is too big, and we will
+     * return a range error.
+     *
+     * Set any if any `digits' consumed; make it negative to indicate
+     * overflow.
+     */
+    qbase = (unsigned)base;
+    cutoff = neg ? (unsigned jim_wide)-(LLONG_MIN + LLONG_MAX) + LLONG_MAX
+        : LLONG_MAX;
+    cutlim = (int)(cutoff % qbase);
+    cutoff /= qbase;
+    for (acc = 0, any = 0;; c = *s++) {
+        if (!isascii(c))
+            break;
+        if (isdigit(c))
+            c -= '0';
+        else if (isalpha(c))
+            c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+        else
+            break;
+        if (c >= base)
+            break;
+        if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
+            any = -1;
+        else {
+            any = 1;
+            acc *= qbase;
+            acc += c;
+        }
+    }
+    if (any < 0) {
+        acc = neg ? LLONG_MIN : LLONG_MAX;
+        errno = ERANGE;
+    } else if (neg)
+        acc = -acc;
+    if (endptr != 0)
+        *endptr = (char *)(any ? s - 1 : nptr);
+    return (acc);
 }
 #endif
 
 /* Glob-style pattern matching. */
 int Jim_StringMatch(char *pattern, char *string, int nocase)
 {
-	while(pattern[0]) {
-		switch(pattern[0]) {
-		case '*':
-			while (pattern[1] == '*')
-				pattern++;
-			if (pattern[1] == '\0')
-				return 1; /* match */
-			while(string[0]) {
-				if (Jim_StringMatch(pattern+1, string, nocase))
-					return 1; /* match */
-				string++;
-			}
-			return 0; /* no match */
-			break;
-		case '?':
-			if (string[0] == '\0')
-				return 0; /* no match */
-			string++;
-			break;
-		case '[':
-		{
-			int not, match;
-
-			pattern++;
-			not = pattern[0] == '^';
-			if (not) pattern++;
-			match = 0;
-			while(1) {
-				if (pattern[0] == '\\') {
-					pattern++;
-					if (pattern[0] == string[0])
-						match = 1;
-				} else if (pattern[0] == ']') {
-					break;
-				} else if (pattern[0] == '\0') {
-					pattern--;
-					break;
-				} else if (pattern[1] == '-' &&
-					   pattern[2] != '\0') {
-					int start = pattern[0];
-					int end = pattern[2];
-					int c = string[0];
-					if (start > end) {
-						int t = start;
-						start = end;
-						end = t;
-					}
-					if (nocase) {
-						start = tolower(start);
-						end = tolower(end);
-						c = tolower(c);
-					}
-					pattern += 2;
-					if (c >= start && c <= end)
-						match = 1;
-				} else {
-					if (!nocase) {
-						if (pattern[0] == string[0])
-							match = 1;
-					} else {
-						if (tolower((int)pattern[0]) == 
-						    tolower((int)string[0]))
-							match = 1;
-					}
-				}
-				pattern++;
-			}
-			if (not)
-				match = !match;
-			if (!match)
-				return 0; /* no match */
-			string++;
-			break;
-		}
-		case '\\':
-			if (pattern[1] != '\0')
-				pattern++;
-			/* fall through */
-		default:
-			if (!nocase) {
-				if (pattern[0] != string[0])
-					return 0; /* no match */
-			} else {
-				if (tolower(pattern[0]) !=
-				    tolower(string[0]))
-					return 0; /* no match */
-			}
-			string++;
-			break;
-		}
-		pattern++;
-		if (string[0] == '\0') {
-			while(*pattern == '*')
-				pattern++;
-			break;
-		}
-	}
-	if (pattern[0] == '\0' &&
-			string[0] == '\0')
-		return 1;
-	return 0;
+    while(pattern[0]) {
+        switch(pattern[0]) {
+        case '*':
+            while (pattern[1] == '*')
+                pattern++;
+            if (pattern[1] == '\0')
+                return 1; /* match */
+            while(string[0]) {
+                if (Jim_StringMatch(pattern+1, string, nocase))
+                    return 1; /* match */
+                string++;
+            }
+            return 0; /* no match */
+            break;
+        case '?':
+            if (string[0] == '\0')
+                return 0; /* no match */
+            string++;
+            break;
+        case '[':
+        {
+            int not, match;
+
+            pattern++;
+            not = pattern[0] == '^';
+            if (not) pattern++;
+            match = 0;
+            while(1) {
+                if (pattern[0] == '\\') {
+                    pattern++;
+                    if (pattern[0] == string[0])
+                        match = 1;
+                } else if (pattern[0] == ']') {
+                    break;
+                } else if (pattern[0] == '\0') {
+                    pattern--;
+                    break;
+                } else if (pattern[1] == '-' &&
+                       pattern[2] != '\0') {
+                    int start = pattern[0];
+                    int end = pattern[2];
+                    int c = string[0];
+                    if (start > end) {
+                        int t = start;
+                        start = end;
+                        end = t;
+                    }
+                    if (nocase) {
+                        start = tolower(start);
+                        end = tolower(end);
+                        c = tolower(c);
+                    }
+                    pattern += 2;
+                    if (c >= start && c <= end)
+                        match = 1;
+                } else {
+                    if (!nocase) {
+                        if (pattern[0] == string[0])
+                            match = 1;
+                    } else {
+                        if (tolower((int)pattern[0]) == 
+                            tolower((int)string[0]))
+                            match = 1;
+                    }
+                }
+                pattern++;
+            }
+            if (not)
+                match = !match;
+            if (!match)
+                return 0; /* no match */
+            string++;
+            break;
+        }
+        case '\\':
+            if (pattern[1] != '\0')
+                pattern++;
+            /* fall through */
+        default:
+            if (!nocase) {
+                if (pattern[0] != string[0])
+                    return 0; /* no match */
+            } else {
+                if (tolower(pattern[0]) !=
+                    tolower(string[0]))
+                    return 0; /* no match */
+            }
+            string++;
+            break;
+        }
+        pattern++;
+        if (string[0] == '\0') {
+            while(*pattern == '*')
+                pattern++;
+            break;
+        }
+    }
+    if (pattern[0] == '\0' &&
+            string[0] == '\0')
+        return 1;
+    return 0;
 }
 
 int testGlobMatching(void)
 {
-	char buf[1024];
-	char *str = "hello worldo";
-	
-	printf("string: %s\n", str);
-	while(1) {
-		int len;
-
-		printf("pattern> ");
-		if (fgets(buf, 1024, stdin) == NULL) return 0;
-		len = strlen(buf);
-		if (len && buf[len-1] == '\n') {
-			buf[len-1] = '\0';
-		}
-		printf("%d\n", Jim_StringMatch(buf, str, 0));
-	}
-	return 0;
+    char buf[1024];
+    char *str = "hello worldo";
+    
+    printf("string: %s\n", str);
+    while(1) {
+        int len;
+
+        printf("pattern> ");
+        if (fgets(buf, 1024, stdin) == NULL) return 0;
+        len = strlen(buf);
+        if (len && buf[len-1] == '\n') {
+            buf[len-1] = '\0';
+        }
+        printf("%d\n", Jim_StringMatch(buf, str, 0));
+    }
+    return 0;
 }
 
 int Jim_WideToString(char *buf, jim_wide wideValue)
 {
 #ifdef HAVE_LONG_LONG
-	const char *fmt = "%" JIM_LL_MODIFIER;
-	return sprintf(buf, fmt, wideValue);
+    const char *fmt = "%" JIM_LL_MODIFIER;
+    return sprintf(buf, fmt, wideValue);
 #else
-	return sprintf(buf, "%ld", wideValue);
+    return sprintf(buf, "%ld", wideValue);
 #endif
 }
 
 int Jim_StringToWide(char *str, jim_wide *widePtr, int base)
 {
-	char *endptr;
+    char *endptr;
 
 #ifdef HAVE_LONG_LONG
-	*widePtr = Jim_Strtoll(str, &endptr, base);
+    *widePtr = Jim_Strtoll(str, &endptr, base);
 #else
-	*widePtr = strtol(str, &endptr, base);
+    *widePtr = strtol(str, &endptr, base);
 #endif
-	if (str[0] == '\0')
-		return JIM_ERR;
-	if (endptr[0] != '\0') {
-		while(*endptr) {
-			if (!isspace((int)*endptr))
-				return JIM_ERR;
-			endptr++;
-		}
-	}
-	return JIM_OK;
+    if (str[0] == '\0')
+        return JIM_ERR;
+    if (endptr[0] != '\0') {
+        while(*endptr) {
+            if (!isspace((int)*endptr))
+                return JIM_ERR;
+            endptr++;
+        }
+    }
+    return JIM_OK;
 }
 
 int Jim_StringToIndex(char *str, int *intPtr)
 {
-	char *endptr;
-
-	*intPtr = strtol(str, &endptr, 10);
-	if (str[0] == '\0')
-		return JIM_ERR;
-	if (endptr[0] != '\0') {
-		while(*endptr) {
-			if (!isspace((int)*endptr))
-				return JIM_ERR;
-			endptr++;
-		}
-	}
-	return JIM_OK;
+    char *endptr;
+
+    *intPtr = strtol(str, &endptr, 10);
+    if (str[0] == '\0')
+        return JIM_ERR;
+    if (endptr[0] != '\0') {
+        while(*endptr) {
+            if (!isspace((int)*endptr))
+                return JIM_ERR;
+            endptr++;
+        }
+    }
+    return JIM_OK;
 }
 
 /* The string representation of references has two features in order
@@ -345,44 +345,44 @@ int Jim_StringToIndex(char *str, int *intPtr)
 int Jim_WideToReferenceString(char *buf, jim_wide wideValue)
 {
 #ifdef HAVE_LONG_LONG
-	const char *fmt = "~reference:%020" JIM_LL_MODIFIER ":";
-	sprintf(buf, fmt, wideValue);
+    const char *fmt = "~reference:%020" JIM_LL_MODIFIER ":";
+    sprintf(buf, fmt, wideValue);
 #else
-	sprintf(buf, "~reference:%020ld:", wideValue);
+    sprintf(buf, "~reference:%020ld:", wideValue);
 #endif
-	return JIM_REFERENCE_SPACE;
+    return JIM_REFERENCE_SPACE;
 }
 
 int Jim_DoubleToString(char *buf, double doubleValue)
 {
-	char *s;
-	int len;
-
-	len = sprintf(buf, "%.17g", doubleValue);
-	s = buf;
-	while(*s) {
-		if (*s == '.') return len;
-		s++;
-	}
-	/* Add a final ".0" if it's a number. But not
-	 * for NaN or InF */
-	if (isdigit((int)buf[0])) {
-		s[0] = '.';
-		s[1] = '0';
-		s[2] = '\0';
-		return len+2;
-	}
-	return len;
+    char *s;
+    int len;
+
+    len = sprintf(buf, "%.17g", doubleValue);
+    s = buf;
+    while(*s) {
+        if (*s == '.') return len;
+        s++;
+    }
+    /* Add a final ".0" if it's a number. But not
+     * for NaN or InF */
+    if (isdigit((int)buf[0])) {
+        s[0] = '.';
+        s[1] = '0';
+        s[2] = '\0';
+        return len+2;
+    }
+    return len;
 }
 
 int Jim_StringToDouble(char *str, double *doublePtr)
 {
-	char *endptr;
+    char *endptr;
 
-	*doublePtr = strtod(str, &endptr);
-	if (str[0] == '\0' || endptr[0] != '\0')
-		return JIM_ERR;
-	return JIM_OK;
+    *doublePtr = strtod(str, &endptr);
+    if (str[0] == '\0' || endptr[0] != '\0')
+        return JIM_ERR;
+    return JIM_OK;
 }
 
 /* -----------------------------------------------------------------------------
@@ -390,28 +390,28 @@ int Jim_StringToDouble(char *str, double *doublePtr)
  * ---------------------------------------------------------------------------*/
 void Jim_Panic(char *fmt, ...)
 {
-	va_list ap;
+    va_list ap;
 
-	va_start(ap, fmt);
-	fprintf(stderr, "\nJIM INTERPRETER PANIC: ");
-	vfprintf(stderr, fmt, ap);
-	fprintf(stderr, "\n\n");
-	va_end(ap);
+    va_start(ap, fmt);
+    fprintf(stderr, "\nJIM INTERPRETER PANIC: ");
+    vfprintf(stderr, fmt, ap);
+    fprintf(stderr, "\n\n");
+    va_end(ap);
 #ifdef HAVE_BACKTRACE
-	{
-		void *array[40];
-		int size, i;
-		char **strings;
-
-		size = backtrace(array, 40);
-		strings = backtrace_symbols(array, size);
-		for (i = 0; i < size; i++)
-			printf("[backtrace] %s\n", strings[i]);
-		printf("[backtrace] Include the above lines and the output\n");
-		printf("[backtrace] of 'nm <executable>' in the bug report.\n");
-	}
+    {
+        void *array[40];
+        int size, i;
+        char **strings;
+
+        size = backtrace(array, 40);
+        strings = backtrace_symbols(array, size);
+        for (i = 0; i < size; i++)
+            printf("[backtrace] %s\n", strings[i]);
+        printf("[backtrace] Include the above lines and the output\n");
+        printf("[backtrace] of 'nm <executable>' in the bug report.\n");
+    }
 #endif
-	abort();
+    abort();
 }
 
 /* -----------------------------------------------------------------------------
@@ -420,35 +420,35 @@ void Jim_Panic(char *fmt, ...)
 
 void *Jim_Alloc(int size)
 {
-	void *p = malloc(size);
-	if (p == NULL)
-		Jim_Panic("Out of memory");
-	return p;
+    void *p = malloc(size);
+    if (p == NULL)
+        Jim_Panic("Out of memory");
+    return p;
 }
 
 void *Jim_Realloc(void *ptr, int size)
 {
-	void *p = realloc(ptr, size);
-	if (p == NULL)
-		Jim_Panic("Out of memory");
-	return p;
+    void *p = realloc(ptr, size);
+    if (p == NULL)
+        Jim_Panic("Out of memory");
+    return p;
 }
 
 char *Jim_StrDup(char *s)
 {
-	int l = strlen(s);
-	char *copy = Jim_Alloc(l+1);
+    int l = strlen(s);
+    char *copy = Jim_Alloc(l+1);
 
-	memcpy(copy, s, l+1);
-	return copy;
+    memcpy(copy, s, l+1);
+    return copy;
 }
 
 char *Jim_StrDupLen(char *s, int l)
 {
-	char *copy = Jim_Alloc(l+1);
-	
-	memcpy(copy, s, l+1);
-	return copy;
+    char *copy = Jim_Alloc(l+1);
+    
+    memcpy(copy, s, l+1);
+    return copy;
 }
 
 /* -----------------------------------------------------------------------------
@@ -457,9 +457,9 @@ char *Jim_StrDupLen(char *s, int l)
 /* Returns microseconds of CPU used since start. */
 static long Jim_Clock(void)
 {
-	clock_t clocks = clock();
+    clock_t clocks = clock();
 
-	return (long)(clocks*(1000000/CLOCKS_PER_SEC));
+    return (long)(clocks*(1000000/CLOCKS_PER_SEC));
 }
 
 /* -----------------------------------------------------------------------------
@@ -476,60 +476,60 @@ static int Jim_InsertHashEntry(Jim_HashTable *ht, void *key);
 /* Thomas Wang's 32 bit Mix Function */
 unsigned int Jim_IntHashFunction(unsigned int key)
 {
-	key += ~(key << 15);
-	key ^=  (key >> 10);
-	key +=  (key << 3);
-	key ^=  (key >> 6);
-	key += ~(key << 11);
-	key ^=  (key >> 16);
-	return key;
+    key += ~(key << 15);
+    key ^=  (key >> 10);
+    key +=  (key << 3);
+    key ^=  (key >> 6);
+    key += ~(key << 11);
+    key ^=  (key >> 16);
+    return key;
 }
 
 /* Identity hash function for integer keys */
 unsigned int Jim_IdentityHashFunction(unsigned int key)
 {
-	return key;
+    return key;
 }
 
 /* The djb hash function, that's under public domain */
 unsigned int Jim_DjbHashFunction(unsigned char *buf, int len)
 {
-	unsigned int h = 5381;
-	while(len--)
-		h = (h + (h << 5)) ^ *buf++;
-	return h;
+    unsigned int h = 5381;
+    while(len--)
+        h = (h + (h << 5)) ^ *buf++;
+    return h;
 }
 
 unsigned int Jim_RightDbjHashFunction(unsigned char *buf, int len)
 {
-	unsigned int h = 5381;
-	buf += len-1;
-	while(len--)
-		h = (h + (h << 5)) ^ *buf--;
-	return h;
+    unsigned int h = 5381;
+    buf += len-1;
+    while(len--)
+        h = (h + (h << 5)) ^ *buf--;
+    return h;
 }
 
 /* Another simple hash function mixing bit rotation and addition */
 #define ROT32R(x,n) (((x)>>(n))|((x)<<(32-(n))))
 unsigned int Jim_RotHashFunction(unsigned char *buf, int len)
 {
-	unsigned int h = 0;
-	while(len--) {
-		h = h + *buf++;
-		h = ROT32R(h, 3);
-	}
-	return h;
+    unsigned int h = 0;
+    while(len--) {
+        h = h + *buf++;
+        h = ROT32R(h, 3);
+    }
+    return h;
 }
 
 unsigned int Jim_RightRotHashFunction(unsigned char *buf, int len)
 {
-	unsigned int h = 0;
-	buf += len-1;
-	while(len--) {
-		h = h + *buf--;
-		h = ROT32R(h, 3);
-	}
-	return h;
+    unsigned int h = 0;
+    buf += len-1;
+    while(len--) {
+        h = h + *buf--;
+        h = ROT32R(h, 3);
+    }
+    return h;
 }
 
 /* ----------------------------- API implementation ------------------------- */
@@ -537,223 +537,223 @@ unsigned int Jim_RightRotHashFunction(unsigned char *buf, int len)
  * NOTE: This function should only called by ht_destroy(). */
 static void Jim_ResetHashTable(Jim_HashTable *ht)
 {
-	ht->table = NULL;
-	ht->size = 0;
-	ht->sizemask = 0;
-	ht->used = 0;
-	ht->collisions = 0;
+    ht->table = NULL;
+    ht->size = 0;
+    ht->sizemask = 0;
+    ht->used = 0;
+    ht->collisions = 0;
 }
 
 /* Initialize the hash table */
 int Jim_InitHashTable(Jim_HashTable *ht, Jim_HashTableType *type,
-		void *privDataPtr)
+        void *privDataPtr)
 {
-	Jim_ResetHashTable(ht);
-	ht->type = type;
-	ht->privdata = privDataPtr;
-	return JIM_OK;
+    Jim_ResetHashTable(ht);
+    ht->type = type;
+    ht->privdata = privDataPtr;
+    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;
+    int minimal = ht->used;
 
-	if (minimal < JIM_HT_INITIAL_SIZE)
-		minimal = JIM_HT_INITIAL_SIZE;
-	return Jim_ExpandHashTable(ht, minimal);
+    if (minimal < JIM_HT_INITIAL_SIZE)
+        minimal = JIM_HT_INITIAL_SIZE;
+    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 */
-	unsigned int realsize = Jim_HashTableNextPower(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;
-
-	Jim_InitHashTable(&n, ht->type, ht->privdata);
-	n.size = realsize;
-	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++) {
-		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;
+    Jim_HashTable n; /* the new hashtable */
+    unsigned int realsize = Jim_HashTableNextPower(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;
+
+    Jim_InitHashTable(&n, ht->type, ht->privdata);
+    n.size = realsize;
+    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++) {
+        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, void *key, void *val)
 {
-	int index;
-	Jim_HashEntry *entry;
+    int index;
+    Jim_HashEntry *entry;
 
-	/* Get the index of the new element, or -1 if
-	 * the element already exists. */
-	if ((index = Jim_InsertHashEntry(ht, key)) == -1)
-		return JIM_ERR;
+    /* Get the index of the new element, or -1 if
+     * the element already exists. */
+    if ((index = Jim_InsertHashEntry(ht, key)) == -1)
+        return JIM_ERR;
 
-	/* Allocates the memory and stores key */
-	entry = Jim_Alloc(sizeof(*entry));
-	entry->next = ht->table[index];
-	ht->table[index] = entry;
+    /* Allocates the memory and stores key */
+    entry = Jim_Alloc(sizeof(*entry));
+    entry->next = ht->table[index];
+    ht->table[index] = entry;
 
-	/* Set the hash entry fields. */
-	Jim_SetHashKey(ht, entry, key);
-	Jim_SetHashVal(ht, entry, val);
-	ht->used++;
-	return JIM_OK;
+    /* 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, void *key, void *val)
 {
-	Jim_HashEntry *entry;
+    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;
+    /* 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, void *key)
 {
-	unsigned int h;
-	Jim_HashEntry *he, *prevHe;
-
-	if (ht->size == 0)
-		return JIM_ERR;
-	h = Jim_HashKey(ht, key) & ht->sizemask;
-	he = ht->table[h];
-
-	prevHe = NULL;
-	while(he) {
-		if (Jim_CompareHashKeys(ht, key, he->key)) {
-			/* Unlink the element from the list */
-			if (prevHe)
-				prevHe->next = he->next;
-			else
-				ht->table[h] = he->next;
-			Jim_FreeEntryKey(ht, he);
-			Jim_FreeEntryVal(ht, he);
-			Jim_Free(he);
-			ht->used--;
-			return JIM_OK;
-		}
-		prevHe = he;
-		he = he->next;
-	}
-	return JIM_ERR; /* not found */
+    unsigned int h;
+    Jim_HashEntry *he, *prevHe;
+
+    if (ht->size == 0)
+        return JIM_ERR;
+    h = Jim_HashKey(ht, key) & ht->sizemask;
+    he = ht->table[h];
+
+    prevHe = NULL;
+    while(he) {
+        if (Jim_CompareHashKeys(ht, key, he->key)) {
+            /* Unlink the element from the list */
+            if (prevHe)
+                prevHe->next = he->next;
+            else
+                ht->table[h] = he->next;
+            Jim_FreeEntryKey(ht, he);
+            Jim_FreeEntryVal(ht, he);
+            Jim_Free(he);
+            ht->used--;
+            return JIM_OK;
+        }
+        prevHe = he;
+        he = he->next;
+    }
+    return JIM_ERR; /* not found */
 }
 
 /* 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++) {
-		Jim_HashEntry *he, *nextHe;
-
-		if ((he = ht->table[i]) == NULL) continue;
-		while(he) {
-			nextHe = he->next;
-			Jim_FreeEntryKey(ht, he);
-			Jim_FreeEntryVal(ht, he);
-			Jim_Free(he);
-			ht->used--;
-			he = nextHe;
-		}
-	}
-	/* Free the table and the allocated cache structure */
-	Jim_Free(ht->table);
-	/* Re-initialize the table */
-	Jim_ResetHashTable(ht);
-	return JIM_OK; /* never fails */
+    unsigned int i;
+
+    /* Free all the elements */
+    for (i = 0; i < ht->size && ht->used > 0; i++) {
+        Jim_HashEntry *he, *nextHe;
+
+        if ((he = ht->table[i]) == NULL) continue;
+        while(he) {
+            nextHe = he->next;
+            Jim_FreeEntryKey(ht, he);
+            Jim_FreeEntryVal(ht, he);
+            Jim_Free(he);
+            ht->used--;
+            he = nextHe;
+        }
+    }
+    /* Free the table and the allocated cache structure */
+    Jim_Free(ht->table);
+    /* Re-initialize the table */
+    Jim_ResetHashTable(ht);
+    return JIM_OK; /* never fails */
 }
 
 Jim_HashEntry *Jim_FindHashEntry(Jim_HashTable *ht, void *key)
 {
-	Jim_HashEntry *he;
-	unsigned int h;
+    Jim_HashEntry *he;
+    unsigned int h;
 
-	if (ht->size == 0) return NULL;
-	h = Jim_HashKey(ht, key) & ht->sizemask;
-	he = ht->table[h];
-	while(he) {
-		if (Jim_CompareHashKeys(ht, key, he->key))
-			return he;
-		he = he->next;
-	}
-	return NULL;
+    if (ht->size == 0) return NULL;
+    h = Jim_HashKey(ht, key) & ht->sizemask;
+    he = ht->table[h];
+    while(he) {
+        if (Jim_CompareHashKeys(ht, key, he->key))
+            return he;
+        he = he->next;
+    }
+    return NULL;
 }
 
 Jim_HashTableIterator *Jim_GetHashTableIterator(Jim_HashTable *ht)
 {
-	Jim_HashTableIterator *iterator = Jim_Alloc(sizeof(*iterator));
+    Jim_HashTableIterator *iterator = Jim_Alloc(sizeof(*iterator));
 
-	iterator->ht = ht;
-	iterator->index = -1;
-	iterator->entry = NULL;
-	return iterator;
+    iterator->ht = ht;
+    iterator->index = -1;
+    iterator->entry = NULL;
+    return iterator;
 }
 
 Jim_HashEntry *Jim_NextHashEntry(Jim_HashTableIterator *iterator)
 {
-	while (1) {
-		if (iterator->entry == NULL) {
-			iterator->index++;
-			if (iterator->index >=
-					(signed)iterator->ht->size) break;
-			iterator->entry = iterator->ht->table[iterator->index];
-		} else {
-			iterator->entry = iterator->entry->next;
-		}
-		if (iterator->entry)
-			return iterator->entry;
-	}
-	return NULL;
+    while (1) {
+        if (iterator->entry == NULL) {
+            iterator->index++;
+            if (iterator->index >=
+                    (signed)iterator->ht->size) break;
+            iterator->entry = iterator->ht->table[iterator->index];
+        } else {
+            iterator->entry = iterator->entry->next;
+        }
+        if (iterator->entry)
+            return iterator->entry;
+    }
+    return NULL;
 }
 
 /* ------------------------- private functions ------------------------------ */
@@ -761,27 +761,27 @@ Jim_HashEntry *Jim_NextHashEntry(Jim_HashTableIterator *iterator)
 /* Expand the hash table if needed */
 static int Jim_ExpandHashTableIfNeeded(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)
-		return Jim_ExpandHashTable(ht, ht->size*2);
-	return JIM_OK;
+    /* 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)
+        return Jim_ExpandHashTable(ht, ht->size*2);
+    return JIM_OK;
 }
 
 /* Our hash table capability is a power of two */
 static unsigned int Jim_HashTableNextPower(unsigned int size)
 {
-	unsigned int i = 256;
+    unsigned int i = 256;
 
-	if (size >= 2147483648U)
-		return 2147483648U;
-	while(1) {
-		if (i >= size)
-			return i;
-		i *= 2;
-	}
+    if (size >= 2147483648U)
+        return 2147483648U;
+    while(1) {
+        if (i >= size)
+            return i;
+        i *= 2;
+    }
 }
 
 /* Returns the index of a free slot that can be populated with
@@ -789,90 +789,90 @@ static unsigned int Jim_HashTableNextPower(unsigned int size)
  * If the key already exists, -1 is returned. */
 static int Jim_InsertHashEntry(Jim_HashTable *ht, void *key)
 {
-	unsigned int h;
-	Jim_HashEntry *he;
-
-	/* Expand the hashtable if needed */
-	if (Jim_ExpandHashTableIfNeeded(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))
-			return -1;
-		he = he->next;
-	}
-	return h;
+    unsigned int h;
+    Jim_HashEntry *he;
+
+    /* Expand the hashtable if needed */
+    if (Jim_ExpandHashTableIfNeeded(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))
+            return -1;
+        he = he->next;
+    }
+    return h;
 }
 
 /* ----------------------- StringCopy Hash Table Type ------------------------*/
 
 unsigned int Jim_StringCopyHT_HashFunction(void *key)
 {
-	return Jim_DjbHashFunction(key, strlen(key));
+    return Jim_DjbHashFunction(key, strlen(key));
 }
 
 void *Jim_StringCopyHT_KeyDup(void *privdata, void *key)
 {
-	int len = strlen(key);
-	char *copy = Jim_Alloc(len+1);
-	privdata = privdata; /* not used */
+    int len = strlen(key);
+    char *copy = Jim_Alloc(len+1);
+    privdata = privdata; /* not used */
 
-	memcpy(copy, key, len);
-	copy[len] = '\0';
-	return copy;
+    memcpy(copy, key, len);
+    copy[len] = '\0';
+    return copy;
 }
 
 int Jim_StringCopyHT_KeyCompare(void *privdata, void *key1, void *key2)
 {
-	privdata = privdata; /* not used */
+    privdata = privdata; /* not used */
 
-	return strcmp(key1, key2) == 0;
+    return strcmp(key1, key2) == 0;
 }
 
 void Jim_StringCopyHT_KeyDestructor(void *privdata, void *key)
 {
-	privdata = privdata; /* not used */
+    privdata = privdata; /* not used */
 
-	Jim_Free(key);
+    Jim_Free(key);
 }
-	
+    
 static Jim_HashTableType Jim_StringCopyHashTableType = {
-	Jim_StringCopyHT_HashFunction,		/* hash function */
-	Jim_StringCopyHT_KeyDup,		/* key dup */
-	NULL,					/* val dup */
-	Jim_StringCopyHT_KeyCompare,		/* key compare */
-	Jim_StringCopyHT_KeyDestructor,		/* key destructor */
-	NULL					/* val destructor */
+    Jim_StringCopyHT_HashFunction,        /* hash function */
+    Jim_StringCopyHT_KeyDup,        /* key dup */
+    NULL,                    /* val dup */
+    Jim_StringCopyHT_KeyCompare,        /* key compare */
+    Jim_StringCopyHT_KeyDestructor,        /* key destructor */
+    NULL                    /* val destructor */
 };
 
 /* This is like StringCopy but does not auto-duplicate the key.
  * It's used for intepreter's shared strings. */
 static Jim_HashTableType Jim_SharedStringsHashTableType = {
-	Jim_StringCopyHT_HashFunction,		/* hash function */
-	NULL,					/* key dup */
-	NULL,					/* val dup */
-	Jim_StringCopyHT_KeyCompare,		/* key compare */
-	Jim_StringCopyHT_KeyDestructor,		/* key destructor */
-	NULL					/* val destructor */
+    Jim_StringCopyHT_HashFunction,        /* hash function */
+    NULL,                    /* key dup */
+    NULL,                    /* val dup */
+    Jim_StringCopyHT_KeyCompare,        /* key compare */
+    Jim_StringCopyHT_KeyDestructor,        /* key destructor */
+    NULL                    /* val destructor */
 };
 
 /* --------------------------- Int Hash Table Type ---------------------------*/
 unsigned int Jim_IntHT_HashFunction(void *key)
 {
-	return Jim_IntHashFunction((unsigned int)key);
+    return Jim_IntHashFunction((unsigned int)key);
 }
 
 #if 0
 static Jim_HashTableType Jim_IntHashTableType = {
-	Jim_IntHT_HashFunction,			/* hash function */
-	NULL,					/* key dup */
-	NULL,					/* val dup */
-	NULL,					/* key compare */
-	NULL,					/* key destructor */
-	NULL					/* val destructor */
+    Jim_IntHT_HashFunction,            /* hash function */
+    NULL,                    /* key dup */
+    NULL,                    /* val dup */
+    NULL,                    /* key compare */
+    NULL,                    /* key destructor */
+    NULL                    /* val destructor */
 };
 #endif
 
@@ -880,38 +880,38 @@ static Jim_HashTableType Jim_IntHashTableType = {
 
 int testHashTable(void)
 {
-	Jim_HashTable t;
-	Jim_HashTableIterator *iterator;
-	Jim_HashEntry *entry;
-	int i;
-
-	Jim_InitHashTable(&t, &Jim_StringCopyHashTableType, NULL);
-	Jim_AddHashEntry(&t, "foo", "bar");
-	Jim_AddHashEntry(&t, "ciao", "foobar");
-	Jim_AddHashEntry(&t, "a", "1");
-	Jim_AddHashEntry(&t, "b", "2");
-	Jim_AddHashEntry(&t, "c", "3");
-	printf("Used: %d, Size: %d\n", t.used, t.size);
-
-	iterator = Jim_GetHashTableIterator(&t);
-	while ((entry = Jim_NextHashEntry(iterator))) {
-		printf("%s -> %s\n", (char*)entry->key, (char*)entry->val);
-	}
-	Jim_FreeHashTableIterator(iterator);
-	Jim_FreeHashTable(&t);
-
-
-	Jim_InitHashTable(&t, &Jim_StringCopyHashTableType, NULL);
-	for (i = 0; i < 150000; i++) {
-		char buf[64];
-		sprintf(buf, "%d", i);
-		Jim_AddHashEntry(&t, (void*)buf, (void*)i);
-	}
-	printf("Size: %d\n", Jim_GetHashTableSize(&t));
-	printf("Used: %d\n", Jim_GetHashTableUsed(&t));
-	printf("Collisions: %d\n", Jim_GetHashTableCollisions(&t));
-	Jim_FreeHashTable(&t);
-	return 0;
+    Jim_HashTable t;
+    Jim_HashTableIterator *iterator;
+    Jim_HashEntry *entry;
+    int i;
+
+    Jim_InitHashTable(&t, &Jim_StringCopyHashTableType, NULL);
+    Jim_AddHashEntry(&t, "foo", "bar");
+    Jim_AddHashEntry(&t, "ciao", "foobar");
+    Jim_AddHashEntry(&t, "a", "1");
+    Jim_AddHashEntry(&t, "b", "2");
+    Jim_AddHashEntry(&t, "c", "3");
+    printf("Used: %d, Size: %d\n", t.used, t.size);
+
+    iterator = Jim_GetHashTableIterator(&t);
+    while ((entry = Jim_NextHashEntry(iterator))) {
+        printf("%s -> %s\n", (char*)entry->key, (char*)entry->val);
+    }
+    Jim_FreeHashTableIterator(iterator);
+    Jim_FreeHashTable(&t);
+
+
+    Jim_InitHashTable(&t, &Jim_StringCopyHashTableType, NULL);
+    for (i = 0; i < 150000; i++) {
+        char buf[64];
+        sprintf(buf, "%d", i);
+        Jim_AddHashEntry(&t, (void*)buf, (void*)i);
+    }
+    printf("Size: %d\n", Jim_GetHashTableSize(&t));
+    printf("Used: %d\n", Jim_GetHashTableUsed(&t));
+    printf("Collisions: %d\n", Jim_GetHashTableCollisions(&t));
+    Jim_FreeHashTable(&t);
+    return 0;
 }
 
 /* -----------------------------------------------------------------------------
@@ -919,57 +919,57 @@ int testHashTable(void)
  * example in the 'expr' expression compiler.
  * ---------------------------------------------------------------------------*/
 typedef struct Jim_Stack {
-	int len;
-	int maxlen;
-	void **vector;
+    int len;
+    int maxlen;
+    void **vector;
 } Jim_Stack;
 
 void Jim_InitStack(Jim_Stack *stack)
 {
-	stack->len = 0;
-	stack->maxlen = 0;
-	stack->vector = NULL;
+    stack->len = 0;
+    stack->maxlen = 0;
+    stack->vector = NULL;
 }
 
 void Jim_FreeStack(Jim_Stack *stack)
 {
-	Jim_Free(stack->vector);
+    Jim_Free(stack->vector);
 }
 
 int Jim_StackLen(Jim_Stack *stack)
 {
-	return stack->len;
+    return stack->len;
 }
 
 void Jim_StackPush(Jim_Stack *stack, void *element) {
-	int neededLen = stack->len+1;
-	if (neededLen > stack->maxlen) {
-		stack->maxlen = neededLen*2;
-		stack->vector = Jim_Realloc(stack->vector, sizeof(void*)*stack->maxlen);
-	}
-	stack->vector[stack->len] = element;
-	stack->len++;
+    int neededLen = stack->len+1;
+    if (neededLen > stack->maxlen) {
+        stack->maxlen = neededLen*2;
+        stack->vector = Jim_Realloc(stack->vector, sizeof(void*)*stack->maxlen);
+    }
+    stack->vector[stack->len] = element;
+    stack->len++;
 }
 
 void *Jim_StackPop(Jim_Stack *stack)
 {
-	if (stack->len == 0) return NULL;
-	stack->len--;
-	return stack->vector[stack->len];
+    if (stack->len == 0) return NULL;
+    stack->len--;
+    return stack->vector[stack->len];
 }
 
 void *Jim_StackPeek(Jim_Stack *stack)
 {
-	if (stack->len == 0) return NULL;
-	return stack->vector[stack->len-1];
+    if (stack->len == 0) return NULL;
+    return stack->vector[stack->len-1];
 }
 
 void Jim_FreeStackElements(Jim_Stack *stack, void (*freeFunc)(void *ptr))
 {
-	int i;
+    int i;
 
-	for (i = 0; i < stack->len; i++)
-		freeFunc(stack->vector[i]);
+    for (i = 0; i < stack->len; i++)
+        freeFunc(stack->vector[i]);
 }
 
 /* -----------------------------------------------------------------------------
@@ -977,14 +977,14 @@ void Jim_FreeStackElements(Jim_Stack *stack, void (*freeFunc)(void *ptr))
  * ---------------------------------------------------------------------------*/
 
 /* Token types */
-#define JIM_TT_NONE -1		/* No token returned */
-#define JIM_TT_STR 0		/* simple string */
-#define JIM_TT_ESC 1		/* string that needs escape chars conversion */
-#define JIM_TT_VAR 2		/* var substitution */
-#define JIM_TT_DICTSUGAR 3	/* Syntax sugar for [dict get], $foo(bar) */
-#define JIM_TT_CMD 4		/* command substitution */
-#define JIM_TT_SEP 5		/* word separator */
-#define JIM_TT_EOL 6		/* line separator */
+#define JIM_TT_NONE -1        /* No token returned */
+#define JIM_TT_STR 0        /* simple string */
+#define JIM_TT_ESC 1        /* string that needs escape chars conversion */
+#define JIM_TT_VAR 2        /* var substitution */
+#define JIM_TT_DICTSUGAR 3    /* Syntax sugar for [dict get], $foo(bar) */
+#define JIM_TT_CMD 4        /* command substitution */
+#define JIM_TT_SEP 5        /* word separator */
+#define JIM_TT_EOL 6        /* line separator */
 
 /* Additional token types needed for expressions */
 #define JIM_TT_SUBEXPR_START 7
@@ -993,22 +993,22 @@ void Jim_FreeStackElements(Jim_Stack *stack, void (*freeFunc)(void *ptr))
 #define JIM_TT_EXPR_OPERATOR 10
 
 /* Parser states */
-#define JIM_PS_DEF 0		/* Default state */
-#define JIM_PS_QUOTE 1		/* Inside "" */
+#define JIM_PS_DEF 0        /* Default state */
+#define JIM_PS_QUOTE 1        /* Inside "" */
 
 /* Parser context structure. The same context is used both to parse
  * Tcl scripts and lists. */
 struct JimParserCtx {
-	char *prg;	/* Program text */
-	char *p;	/* Pointer to the point of the program we are parsing */
-	int linenr;	/* Current line number */
-	char *tstart;
-	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 *prg;    /* Program text */
+    char *p;    /* Pointer to the point of the program we are parsing */
+    int linenr;    /* Current line number */
+    char *tstart;
+    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. */
 };
 
 #define JimParserEof(c) ((c)->eof)
@@ -1026,342 +1026,342 @@ static int JimParseBrace(struct JimParserCtx *pc);
 static int JimParseStr(struct JimParserCtx *pc);
 static int JimParseComment(struct JimParserCtx *pc);
 static char *JimParserGetToken(struct JimParserCtx *pc,
-		int *lenPtr, int *typePtr, int *linePtr);
+        int *lenPtr, int *typePtr, int *linePtr);
 
 /* 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. */
 void JimParserInit(struct JimParserCtx *pc, char *prg, int linenr)
 {
-	pc->prg = prg;
-	pc->p = prg;
-	pc->tstart = NULL;
-	pc->tend = NULL;
-	pc->tline = 0;
-	pc->tt = JIM_TT_NONE;
-	pc->eof = 0;
-	pc->state = JIM_PS_DEF;
-	pc->linenr = linenr;
-	pc->comment = 1;
+    pc->prg = prg;
+    pc->p = prg;
+    pc->tstart = NULL;
+    pc->tend = NULL;
+    pc->tline = 0;
+    pc->tt = JIM_TT_NONE;
+    pc->eof = 0;
+    pc->state = JIM_PS_DEF;
+    pc->linenr = linenr;
+    pc->comment = 1;
 }
 
 int JimParseScript(struct JimParserCtx *pc)
 {
-	while(1) { /* the while is used to reiterate with continue if needed */
-		switch(*(pc->p)) {
-		case '\0':
-			pc->tstart = pc->tend = pc->p;
-			pc->tline = pc->linenr;
-			pc->tt = JIM_TT_EOL;
-			pc->eof = 1;
-			break;
-		case '\\':
-			if (*(pc->p+1) == '\n')
-				return JimParseSep(pc);
-			else {
-				pc->comment = 0;
-				return JimParseStr(pc);
-			}
-			break;
-		case ' ':
-		case '\t':
-		case '\r':
-			if (pc->state == JIM_PS_DEF)
-				return JimParseSep(pc);
-			else {
-				pc->comment = 0;
-				return JimParseStr(pc);
-			}
-			break;
-		case '\n':
-		case ';':
-			pc->comment = 1;
-			if (pc->state == JIM_PS_DEF)
-				return JimParseEol(pc);
-			else
-				return JimParseStr(pc);
-			break;
-		case '[':
-			pc->comment = 0;
-			return JimParseCmd(pc);
-			break;
-		case '$':
-			pc->comment = 0;
-			if (JimParseVar(pc) == JIM_ERR) {
-				pc->tstart = pc->tend = pc->p++;
-				pc->tline = pc->linenr;
-				pc->tt = JIM_TT_STR;
-				return JIM_OK;
-			} else
-				return JIM_OK;
-			break;
-		case '#':
-			if (pc->comment) {
-				JimParseComment(pc);
-				continue;
-			} else {
-				return JimParseStr(pc);
-			}
-		default:
-			pc->comment = 0;
-			return JimParseStr(pc);
-			break;
-		}
-		return JIM_OK;
-	}
+    while(1) { /* the while is used to reiterate with continue if needed */
+        switch(*(pc->p)) {
+        case '\0':
+            pc->tstart = pc->tend = pc->p;
+            pc->tline = pc->linenr;
+            pc->tt = JIM_TT_EOL;
+            pc->eof = 1;
+            break;
+        case '\\':
+            if (*(pc->p+1) == '\n')
+                return JimParseSep(pc);
+            else {
+                pc->comment = 0;
+                return JimParseStr(pc);
+            }
+            break;
+        case ' ':
+        case '\t':
+        case '\r':
+            if (pc->state == JIM_PS_DEF)
+                return JimParseSep(pc);
+            else {
+                pc->comment = 0;
+                return JimParseStr(pc);
+            }
+            break;
+        case '\n':
+        case ';':
+            pc->comment = 1;
+            if (pc->state == JIM_PS_DEF)
+                return JimParseEol(pc);
+            else
+                return JimParseStr(pc);
+            break;
+        case '[':
+            pc->comment = 0;
+            return JimParseCmd(pc);
+            break;
+        case '$':
+            pc->comment = 0;
+            if (JimParseVar(pc) == JIM_ERR) {
+                pc->tstart = pc->tend = pc->p++;
+                pc->tline = pc->linenr;
+                pc->tt = JIM_TT_STR;
+                return JIM_OK;
+            } else
+                return JIM_OK;
+            break;
+        case '#':
+            if (pc->comment) {
+                JimParseComment(pc);
+                continue;
+            } else {
+                return JimParseStr(pc);
+            }
+        default:
+            pc->comment = 0;
+            return JimParseStr(pc);
+            break;
+        }
+        return JIM_OK;
+    }
 }
 
 int JimParseSep(struct JimParserCtx *pc)
 {
-	pc->tstart = pc->p;
-	pc->tline = pc->linenr;
-	while (*pc->p == ' ' || *pc->p == '\t' || *pc->p == '\r' ||
-	       (*pc->p == '\\' && *(pc->p+1) == '\n')) {
-		if (*pc->p == '\\') {
-			pc->p++;
-			pc->linenr++;
-		}
-		pc->p++;
-	}
-	pc->tend = pc->p-1;
-	pc->tt = JIM_TT_SEP;
-	return JIM_OK;
+    pc->tstart = pc->p;
+    pc->tline = pc->linenr;
+    while (*pc->p == ' ' || *pc->p == '\t' || *pc->p == '\r' ||
+           (*pc->p == '\\' && *(pc->p+1) == '\n')) {
+        if (*pc->p == '\\') {
+            pc->p++;
+            pc->linenr++;
+        }
+        pc->p++;
+    }
+    pc->tend = pc->p-1;
+    pc->tt = JIM_TT_SEP;
+    return JIM_OK;
 }
 
 int JimParseEol(struct JimParserCtx *pc)
 {
-	pc->tstart = pc->p;
-	pc->tline = pc->linenr;
-	while (*pc->p == ' ' || *pc->p == '\n' ||
-	       *pc->p == '\t' || *pc->p == '\r' ||
-	       *pc->p == ';') {
-		if (*pc->p == '\n')
-			pc->linenr++;
-		pc->p++;
-	}
-	pc->tend = pc->p-1;
-	pc->tt = JIM_TT_EOL;
-	return JIM_OK;
+    pc->tstart = pc->p;
+    pc->tline = pc->linenr;
+    while (*pc->p == ' ' || *pc->p == '\n' ||
+           *pc->p == '\t' || *pc->p == '\r' ||
+           *pc->p == ';') {
+        if (*pc->p == '\n')
+            pc->linenr++;
+        pc->p++;
+    }
+    pc->tend = pc->p-1;
+    pc->tt = JIM_TT_EOL;
+    return JIM_OK;
 }
 
 /* Todo. Don't stop if ']' appears inside {} or quoted.
  * Also should handle the case of puts [string length "]"] */
 int JimParseCmd(struct JimParserCtx *pc)
 {
-	int level = 1;
-	int blevel = 0;
-
-	pc->tstart = ++pc->p;
-	pc->tline = pc->linenr;
-	while (1) {
-		if (*pc->p == '[' && blevel == 0)
-			level++;
-		else if (*pc->p == ']' && blevel == 0) {
-			level--;
-			if (!level) break;
-		} else if (*pc->p == '\\') {
-			pc->p++;
-		} else if (*pc->p == '{') {
-			blevel++;
-		} else if (*pc->p == '}') {
-			if (blevel != 0)
-				blevel--;
-		} else if (*pc->p == '\0') {
-			break;
-		} else if (*pc->p == '\n')
-			pc->linenr++;
-		pc->p++;
-	}
-	pc->tend = pc->p-1;
-	pc->tt = JIM_TT_CMD;
-	if (*pc->p == ']') pc->p++;
-	return JIM_OK;
+    int level = 1;
+    int blevel = 0;
+
+    pc->tstart = ++pc->p;
+    pc->tline = pc->linenr;
+    while (1) {
+        if (*pc->p == '[' && blevel == 0)
+            level++;
+        else if (*pc->p == ']' && blevel == 0) {
+            level--;
+            if (!level) break;
+        } else if (*pc->p == '\\') {
+            pc->p++;
+        } else if (*pc->p == '{') {
+            blevel++;
+        } else if (*pc->p == '}') {
+            if (blevel != 0)
+                blevel--;
+        } else if (*pc->p == '\0') {
+            break;
+        } else if (*pc->p == '\n')
+            pc->linenr++;
+        pc->p++;
+    }
+    pc->tend = pc->p-1;
+    pc->tt = JIM_TT_CMD;
+    if (*pc->p == ']') pc->p++;
+    return JIM_OK;
 }
 
 int JimParseVar(struct JimParserCtx *pc)
 {
-	int brace = 0, stop = 0, ttype = JIM_TT_VAR;
-
-	pc->tstart = ++pc->p; /* skip the $ */
-	pc->tline = pc->linenr;
-	if (*pc->p == '{') {
-		pc->tstart = ++pc->p;
-		brace = 1;
-	}
-	if (brace) {
-		while (!stop) {
-			if (*pc->p == '}' || *pc->p == '\0') {
-				stop = 1;
-				if (*pc->p == '\0')
-					continue;
-			}
-			else if (*pc->p == '\n')
-				pc->linenr++;
-			pc->p++;
-		}
-		if (*pc->p == '\0')
-			pc->tend = pc->p-1;
-		else
-			pc->tend = pc->p-2;
-	} else {
-		while (!stop) {
-			if (!((*pc->p >= 'a' && *pc->p <= 'z') ||
-			    (*pc->p >= 'A' && *pc->p <= 'Z') ||
-			    (*pc->p >= '0' && *pc->p <= '9') ||
-			    *pc->p == '_'))
-				stop = 1;
-			else
-				pc->p++;
-		}
-		/* Parse [dict get] syntax sugar. */
-		if (*pc->p == '(') {
-			while (*pc->p != ')' && *pc->p != '\0') {
-				pc->p++;
-				if (*pc->p == '\\' && *(pc->p+1) != '\0')
-					pc->p+=2;
-			}
-			if (*pc->p != '\0')
-				pc->p++;
-			ttype = JIM_TT_DICTSUGAR;
-		}
-		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--;
-		return JIM_ERR;
-	}
-	pc->tt = ttype;
-	return JIM_OK;
+    int brace = 0, stop = 0, ttype = JIM_TT_VAR;
+
+    pc->tstart = ++pc->p; /* skip the $ */
+    pc->tline = pc->linenr;
+    if (*pc->p == '{') {
+        pc->tstart = ++pc->p;
+        brace = 1;
+    }
+    if (brace) {
+        while (!stop) {
+            if (*pc->p == '}' || *pc->p == '\0') {
+                stop = 1;
+                if (*pc->p == '\0')
+                    continue;
+            }
+            else if (*pc->p == '\n')
+                pc->linenr++;
+            pc->p++;
+        }
+        if (*pc->p == '\0')
+            pc->tend = pc->p-1;
+        else
+            pc->tend = pc->p-2;
+    } else {
+        while (!stop) {
+            if (!((*pc->p >= 'a' && *pc->p <= 'z') ||
+                (*pc->p >= 'A' && *pc->p <= 'Z') ||
+                (*pc->p >= '0' && *pc->p <= '9') ||
+                *pc->p == '_'))
+                stop = 1;
+            else
+                pc->p++;
+        }
+        /* Parse [dict get] syntax sugar. */
+        if (*pc->p == '(') {
+            while (*pc->p != ')' && *pc->p != '\0') {
+                pc->p++;
+                if (*pc->p == '\\' && *(pc->p+1) != '\0')
+                    pc->p+=2;
+            }
+            if (*pc->p != '\0')
+                pc->p++;
+            ttype = JIM_TT_DICTSUGAR;
+        }
+        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--;
+        return JIM_ERR;
+    }
+    pc->tt = ttype;
+    return JIM_OK;
 }
 
 int JimParseBrace(struct JimParserCtx *pc)
 {
-	int level = 1;
-
-	pc->tstart = ++pc->p;
-	pc->tline = pc->linenr;
-	while (1) {
-		if (*pc->p == '\\' && *(pc->p+1) != '\0') {
-			pc->p++;
-			if (*pc->p == '\n')
-				pc->linenr++;
-		} else if (*pc->p == '{') {
-			level++;
-		} else if (*pc->p == '\0' || *pc->p == '}') {
-			level--;
-			if (*pc->p == '\0' || level == 0) {
-				pc->tend = pc->p-1;
-				if (*pc->p != '\0') pc->p++;
-				pc->tt = JIM_TT_STR;
-				return JIM_OK;
-			}
-		} else if (*pc->p == '\n') {
-			pc->linenr++;
-		}
-		pc->p++;
-	}
-	return JIM_OK; /* unreached */
+    int level = 1;
+
+    pc->tstart = ++pc->p;
+    pc->tline = pc->linenr;
+    while (1) {
+        if (*pc->p == '\\' && *(pc->p+1) != '\0') {
+            pc->p++;
+            if (*pc->p == '\n')
+                pc->linenr++;
+        } else if (*pc->p == '{') {
+            level++;
+        } else if (*pc->p == '\0' || *pc->p == '}') {
+            level--;
+            if (*pc->p == '\0' || level == 0) {
+                pc->tend = pc->p-1;
+                if (*pc->p != '\0') pc->p++;
+                pc->tt = JIM_TT_STR;
+                return JIM_OK;
+            }
+        } else if (*pc->p == '\n') {
+            pc->linenr++;
+        }
+        pc->p++;
+    }
+    return JIM_OK; /* unreached */
 }
 
 int JimParseStr(struct JimParserCtx *pc)
 {
-	int newword = (pc->tt == JIM_TT_SEP || pc->tt == JIM_TT_EOL ||
-			pc->tt == JIM_TT_NONE || pc->tt == JIM_TT_STR);
-	if (newword && *pc->p == '{') {
-		return JimParseBrace(pc);
-	} else if (newword && *pc->p == '"') {
-		pc->state = JIM_PS_QUOTE;
-		pc->p++;
-	}
-	pc->tstart = pc->p;
-	pc->tline = pc->linenr;
-	while (1) {
-		switch(*pc->p) {
-		case '\\':
-			if (pc->state == JIM_PS_DEF &&
-			    *(pc->p+1) == '\n') {
-				pc->tend = pc->p-1;
-				pc->tt = JIM_TT_ESC;
-				return JIM_OK;
-			}
-			if (*(pc->p+1) != '\0') pc->p++;
-			break;
-		case '$':
-		case '[':
-		case '\0':
-			pc->tend = pc->p-1;
-			pc->tt = JIM_TT_ESC;
-			return JIM_OK;
-		case ' ':
-		case '\t':
-		case '\n':
-		case '\r':
-		case ';':
-			if (pc->state == JIM_PS_DEF) {
-				pc->tend = pc->p-1;
-				pc->tt = JIM_TT_ESC;
-				return JIM_OK;
-			} else if (*pc->p == '\n') {
-				pc->linenr++;
-			}
-			break;
-		case '"':
-			if (pc->state == JIM_PS_QUOTE) {
-				pc->tend = pc->p-1;
-				pc->tt = JIM_TT_ESC;
-				pc->p++;
-				pc->state = JIM_PS_DEF;
-				return JIM_OK;
-			}
-			break;
-		}
-		pc->p++;
-	}
-	return JIM_OK; /* unreached */
+    int newword = (pc->tt == JIM_TT_SEP || pc->tt == JIM_TT_EOL ||
+            pc->tt == JIM_TT_NONE || pc->tt == JIM_TT_STR);
+    if (newword && *pc->p == '{') {
+        return JimParseBrace(pc);
+    } else if (newword && *pc->p == '"') {
+        pc->state = JIM_PS_QUOTE;
+        pc->p++;
+    }
+    pc->tstart = pc->p;
+    pc->tline = pc->linenr;
+    while (1) {
+        switch(*pc->p) {
+        case '\\':
+            if (pc->state == JIM_PS_DEF &&
+                *(pc->p+1) == '\n') {
+                pc->tend = pc->p-1;
+                pc->tt = JIM_TT_ESC;
+                return JIM_OK;
+            }
+            if (*(pc->p+1) != '\0') pc->p++;
+            break;
+        case '$':
+        case '[':
+        case '\0':
+            pc->tend = pc->p-1;
+            pc->tt = JIM_TT_ESC;
+            return JIM_OK;
+        case ' ':
+        case '\t':
+        case '\n':
+        case '\r':
+        case ';':
+            if (pc->state == JIM_PS_DEF) {
+                pc->tend = pc->p-1;
+                pc->tt = JIM_TT_ESC;
+                return JIM_OK;
+            } else if (*pc->p == '\n') {
+                pc->linenr++;
+            }
+            break;
+        case '"':
+            if (pc->state == JIM_PS_QUOTE) {
+                pc->tend = pc->p-1;
+                pc->tt = JIM_TT_ESC;
+                pc->p++;
+                pc->state = JIM_PS_DEF;
+                return JIM_OK;
+            }
+            break;
+        }
+        pc->p++;
+    }
+    return JIM_OK; /* unreached */
 }
 
 int JimParseComment(struct JimParserCtx *pc)
 {
-	while (*pc->p) {
-		if (*pc->p == '\n') {
-			pc->linenr++;
-			if (*(pc->p-1) != '\\') {
-				pc->p++;
-				return JIM_OK;
-			}
-		}
-		pc->p++;
-	}
-	return JIM_OK;
+    while (*pc->p) {
+        if (*pc->p == '\n') {
+            pc->linenr++;
+            if (*(pc->p-1) != '\\') {
+                pc->p++;
+                return JIM_OK;
+            }
+        }
+        pc->p++;
+    }
+    return JIM_OK;
 }
 
 /* xdigitval and odigitval are helper functions for JimParserGetToken() */
 static int xdigitval(int c)
 {
-	switch(c) {
-	case '0': return 0; case '1': return 1; case '2': return 2;
-	case '3': return 3; case '4': return 4; case '5': return 5;
-	case '6': return 6; case '7': return 7; case '8': return 8;
-	case '9': return 9; case 'A': case 'a': return 10;
-	case 'B': case 'b': return 11; case 'C': case 'c': return 12;
-	case 'D': case 'd': return 13; case 'E': case 'e': return 14;
-	case 'F': case 'f': return 15;
-	}
-	return -1;
+    switch(c) {
+    case '0': return 0; case '1': return 1; case '2': return 2;
+    case '3': return 3; case '4': return 4; case '5': return 5;
+    case '6': return 6; case '7': return 7; case '8': return 8;
+    case '9': return 9; case 'A': case 'a': return 10;
+    case 'B': case 'b': return 11; case 'C': case 'c': return 12;
+    case 'D': case 'd': return 13; case 'E': case 'e': return 14;
+    case 'F': case 'f': return 15;
+    }
+    return -1;
 }
 
 static int odigitval(int c)
 {
-	switch(c) {
-	case '0': return 0; case '1': return 1; case '2': return 2;
-	case '3': return 3; case '4': return 4; case '5': return 5;
-	case '6': return 6; case '7': return 7;
-	}
-	return -1;
+    switch(c) {
+    case '0': return 0; case '1': return 1; case '2': return 2;
+    case '3': return 3; case '4': return 4; case '5': return 5;
+    case '6': return 6; case '7': return 7;
+    }
+    return -1;
 }
 
 /* Perform Tcl escape substitution of 's', storing the result
@@ -1373,82 +1373,82 @@ static int odigitval(int c)
  * The function returns the length of the resulting string. */
 static int Jim_Escape(char *dest, char *s, int slen)
 {
-	char *p = dest;
-	int i, len;
-	
-	if (slen == -1)
-		slen = strlen(s);
-
-	for (i = 0; i < slen; i++) {
-		switch(s[i]) {
-		case '\\':
-			switch(s[i+1]) {
-			case 'a': *p++ = 0x7; i++; break;
-			case 'b': *p++ = 0x8; i++; break;
-			case 'f': *p++ = 0xc; i++; break;
-			case 'n': *p++ = 0xa; i++; break;
-			case 'r': *p++ = 0xd; i++; break;
-			case 't': *p++ = 0x9; i++; break;
-			case 'v': *p++ = 0xb; i++; break;
-			case '\0': *p++ = '\\'; i++; break;
-			case '\n': *p++ = ' '; i++; break;
-			default:
-				  if (s[i+1] == 'x') {
-					int val = 0;
-					int c = xdigitval(s[i+2]);
-					if (c == -1) {
-						*p++ = 'x';
-						i++;
-						break;
-					}
-					val = c;
-					c = xdigitval(s[i+3]);
-					if (c == -1) {
-						*p++ = val;
-						i += 2;
-						break;
-					}
-					val = (val*16)+c;
-					*p++ = val;
-					i += 3;
-					break;
-				  } else if (s[i+1] >= '0' &&
-					     s[i+1] <= '7')
-				  {
-					int val = 0;
-					int c = odigitval(s[i+1]);
-					val = c;
-					c = odigitval(s[i+2]);
-					if (c == -1) {
-						*p++ = val;
-						i ++;
-						break;
-					}
-					val = (val*8)+c;
-					c = odigitval(s[i+3]);
-					if (c == -1) {
-						*p++ = val;
-						i += 2;
-						break;
-					}
-					val = (val*8)+c;
-					*p++ = val;
-					i += 3;
-				  } else {
-					*p++ = s[i+1];
-					i++;
-				  }
-				  break;
-			}
-			break;
-		default:
-			*p++ = s[i];
-			break;
-		}
-	}
-	len = p-dest;
-	*p++ = '\0';
-	return len;
+    char *p = dest;
+    int i, len;
+    
+    if (slen == -1)
+        slen = strlen(s);
+
+    for (i = 0; i < slen; i++) {
+        switch(s[i]) {
+        case '\\':
+            switch(s[i+1]) {
+            case 'a': *p++ = 0x7; i++; break;
+            case 'b': *p++ = 0x8; i++; break;
+            case 'f': *p++ = 0xc; i++; break;
+            case 'n': *p++ = 0xa; i++; break;
+            case 'r': *p++ = 0xd; i++; break;
+            case 't': *p++ = 0x9; i++; break;
+            case 'v': *p++ = 0xb; i++; break;
+            case '\0': *p++ = '\\'; i++; break;
+            case '\n': *p++ = ' '; i++; break;
+            default:
+                  if (s[i+1] == 'x') {
+                    int val = 0;
+                    int c = xdigitval(s[i+2]);
+                    if (c == -1) {
+                        *p++ = 'x';
+                        i++;
+                        break;
+                    }
+                    val = c;
+                    c = xdigitval(s[i+3]);
+                    if (c == -1) {
+                        *p++ = val;
+                        i += 2;
+                        break;
+                    }
+                    val = (val*16)+c;
+                    *p++ = val;
+                    i += 3;
+                    break;
+                  } else if (s[i+1] >= '0' &&
+                         s[i+1] <= '7')
+                  {
+                    int val = 0;
+                    int c = odigitval(s[i+1]);
+                    val = c;
+                    c = odigitval(s[i+2]);
+                    if (c == -1) {
+                        *p++ = val;
+                        i ++;
+                        break;
+                    }
+                    val = (val*8)+c;
+                    c = odigitval(s[i+3]);
+                    if (c == -1) {
+                        *p++ = val;
+                        i += 2;
+                        break;
+                    }
+                    val = (val*8)+c;
+                    *p++ = val;
+                    i += 3;
+                  } else {
+                    *p++ = s[i+1];
+                    i++;
+                  }
+                  break;
+            }
+            break;
+        default:
+            *p++ = s[i];
+            break;
+        }
+    }
+    len = p-dest;
+    *p++ = '\0';
+    return len;
 }
 
 /* Returns a dynamically allocated copy of the current token in the
@@ -1472,33 +1472,33 @@ static int Jim_Escape(char *dest, char *s, int slen)
  * will return as first token "expand", of type JIM_TT_ESC
  */
 char *JimParserGetToken(struct JimParserCtx *pc,
-		int *lenPtr, int *typePtr, int *linePtr)
-{
-	char *start, *end, *token;
-	int len;
-
-	start = JimParserTstart(pc);
-	end = JimParserTend(pc);
-	if (start > end) {
-		if (lenPtr) *lenPtr = 0;
-		if (typePtr) *typePtr = JimParserTtype(pc);
-		if (linePtr) *linePtr = JimParserTline(pc);
-		return JimEmptyStringRep;
-	}
-	len = (end-start)+1;
-	token = Jim_Alloc(len+1);
-	if (JimParserTtype(pc) != JIM_TT_ESC) {
-		/* No escape conversion needed? Just copy it. */
-		memcpy(token, start, len);
-		token[len] = '\0';
-	} else {
-		/* Else convert the escape chars. */
-		len = Jim_Escape(token, start, len);
-	}
-	if (lenPtr) *lenPtr = len;
-	if (typePtr) *typePtr = JimParserTtype(pc);
-	if (linePtr) *linePtr = JimParserTline(pc);
-	return token;
+        int *lenPtr, int *typePtr, int *linePtr)
+{
+    char *start, *end, *token;
+    int len;
+
+    start = JimParserTstart(pc);
+    end = JimParserTend(pc);
+    if (start > end) {
+        if (lenPtr) *lenPtr = 0;
+        if (typePtr) *typePtr = JimParserTtype(pc);
+        if (linePtr) *linePtr = JimParserTline(pc);
+        return JimEmptyStringRep;
+    }
+    len = (end-start)+1;
+    token = Jim_Alloc(len+1);
+    if (JimParserTtype(pc) != JIM_TT_ESC) {
+        /* No escape conversion needed? Just copy it. */
+        memcpy(token, start, len);
+        token[len] = '\0';
+    } else {
+        /* Else convert the escape chars. */
+        len = Jim_Escape(token, start, len);
+    }
+    if (lenPtr) *lenPtr = len;
+    if (typePtr) *typePtr = JimParserTtype(pc);
+    if (linePtr) *linePtr = JimParserTline(pc);
+    return token;
 }
 
 /* -----------------------------------------------------------------------------
@@ -1509,89 +1509,89 @@ static int JimParseListStr(struct JimParserCtx *pc);
 
 int JimParseList(struct JimParserCtx *pc)
 {
-	switch(*pc->p) {
-	case '\0':
-		pc->tstart = pc->tend = pc->p;
-		pc->tline = pc->linenr;
-		pc->tt = JIM_TT_EOL;
-		pc->eof = 1;
-		break;
-	case ' ':
-	case '\n':
-	case '\t':
-	case '\r':
-		if (pc->state == JIM_PS_DEF)
-			return JimParseListSep(pc);
-		else
-			return JimParseListStr(pc);
-		break;
-	default:
-		return JimParseListStr(pc);
-		break;
-	}
-	return JIM_OK;
+    switch(*pc->p) {
+    case '\0':
+        pc->tstart = pc->tend = pc->p;
+        pc->tline = pc->linenr;
+        pc->tt = JIM_TT_EOL;
+        pc->eof = 1;
+        break;
+    case ' ':
+    case '\n':
+    case '\t':
+    case '\r':
+        if (pc->state == JIM_PS_DEF)
+            return JimParseListSep(pc);
+        else
+            return JimParseListStr(pc);
+        break;
+    default:
+        return JimParseListStr(pc);
+        break;
+    }
+    return JIM_OK;
 }
 
 int JimParseListSep(struct JimParserCtx *pc)
 {
-	pc->tstart = pc->p;
-	pc->tline = pc->linenr;
-	while (*pc->p == ' ' || *pc->p == '\t' || *pc->p == '\r' ||
-	       *pc->p == '\n')
-	{
-		pc->p++;
-	}
-	pc->tend = pc->p-1;
-	pc->tt = JIM_TT_SEP;
-	return JIM_OK;
+    pc->tstart = pc->p;
+    pc->tline = pc->linenr;
+    while (*pc->p == ' ' || *pc->p == '\t' || *pc->p == '\r' ||
+           *pc->p == '\n')
+    {
+        pc->p++;
+    }
+    pc->tend = pc->p-1;
+    pc->tt = JIM_TT_SEP;
+    return JIM_OK;
 }
 
 int JimParseListStr(struct JimParserCtx *pc)
 {
-	int newword = (pc->tt == JIM_TT_SEP || pc->tt == JIM_TT_EOL ||
-			pc->tt == JIM_TT_NONE);
-	if (newword && *pc->p == '{') {
-		return JimParseBrace(pc);
-	} else if (newword && *pc->p == '"') {
-		pc->state = JIM_PS_QUOTE;
-		pc->p++;
-	}
-	pc->tstart = pc->p;
-	pc->tline = pc->linenr;
-	while (1) {
-		switch(*pc->p) {
-		case '\\':
-			pc->p++;
-			break;
-		case '\0':
-			pc->tend = pc->p-1;
-			pc->tt = JIM_TT_ESC;
-			return JIM_OK;
-		case ' ':
-		case '\t':
-		case '\n':
-		case '\r':
-			if (pc->state == JIM_PS_DEF) {
-				pc->tend = pc->p-1;
-				pc->tt = JIM_TT_ESC;
-				return JIM_OK;
-			} else if (*pc->p == '\n') {
-				pc->linenr++;
-			}
-			break;
-		case '"':
-			if (pc->state == JIM_PS_QUOTE) {
-				pc->tend = pc->p-1;
-				pc->tt = JIM_TT_ESC;
-				pc->p++;
-				pc->state = JIM_PS_DEF;
-				return JIM_OK;
-			}
-			break;
-		}
-		pc->p++;
-	}
-	return JIM_OK; /* unreached */
+    int newword = (pc->tt == JIM_TT_SEP || pc->tt == JIM_TT_EOL ||
+            pc->tt == JIM_TT_NONE);
+    if (newword && *pc->p == '{') {
+        return JimParseBrace(pc);
+    } else if (newword && *pc->p == '"') {
+        pc->state = JIM_PS_QUOTE;
+        pc->p++;
+    }
+    pc->tstart = pc->p;
+    pc->tline = pc->linenr;
+    while (1) {
+        switch(*pc->p) {
+        case '\\':
+            pc->p++;
+            break;
+        case '\0':
+            pc->tend = pc->p-1;
+            pc->tt = JIM_TT_ESC;
+            return JIM_OK;
+        case ' ':
+        case '\t':
+        case '\n':
+        case '\r':
+            if (pc->state == JIM_PS_DEF) {
+                pc->tend = pc->p-1;
+                pc->tt = JIM_TT_ESC;
+                return JIM_OK;
+            } else if (*pc->p == '\n') {
+                pc->linenr++;
+            }
+            break;
+        case '"':
+            if (pc->state == JIM_PS_QUOTE) {
+                pc->tend = pc->p-1;
+                pc->tt = JIM_TT_ESC;
+                pc->p++;
+                pc->state = JIM_PS_DEF;
+                return JIM_OK;
+            }
+            break;
+        }
+        pc->p++;
+    }
+    return JIM_OK; /* unreached */
 }
 
 /* -----------------------------------------------------------------------------
@@ -1600,47 +1600,47 @@ int JimParseListStr(struct JimParserCtx *pc)
 
 /* Free the internal representation of the object. */
 #define Jim_FreeIntRep(i,o) \
-	if ((o)->typePtr && (o)->typePtr->freeIntRepProc) \
-		(o)->typePtr->freeIntRepProc(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)
+    (o)->internalRep.ptr = (p)
 
 /* Return a new initialized object. */
 Jim_Obj *Jim_NewObj(Jim_Interp *interp)
 {
-	Jim_Obj *objPtr;
+    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));
-	}
+    /* -- 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 set they to the right
-	 * value anyway. */
+    /* 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 set they to the right
+     * value anyway. */
 
-	/* -- Put the object into the live list -- */
-	objPtr->prevObjPtr = NULL;
-	objPtr->nextObjPtr = interp->liveList;
-	if (interp->liveList)
-		interp->liveList->prevObjPtr = objPtr;
-	interp->liveList = objPtr;
+    /* -- Put the object into the live list -- */
+    objPtr->prevObjPtr = NULL;
+    objPtr->nextObjPtr = interp->liveList;
+    if (interp->liveList)
+        interp->liveList->prevObjPtr = objPtr;
+    interp->liveList = objPtr;
 
-	return objPtr;
+    return objPtr;
 }
 
 /* Free an object. Actually objects are never freed, but
@@ -1648,84 +1648,84 @@ Jim_Obj *Jim_NewObj(Jim_Interp *interp)
  * reused by Jim_NewObj(). */
 void Jim_FreeObj(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	/* Check if the object was already freed, panic. */
-	if (objPtr->refCount == -1)  {
-		Jim_Panic("Object %p double freed!", objPtr);
-	}
-	/* Free the string representation */
-	if (objPtr->bytes != NULL) {
-		if (objPtr->bytes != JimEmptyStringRep)
-			Jim_Free(objPtr->bytes);
-	}
-	/* Free the internal representation */
-	Jim_FreeIntRep(interp, objPtr);
-	/* 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)
-		interp->freeList->prevObjPtr = objPtr;
-	interp->freeList = objPtr;
-	objPtr->refCount = -1;
+    /* Check if the object was already freed, panic. */
+    if (objPtr->refCount == -1)  {
+        Jim_Panic("Object %p double freed!", objPtr);
+    }
+    /* Free the string representation */
+    if (objPtr->bytes != NULL) {
+        if (objPtr->bytes != JimEmptyStringRep)
+            Jim_Free(objPtr->bytes);
+    }
+    /* Free the internal representation */
+    Jim_FreeIntRep(interp, objPtr);
+    /* 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)
+        interp->freeList->prevObjPtr = objPtr;
+    interp->freeList = objPtr;
+    objPtr->refCount = -1;
 }
 
 /* Invalidate the string representation of an object. */
 void Jim_InvalidateStringRep(Jim_Obj *objPtr)
 {
-	if (objPtr->bytes != NULL) {
-		if (objPtr->bytes != JimEmptyStringRep)
-			Jim_Free(objPtr->bytes);
-	}
-	objPtr->bytes = NULL;
+    if (objPtr->bytes != NULL) {
+        if (objPtr->bytes != JimEmptyStringRep)
+            Jim_Free(objPtr->bytes);
+    }
+    objPtr->bytes = NULL;
 }
 
 #define Jim_SetStringRep(o, b, l) \
-	do { (o)->bytes = b; (o)->length = l; } while (0)
+    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, char *bytes, int length)
 {
-	if (length == 0) {
-		objPtr->bytes = JimEmptyStringRep;
-		objPtr->length = 0;
-	} else {
-		objPtr->bytes = Jim_Alloc(length+1);
-		objPtr->length = length;
-		memcpy(objPtr->bytes, bytes, length);
-		objPtr->bytes[length] = '\0';
-	}
+    if (length == 0) {
+        objPtr->bytes = JimEmptyStringRep;
+        objPtr->length = 0;
+    } else {
+        objPtr->bytes = Jim_Alloc(length+1);
+        objPtr->length = length;
+        memcpy(objPtr->bytes, bytes, length);
+        objPtr->bytes[length] = '\0';
+    }
 }
 
 /* Duplicate an object. */
 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);
-	}
-	if (objPtr->typePtr != NULL) {
-		if (objPtr->typePtr->dupIntRepProc == NULL) {
-			dupPtr->internalRep = objPtr->internalRep;
-		} else {
-			objPtr->typePtr->dupIntRepProc(interp, objPtr, dupPtr);
-		}
-		dupPtr->typePtr = objPtr->typePtr;
-	} else {
-		dupPtr->typePtr = NULL;
-	}
-	return dupPtr;
+    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);
+    }
+    if (objPtr->typePtr != NULL) {
+        if (objPtr->typePtr->dupIntRepProc == NULL) {
+            dupPtr->internalRep = objPtr->internalRep;
+        } else {
+            objPtr->typePtr->dupIntRepProc(interp, objPtr, dupPtr);
+        }
+        dupPtr->typePtr = objPtr->typePtr;
+    } else {
+        dupPtr->typePtr = NULL;
+    }
+    return dupPtr;
 }
 
 /* Return the string representation for objPtr. If the object
@@ -1733,17 +1733,17 @@ Jim_Obj *Jim_DuplicateObj(Jim_Interp *interp, Jim_Obj *objPtr)
  * a new one starting from the internal representation of the object. */
 char *Jim_GetString(Jim_Obj *objPtr, int *lenPtr)
 {
-	if (objPtr->bytes == NULL) {
-		/* Invalid string repr. Generate it. */
-		if (objPtr->typePtr->updateStringProc == NULL) {
-			Jim_Panic("UpdataStringProc called against '%s' type."
-					, objPtr->typePtr->name);
-		}
-		objPtr->typePtr->updateStringProc(objPtr);
-	}
-	if (lenPtr)
-		*lenPtr = objPtr->length;
-	return objPtr->bytes;
+    if (objPtr->bytes == NULL) {
+        /* Invalid string repr. Generate it. */
+        if (objPtr->typePtr->updateStringProc == NULL) {
+            Jim_Panic("UpdataStringProc called against '%s' type."
+                    , objPtr->typePtr->name);
+        }
+        objPtr->typePtr->updateStringProc(objPtr);
+    }
+    if (lenPtr)
+        *lenPtr = objPtr->length;
+    return objPtr->bytes;
 }
 
 /* -----------------------------------------------------------------------------
@@ -1753,164 +1753,164 @@ static void DupStringInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *d
 static int SetStringFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
 static Jim_ObjType stringObjType = {
-	"string",
-	NULL,
-	DupStringInternalRep,
-	NULL,
-	JIM_TYPE_REFERENCES,
+    "string",
+    NULL,
+    DupStringInternalRep,
+    NULL,
+    JIM_TYPE_REFERENCES,
 };
 
 void DupStringInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
 {
-	interp = interp; /* unused */
-	/* 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;
+    interp = interp; /* unused */
+    /* 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;
 }
 
 int SetStringFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	/* Get a fresh string representation. */
-	(void*) Jim_GetString(objPtr, NULL);
-	/* 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;
-	return JIM_OK;
+    /* Get a fresh string representation. */
+    (void*) Jim_GetString(objPtr, NULL);
+    /* 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;
+    return JIM_OK;
 }
 
 Jim_Obj *Jim_NewStringObj(Jim_Interp *interp, const char *s, int len)
 {
-	Jim_Obj *objPtr = Jim_NewObj(interp);
-
-	if (len == -1)
-		len = strlen(s);
-	/* Alloc/Set the string rep. */
-	if (len == 0) {
-		objPtr->bytes = JimEmptyStringRep;
-		objPtr->length = 0;
-	} else {
-		objPtr->bytes = Jim_Alloc(len+1);
-		objPtr->length = len;
-		memcpy(objPtr->bytes, s, len);
-		objPtr->bytes[len] = '\0';
-	}
+    Jim_Obj *objPtr = Jim_NewObj(interp);
+
+    if (len == -1)
+        len = strlen(s);
+    /* Alloc/Set the string rep. */
+    if (len == 0) {
+        objPtr->bytes = JimEmptyStringRep;
+        objPtr->length = 0;
+    } else {
+        objPtr->bytes = Jim_Alloc(len+1);
+        objPtr->length = len;
+        memcpy(objPtr->bytes, s, len);
+        objPtr->bytes[len] = '\0';
+    }
 
-	/* No typePtr field for the vanilla string object. */
-	objPtr->typePtr = NULL;
-	return objPtr;
+    /* No typePtr field for the vanilla string object. */
+    objPtr->typePtr = NULL;
+    return objPtr;
 }
 
 /* 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);
+    Jim_Obj *objPtr = Jim_NewObj(interp);
 
-	if (len == -1)
-		len = strlen(s);
-	Jim_SetStringRep(objPtr, s, len);
-	objPtr->typePtr = NULL;
-	return objPtr;
+    if (len == -1)
+        len = strlen(s);
+    Jim_SetStringRep(objPtr, s, len);
+    objPtr->typePtr = NULL;
+    return objPtr;
 }
 
 /* Low-level string append. Use it only against objects
  * of type "string". */
 void StringAppendString(Jim_Obj *objPtr, char *str, int len)
 {
-	int needlen;
-
-	if (len == -1)
-		len = strlen(str);
-	needlen = objPtr->length + len;
-	if (objPtr->internalRep.strValue.maxLength < needlen ||
-	    objPtr->internalRep.strValue.maxLength == 0) {
-		if (objPtr->bytes == JimEmptyStringRep) {
-			objPtr->bytes = Jim_Alloc((needlen*2)+1);
-		} else {
-			objPtr->bytes = Jim_Realloc(objPtr->bytes, (needlen*2)+1);
-		}
-		objPtr->internalRep.strValue.maxLength = needlen*2;
-	}
-	memcpy(objPtr->bytes + objPtr->length, str, len);
-	objPtr->bytes[objPtr->length+len] = '\0';
-	objPtr->length += len;
+    int needlen;
+
+    if (len == -1)
+        len = strlen(str);
+    needlen = objPtr->length + len;
+    if (objPtr->internalRep.strValue.maxLength < needlen ||
+        objPtr->internalRep.strValue.maxLength == 0) {
+        if (objPtr->bytes == JimEmptyStringRep) {
+            objPtr->bytes = Jim_Alloc((needlen*2)+1);
+        } else {
+            objPtr->bytes = Jim_Realloc(objPtr->bytes, (needlen*2)+1);
+        }
+        objPtr->internalRep.strValue.maxLength = needlen*2;
+    }
+    memcpy(objPtr->bytes + objPtr->length, str, len);
+    objPtr->bytes[objPtr->length+len] = '\0';
+    objPtr->length += len;
 }
 
 /* Low-level wrapper to append an object. */
 void StringAppendObj(Jim_Obj *objPtr, Jim_Obj *appendObjPtr)
 {
-	int len;
-	char *str;
+    int len;
+    char *str;
 
-	str = Jim_GetString(appendObjPtr, &len);
-	StringAppendString(objPtr, str, len);
+    str = Jim_GetString(appendObjPtr, &len);
+    StringAppendString(objPtr, str, len);
 }
 
 /* Higher level API to append strings to objects. */
 void Jim_AppendString(Jim_Interp *interp, Jim_Obj *objPtr, char *str, int len)
 {
-	if (Jim_IsShared(objPtr))
-		Jim_Panic("Jim_AppendString called with shared object");
-	if (objPtr->typePtr != &stringObjType)
-		SetStringFromAny(interp, objPtr);
-	StringAppendString(objPtr, str, len);
+    if (Jim_IsShared(objPtr))
+        Jim_Panic("Jim_AppendString called with shared object");
+    if (objPtr->typePtr != &stringObjType)
+        SetStringFromAny(interp, objPtr);
+    StringAppendString(objPtr, str, len);
 }
 
 void Jim_AppendObj(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *appendObjPtr)
 {
-	int len;
-	char *str;
+    int len;
+    char *str;
 
-	str = Jim_GetString(appendObjPtr, &len);
-	Jim_AppendString(interp, objPtr, str, len);
+    str = Jim_GetString(appendObjPtr, &len);
+    Jim_AppendString(interp, objPtr, str, len);
 }
 
 void Jim_AppendStrings(Jim_Interp *interp, Jim_Obj *objPtr, ...)
 {
-	va_list ap;
+    va_list ap;
 
-	if (objPtr->typePtr != &stringObjType)
-		SetStringFromAny(interp, objPtr);
-	va_start(ap, objPtr);
-	while (1) {
-		char *s = va_arg(ap, char*);
+    if (objPtr->typePtr != &stringObjType)
+        SetStringFromAny(interp, objPtr);
+    va_start(ap, objPtr);
+    while (1) {
+        char *s = va_arg(ap, char*);
 
-		if (s == NULL) break;
-		Jim_AppendString(interp, objPtr, s, -1);
-	}
-	va_end(ap);
+        if (s == NULL) break;
+        Jim_AppendString(interp, objPtr, s, -1);
+    }
+    va_end(ap);
 }
 
 int Jim_StringEqObj(Jim_Obj *aObjPtr, Jim_Obj *bObjPtr, int nocase)
 {
-	char *aStr, *bStr;
-	int aLen, bLen, i;
-
-	if (aObjPtr == bObjPtr) return 1;
-	aStr = Jim_GetString(aObjPtr, &aLen);
-	bStr = Jim_GetString(bObjPtr, &bLen);
-	if (aLen != bLen) return 0;
-	if (nocase == 0)
-		return memcmp(aStr, bStr, aLen) == 0;
-	for (i = 0; i < aLen; i++) {
-		if (tolower((int)aStr[i]) != tolower((int)bStr[i]))
-			return 0;
-	}
-	return 1;
+    char *aStr, *bStr;
+    int aLen, bLen, i;
+
+    if (aObjPtr == bObjPtr) return 1;
+    aStr = Jim_GetString(aObjPtr, &aLen);
+    bStr = Jim_GetString(bObjPtr, &bLen);
+    if (aLen != bLen) return 0;
+    if (nocase == 0)
+        return memcmp(aStr, bStr, aLen) == 0;
+    for (i = 0; i < aLen; i++) {
+        if (tolower((int)aStr[i]) != tolower((int)bStr[i]))
+            return 0;
+    }
+    return 1;
 }
 
 int Jim_StringMatchObj(Jim_Obj *patternObjPtr, Jim_Obj *objPtr, int nocase)
 {
-	char *pattern, *string;
+    char *pattern, *string;
 
-	pattern = Jim_GetString(patternObjPtr, NULL);
-	string = Jim_GetString(objPtr, NULL);
-	return Jim_StringMatch(pattern, string, nocase);
+    pattern = Jim_GetString(patternObjPtr, NULL);
+    string = Jim_GetString(objPtr, NULL);
+    return Jim_StringMatch(pattern, string, nocase);
 }
 
 /* Convert a range, as returned by Jim_GetRange(), into
@@ -1923,42 +1923,42 @@ int Jim_StringMatchObj(Jim_Obj *patternObjPtr, Jim_Obj *objPtr, int nocase)
  * it's set to 0. */
 int Jim_RelToAbsIndex(int len, int index, int *outOfRangePtr)
 {
-	if (outOfRangePtr) *outOfRangePtr = 0;
-	if (index >= len) {
-		index = len-1;
-		if (outOfRangePtr) *outOfRangePtr = 1;
-	}
-	else if (index < 0) {
-		index = len + index;
-		if (index < 0) {
-			index = 0;
-			if (outOfRangePtr) *outOfRangePtr = 1;
-		} else if (index >= len) {
-			index = len-1;
-			if (outOfRangePtr) *outOfRangePtr = 1;
-		}
-	}
-	return index;
+    if (outOfRangePtr) *outOfRangePtr = 0;
+    if (index >= len) {
+        index = len-1;
+        if (outOfRangePtr) *outOfRangePtr = 1;
+    }
+    else if (index < 0) {
+        index = len + index;
+        if (index < 0) {
+            index = 0;
+            if (outOfRangePtr) *outOfRangePtr = 1;
+        } else if (index >= len) {
+            index = len-1;
+            if (outOfRangePtr) *outOfRangePtr = 1;
+        }
+    }
+    return index;
 }
 
 Jim_Obj *Jim_StringRangeObj(Jim_Interp *interp,
-		Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr,
-		Jim_Obj *lastObjPtr)
+        Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr,
+        Jim_Obj *lastObjPtr)
 {
-	int first, last;
-	char *str;
-	int len, rangeLen;
+    int first, last;
+    char *str;
+    int len, rangeLen;
 
-	if (Jim_GetIndex(interp, firstObjPtr, &first) != JIM_OK ||
-	    Jim_GetIndex(interp, lastObjPtr, &last) != JIM_OK)
-		return NULL;
-	str = Jim_GetString(strObjPtr, &len);
-	first = Jim_RelToAbsIndex(len, first, NULL);
-	last = Jim_RelToAbsIndex(len, last, NULL);
-	rangeLen = last-first+1;
-	if (rangeLen < 0)
-		rangeLen = 0;
-	return Jim_NewStringObj(interp, str+first, rangeLen);
+    if (Jim_GetIndex(interp, firstObjPtr, &first) != JIM_OK ||
+        Jim_GetIndex(interp, lastObjPtr, &last) != JIM_OK)
+        return NULL;
+    str = Jim_GetString(strObjPtr, &len);
+    first = Jim_RelToAbsIndex(len, first, NULL);
+    last = Jim_RelToAbsIndex(len, last, NULL);
+    rangeLen = last-first+1;
+    if (rangeLen < 0)
+        rangeLen = 0;
+    return Jim_NewStringObj(interp, str+first, rangeLen);
 }
 
 /* -----------------------------------------------------------------------------
@@ -1977,11 +1977,11 @@ Jim_Obj *Jim_StringRangeObj(Jim_Interp *interp,
  * inside the C code. */
 
 static Jim_ObjType comparedStringObjType = {
-	"compared-string",
-	NULL,
-	NULL,
-	NULL,
-	JIM_TYPE_REFERENCES,
+    "compared-string",
+    NULL,
+    NULL,
+    NULL,
+    JIM_TYPE_REFERENCES,
 };
 
 /* The only way this object is exposed to the API is via the following
@@ -1989,19 +1989,19 @@ static Jim_ObjType comparedStringObjType = {
  * are the same, otherwise zero is returned. */
 int Jim_CompareStringImmediate(Jim_Interp *interp, Jim_Obj *objPtr, char *str)
 {
-	if (objPtr->typePtr == &comparedStringObjType &&
-	    objPtr->internalRep.ptr == str)
-		return 1;
-	else {
-		char *objStr = Jim_GetString(objPtr, NULL);
-		if (strcmp(str, objStr) != 0) return 0;
-		if (objPtr->typePtr != &comparedStringObjType) {
-			Jim_FreeIntRep(interp, objPtr);
-			objPtr->typePtr = &comparedStringObjType;
-		}
-		objPtr->internalRep.ptr = str;
-		return 1;
-	}
+    if (objPtr->typePtr == &comparedStringObjType &&
+        objPtr->internalRep.ptr == str)
+        return 1;
+    else {
+        char *objStr = Jim_GetString(objPtr, NULL);
+        if (strcmp(str, objStr) != 0) return 0;
+        if (objPtr->typePtr != &comparedStringObjType) {
+            Jim_FreeIntRep(interp, objPtr);
+            objPtr->typePtr = &comparedStringObjType;
+        }
+        objPtr->internalRep.ptr = str;
+        return 1;
+    }
 }
 
 /* -----------------------------------------------------------------------------
@@ -2030,40 +2030,40 @@ static void FreeSourceInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
 static void DupSourceInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr);
 
 static Jim_ObjType sourceObjType = {
-	"source",
-	FreeSourceInternalRep,
-	DupSourceInternalRep,
-	NULL,
-	JIM_TYPE_REFERENCES,
+    "source",
+    FreeSourceInternalRep,
+    DupSourceInternalRep,
+    NULL,
+    JIM_TYPE_REFERENCES,
 };
 
 void FreeSourceInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	Jim_ReleaseSharedString(interp,
-			objPtr->internalRep.sourceValue.fileName);
+    Jim_ReleaseSharedString(interp,
+            objPtr->internalRep.sourceValue.fileName);
 }
 
 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.sourceValue.fileName =
+        Jim_GetSharedString(interp,
+                srcPtr->internalRep.sourceValue.fileName);
+    dupPtr->internalRep.sourceValue.lineNumber =
+        dupPtr->internalRep.sourceValue.lineNumber;
+    dupPtr->typePtr = &sourceObjType;
 }
 
 static void Jim_SetSourceInfo(Jim_Interp *interp, Jim_Obj *objPtr,
-		char *fileName, int lineNumber)
+        char *fileName, int lineNumber)
 {
-	if (Jim_IsShared(objPtr))
-		Jim_Panic("Jim_SetSourceInfo called with shared object");
-	if (objPtr->typePtr != NULL)
-		Jim_Panic("Jim_SetSourceInfo called with typePtr != NULL");
-	objPtr->internalRep.sourceValue.fileName =
-		Jim_GetSharedString(interp, fileName);
-	objPtr->internalRep.sourceValue.lineNumber = lineNumber;
-	objPtr->typePtr = &sourceObjType;
+    if (Jim_IsShared(objPtr))
+        Jim_Panic("Jim_SetSourceInfo called with shared object");
+    if (objPtr->typePtr != NULL)
+        Jim_Panic("Jim_SetSourceInfo called with typePtr != NULL");
+    objPtr->internalRep.sourceValue.fileName =
+        Jim_GetSharedString(interp, fileName);
+    objPtr->internalRep.sourceValue.lineNumber = lineNumber;
+    objPtr->typePtr = &sourceObjType;
 }
 
 /* -----------------------------------------------------------------------------
@@ -2077,20 +2077,20 @@ static void DupScriptInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *d
 static int SetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
 static Jim_ObjType scriptObjType = {
-	"script",
-	FreeScriptInternalRep,
-	DupScriptInternalRep,
-	NULL,
-	JIM_TYPE_REFERENCES,
+    "script",
+    FreeScriptInternalRep,
+    DupScriptInternalRep,
+    NULL,
+    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;
-	int linenr;
+    int type;
+    Jim_Obj *objPtr;
+    int linenr;
 } ScriptToken;
 
 /* This is the script object internal representation. An array of
@@ -2174,176 +2174,176 @@ typedef struct ScriptToken {
  * two times.
  */
 typedef struct ScriptObj {
-	int len; /* Length as number of tokens. */
-	int commands; /* number of top-level commands in script. */
-	ScriptToken *token; /* Tokens array. */
-	int *cmdStruct; /* commands structure */
-	int csLen; /* length of the cmdStruct array. */
-	int substFlags; /* flags used for the compilation of "subst" objects */
-	int inUse; /* Used to share a ScriptObj. Currently
-		      only used by Jim_EvalObj() as protection against
-		      shimmering of the currently evaluated object. */
-	char *fileName;
+    int len; /* Length as number of tokens. */
+    int commands; /* number of top-level commands in script. */
+    ScriptToken *token; /* Tokens array. */
+    int *cmdStruct; /* commands structure */
+    int csLen; /* length of the cmdStruct array. */
+    int substFlags; /* flags used for the compilation of "subst" objects */
+    int inUse; /* Used to share a ScriptObj. Currently
+              only used by Jim_EvalObj() as protection against
+              shimmering of the currently evaluated object. */
+    char *fileName;
 } ScriptObj;
 
 void FreeScriptInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	int i;
-	struct ScriptObj *script = (void*) objPtr->internalRep.ptr;
+    int i;
+    struct ScriptObj *script = (void*) objPtr->internalRep.ptr;
 
-	script->inUse--;
-	if (script->inUse != 0) return;
-	for (i = 0; i < script->len; i++) {
-		if (script->token[i].objPtr != NULL)
-			Jim_DecrRefCount(interp, script->token[i].objPtr);
-	}
-	Jim_Free(script->token);
-	Jim_Free(script->cmdStruct);
-	Jim_Free(script->fileName);
-	Jim_Free(script);
+    script->inUse--;
+    if (script->inUse != 0) return;
+    for (i = 0; i < script->len; i++) {
+        if (script->token[i].objPtr != NULL)
+            Jim_DecrRefCount(interp, script->token[i].objPtr);
+    }
+    Jim_Free(script->token);
+    Jim_Free(script->cmdStruct);
+    Jim_Free(script->fileName);
+    Jim_Free(script);
 }
 
 void DupScriptInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
 {
-	interp = interp;
-	srcPtr = srcPtr;
+    interp = interp;
+    srcPtr = srcPtr;
 
-	/* Just returns an simple string. */
-	dupPtr->typePtr = NULL;
+    /* Just returns an simple string. */
+    dupPtr->typePtr = NULL;
 }
 
 /* Add a new token to the internal repr of a script object */
 static void ScriptObjAddToken(Jim_Interp *interp, struct ScriptObj *script,
-		char *strtoken, int len, int type, char *filename, int linenr)
-{
-	int prevtype;
-	struct ScriptToken *token;
-
-	prevtype = (script->len == 0) ? JIM_TT_EOL : \
-		script->token[script->len-1].type;
-	/* Skip tokens without meaning, like words separators
-	 * following a word separator or an end of command and
-	 * so on. */
-	if (prevtype == JIM_TT_EOL) {
-		if (type == JIM_TT_EOL || type == JIM_TT_SEP) {
-			free(strtoken);
-			return;
-		}
-	} else if (prevtype == JIM_TT_SEP) {
-		if (type == JIM_TT_SEP) {
-			free(strtoken);
-			return;
-		} else if (type == JIM_TT_EOL) {
-			/* If an EOL is following by a SEP, drop the previous
-			 * separator. */
-			script->len--;
-			Jim_DecrRefCount(interp,
-					script->token[script->len].objPtr);
-		}
-	} else if (prevtype != JIM_TT_EOL && prevtype != JIM_TT_SEP &&
-			type == JIM_TT_ESC && len == 0)
-	{
-		/* Don't add empty tokens used in interpolation */
-		return;
-	}
-	/* Make space for a new istruction */
-	script->len++;
-	script->token = Jim_Realloc(script->token,
-			sizeof(ScriptToken)*script->len);
-	/* Initialize the new token */
-	token = script->token+(script->len-1);
-	token->type = type;
-	/* Every object is intially as a string, but the
-	 * internal type may be specialized during execution of the
-	 * script. */
-	token->objPtr = Jim_NewStringObjNoAlloc(interp, strtoken, len);
-	/* To add source info to SEP and EOL tokens is useless because
-	 * they will never by called as arguments of Jim_EvalObj(). */
-	if (filename && type != JIM_TT_SEP && type != JIM_TT_EOL)
-		Jim_SetSourceInfo(interp, token->objPtr, filename, linenr);
-	Jim_IncrRefCount(token->objPtr);
-	token->linenr = linenr;
+        char *strtoken, int len, int type, char *filename, int linenr)
+{
+    int prevtype;
+    struct ScriptToken *token;
+
+    prevtype = (script->len == 0) ? JIM_TT_EOL : \
+        script->token[script->len-1].type;
+    /* Skip tokens without meaning, like words separators
+     * following a word separator or an end of command and
+     * so on. */
+    if (prevtype == JIM_TT_EOL) {
+        if (type == JIM_TT_EOL || type == JIM_TT_SEP) {
+            free(strtoken);
+            return;
+        }
+    } else if (prevtype == JIM_TT_SEP) {
+        if (type == JIM_TT_SEP) {
+            free(strtoken);
+            return;
+        } else if (type == JIM_TT_EOL) {
+            /* If an EOL is following by a SEP, drop the previous
+             * separator. */
+            script->len--;
+            Jim_DecrRefCount(interp,
+                    script->token[script->len].objPtr);
+        }
+    } else if (prevtype != JIM_TT_EOL && prevtype != JIM_TT_SEP &&
+            type == JIM_TT_ESC && len == 0)
+    {
+        /* Don't add empty tokens used in interpolation */
+        return;
+    }
+    /* Make space for a new istruction */
+    script->len++;
+    script->token = Jim_Realloc(script->token,
+            sizeof(ScriptToken)*script->len);
+    /* Initialize the new token */
+    token = script->token+(script->len-1);
+    token->type = type;
+    /* Every object is intially as a string, but the
+     * internal type may be specialized during execution of the
+     * script. */
+    token->objPtr = Jim_NewStringObjNoAlloc(interp, strtoken, len);
+    /* To add source info to SEP and EOL tokens is useless because
+     * they will never by called as arguments of Jim_EvalObj(). */
+    if (filename && type != JIM_TT_SEP && type != JIM_TT_EOL)
+        Jim_SetSourceInfo(interp, token->objPtr, filename, linenr);
+    Jim_IncrRefCount(token->objPtr);
+    token->linenr = linenr;
 }
 
 /* Add an integer into the command structure field of the script object. */
 static void ScriptObjAddInt(struct ScriptObj *script, int val)
 {
-	script->csLen++;
-	script->cmdStruct = Jim_Realloc(script->cmdStruct,
-					sizeof(int)*script->csLen);
-	script->cmdStruct[script->csLen-1] = val;
+    script->csLen++;
+    script->cmdStruct = Jim_Realloc(script->cmdStruct,
+                    sizeof(int)*script->csLen);
+    script->cmdStruct[script->csLen-1] = val;
 }
 
 /* Search a Jim_Obj contained in 'script' with the same stinrg repr.
  * of objPtr. Search nested script objects recursively. */
 static Jim_Obj *ScriptSearchLiteral(Jim_Interp *interp, ScriptObj *script,
-		Jim_Obj *objPtr)
-{
-	int i;
-
-	for (i = 0; i < script->len; i++) {
-		if (script->token[i].objPtr != objPtr &&
-		    Jim_StringEqObj(script->token[i].objPtr, objPtr, 0))
-			return script->token[i].objPtr;
-		if (script->token[i].objPtr->typePtr == &scriptObjType) {
-			Jim_Obj *foundObjPtr;
-
-			ScriptObj *subScript =
-				script->token[i].objPtr->internalRep.ptr;
-			foundObjPtr =
-				ScriptSearchLiteral(interp, subScript, objPtr);
-			if (foundObjPtr != NULL)
-				return foundObjPtr;
-		}
-	}
-	return NULL;
+        Jim_Obj *objPtr)
+{
+    int i;
+
+    for (i = 0; i < script->len; i++) {
+        if (script->token[i].objPtr != objPtr &&
+            Jim_StringEqObj(script->token[i].objPtr, objPtr, 0))
+            return script->token[i].objPtr;
+        if (script->token[i].objPtr->typePtr == &scriptObjType) {
+            Jim_Obj *foundObjPtr;
+
+            ScriptObj *subScript =
+                script->token[i].objPtr->internalRep.ptr;
+            foundObjPtr =
+                ScriptSearchLiteral(interp, subScript, objPtr);
+            if (foundObjPtr != NULL)
+                return foundObjPtr;
+        }
+    }
+    return NULL;
 }
 
 /* Share literals of a script recursively sharing sub-scripts literals. */
 static void ScriptShareLiterals(Jim_Interp *interp, ScriptObj *script,
-		ScriptObj *topLevelScript)
-{
-	int i, j;
-
-	/* Try to share with toplevel object. */
-	if (1 && topLevelScript != NULL) {
-		for (i = 0; i < script->len; i++) {
-			Jim_Obj *foundObjPtr;
-			char *str = script->token[i].objPtr->bytes;
-
-			if (script->token[i].objPtr->refCount != 1) continue;
-			if (strchr(str, ' ') || strchr(str, '\n')) continue;
-			foundObjPtr = ScriptSearchLiteral(interp,
-					topLevelScript,
-					script->token[i].objPtr);
-			if (foundObjPtr != NULL) {
-				Jim_IncrRefCount(foundObjPtr);
-				Jim_DecrRefCount(interp,
-						script->token[i].objPtr);
-				script->token[i].objPtr = foundObjPtr;
-			}
-		}
-	}
-	/* Try to share locally */
-	for (i = 0; i < script->len; i++) {
-		char *str = script->token[i].objPtr->bytes;
-
-		if (script->token[i].objPtr->refCount != 1) continue;
-		if (strchr(str, ' ') || strchr(str, '\n')) continue;
-		for (j = 0; j < script->len; j++) {
-			if (script->token[i].objPtr !=
-					script->token[j].objPtr &&
-			    Jim_StringEqObj(script->token[i].objPtr,
-				    	    script->token[j].objPtr, 0))
-			{
-				Jim_IncrRefCount(script->token[j].objPtr);
-				Jim_DecrRefCount(interp,
-						script->token[i].objPtr);
-				script->token[i].objPtr =
-					script->token[j].objPtr;
-			}
-		}
-	}
+        ScriptObj *topLevelScript)
+{
+    int i, j;
+
+    /* Try to share with toplevel object. */
+    if (1 && topLevelScript != NULL) {
+        for (i = 0; i < script->len; i++) {
+            Jim_Obj *foundObjPtr;
+            char *str = script->token[i].objPtr->bytes;
+
+            if (script->token[i].objPtr->refCount != 1) continue;
+            if (strchr(str, ' ') || strchr(str, '\n')) continue;
+            foundObjPtr = ScriptSearchLiteral(interp,
+                    topLevelScript,
+                    script->token[i].objPtr);
+            if (foundObjPtr != NULL) {
+                Jim_IncrRefCount(foundObjPtr);
+                Jim_DecrRefCount(interp,
+                        script->token[i].objPtr);
+                script->token[i].objPtr = foundObjPtr;
+            }
+        }
+    }
+    /* Try to share locally */
+    for (i = 0; i < script->len; i++) {
+        char *str = script->token[i].objPtr->bytes;
+
+        if (script->token[i].objPtr->refCount != 1) continue;
+        if (strchr(str, ' ') || strchr(str, '\n')) continue;
+        for (j = 0; j < script->len; j++) {
+            if (script->token[i].objPtr !=
+                    script->token[j].objPtr &&
+                Jim_StringEqObj(script->token[i].objPtr,
+                            script->token[j].objPtr, 0))
+            {
+                Jim_IncrRefCount(script->token[j].objPtr);
+                Jim_DecrRefCount(interp,
+                        script->token[i].objPtr);
+                script->token[i].objPtr =
+                    script->token[j].objPtr;
+            }
+        }
+    }
 }
 
 /* This method takes the string representation of an object
@@ -2351,130 +2351,130 @@ static void ScriptShareLiterals(Jim_Interp *interp, ScriptObj *script,
  * of the script. */
 int SetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
 {
-	char *scriptText = Jim_GetString(objPtr, NULL);
-	struct JimParserCtx parser;
-	struct ScriptObj *script = Jim_Alloc(sizeof(*script));
-	ScriptToken *token;
-	int args, tokens, start, end, i;
-	int initialLineNumber;
-	int propagateSourceInfo = 0;
-
-	script->len = 0;
-	script->csLen = 0;
-	script->commands = 0;
-	script->token = NULL;
-	script->cmdStruct = NULL;
-	script->inUse = 1;
-	/* Try to get information about filename / line number */
-	if (objPtr->typePtr == &sourceObjType) {
-		script->fileName =
-			Jim_StrDup(objPtr->internalRep.sourceValue.fileName);
-		initialLineNumber = objPtr->internalRep.sourceValue.lineNumber;
-		propagateSourceInfo = 1;
-	} else {
-		script->fileName = Jim_StrDup("?");
-		initialLineNumber = 1;
-	}
-
-	JimParserInit(&parser, scriptText, initialLineNumber);
-	while(!JimParserEof(&parser)) {
-		char *token;
-		int len, type, linenr;
-
-		JimParseScript(&parser);
-		token = JimParserGetToken(&parser, &len, &type, &linenr);
-		ScriptObjAddToken(interp, script, token, len, type,
-				propagateSourceInfo ? script->fileName : NULL,
-				linenr);
-	}
-	token = script->token;
-
-	/* Compute the command structure array
-	 * (see the ScriptObj struct definition for more info) */
-	start = 0; /* Current command start token index */
-	end = -1; /* Current command end token index */
-	while (1) {
-		int expand = 0; /* expand flag. set to 1 on {expand} form. */
-		int interpolation = 0; /* set to 1 if there is at least one
-					  argument of the command obtained via
-					  interpolation of more tokens. */
-		/* Search for the end of command, while
-		 * count the number of args. */
-		start = ++end;
-		if (start >= script->len) break;
-		args = 1; /* Number of args in current command */
-		while (token[end].type != JIM_TT_EOL) {
-			if (end == 0 || token[end-1].type == JIM_TT_SEP ||
-					token[end-1].type == JIM_TT_EOL)
-			{
-				if (token[end].type == JIM_TT_STR &&
-				    token[end+1].type != JIM_TT_SEP &&
-				    token[end+1].type != JIM_TT_EOL &&
-				    !strcmp(token[end].objPtr->bytes, "expand"))
-					expand++;
-			}
-			if (token[end].type == JIM_TT_SEP)
-				args++;
-			end++;
-		}
-		interpolation = !((end-start+1) == args*2);
-		/* Add the 'number of arguments' info into cmdstruct.
-		 * Negative value if there is list expansion involved. */
-		if (expand)
-			ScriptObjAddInt(script, -1);
-		ScriptObjAddInt(script, args);
-		/* Now add info about the number of tokens. */
-		tokens = 0; /* Number of tokens in current argument. */
-		expand = 0;
-		for (i = start; i <= end; i++) {
-			if (token[i].type == JIM_TT_SEP ||
-			    token[i].type == JIM_TT_EOL)
-			{
-				if (tokens == 1 && expand)
-					expand = 0;
-				ScriptObjAddInt(script,
-						expand ? -tokens : tokens);
-
-				expand = 0;
-				tokens = 0;
-				continue;
-			} else if (tokens == 0 && token[i].type == JIM_TT_STR &&
-				   !strcmp(token[i].objPtr->bytes, "expand"))
-			{
-				expand++;
-			}
-			tokens++;
-		}
-	}
-	/* Perform literal sharing, but only for objects that appear
-	 * to be scripts written as literals inside the source code,
-	 * and not computed at runtime. Literal sharing is a costly
-	 * operation that should be done only against objects that
-	 * are likely to require compilation only the first time, and
-	 * then are executed multiple times. */
-	if (propagateSourceInfo && interp->framePtr->procBodyObjPtr) {
-		Jim_Obj *bodyObjPtr = interp->framePtr->procBodyObjPtr;
-		if (bodyObjPtr->typePtr == &scriptObjType) {
-			ScriptObj *bodyScript =
-				bodyObjPtr->internalRep.ptr;
-			ScriptShareLiterals(interp, script, bodyScript);
-		}
-	} else if (propagateSourceInfo) {
-		ScriptShareLiterals(interp, script, NULL);
-	}
-	/* Free the old internal rep and set the new one. */
-	Jim_FreeIntRep(interp, objPtr);
-	Jim_SetIntRepPtr(objPtr, script);
-	objPtr->typePtr = &scriptObjType;
-	return JIM_OK;
+    char *scriptText = Jim_GetString(objPtr, NULL);
+    struct JimParserCtx parser;
+    struct ScriptObj *script = Jim_Alloc(sizeof(*script));
+    ScriptToken *token;
+    int args, tokens, start, end, i;
+    int initialLineNumber;
+    int propagateSourceInfo = 0;
+
+    script->len = 0;
+    script->csLen = 0;
+    script->commands = 0;
+    script->token = NULL;
+    script->cmdStruct = NULL;
+    script->inUse = 1;
+    /* Try to get information about filename / line number */
+    if (objPtr->typePtr == &sourceObjType) {
+        script->fileName =
+            Jim_StrDup(objPtr->internalRep.sourceValue.fileName);
+        initialLineNumber = objPtr->internalRep.sourceValue.lineNumber;
+        propagateSourceInfo = 1;
+    } else {
+        script->fileName = Jim_StrDup("?");
+        initialLineNumber = 1;
+    }
+
+    JimParserInit(&parser, scriptText, initialLineNumber);
+    while(!JimParserEof(&parser)) {
+        char *token;
+        int len, type, linenr;
+
+        JimParseScript(&parser);
+        token = JimParserGetToken(&parser, &len, &type, &linenr);
+        ScriptObjAddToken(interp, script, token, len, type,
+                propagateSourceInfo ? script->fileName : NULL,
+                linenr);
+    }
+    token = script->token;
+
+    /* Compute the command structure array
+     * (see the ScriptObj struct definition for more info) */
+    start = 0; /* Current command start token index */
+    end = -1; /* Current command end token index */
+    while (1) {
+        int expand = 0; /* expand flag. set to 1 on {expand} form. */
+        int interpolation = 0; /* set to 1 if there is at least one
+                      argument of the command obtained via
+                      interpolation of more tokens. */
+        /* Search for the end of command, while
+         * count the number of args. */
+        start = ++end;
+        if (start >= script->len) break;
+        args = 1; /* Number of args in current command */
+        while (token[end].type != JIM_TT_EOL) {
+            if (end == 0 || token[end-1].type == JIM_TT_SEP ||
+                    token[end-1].type == JIM_TT_EOL)
+            {
+                if (token[end].type == JIM_TT_STR &&
+                    token[end+1].type != JIM_TT_SEP &&
+                    token[end+1].type != JIM_TT_EOL &&
+                    !strcmp(token[end].objPtr->bytes, "expand"))
+                    expand++;
+            }
+            if (token[end].type == JIM_TT_SEP)
+                args++;
+            end++;
+        }
+        interpolation = !((end-start+1) == args*2);
+        /* Add the 'number of arguments' info into cmdstruct.
+         * Negative value if there is list expansion involved. */
+        if (expand)
+            ScriptObjAddInt(script, -1);
+        ScriptObjAddInt(script, args);
+        /* Now add info about the number of tokens. */
+        tokens = 0; /* Number of tokens in current argument. */
+        expand = 0;
+        for (i = start; i <= end; i++) {
+            if (token[i].type == JIM_TT_SEP ||
+                token[i].type == JIM_TT_EOL)
+            {
+                if (tokens == 1 && expand)
+                    expand = 0;
+                ScriptObjAddInt(script,
+                        expand ? -tokens : tokens);
+
+                expand = 0;
+                tokens = 0;
+                continue;
+            } else if (tokens == 0 && token[i].type == JIM_TT_STR &&
+                   !strcmp(token[i].objPtr->bytes, "expand"))
+            {
+                expand++;
+            }
+            tokens++;
+        }
+    }
+    /* Perform literal sharing, but only for objects that appear
+     * to be scripts written as literals inside the source code,
+     * and not computed at runtime. Literal sharing is a costly
+     * operation that should be done only against objects that
+     * are likely to require compilation only the first time, and
+     * then are executed multiple times. */
+    if (propagateSourceInfo && interp->framePtr->procBodyObjPtr) {
+        Jim_Obj *bodyObjPtr = interp->framePtr->procBodyObjPtr;
+        if (bodyObjPtr->typePtr == &scriptObjType) {
+            ScriptObj *bodyScript =
+                bodyObjPtr->internalRep.ptr;
+            ScriptShareLiterals(interp, script, bodyScript);
+        }
+    } else if (propagateSourceInfo) {
+        ScriptShareLiterals(interp, script, NULL);
+    }
+    /* Free the old internal rep and set the new one. */
+    Jim_FreeIntRep(interp, objPtr);
+    Jim_SetIntRepPtr(objPtr, script);
+    objPtr->typePtr = &scriptObjType;
+    return JIM_OK;
 }
 
 ScriptObj *Jim_GetScript(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	if (objPtr->typePtr != &scriptObjType) {
-		SetScriptFromAny(interp, objPtr);
-	}
-	return (ScriptObj*) Jim_GetIntRepPtr(objPtr);
+    if (objPtr->typePtr != &scriptObjType) {
+        SetScriptFromAny(interp, objPtr);
+    }
+    return (ScriptObj*) Jim_GetIntRepPtr(objPtr);
 }
 
 /* -----------------------------------------------------------------------------
@@ -2486,127 +2486,127 @@ ScriptObj *Jim_GetScript(Jim_Interp *interp, Jim_Obj *objPtr)
  * Keys are dynamic allocated strings, Values are Jim_Cmd structures. */
 static void Jim_CommandsHT_ValDestructor(void *interp, void *val)
 {
-	Jim_Cmd *cmdPtr = (void*) val;
+    Jim_Cmd *cmdPtr = (void*) val;
 
-	if (cmdPtr->cmdProc == NULL) {
-		Jim_DecrRefCount(interp, cmdPtr->argListObjPtr);
-		Jim_DecrRefCount(interp, cmdPtr->bodyObjPtr);
-	}
-	Jim_Free(val);
+    if (cmdPtr->cmdProc == NULL) {
+        Jim_DecrRefCount(interp, cmdPtr->argListObjPtr);
+        Jim_DecrRefCount(interp, cmdPtr->bodyObjPtr);
+    }
+    Jim_Free(val);
 }
 
 static Jim_HashTableType Jim_CommandsHashTableType = {
-	Jim_StringCopyHT_HashFunction,		/* hash function */
-	Jim_StringCopyHT_KeyDup,		/* key dup */
-	NULL,					/* val dup */
-	Jim_StringCopyHT_KeyCompare,		/* key compare */
-	Jim_StringCopyHT_KeyDestructor,		/* key destructor */
-	Jim_CommandsHT_ValDestructor		/* val destructor */
+    Jim_StringCopyHT_HashFunction,        /* hash function */
+    Jim_StringCopyHT_KeyDup,        /* key dup */
+    NULL,                    /* val dup */
+    Jim_StringCopyHT_KeyCompare,        /* key compare */
+    Jim_StringCopyHT_KeyDestructor,        /* key destructor */
+    Jim_CommandsHT_ValDestructor        /* val destructor */
 };
 
 /* ------------------------- Commands related functions --------------------- */
 
 int Jim_CreateCommand(Jim_Interp *interp, char *cmdName, Jim_CmdProc cmdProc,
-		void *privData)
-{
-	Jim_HashEntry *he;
-	Jim_Cmd *cmdPtr;
-
-	he = Jim_FindHashEntry(&interp->commands, cmdName);
-	if (he == NULL) { /* New command to create */
-		cmdPtr = Jim_Alloc(sizeof(*cmdPtr));
-		cmdPtr->cmdProc = cmdProc;
-		cmdPtr->privData = privData;
-		Jim_AddHashEntry(&interp->commands, cmdName, cmdPtr);
-	} else {
-		/* Free the arglist/body objects if it was a Tcl procedure */
-		cmdPtr = he->val;
-		if (cmdPtr->cmdProc == NULL) {
-			Jim_DecrRefCount(interp, cmdPtr->argListObjPtr);
-			Jim_DecrRefCount(interp, cmdPtr->bodyObjPtr);
-		}
-		cmdPtr->cmdProc = cmdProc;
-		cmdPtr->privData = privData;
-	}
-	/* 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;
+        void *privData)
+{
+    Jim_HashEntry *he;
+    Jim_Cmd *cmdPtr;
+
+    he = Jim_FindHashEntry(&interp->commands, cmdName);
+    if (he == NULL) { /* New command to create */
+        cmdPtr = Jim_Alloc(sizeof(*cmdPtr));
+        cmdPtr->cmdProc = cmdProc;
+        cmdPtr->privData = privData;
+        Jim_AddHashEntry(&interp->commands, cmdName, cmdPtr);
+    } else {
+        /* Free the arglist/body objects if it was a Tcl procedure */
+        cmdPtr = he->val;
+        if (cmdPtr->cmdProc == NULL) {
+            Jim_DecrRefCount(interp, cmdPtr->argListObjPtr);
+            Jim_DecrRefCount(interp, cmdPtr->bodyObjPtr);
+        }
+        cmdPtr->cmdProc = cmdProc;
+        cmdPtr->privData = privData;
+    }
+    /* 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;
 }
 
 int Jim_CreateProcedure(Jim_Interp *interp, char *cmdName,
-		Jim_Obj *argListObjPtr, Jim_Obj *bodyObjPtr,
-		int arityMin, int arityMax)
-{
-	Jim_HashEntry *he;
-	Jim_Cmd *cmdPtr;
-
-	he = Jim_FindHashEntry(&interp->commands, cmdName);
-	if (he == NULL) { /* New procedure to create */
-		cmdPtr = Jim_Alloc(sizeof(*cmdPtr));
-		cmdPtr->cmdProc = NULL; /* Not a C coded command */
-		cmdPtr->argListObjPtr = argListObjPtr;
-		cmdPtr->bodyObjPtr = bodyObjPtr;
-		Jim_IncrRefCount(argListObjPtr);
-		Jim_IncrRefCount(bodyObjPtr);
-		cmdPtr->arityMin = arityMin;
-		cmdPtr->arityMax = arityMax;
-		Jim_AddHashEntry(&interp->commands, cmdName, cmdPtr);
-	} else {
-		/* Free the arglist/body objects if it was a Tcl procedure */
-		cmdPtr = he->val;
-		if (cmdPtr->cmdProc == NULL) {
-			Jim_DecrRefCount(interp, cmdPtr->argListObjPtr);
-			Jim_DecrRefCount(interp, cmdPtr->bodyObjPtr);
-		}
-		cmdPtr->cmdProc = NULL; /* Not a C coded command */
-		cmdPtr->arityMin = arityMin;
-		cmdPtr->arityMax = arityMax;
-		cmdPtr->argListObjPtr = argListObjPtr;
-		cmdPtr->bodyObjPtr = bodyObjPtr;
-		Jim_IncrRefCount(argListObjPtr);
-		Jim_IncrRefCount(bodyObjPtr);
-	}
-	/* 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;
+        Jim_Obj *argListObjPtr, Jim_Obj *bodyObjPtr,
+        int arityMin, int arityMax)
+{
+    Jim_HashEntry *he;
+    Jim_Cmd *cmdPtr;
+
+    he = Jim_FindHashEntry(&interp->commands, cmdName);
+    if (he == NULL) { /* New procedure to create */
+        cmdPtr = Jim_Alloc(sizeof(*cmdPtr));
+        cmdPtr->cmdProc = NULL; /* Not a C coded command */
+        cmdPtr->argListObjPtr = argListObjPtr;
+        cmdPtr->bodyObjPtr = bodyObjPtr;
+        Jim_IncrRefCount(argListObjPtr);
+        Jim_IncrRefCount(bodyObjPtr);
+        cmdPtr->arityMin = arityMin;
+        cmdPtr->arityMax = arityMax;
+        Jim_AddHashEntry(&interp->commands, cmdName, cmdPtr);
+    } else {
+        /* Free the arglist/body objects if it was a Tcl procedure */
+        cmdPtr = he->val;
+        if (cmdPtr->cmdProc == NULL) {
+            Jim_DecrRefCount(interp, cmdPtr->argListObjPtr);
+            Jim_DecrRefCount(interp, cmdPtr->bodyObjPtr);
+        }
+        cmdPtr->cmdProc = NULL; /* Not a C coded command */
+        cmdPtr->arityMin = arityMin;
+        cmdPtr->arityMax = arityMax;
+        cmdPtr->argListObjPtr = argListObjPtr;
+        cmdPtr->bodyObjPtr = bodyObjPtr;
+        Jim_IncrRefCount(argListObjPtr);
+        Jim_IncrRefCount(bodyObjPtr);
+    }
+    /* 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;
 }
 
 int Jim_DeleteCommand(Jim_Interp *interp, char *cmdName)
 {
-	if (Jim_DeleteHashEntry(&interp->commands, cmdName) == JIM_ERR)
-		return JIM_ERR;
-	Jim_InterpIncrProcEpoch(interp);
-	return JIM_OK;
+    if (Jim_DeleteHashEntry(&interp->commands, cmdName) == JIM_ERR)
+        return JIM_ERR;
+    Jim_InterpIncrProcEpoch(interp);
+    return JIM_OK;
 }
 
 int Jim_RenameCommand(Jim_Interp *interp, char *oldName, char *newName)
 {
-	Jim_Cmd *cmdPtr;
-	Jim_HashEntry *he;
-
-	if (newName[0] == '\0') /* Delete! */
-		return Jim_DeleteCommand(interp, oldName);
-	/* Rename */
-	he = Jim_FindHashEntry(&interp->commands, oldName);
-	if (he == NULL)
-		return JIM_ERR; /* Invalid command name */
-	cmdPtr = he->val;
-	if (cmdPtr->cmdProc == NULL) {	/* Tcl procedure? */
-		Jim_IncrRefCount(cmdPtr->argListObjPtr);
-		Jim_IncrRefCount(cmdPtr->bodyObjPtr);
-		Jim_CreateProcedure(interp, newName, cmdPtr->argListObjPtr,
-				cmdPtr->bodyObjPtr, cmdPtr->arityMin,
-				cmdPtr->arityMax);
-		Jim_DecrRefCount(interp, cmdPtr->argListObjPtr);
-		Jim_DecrRefCount(interp, cmdPtr->bodyObjPtr);
-	} else {			/* Or C-coded command. */
-		Jim_CreateCommand(interp, newName, cmdPtr->cmdProc,
-				cmdPtr->privData);
-	}
-	/* DeleteCommand will incr the proc epoch */
-	return Jim_DeleteCommand(interp, oldName);
+    Jim_Cmd *cmdPtr;
+    Jim_HashEntry *he;
+
+    if (newName[0] == '\0') /* Delete! */
+        return Jim_DeleteCommand(interp, oldName);
+    /* Rename */
+    he = Jim_FindHashEntry(&interp->commands, oldName);
+    if (he == NULL)
+        return JIM_ERR; /* Invalid command name */
+    cmdPtr = he->val;
+    if (cmdPtr->cmdProc == NULL) {    /* Tcl procedure? */
+        Jim_IncrRefCount(cmdPtr->argListObjPtr);
+        Jim_IncrRefCount(cmdPtr->bodyObjPtr);
+        Jim_CreateProcedure(interp, newName, cmdPtr->argListObjPtr,
+                cmdPtr->bodyObjPtr, cmdPtr->arityMin,
+                cmdPtr->arityMax);
+        Jim_DecrRefCount(interp, cmdPtr->argListObjPtr);
+        Jim_DecrRefCount(interp, cmdPtr->bodyObjPtr);
+    } else {            /* Or C-coded command. */
+        Jim_CreateCommand(interp, newName, cmdPtr->cmdProc,
+                cmdPtr->privData);
+    }
+    /* DeleteCommand will incr the proc epoch */
+    return Jim_DeleteCommand(interp, oldName);
 }
 
 /* -----------------------------------------------------------------------------
@@ -2616,31 +2616,31 @@ int Jim_RenameCommand(Jim_Interp *interp, char *oldName, char *newName)
 static int SetCommandFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
 static Jim_ObjType commandObjType = {
-	"command",
-	NULL,
-	NULL,
-	NULL,
-	JIM_TYPE_REFERENCES,
+    "command",
+    NULL,
+    NULL,
+    NULL,
+    JIM_TYPE_REFERENCES,
 };
 
 int SetCommandFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	Jim_HashEntry *he;
-	char *cmdName;
+    Jim_HashEntry *he;
+    char *cmdName;
 
-	/* Get the string representation */
-	cmdName = Jim_GetString(objPtr, NULL);
-	/* Lookup this name into the commands hash table */
-	he = Jim_FindHashEntry(&interp->commands, cmdName);
-	if (he == NULL)
-		return JIM_ERR;
+    /* Get the string representation */
+    cmdName = Jim_GetString(objPtr, NULL);
+    /* 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;
-	objPtr->internalRep.cmdValue.cmdPtr = (void*)he->val;
-	return JIM_OK;
+    /* Free the old internal repr and set the new one. */
+    Jim_FreeIntRep(interp, objPtr);
+    objPtr->typePtr = &commandObjType;
+    objPtr->internalRep.cmdValue.procEpoch = interp->procEpoch;
+    objPtr->internalRep.cmdValue.cmdPtr = (void*)he->val;
+    return JIM_OK;
 }
 
 /* This function returns the command structure for the command name
@@ -2650,18 +2650,18 @@ int SetCommandFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
  * a case the lookup is performed and the cache updated. */
 Jim_Cmd *Jim_GetCommand(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
 {
-	if ((objPtr->typePtr != &commandObjType ||
-	    objPtr->internalRep.cmdValue.procEpoch != interp->procEpoch) &&
-	    SetCommandFromAny(interp, objPtr) == JIM_ERR) {
-		if (flags & JIM_ERRMSG) {
-			Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-			Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"invalid command name \"", objPtr->bytes, "\"",
-				NULL);
-		}
-		return NULL;
-	}
-	return objPtr->internalRep.cmdValue.cmdPtr;
+    if ((objPtr->typePtr != &commandObjType ||
+        objPtr->internalRep.cmdValue.procEpoch != interp->procEpoch) &&
+        SetCommandFromAny(interp, objPtr) == JIM_ERR) {
+        if (flags & JIM_ERRMSG) {
+            Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+            Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "invalid command name \"", objPtr->bytes, "\"",
+                NULL);
+        }
+        return NULL;
+    }
+    return objPtr->internalRep.cmdValue.cmdPtr;
 }
 
 /* -----------------------------------------------------------------------------
@@ -2673,19 +2673,19 @@ Jim_Cmd *Jim_GetCommand(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
  * Keys are dynamic allocated strings, Values are Jim_Var structures. */
 static void Jim_VariablesHT_ValDestructor(void *interp, void *val)
 {
-	Jim_Var *varPtr = (void*) val;
+    Jim_Var *varPtr = (void*) val;
 
-	Jim_DecrRefCount(interp, varPtr->objPtr);
-	Jim_Free(val);
+    Jim_DecrRefCount(interp, varPtr->objPtr);
+    Jim_Free(val);
 }
 
 static Jim_HashTableType Jim_VariablesHashTableType = {
-	Jim_StringCopyHT_HashFunction,		/* hash function */
-	Jim_StringCopyHT_KeyDup,		/* key dup */
-	NULL,					/* val dup */
-	Jim_StringCopyHT_KeyCompare,		/* key compare */
-	Jim_StringCopyHT_KeyDestructor,		/* key destructor */
-	Jim_VariablesHT_ValDestructor		/* val destructor */
+    Jim_StringCopyHT_HashFunction,        /* hash function */
+    Jim_StringCopyHT_KeyDup,        /* key dup */
+    NULL,                    /* val dup */
+    Jim_StringCopyHT_KeyCompare,        /* key compare */
+    Jim_StringCopyHT_KeyDestructor,        /* key destructor */
+    Jim_VariablesHT_ValDestructor        /* val destructor */
 };
 
 /* -----------------------------------------------------------------------------
@@ -2697,22 +2697,22 @@ static Jim_HashTableType Jim_VariablesHashTableType = {
 static int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
 static Jim_ObjType variableObjType = {
-	"variable",
-	NULL,
-	NULL,
-	NULL,
-	JIM_TYPE_REFERENCES,
+    "variable",
+    NULL,
+    NULL,
+    NULL,
+    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 Jim_NameIsDictSugar(char *str, int len)
 {
-	if (len == -1)
-		len = strlen(str);
-	if (len && str[len-1] == ')' && strchr(str, '(') != NULL)
-		return 1;
-	return 0;
+    if (len == -1)
+        len = strlen(str);
+    if (len && str[len-1] == ')' && strchr(str, '(') != NULL)
+        return 1;
+    return 0;
 }
 
 /* This method should be called only by the variable API.
@@ -2722,36 +2722,35 @@ static int Jim_NameIsDictSugar(char *str, int len)
  * character is ')' */
 int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
 {
-	Jim_HashEntry *he;
-	char *varName;
-	int len;
-
-	/* Check if the object is already an uptodate variable */
-	if (objPtr->typePtr == &variableObjType &&
-	    objPtr->internalRep.varValue.callFrameId == interp->framePtr->id)
-		return JIM_OK; /* nothing to do */
-	/* Get the string representation */
-	varName = Jim_GetString(objPtr, &len);
-	//printf("HERE %s\n", varName);
-	/* Make sure it's not syntax glue to get/set dict. */
-	if (Jim_NameIsDictSugar(varName, len))
-			return JIM_DICT_SUGAR;
-	/* Lookup this name into the variables hash table */
-	he = Jim_FindHashEntry(&interp->framePtr->vars, varName);
-	if (he == NULL)
-		return JIM_ERR;
-
-	/* Free the old internal repr and set the new one. */
-	Jim_FreeIntRep(interp, objPtr);
-	objPtr->typePtr = &variableObjType;
-	objPtr->internalRep.varValue.callFrameId = interp->framePtr->id;
-	objPtr->internalRep.varValue.varPtr = (void*)he->val;
-	return JIM_OK;
+    Jim_HashEntry *he;
+    char *varName;
+    int len;
+
+    /* Check if the object is already an uptodate variable */
+    if (objPtr->typePtr == &variableObjType &&
+        objPtr->internalRep.varValue.callFrameId == interp->framePtr->id)
+        return JIM_OK; /* nothing to do */
+    /* Get the string representation */
+    varName = Jim_GetString(objPtr, &len);
+    /* Make sure it's not syntax glue to get/set dict. */
+    if (Jim_NameIsDictSugar(varName, len))
+            return JIM_DICT_SUGAR;
+    /* Lookup this name into the variables hash table */
+    he = Jim_FindHashEntry(&interp->framePtr->vars, varName);
+    if (he == NULL)
+        return JIM_ERR;
+
+    /* Free the old internal repr and set the new one. */
+    Jim_FreeIntRep(interp, objPtr);
+    objPtr->typePtr = &variableObjType;
+    objPtr->internalRep.varValue.callFrameId = interp->framePtr->id;
+    objPtr->internalRep.varValue.varPtr = (void*)he->val;
+    return JIM_OK;
 }
 
 /* -------------------- Variables related functions ------------------------- */
 static int Jim_DictSugarSet(Jim_Interp *interp, Jim_Obj *ObjPtr,
-		Jim_Obj *valObjPtr);
+        Jim_Obj *valObjPtr);
 static Jim_Obj *Jim_DictSugarGet(Jim_Interp *interp, Jim_Obj *ObjPtr);
 
 /* For now that's dummy. Variables lookup should be optimized
@@ -2762,100 +2761,100 @@ static Jim_Obj *Jim_DictSugarGet(Jim_Interp *interp, Jim_Obj *ObjPtr);
 
 int Jim_SetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr)
 {
-	char *name;
-	Jim_Var *var;
-	int err;
-
-	if ((err = SetVariableFromAny(interp, nameObjPtr)) != JIM_OK) {
-		/* Check for [dict] syntax sugar. */
-		if (err == JIM_DICT_SUGAR)
-			return Jim_DictSugarSet(interp, nameObjPtr, valObjPtr);
-		/* New variable to create */
-		name = Jim_GetString(nameObjPtr, NULL);
-
-		var = Jim_Alloc(sizeof(*var));
-		var->objPtr = valObjPtr;
-		Jim_IncrRefCount(valObjPtr);
-		var->linkFramePtr = NULL;
-		/* Insert the new variable */
-		Jim_AddHashEntry(&interp->framePtr->vars, name, var);
-		/* Make the object int rep a variable */
-		Jim_FreeIntRep(interp, nameObjPtr);
-		nameObjPtr->typePtr = &variableObjType;
-		nameObjPtr->internalRep.varValue.callFrameId =
-			interp->framePtr->id;
-		nameObjPtr->internalRep.varValue.varPtr = var;
-	} else {
-		var = nameObjPtr->internalRep.varValue.varPtr;
-		if (var->linkFramePtr == NULL) {
-			Jim_DecrRefCount(interp, var->objPtr);
-			var->objPtr = valObjPtr;
-			Jim_IncrRefCount(valObjPtr);
-		} else { /* Else handle the link */
-			Jim_CallFrame *savedCallFrame;
-
-			savedCallFrame = interp->framePtr;
-			interp->framePtr = var->linkFramePtr;
-			err = Jim_SetVariable(interp, var->objPtr, valObjPtr);
-			interp->framePtr = savedCallFrame;
-			if (err != JIM_OK)
-				return err;
-		}
-	}
-	return JIM_OK;
+    char *name;
+    Jim_Var *var;
+    int err;
+
+    if ((err = SetVariableFromAny(interp, nameObjPtr)) != JIM_OK) {
+        /* Check for [dict] syntax sugar. */
+        if (err == JIM_DICT_SUGAR)
+            return Jim_DictSugarSet(interp, nameObjPtr, valObjPtr);
+        /* New variable to create */
+        name = Jim_GetString(nameObjPtr, NULL);
+
+        var = Jim_Alloc(sizeof(*var));
+        var->objPtr = valObjPtr;
+        Jim_IncrRefCount(valObjPtr);
+        var->linkFramePtr = NULL;
+        /* Insert the new variable */
+        Jim_AddHashEntry(&interp->framePtr->vars, name, var);
+        /* Make the object int rep a variable */
+        Jim_FreeIntRep(interp, nameObjPtr);
+        nameObjPtr->typePtr = &variableObjType;
+        nameObjPtr->internalRep.varValue.callFrameId =
+            interp->framePtr->id;
+        nameObjPtr->internalRep.varValue.varPtr = var;
+    } else {
+        var = nameObjPtr->internalRep.varValue.varPtr;
+        if (var->linkFramePtr == NULL) {
+            Jim_DecrRefCount(interp, var->objPtr);
+            var->objPtr = valObjPtr;
+            Jim_IncrRefCount(valObjPtr);
+        } else { /* Else handle the link */
+            Jim_CallFrame *savedCallFrame;
+
+            savedCallFrame = interp->framePtr;
+            interp->framePtr = var->linkFramePtr;
+            err = Jim_SetVariable(interp, var->objPtr, valObjPtr);
+            interp->framePtr = savedCallFrame;
+            if (err != JIM_OK)
+                return err;
+        }
+    }
+    return JIM_OK;
 }
 
 int Jim_SetVariableString(Jim_Interp *interp, char *name, char *val)
 {
-	Jim_Obj *nameObjPtr, *valObjPtr;
-	int result;
+    Jim_Obj *nameObjPtr, *valObjPtr;
+    int result;
 
-	nameObjPtr = Jim_NewStringObj(interp, name, -1);
-	valObjPtr = Jim_NewStringObj(interp, val, -1);
-	Jim_IncrRefCount(nameObjPtr);
-	Jim_IncrRefCount(valObjPtr);
-	result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
-	Jim_DecrRefCount(interp, nameObjPtr);
-	Jim_DecrRefCount(interp, valObjPtr);
-	return result;
+    nameObjPtr = Jim_NewStringObj(interp, name, -1);
+    valObjPtr = Jim_NewStringObj(interp, val, -1);
+    Jim_IncrRefCount(nameObjPtr);
+    Jim_IncrRefCount(valObjPtr);
+    result = Jim_SetVariable(interp, nameObjPtr, valObjPtr);
+    Jim_DecrRefCount(interp, nameObjPtr);
+    Jim_DecrRefCount(interp, valObjPtr);
+    return result;
 }
 
 int Jim_SetVariableLink(Jim_Interp *interp, Jim_Obj *nameObjPtr,
-		Jim_Obj *targetNameObjPtr, Jim_CallFrame *targetCallFrame)
-{
-	char *varName;
-	int len;
-
-	/* 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, 0)) {
-				Jim_SetResultString(interp,
-					"can't upvar from variable to itself",
-					-1);
-				return JIM_ERR;
-			}
-			if (SetVariableFromAny(interp, objPtr) != JIM_OK)
-				break;
-			varPtr = objPtr->internalRep.varValue.varPtr;
-			if (varPtr->linkFramePtr != targetCallFrame) break;
-			objPtr = varPtr->objPtr;
-		}
-	}
-	varName = Jim_GetString(nameObjPtr, &len);
-	if (Jim_NameIsDictSugar(varName, len)) {
-		Jim_SetResultString(interp,
-			"Dict key syntax invalid as link source", -1);
-		return JIM_ERR;
-	}
-	/* 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;
+        Jim_Obj *targetNameObjPtr, Jim_CallFrame *targetCallFrame)
+{
+    char *varName;
+    int len;
+
+    /* 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, 0)) {
+                Jim_SetResultString(interp,
+                    "can't upvar from variable to itself",
+                    -1);
+                return JIM_ERR;
+            }
+            if (SetVariableFromAny(interp, objPtr) != JIM_OK)
+                break;
+            varPtr = objPtr->internalRep.varValue.varPtr;
+            if (varPtr->linkFramePtr != targetCallFrame) break;
+            objPtr = varPtr->objPtr;
+        }
+    }
+    varName = Jim_GetString(nameObjPtr, &len);
+    if (Jim_NameIsDictSugar(varName, len)) {
+        Jim_SetResultString(interp,
+            "Dict key syntax invalid as link source", -1);
+        return JIM_ERR;
+    }
+    /* 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,
@@ -2864,54 +2863,54 @@ int Jim_SetVariableLink(Jim_Interp *interp, Jim_Obj *nameObjPtr,
  * 'SetVariable' function should apply here. */
 Jim_Obj *Jim_GetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
 {
-	int err;
-
-	/* All the rest is handled here */
-	if ((err = SetVariableFromAny(interp, nameObjPtr)) != JIM_OK) {
-		/* Check for [dict] syntax sugar. */
-		if (err == JIM_DICT_SUGAR)
-			return Jim_DictSugarGet(interp, nameObjPtr);
-		if (flags & JIM_ERRMSG) {
-			Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-			Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"can't read \"", nameObjPtr->bytes,
-				"\": no such variable",
-				NULL);
-		}
-		return NULL;
-	} else {
-		Jim_Var *varPtr;
-		Jim_Obj *objPtr;
-		Jim_CallFrame *savedCallFrame;
-
-		varPtr = nameObjPtr->internalRep.varValue.varPtr;
-		if (varPtr->linkFramePtr == NULL)
-			return varPtr->objPtr;
-		/* The variable is a link? Resolve it. */
-		savedCallFrame = interp->framePtr;
-		interp->framePtr = varPtr->linkFramePtr;
-		objPtr = Jim_GetVariable(interp, varPtr->objPtr, JIM_NONE);
-		if (objPtr == NULL && flags & JIM_ERRMSG) {
-			Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-			Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"can't read \"", nameObjPtr->bytes,
-				"\": no such variable",
-				NULL);
-		}
-		interp->framePtr = savedCallFrame;
-		return objPtr;
-	}
+    int err;
+
+    /* All the rest is handled here */
+    if ((err = SetVariableFromAny(interp, nameObjPtr)) != JIM_OK) {
+        /* Check for [dict] syntax sugar. */
+        if (err == JIM_DICT_SUGAR)
+            return Jim_DictSugarGet(interp, nameObjPtr);
+        if (flags & JIM_ERRMSG) {
+            Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+            Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "can't read \"", nameObjPtr->bytes,
+                "\": no such variable",
+                NULL);
+        }
+        return NULL;
+    } else {
+        Jim_Var *varPtr;
+        Jim_Obj *objPtr;
+        Jim_CallFrame *savedCallFrame;
+
+        varPtr = nameObjPtr->internalRep.varValue.varPtr;
+        if (varPtr->linkFramePtr == NULL)
+            return varPtr->objPtr;
+        /* The variable is a link? Resolve it. */
+        savedCallFrame = interp->framePtr;
+        interp->framePtr = varPtr->linkFramePtr;
+        objPtr = Jim_GetVariable(interp, varPtr->objPtr, JIM_NONE);
+        if (objPtr == NULL && flags & JIM_ERRMSG) {
+            Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+            Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "can't read \"", nameObjPtr->bytes,
+                "\": no such variable",
+                NULL);
+        }
+        interp->framePtr = savedCallFrame;
+        return objPtr;
+    }
 }
 
 Jim_Obj *Jim_GetVariableString(Jim_Interp *interp, char *name, int flags)
 {
-	Jim_Obj *nameObjPtr, *varObjPtr;
+    Jim_Obj *nameObjPtr, *varObjPtr;
 
-	nameObjPtr = Jim_NewStringObj(interp, name, -1);
-	Jim_IncrRefCount(nameObjPtr);
-	varObjPtr = Jim_GetVariable(interp, nameObjPtr, flags);
-	Jim_DecrRefCount(interp, nameObjPtr);
-	return varObjPtr;
+    nameObjPtr = Jim_NewStringObj(interp, name, -1);
+    Jim_IncrRefCount(nameObjPtr);
+    varObjPtr = Jim_GetVariable(interp, nameObjPtr, flags);
+    Jim_DecrRefCount(interp, nameObjPtr);
+    return varObjPtr;
 }
 
 /* Unset a variable.
@@ -2919,48 +2918,48 @@ Jim_Obj *Jim_GetVariableString(Jim_Interp *interp, char *name, int flags)
  * in the current call frame incrementing. */
 int Jim_UnsetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
 {
-	char *name;
-	Jim_Var *varPtr;
-	int err;
-	
-	if ((err = SetVariableFromAny(interp, nameObjPtr)) != JIM_OK) {
-		/* Check for [dict] syntax sugar. */
-		if (err == JIM_DICT_SUGAR)
-			return Jim_DictSugarSet(interp, nameObjPtr, NULL);
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-			"can't unset \"", nameObjPtr->bytes,
-			"\": no such variable",
-			NULL);
-		return JIM_ERR; /* var not found */
-	}
-	varPtr = nameObjPtr->internalRep.varValue.varPtr;
-	/* If it's a link call UnsetVariable recursively */
-	if (varPtr->linkFramePtr) {
-		int retval;
-
-		Jim_CallFrame *savedCallFrame;
-
-		savedCallFrame = interp->framePtr;
-		interp->framePtr = varPtr->linkFramePtr;
-		retval = Jim_UnsetVariable(interp, varPtr->objPtr, JIM_NONE);
-		interp->framePtr = savedCallFrame;
-		if (retval != JIM_OK && flags & JIM_ERRMSG) {
-			Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-			Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"can't unset \"", nameObjPtr->bytes,
-				"\": no such variable",
-				NULL);
-		}
-		return retval;
-	} else {
-		name = Jim_GetString(nameObjPtr, NULL);
-		if (Jim_DeleteHashEntry(&interp->framePtr->vars, name)
-				!= JIM_OK) return JIM_ERR;
-		/* Change the callframe id, invalidating var lookup caching */
-		Jim_ChangeCallFrameId(interp, interp->framePtr);
-		return JIM_OK;
-	}
+    char *name;
+    Jim_Var *varPtr;
+    int err;
+    
+    if ((err = SetVariableFromAny(interp, nameObjPtr)) != JIM_OK) {
+        /* Check for [dict] syntax sugar. */
+        if (err == JIM_DICT_SUGAR)
+            return Jim_DictSugarSet(interp, nameObjPtr, NULL);
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+            "can't unset \"", nameObjPtr->bytes,
+            "\": no such variable",
+            NULL);
+        return JIM_ERR; /* var not found */
+    }
+    varPtr = nameObjPtr->internalRep.varValue.varPtr;
+    /* If it's a link call UnsetVariable recursively */
+    if (varPtr->linkFramePtr) {
+        int retval;
+
+        Jim_CallFrame *savedCallFrame;
+
+        savedCallFrame = interp->framePtr;
+        interp->framePtr = varPtr->linkFramePtr;
+        retval = Jim_UnsetVariable(interp, varPtr->objPtr, JIM_NONE);
+        interp->framePtr = savedCallFrame;
+        if (retval != JIM_OK && flags & JIM_ERRMSG) {
+            Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+            Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "can't unset \"", nameObjPtr->bytes,
+                "\": no such variable",
+                NULL);
+        }
+        return retval;
+    } else {
+        name = Jim_GetString(nameObjPtr, NULL);
+        if (Jim_DeleteHashEntry(&interp->framePtr->vars, name)
+                != JIM_OK) return JIM_ERR;
+        /* Change the callframe id, invalidating var lookup caching */
+        Jim_ChangeCallFrameId(interp, interp->framePtr);
+        return JIM_OK;
+    }
 }
 
 /* ----------  Dict syntax sugar (similar to array Tcl syntax) -------------- */
@@ -2973,113 +2972,113 @@ int Jim_UnsetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, int flags)
  *
  * The returned objects have refcount = 1. The function can't fail. */
 static void Jim_DictSugarParseVarKey(Jim_Interp *interp, Jim_Obj *objPtr,
-		Jim_Obj **varPtrPtr, Jim_Obj **keyPtrPtr)
-{
-	char *str, *p, *t;
-	int len, keyLen, nameLen;
-	Jim_Obj *varObjPtr, *keyObjPtr;
-
-	str = Jim_GetString(objPtr, &len);
-	p = strchr(str, '(');
-	p++;
-	keyLen = len-((p-str)+1);
-	nameLen = (p-str)-1;
-	/* Create the objects with the variable name and key. */
-	t = Jim_Alloc(nameLen+1);
-	memcpy(t, str, nameLen);
-	t[nameLen] = '\0';
-	varObjPtr = Jim_NewStringObjNoAlloc(interp, t, nameLen);
-
-	t = Jim_Alloc(keyLen+1);
-	memcpy(t, p, keyLen);
-	t[keyLen] = '\0';
-	keyObjPtr = Jim_NewStringObjNoAlloc(interp, t, keyLen);
-
-	Jim_IncrRefCount(varObjPtr);
-	Jim_IncrRefCount(keyObjPtr);
-	*varPtrPtr = varObjPtr;
-	*keyPtrPtr = keyObjPtr;
+        Jim_Obj **varPtrPtr, Jim_Obj **keyPtrPtr)
+{
+    char *str, *p, *t;
+    int len, keyLen, nameLen;
+    Jim_Obj *varObjPtr, *keyObjPtr;
+
+    str = Jim_GetString(objPtr, &len);
+    p = strchr(str, '(');
+    p++;
+    keyLen = len-((p-str)+1);
+    nameLen = (p-str)-1;
+    /* Create the objects with the variable name and key. */
+    t = Jim_Alloc(nameLen+1);
+    memcpy(t, str, nameLen);
+    t[nameLen] = '\0';
+    varObjPtr = Jim_NewStringObjNoAlloc(interp, t, nameLen);
+
+    t = Jim_Alloc(keyLen+1);
+    memcpy(t, p, keyLen);
+    t[keyLen] = '\0';
+    keyObjPtr = Jim_NewStringObjNoAlloc(interp, t, keyLen);
+
+    Jim_IncrRefCount(varObjPtr);
+    Jim_IncrRefCount(keyObjPtr);
+    *varPtrPtr = varObjPtr;
+    *keyPtrPtr = keyObjPtr;
 }
 
 /* Helper of Jim_SetVariable() to deal with dict-syntax variable names.
  * Also used by Jim_UnsetVariable() with valObjPtr = NULL. */
 static int Jim_DictSugarSet(Jim_Interp *interp, Jim_Obj *objPtr,
-		Jim_Obj *valObjPtr)
-{
-	Jim_Obj *varObjPtr, *keyObjPtr;
-	int err, retval = JIM_OK;
-
-	Jim_DictSugarParseVarKey(interp, objPtr, &varObjPtr, &keyObjPtr);
-	err = Jim_SetDictKeysVector(interp, varObjPtr, &keyObjPtr, 1,
-			valObjPtr);
-	if (err != JIM_OK) {
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"Variable '", Jim_GetString(varObjPtr, NULL),
-				"' does not contain a valid dictionary", NULL);
-		retval = err;
-	}
-	Jim_DecrRefCount(interp, varObjPtr);
-	Jim_DecrRefCount(interp, keyObjPtr);
-	return retval;
+        Jim_Obj *valObjPtr)
+{
+    Jim_Obj *varObjPtr, *keyObjPtr;
+    int err, retval = JIM_OK;
+
+    Jim_DictSugarParseVarKey(interp, objPtr, &varObjPtr, &keyObjPtr);
+    err = Jim_SetDictKeysVector(interp, varObjPtr, &keyObjPtr, 1,
+            valObjPtr);
+    if (err != JIM_OK) {
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "Variable '", Jim_GetString(varObjPtr, NULL),
+                "' does not contain a valid dictionary", NULL);
+        retval = err;
+    }
+    Jim_DecrRefCount(interp, varObjPtr);
+    Jim_DecrRefCount(interp, keyObjPtr);
+    return retval;
 }
 
 /* Helper of Jim_GetVariable() to deal with dict-syntax variable names */
 static Jim_Obj *Jim_DictSugarGet(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	Jim_Obj *varObjPtr, *keyObjPtr, *dictObjPtr, *resObjPtr;
-
-	Jim_DictSugarParseVarKey(interp, objPtr, &varObjPtr, &keyObjPtr);
-	dictObjPtr = Jim_GetVariable(interp, varObjPtr, JIM_ERRMSG);
-	if (!dictObjPtr) {
-		resObjPtr = NULL;
-		goto err;
-	}
-	if (Jim_DictKey(interp, dictObjPtr, keyObjPtr, &resObjPtr, JIM_ERRMSG)
-			!= JIM_OK) {
-		resObjPtr = NULL;
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"Variable '", Jim_GetString(varObjPtr, NULL),
-				"' does not contain a valid dictionary", NULL);
-		goto err;
-	}
+    Jim_Obj *varObjPtr, *keyObjPtr, *dictObjPtr, *resObjPtr;
+
+    Jim_DictSugarParseVarKey(interp, objPtr, &varObjPtr, &keyObjPtr);
+    dictObjPtr = Jim_GetVariable(interp, varObjPtr, JIM_ERRMSG);
+    if (!dictObjPtr) {
+        resObjPtr = NULL;
+        goto err;
+    }
+    if (Jim_DictKey(interp, dictObjPtr, keyObjPtr, &resObjPtr, JIM_ERRMSG)
+            != JIM_OK) {
+        resObjPtr = NULL;
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "Variable '", Jim_GetString(varObjPtr, NULL),
+                "' does not contain a valid dictionary", NULL);
+        goto err;
+    }
 err:
-	Jim_DecrRefCount(interp, varObjPtr);
-	Jim_DecrRefCount(interp, keyObjPtr);
-	return resObjPtr;
+    Jim_DecrRefCount(interp, varObjPtr);
+    Jim_DecrRefCount(interp, keyObjPtr);
+    return resObjPtr;
 }
 
 /* --------- $var(INDEX) substitution, using a specialized object ----------- */
 
 static void FreeDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *objPtr);
 static void DupDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr,
-		Jim_Obj *dupPtr);
+        Jim_Obj *dupPtr);
 
 static Jim_ObjType dictSubstObjType = {
-	"dict-substitution",
-	FreeDictSubstInternalRep,
-	DupDictSubstInternalRep,
-	NULL,
-	JIM_TYPE_NONE,
+    "dict-substitution",
+    FreeDictSubstInternalRep,
+    DupDictSubstInternalRep,
+    NULL,
+    JIM_TYPE_NONE,
 };
 
 void FreeDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	Jim_DecrRefCount(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr);
-	Jim_DecrRefCount(interp, objPtr->internalRep.dictSubstValue.indexObjPtr);
+    Jim_DecrRefCount(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr);
+    Jim_DecrRefCount(interp, objPtr->internalRep.dictSubstValue.indexObjPtr);
 }
 
 void DupDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr,
-		Jim_Obj *dupPtr)
+        Jim_Obj *dupPtr)
 {
-	interp = interp; /* unused */
+    interp = interp; /* unused */
 
-	dupPtr->internalRep.dictSubstValue.varNameObjPtr =
-		srcPtr->internalRep.dictSubstValue.varNameObjPtr;
-	dupPtr->internalRep.dictSubstValue.indexObjPtr =
-		srcPtr->internalRep.dictSubstValue.indexObjPtr;
-	dupPtr->typePtr = &dictSubstObjType;
+    dupPtr->internalRep.dictSubstValue.varNameObjPtr =
+        srcPtr->internalRep.dictSubstValue.varNameObjPtr;
+    dupPtr->internalRep.dictSubstValue.indexObjPtr =
+        srcPtr->internalRep.dictSubstValue.indexObjPtr;
+    dupPtr->typePtr = &dictSubstObjType;
 }
 
 /* This function is used to expand [dict get] sugar in the form
@@ -3095,46 +3094,46 @@ void DupDictSubstInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr,
  * index substitution. */
 Jim_Obj *Jim_ExpandDictSugar(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	Jim_Obj *varObjPtr, *keyObjPtr, *dictObjPtr, *resObjPtr;
-	Jim_Obj *substKeyObjPtr = NULL;
-
-	if (objPtr->typePtr != &dictSubstObjType) {
-		Jim_DictSugarParseVarKey(interp, objPtr, &varObjPtr,
-				&keyObjPtr);
-		Jim_FreeIntRep(interp, objPtr);
-		objPtr->typePtr = &dictSubstObjType;
-		objPtr->internalRep.dictSubstValue.varNameObjPtr =
-			varObjPtr;
-		objPtr->internalRep.dictSubstValue.indexObjPtr =
-			keyObjPtr;
-	}
-	if (Jim_SubstObj(interp, objPtr->internalRep.dictSubstValue.indexObjPtr,
-				&substKeyObjPtr, JIM_NONE)
-			!= JIM_OK) {
-		substKeyObjPtr = NULL;
-		goto err;
-	}
-	Jim_IncrRefCount(substKeyObjPtr);
-	dictObjPtr = Jim_GetVariable(interp,
-			objPtr->internalRep.dictSubstValue.varNameObjPtr,
-			JIM_ERRMSG);
-	if (!dictObjPtr) {
-		resObjPtr = NULL;
-		goto err;
-	}
-	if (Jim_DictKey(interp, dictObjPtr, substKeyObjPtr, &resObjPtr,
-				JIM_ERRMSG)
-			!= JIM_OK) {
-		resObjPtr = NULL;
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"Variable '", Jim_GetString(varObjPtr, NULL),
-				"' does not contain a valid dictionary", NULL);
-		goto err;
-	}
+    Jim_Obj *varObjPtr, *keyObjPtr, *dictObjPtr, *resObjPtr;
+    Jim_Obj *substKeyObjPtr = NULL;
+
+    if (objPtr->typePtr != &dictSubstObjType) {
+        Jim_DictSugarParseVarKey(interp, objPtr, &varObjPtr,
+                &keyObjPtr);
+        Jim_FreeIntRep(interp, objPtr);
+        objPtr->typePtr = &dictSubstObjType;
+        objPtr->internalRep.dictSubstValue.varNameObjPtr =
+            varObjPtr;
+        objPtr->internalRep.dictSubstValue.indexObjPtr =
+            keyObjPtr;
+    }
+    if (Jim_SubstObj(interp, objPtr->internalRep.dictSubstValue.indexObjPtr,
+                &substKeyObjPtr, JIM_NONE)
+            != JIM_OK) {
+        substKeyObjPtr = NULL;
+        goto err;
+    }
+    Jim_IncrRefCount(substKeyObjPtr);
+    dictObjPtr = Jim_GetVariable(interp,
+            objPtr->internalRep.dictSubstValue.varNameObjPtr,
+            JIM_ERRMSG);
+    if (!dictObjPtr) {
+        resObjPtr = NULL;
+        goto err;
+    }
+    if (Jim_DictKey(interp, dictObjPtr, substKeyObjPtr, &resObjPtr,
+                JIM_ERRMSG)
+            != JIM_OK) {
+        resObjPtr = NULL;
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "Variable '", Jim_GetString(varObjPtr, NULL),
+                "' does not contain a valid dictionary", NULL);
+        goto err;
+    }
 err:
-	if (substKeyObjPtr) Jim_DecrRefCount(interp, substKeyObjPtr);
-	return resObjPtr;
+    if (substKeyObjPtr) Jim_DecrRefCount(interp, substKeyObjPtr);
+    return resObjPtr;
 }
 
 /* -----------------------------------------------------------------------------
@@ -3143,38 +3142,38 @@ err:
 
 static Jim_CallFrame *Jim_CreateCallFrame(Jim_Interp *interp)
 {
-	Jim_CallFrame *cf;
-	if (interp->freeFramesList) {
-		cf = interp->freeFramesList;
-		interp->freeFramesList = cf->nextFramePtr;
-	} else {
-		cf = Jim_Alloc(sizeof(*cf));
-	}
-
-	cf->id = interp->callFrameEpoch++;
-	cf->parentCallFrame = NULL;
-	cf->argv = NULL;
-	cf->argc = 0;
-	cf->procArgsObjPtr = NULL;
-	cf->procBodyObjPtr = NULL;
-	cf->nextFramePtr = NULL;
-	Jim_InitHashTable(&cf->vars, &Jim_VariablesHashTableType, interp);
-	return cf;
+    Jim_CallFrame *cf;
+    if (interp->freeFramesList) {
+        cf = interp->freeFramesList;
+        interp->freeFramesList = cf->nextFramePtr;
+    } else {
+        cf = Jim_Alloc(sizeof(*cf));
+    }
+
+    cf->id = interp->callFrameEpoch++;
+    cf->parentCallFrame = NULL;
+    cf->argv = NULL;
+    cf->argc = 0;
+    cf->procArgsObjPtr = NULL;
+    cf->procBodyObjPtr = NULL;
+    cf->nextFramePtr = NULL;
+    Jim_InitHashTable(&cf->vars, &Jim_VariablesHashTableType, interp);
+    return cf;
 }
 
 /* Used to invalidate every caching related to callframe stability. */
 static void Jim_ChangeCallFrameId(Jim_Interp *interp, Jim_CallFrame *cf)
 {
-	cf->id = interp->callFrameEpoch++;
+    cf->id = interp->callFrameEpoch++;
 }
 
 static void Jim_FreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf)
 {
-	if (cf->procArgsObjPtr) Jim_DecrRefCount(interp, cf->procArgsObjPtr);
-	if (cf->procBodyObjPtr) Jim_DecrRefCount(interp, cf->procBodyObjPtr);
-	Jim_FreeHashTable(&cf->vars);
-	cf->nextFramePtr = interp->freeFramesList;
-	interp->freeFramesList = cf;
+    if (cf->procArgsObjPtr) Jim_DecrRefCount(interp, cf->procArgsObjPtr);
+    if (cf->procBodyObjPtr) Jim_DecrRefCount(interp, cf->procBodyObjPtr);
+    Jim_FreeHashTable(&cf->vars);
+    cf->nextFramePtr = interp->freeFramesList;
+    interp->freeFramesList = cf;
 }
 
 /* -----------------------------------------------------------------------------
@@ -3188,61 +3187,61 @@ static void Jim_FreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf)
  * to Jim_References. */
 static void Jim_ReferencesHT_ValDestructor(void *interp, void *val)
 {
-	Jim_Reference *refPtr = (void*) val;
+    Jim_Reference *refPtr = (void*) val;
 
-	Jim_DecrRefCount(interp, refPtr->objPtr);
-	if (refPtr->finalizerCmdNamePtr != NULL) {
-		Jim_DecrRefCount(interp, refPtr->finalizerCmdNamePtr);
-	}
-	Jim_Free(val);
+    Jim_DecrRefCount(interp, refPtr->objPtr);
+    if (refPtr->finalizerCmdNamePtr != NULL) {
+        Jim_DecrRefCount(interp, refPtr->finalizerCmdNamePtr);
+    }
+    Jim_Free(val);
 }
 
 unsigned int Jim_ReferencesHT_HashFunction(void *key)
 {
-	/* Only the least significant bits are used. */
-	jim_wide *widePtr = key;
-	unsigned int intValue = (unsigned int) *widePtr;
-	return Jim_IntHashFunction(intValue);
+    /* Only the least significant bits are used. */
+    jim_wide *widePtr = key;
+    unsigned int intValue = (unsigned int) *widePtr;
+    return Jim_IntHashFunction(intValue);
 }
 
 unsigned int Jim_ReferencesHT_DoubleHashFunction(void *key)
 {
-	/* Only the least significant bits are used. */
-	jim_wide *widePtr = key;
-	unsigned int intValue = (unsigned int) *widePtr;
-	return intValue; /* identity function. */
+    /* Only the least significant bits are used. */
+    jim_wide *widePtr = key;
+    unsigned int intValue = (unsigned int) *widePtr;
+    return intValue; /* identity function. */
 }
 
 void *Jim_ReferencesHT_KeyDup(void *privdata, void *key)
 {
-	void *copy = Jim_Alloc(sizeof(jim_wide));
-	privdata = privdata; /* not used */
+    void *copy = Jim_Alloc(sizeof(jim_wide));
+    privdata = privdata; /* not used */
 
-	memcpy(copy, key, sizeof(jim_wide));
-	return copy;
+    memcpy(copy, key, sizeof(jim_wide));
+    return copy;
 }
 
 int Jim_ReferencesHT_KeyCompare(void *privdata, void *key1, void *key2)
 {
-	privdata = privdata; /* not used */
+    privdata = privdata; /* not used */
 
-	return memcmp(key1, key2, sizeof(jim_wide)) == 0;
+    return memcmp(key1, key2, sizeof(jim_wide)) == 0;
 }
 
 void Jim_ReferencesHT_KeyDestructor(void *privdata, void *key)
 {
-	privdata = privdata; /* not used */
+    privdata = privdata; /* not used */
 
-	Jim_Free(key);
+    Jim_Free(key);
 }
 
 static Jim_HashTableType Jim_ReferencesHashTableType = {
-	Jim_ReferencesHT_HashFunction,		/* hash function */
-	Jim_ReferencesHT_KeyDup,		/* key dup */
-	NULL,					/* val dup */
-	Jim_ReferencesHT_KeyCompare,		/* key compare */
-	Jim_ReferencesHT_KeyDestructor,		/* key destructor */
-	Jim_ReferencesHT_ValDestructor		/* val destructor */
+    Jim_ReferencesHT_HashFunction,        /* hash function */
+    Jim_ReferencesHT_KeyDup,        /* key dup */
+    NULL,                    /* val dup */
+    Jim_ReferencesHT_KeyCompare,        /* key compare */
+    Jim_ReferencesHT_KeyDestructor,        /* key destructor */
+    Jim_ReferencesHT_ValDestructor        /* val destructor */
 };
 
 /* -----------------------------------------------------------------------------
@@ -3252,107 +3251,107 @@ static Jim_HashTableType Jim_ReferencesHashTableType = {
 static void UpdateStringOfReference(struct Jim_Obj *objPtr);
 
 static Jim_ObjType referenceObjType = {
-	"reference",
-	NULL,
-	NULL,
-	UpdateStringOfReference,
-	JIM_TYPE_REFERENCES,
+    "reference",
+    NULL,
+    NULL,
+    UpdateStringOfReference,
+    JIM_TYPE_REFERENCES,
 };
 
 void UpdateStringOfReference(struct Jim_Obj *objPtr)
 {
-	int len;
-	char buf[JIM_REFERENCE_SPACE+1];
+    int len;
+    char buf[JIM_REFERENCE_SPACE+1];
 
-	len = Jim_WideToReferenceString(buf, objPtr->internalRep.refValue.id);
-	objPtr->bytes = Jim_Alloc(len+1);
-	memcpy(objPtr->bytes, buf, len+1);
-	objPtr->length = len;
+    len = Jim_WideToReferenceString(buf, objPtr->internalRep.refValue.id);
+    objPtr->bytes = Jim_Alloc(len+1);
+    memcpy(objPtr->bytes, buf, len+1);
+    objPtr->length = len;
 }
 
 int SetReferenceFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	jim_wide wideValue;
-	int len;
-	char *str, *start, *end;
-	char refId[21];
-	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 == ' ') start++;
-	while (*end == ' ' && end > start) end--;
-	if (end-start+1 != JIM_REFERENCE_SPACE) goto badformat;
-	if (memcmp(start, "~reference:", 11) != 0) goto badformat;
-	if (end[0] != ':') goto badformat;
-	memcpy(refId, start+11, 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_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"Invalid reference ID \"", str, "\"", NULL);
-		return JIM_ERR;
-	}
-	refPtr = he->val;
-	/* Free the old internal repr and set the new one. */
-	Jim_FreeIntRep(interp, objPtr);
-	objPtr->typePtr = &referenceObjType;
-	objPtr->internalRep.refValue.id = wideValue;
-	objPtr->internalRep.refValue.refPtr = refPtr;
-	return JIM_OK;
+    jim_wide wideValue;
+    int len;
+    char *str, *start, *end;
+    char refId[21];
+    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 == ' ') start++;
+    while (*end == ' ' && end > start) end--;
+    if (end-start+1 != JIM_REFERENCE_SPACE) goto badformat;
+    if (memcmp(start, "~reference:", 11) != 0) goto badformat;
+    if (end[0] != ':') goto badformat;
+    memcpy(refId, start+11, 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_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "Invalid reference ID \"", str, "\"", NULL);
+        return JIM_ERR;
+    }
+    refPtr = he->val;
+    /* Free the old internal repr and set the new one. */
+    Jim_FreeIntRep(interp, objPtr);
+    objPtr->typePtr = &referenceObjType;
+    objPtr->internalRep.refValue.id = wideValue;
+    objPtr->internalRep.refValue.refPtr = refPtr;
+    return JIM_OK;
 
 badformat:
-	Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-	Jim_AppendStrings(interp, Jim_GetResult(interp),
-			"expected reference but got \"", str, "\"", NULL);
-	return JIM_ERR;
+    Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+    Jim_AppendStrings(interp, Jim_GetResult(interp),
+            "expected reference but got \"", str, "\"", NULL);
+    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 *cmdNamePtr)
-{
-	struct Jim_Reference *refPtr;
-	jim_wide wideValue = interp->referenceNextId;
-	Jim_Obj *refObjPtr;
-
-	/* Perform the Garbage Collection if needed. */
-	Jim_CollectIfNeeded(interp);
-
-	refPtr = Jim_Alloc(sizeof(*refPtr));
-	refPtr->objPtr = objPtr;
-	Jim_IncrRefCount(objPtr);
-	refPtr->finalizerCmdNamePtr = cmdNamePtr;
-	if (cmdNamePtr)
-		Jim_IncrRefCount(cmdNamePtr);
-	Jim_AddHashEntry(&interp->references, &wideValue, refPtr);
-	refObjPtr = Jim_NewObj(interp);
-	refObjPtr->typePtr = &referenceObjType;
-	refObjPtr->bytes = NULL;
-	refObjPtr->internalRep.refValue.id = interp->referenceNextId;
-	refObjPtr->internalRep.refValue.refPtr = refPtr;
-	interp->referenceNextId++;
-	return refObjPtr;
+        Jim_Obj *cmdNamePtr)
+{
+    struct Jim_Reference *refPtr;
+    jim_wide wideValue = interp->referenceNextId;
+    Jim_Obj *refObjPtr;
+
+    /* Perform the Garbage Collection if needed. */
+    Jim_CollectIfNeeded(interp);
+
+    refPtr = Jim_Alloc(sizeof(*refPtr));
+    refPtr->objPtr = objPtr;
+    Jim_IncrRefCount(objPtr);
+    refPtr->finalizerCmdNamePtr = cmdNamePtr;
+    if (cmdNamePtr)
+        Jim_IncrRefCount(cmdNamePtr);
+    Jim_AddHashEntry(&interp->references, &wideValue, refPtr);
+    refObjPtr = Jim_NewObj(interp);
+    refObjPtr->typePtr = &referenceObjType;
+    refObjPtr->bytes = NULL;
+    refObjPtr->internalRep.refValue.id = interp->referenceNextId;
+    refObjPtr->internalRep.refValue.refPtr = refPtr;
+    interp->referenceNextId++;
+    return refObjPtr;
 }
 
 Jim_Reference *Jim_GetReference(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	if (objPtr->typePtr != &referenceObjType &&
-		SetReferenceFromAny(interp, objPtr) == JIM_ERR)
-		return NULL;
-	return objPtr->internalRep.refValue.refPtr;
+    if (objPtr->typePtr != &referenceObjType &&
+        SetReferenceFromAny(interp, objPtr) == JIM_ERR)
+        return NULL;
+    return objPtr->internalRep.refValue.refPtr;
 }
 
 /* -----------------------------------------------------------------------------
@@ -3361,12 +3360,12 @@ Jim_Reference *Jim_GetReference(Jim_Interp *interp, Jim_Obj *objPtr)
 
 /* This the hash table type for the "MARK" phase of the GC */
 static Jim_HashTableType Jim_RefMarkHashTableType = {
-	Jim_ReferencesHT_HashFunction,		/* hash function */
-	Jim_ReferencesHT_KeyDup,		/* key dup */
-	NULL,					/* val dup */
-	Jim_ReferencesHT_KeyCompare,		/* key compare */
-	Jim_ReferencesHT_KeyDestructor,		/* key destructor */
-	NULL					/* val destructor */
+    Jim_ReferencesHT_HashFunction,        /* hash function */
+    Jim_ReferencesHT_KeyDup,        /* key dup */
+    NULL,                    /* val dup */
+    Jim_ReferencesHT_KeyCompare,        /* key compare */
+    Jim_ReferencesHT_KeyDestructor,        /* key destructor */
+    NULL                    /* val destructor */
 };
 
 /* #define JIM_DEBUG_GC 1 */
@@ -3374,137 +3373,137 @@ static Jim_HashTableType Jim_RefMarkHashTableType = {
 /* 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, &Jim_RefMarkHashTableType, NULL);
-	objPtr = interp->liveList;
-	while(objPtr) {
-		if (objPtr->typePtr == NULL ||
-		    objPtr->typePtr->flags & JIM_TYPE_REFERENCES) {
-			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);
+    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, &Jim_RefMarkHashTableType, NULL);
+    objPtr = interp->liveList;
+    while(objPtr) {
+        if (objPtr->typePtr == NULL ||
+            objPtr->typePtr->flags & JIM_TYPE_REFERENCES) {
+            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\n", 
-					(int) objPtr->internalRep.refValue.id,
-					objPtr->refCount);
+                printf("MARK (reference): %d refcount: %d\n", 
+                    (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[31] != ':') break;
-				for (i = 11; i < 30; i++)
-					if (!isdigit((int)p[i]))
-						break;
-				/* Get the ID */
-				memcpy(buf, p+11, 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);
+                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[31] != ':') break;
+                for (i = 11; i < 30; i++)
+                    if (!isdigit((int)p[i]))
+                        break;
+                /* Get the ID */
+                memcpy(buf, p+11, 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\n", (int)id);
+                printf("MARK: %d\n", (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) {
-		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) {
+                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) {
+        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\n", (int)*refId);
+            printf("COLLECTING %d\n", (int)*refId);
 #endif
-			collected++;
-			/* Drop the reference, but call the
-			 * finalizer first if registered. */
-			refPtr = he->val;
-			if (refPtr->finalizerCmdNamePtr) {
-				char *refstr = Jim_Alloc(JIM_REFERENCE_SPACE+1);
-				Jim_Obj *objv[2], *oldResult;
-
-				Jim_WideToReferenceString(refstr, *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;
+            collected++;
+            /* Drop the reference, but call the
+             * finalizer first if registered. */
+            refPtr = he->val;
+            if (refPtr->finalizerCmdNamePtr) {
+                char *refstr = Jim_Alloc(JIM_REFERENCE_SPACE+1);
+                Jim_Obj *objv[2], *oldResult;
+
+                Jim_WideToReferenceString(refstr, *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;
 }
 
 #define JIM_COLLECT_ID_PERIOD 5000
@@ -3512,17 +3511,17 @@ int Jim_Collect(Jim_Interp *interp)
 
 void Jim_CollectIfNeeded(Jim_Interp *interp)
 {
-	jim_wide elapsedId;
-	int elapsedTime;
-	
-	elapsedId = interp->referenceNextId - interp->lastCollectId;
-	elapsedTime = time(NULL) - interp->lastCollectTime;
+    jim_wide elapsedId;
+    int elapsedTime;
+    
+    elapsedId = interp->referenceNextId - interp->lastCollectId;
+    elapsedTime = time(NULL) - interp->lastCollectTime;
 
 
-	if (elapsedId > JIM_COLLECT_ID_PERIOD ||
-	    elapsedTime > JIM_COLLECT_TIME_PERIOD) {
-		Jim_Collect(interp);
-	}
+    if (elapsedId > JIM_COLLECT_ID_PERIOD ||
+        elapsedTime > JIM_COLLECT_TIME_PERIOD) {
+        Jim_Collect(interp);
+    }
 }
 
 /* -----------------------------------------------------------------------------
@@ -3531,199 +3530,199 @@ void Jim_CollectIfNeeded(Jim_Interp *interp)
 
 Jim_Interp *Jim_CreateInterp(void)
 {
-	Jim_Interp *i = Jim_Alloc(sizeof(*i));
-
-	i->errorLine = 0;
-	i->errorFileName = Jim_StrDup("");
-	i->numLevels = 0;
-	i->maxNestingDepth = JIM_MAX_NESTING_DEPTH;
-	i->returnCode = JIM_OK;
-	i->procEpoch = 0;
-	i->callFrameEpoch = 0;
-	i->liveList = i->freeList = NULL;
-	i->scriptFileName = Jim_StrDup("");
-	i->referenceNextId = 0;
-	i->lastCollectId = 0;
-	i->lastCollectTime = time(NULL);
-	i->freeFramesList = NULL;
-
-	/* Note that we can create objects only after the
-	 * interpreter liveList and freeList pointers are
-	 * initialized to NULL. */
-	Jim_InitHashTable(&i->commands, &Jim_CommandsHashTableType, i);
-	Jim_InitHashTable(&i->references, &Jim_ReferencesHashTableType, i);
-	Jim_InitHashTable(&i->sharedStrings, &Jim_SharedStringsHashTableType,
-			NULL);
-	Jim_InitHashTable(&i->stub, &Jim_StringCopyHashTableType, NULL);
-	i->framePtr = i->topFramePtr = Jim_CreateCallFrame(i);
-	i->emptyObj = Jim_NewEmptyStringObj(i);
-	i->result = i->emptyObj;
-	i->stackTrace = Jim_NewListObj(i, NULL, 0);
-	i->unknown = Jim_NewStringObj(i, "unknown", -1);
-	Jim_IncrRefCount(i->emptyObj);
-	Jim_IncrRefCount(i->result);
-	Jim_IncrRefCount(i->stackTrace);
-	Jim_IncrRefCount(i->unknown);
-
-	/* Initialize key variables every interpreter should contain */
-	Jim_SetVariableString(i, "jim::libpath", "./ /usr/local/lib/jim");
-
-	/* Export the core API to extensions */
-	Jim_RegisterCoreApi(i);
-	return i;
+    Jim_Interp *i = Jim_Alloc(sizeof(*i));
+
+    i->errorLine = 0;
+    i->errorFileName = Jim_StrDup("");
+    i->numLevels = 0;
+    i->maxNestingDepth = JIM_MAX_NESTING_DEPTH;
+    i->returnCode = JIM_OK;
+    i->procEpoch = 0;
+    i->callFrameEpoch = 0;
+    i->liveList = i->freeList = NULL;
+    i->scriptFileName = Jim_StrDup("");
+    i->referenceNextId = 0;
+    i->lastCollectId = 0;
+    i->lastCollectTime = time(NULL);
+    i->freeFramesList = NULL;
+
+    /* Note that we can create objects only after the
+     * interpreter liveList and freeList pointers are
+     * initialized to NULL. */
+    Jim_InitHashTable(&i->commands, &Jim_CommandsHashTableType, i);
+    Jim_InitHashTable(&i->references, &Jim_ReferencesHashTableType, i);
+    Jim_InitHashTable(&i->sharedStrings, &Jim_SharedStringsHashTableType,
+            NULL);
+    Jim_InitHashTable(&i->stub, &Jim_StringCopyHashTableType, NULL);
+    i->framePtr = i->topFramePtr = Jim_CreateCallFrame(i);
+    i->emptyObj = Jim_NewEmptyStringObj(i);
+    i->result = i->emptyObj;
+    i->stackTrace = Jim_NewListObj(i, NULL, 0);
+    i->unknown = Jim_NewStringObj(i, "unknown", -1);
+    Jim_IncrRefCount(i->emptyObj);
+    Jim_IncrRefCount(i->result);
+    Jim_IncrRefCount(i->stackTrace);
+    Jim_IncrRefCount(i->unknown);
+
+    /* Initialize key variables every interpreter should contain */
+    Jim_SetVariableString(i, "jim::libpath", "./ /usr/local/lib/jim");
+
+    /* Export the core API to extensions */
+    Jim_RegisterCoreApi(i);
+    return i;
 }
 
 void Jim_FreeInterp(Jim_Interp *i)
 {
-	Jim_CallFrame *cf = i->framePtr, *prevcf, *nextcf;
-	Jim_Obj *objPtr, *nextObjPtr;
-
-	Jim_DecrRefCount(i, i->emptyObj);
-	Jim_DecrRefCount(i, i->result);
-	Jim_DecrRefCount(i, i->stackTrace);
-	Jim_DecrRefCount(i, i->unknown);
-	Jim_Free(i->errorFileName);
-	Jim_Free(i->scriptFileName);
-	Jim_FreeHashTable(&i->commands);
-	Jim_FreeHashTable(&i->references);
-	Jim_FreeHashTable(&i->stub);
-	/* Free the call frames list */
-	while(cf) {
-		prevcf = cf->parentCallFrame;
-		Jim_FreeCallFrame(i, cf);
-		cf = prevcf;
-	}
-	/* Check that the live object list is empty, otherwise
-	 * there is a memory leak. */
-	if (i->liveList != NULL) {
-		Jim_Obj *objPtr = i->liveList;
-	
-		printf("\n-------------------------------------\n");
-		printf("Objects still in the free list:\n");
-		while(objPtr) {
-			char *type = objPtr->typePtr ?
-				objPtr->typePtr->name : "";
-			printf("%p \"%-10s\": '%.20s' (refCount: %d)\n",
-					objPtr, type,
-					objPtr->bytes ? objPtr->bytes
-					: "(null)", objPtr->refCount);
-			if (objPtr->typePtr == &sourceObjType) {
-				printf("FILE %s LINE %d\n",
-				objPtr->internalRep.sourceValue.fileName,
-				objPtr->internalRep.sourceValue.lineNumber);
-			}
-			objPtr = objPtr->nextObjPtr;
-		}
-		printf("-------------------------------------\n\n");
-		Jim_Panic("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;
-		free(cf);
-		cf = nextcf;
-	}
-	/* 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);
+    Jim_CallFrame *cf = i->framePtr, *prevcf, *nextcf;
+    Jim_Obj *objPtr, *nextObjPtr;
+
+    Jim_DecrRefCount(i, i->emptyObj);
+    Jim_DecrRefCount(i, i->result);
+    Jim_DecrRefCount(i, i->stackTrace);
+    Jim_DecrRefCount(i, i->unknown);
+    Jim_Free(i->errorFileName);
+    Jim_Free(i->scriptFileName);
+    Jim_FreeHashTable(&i->commands);
+    Jim_FreeHashTable(&i->references);
+    Jim_FreeHashTable(&i->stub);
+    /* Free the call frames list */
+    while(cf) {
+        prevcf = cf->parentCallFrame;
+        Jim_FreeCallFrame(i, cf);
+        cf = prevcf;
+    }
+    /* Check that the live object list is empty, otherwise
+     * there is a memory leak. */
+    if (i->liveList != NULL) {
+        Jim_Obj *objPtr = i->liveList;
+    
+        printf("\n-------------------------------------\n");
+        printf("Objects still in the free list:\n");
+        while(objPtr) {
+            char *type = objPtr->typePtr ?
+                objPtr->typePtr->name : "";
+            printf("%p \"%-10s\": '%.20s' (refCount: %d)\n",
+                    objPtr, type,
+                    objPtr->bytes ? objPtr->bytes
+                    : "(null)", objPtr->refCount);
+            if (objPtr->typePtr == &sourceObjType) {
+                printf("FILE %s LINE %d\n",
+                objPtr->internalRep.sourceValue.fileName,
+                objPtr->internalRep.sourceValue.lineNumber);
+            }
+            objPtr = objPtr->nextObjPtr;
+        }
+        printf("-------------------------------------\n\n");
+        Jim_Panic("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;
+        free(cf);
+        cf = nextcf;
+    }
+    /* 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);
 }
 
 /* Store the call frame relative to the level represented by
  * levelObjPtr into *framePtrPtr. If levelObjPtr == NULL, the
  * level is assumed to be '1'. */
 int Jim_GetCallFrameByLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr,
-		Jim_CallFrame **framePtrPtr, int *newLevelPtr)
-{
-	long level;
-	char *str;
-	Jim_CallFrame *framePtr;
-
-	if (newLevelPtr) *newLevelPtr = interp->numLevels;
-	if (levelObjPtr) {
-		str = Jim_GetString(levelObjPtr, NULL);
-		if (str[0] == '#') {
-			char *endptr;
-			/* speedup for the toplevel (level #0) */
-			if (str[1] == '0' && str[2] == '\0') {
-				if (newLevelPtr) *newLevelPtr = 0;
-				*framePtrPtr = interp->topFramePtr;
-				return JIM_OK;
-			}
-
-			level = strtol(str+1, &endptr, 0);
-			if (str[1] == '\0' || endptr[0] != '\0' || level < 0)
-				goto badlevel;
-			/* An 'absolute' level is converted into the
-			 * 'number of levels to go back' format. */
-			level = interp->numLevels - level;
-			if (level < 0) goto badlevel;
-		} else {
-			if (Jim_GetLong(interp, levelObjPtr, &level) != JIM_OK
-				|| level < 0)
-				goto badlevel;
-		}
-	} else {
-		str = "1"; /* Needed to format the error message. */
-		level = 1;
-	}
-	/* Lookup */
-	framePtr = interp->framePtr;
-	if (newLevelPtr) *newLevelPtr = (*newLevelPtr)-level;
-	while (level--) {
-		framePtr = framePtr->parentCallFrame;
-		if (framePtr == NULL) goto badlevel;
-	}
-	*framePtrPtr = framePtr;
-	return JIM_OK;
+        Jim_CallFrame **framePtrPtr, int *newLevelPtr)
+{
+    long level;
+    char *str;
+    Jim_CallFrame *framePtr;
+
+    if (newLevelPtr) *newLevelPtr = interp->numLevels;
+    if (levelObjPtr) {
+        str = Jim_GetString(levelObjPtr, NULL);
+        if (str[0] == '#') {
+            char *endptr;
+            /* speedup for the toplevel (level #0) */
+            if (str[1] == '0' && str[2] == '\0') {
+                if (newLevelPtr) *newLevelPtr = 0;
+                *framePtrPtr = interp->topFramePtr;
+                return JIM_OK;
+            }
+
+            level = strtol(str+1, &endptr, 0);
+            if (str[1] == '\0' || endptr[0] != '\0' || level < 0)
+                goto badlevel;
+            /* An 'absolute' level is converted into the
+             * 'number of levels to go back' format. */
+            level = interp->numLevels - level;
+            if (level < 0) goto badlevel;
+        } else {
+            if (Jim_GetLong(interp, levelObjPtr, &level) != JIM_OK
+                || level < 0)
+                goto badlevel;
+        }
+    } else {
+        str = "1"; /* Needed to format the error message. */
+        level = 1;
+    }
+    /* Lookup */
+    framePtr = interp->framePtr;
+    if (newLevelPtr) *newLevelPtr = (*newLevelPtr)-level;
+    while (level--) {
+        framePtr = framePtr->parentCallFrame;
+        if (framePtr == NULL) goto badlevel;
+    }
+    *framePtrPtr = framePtr;
+    return JIM_OK;
 badlevel:
-	Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-	Jim_AppendStrings(interp, Jim_GetResult(interp),
-			"bad level \"", str, "\"", NULL);
-	return JIM_ERR;
+    Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+    Jim_AppendStrings(interp, Jim_GetResult(interp),
+            "bad level \"", str, "\"", NULL);
+    return JIM_ERR;
 }
 
 static void Jim_SetErrorFileName(Jim_Interp *interp, char *filename)
 {
-	Jim_Free(interp->errorFileName);
-	interp->errorFileName = Jim_StrDup(filename);
+    Jim_Free(interp->errorFileName);
+    interp->errorFileName = Jim_StrDup(filename);
 }
 
 static void Jim_SetErrorLineNumber(Jim_Interp *interp, int linenr)
 {
-	interp->errorLine = linenr;
+    interp->errorLine = linenr;
 }
 
 static void Jim_ResetStackTrace(Jim_Interp *interp)
 {
-	Jim_DecrRefCount(interp, interp->stackTrace);
-	interp->stackTrace = Jim_NewListObj(interp, NULL, 0);
-	Jim_IncrRefCount(interp->stackTrace);
+    Jim_DecrRefCount(interp, interp->stackTrace);
+    interp->stackTrace = Jim_NewListObj(interp, NULL, 0);
+    Jim_IncrRefCount(interp->stackTrace);
 }
 
 static void Jim_AppendStackTrace(Jim_Interp *interp, char *procname,
-		char *filename, int linenr)
+        char *filename, int linenr)
 {
-	if (Jim_IsShared(interp->stackTrace)) {
-		interp->stackTrace =
-			Jim_DuplicateObj(interp, interp->stackTrace);
-		Jim_IncrRefCount(interp->stackTrace);
-	}
-	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,
-			Jim_NewIntObj(interp, linenr));
+    if (Jim_IsShared(interp->stackTrace)) {
+        interp->stackTrace =
+            Jim_DuplicateObj(interp, interp->stackTrace);
+        Jim_IncrRefCount(interp->stackTrace);
+    }
+    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,
+            Jim_NewIntObj(interp, linenr));
 }
 
 /* -----------------------------------------------------------------------------
@@ -3743,37 +3742,37 @@ static void Jim_AppendStackTrace(Jim_Interp *interp, char *procname,
  * ---------------------------------------------------------------------------*/
 char *Jim_GetSharedString(Jim_Interp *interp, char *str)
 {
-	Jim_HashEntry *he = Jim_FindHashEntry(&interp->sharedStrings, str);
+    Jim_HashEntry *he = Jim_FindHashEntry(&interp->sharedStrings, str);
 
-	if (he == NULL) {
-		char *strCopy = Jim_StrDup(str);
+    if (he == NULL) {
+        char *strCopy = Jim_StrDup(str);
 
-		Jim_AddHashEntry(&interp->sharedStrings, strCopy, (void*)1);
-		return strCopy;
-	} else {
-		long refCount = (long) he->val;
+        Jim_AddHashEntry(&interp->sharedStrings, strCopy, (void*)1);
+        return strCopy;
+    } else {
+        long refCount = (long) he->val;
 
-		refCount++;
-		he->val = (void*) refCount;
-		return he->key;
-	}
+        refCount++;
+        he->val = (void*) refCount;
+        return he->key;
+    }
 }
 
 void Jim_ReleaseSharedString(Jim_Interp *interp, char *str)
 {
-	long refCount;
-	Jim_HashEntry *he = Jim_FindHashEntry(&interp->sharedStrings, str);
-
-	if (he == NULL)
-		Jim_Panic("Jim_ReleaseSharedString called with "
-			  "unknown shared string '%s'", str);
-	refCount = (long) he->val;
-	refCount--;
-	if (refCount == 0) {
-		Jim_DeleteHashEntry(&interp->sharedStrings, str);
-	} else {
-		he->val = (void*) refCount;
-	}
+    long refCount;
+    Jim_HashEntry *he = Jim_FindHashEntry(&interp->sharedStrings, str);
+
+    if (he == NULL)
+        Jim_Panic("Jim_ReleaseSharedString called with "
+              "unknown shared string '%s'", str);
+    refCount = (long) he->val;
+    refCount--;
+    if (refCount == 0) {
+        Jim_DeleteHashEntry(&interp->sharedStrings, str);
+    } else {
+        he->val = (void*) refCount;
+    }
 }
 
 /* -----------------------------------------------------------------------------
@@ -3785,94 +3784,94 @@ static void UpdateStringOfInt(struct Jim_Obj *objPtr);
 static int SetIntFromAny(Jim_Interp *interp, Jim_Obj *objPtr);
 
 static Jim_ObjType intObjType = {
-	"int",
-	NULL,
-	NULL,
-	UpdateStringOfInt,
-	JIM_TYPE_NONE,
+    "int",
+    NULL,
+    NULL,
+    UpdateStringOfInt,
+    JIM_TYPE_NONE,
 };
 
 void UpdateStringOfInt(struct Jim_Obj *objPtr)
 {
-	int len;
-	char buf[JIM_INTEGER_SPACE+1];
+    int len;
+    char buf[JIM_INTEGER_SPACE+1];
 
-	len = Jim_WideToString(buf, objPtr->internalRep.wideValue);
-	objPtr->bytes = Jim_Alloc(len+1);
-	memcpy(objPtr->bytes, buf, len+1);
-	objPtr->length = len;
+    len = Jim_WideToString(buf, objPtr->internalRep.wideValue);
+    objPtr->bytes = Jim_Alloc(len+1);
+    memcpy(objPtr->bytes, buf, len+1);
+    objPtr->length = len;
 }
 
 int SetIntFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	jim_wide wideValue;
-	char *str;
-
-	/* Get the string representation */
-	str = Jim_GetString(objPtr, NULL);
-	/* Try to convert into a jim_wide */
-	if (Jim_StringToWide(str, &wideValue, 0) != JIM_OK) {
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"expected integer but got \"", str, "\"", NULL);
-		return JIM_ERR;
-	}
-	if ((wideValue == JIM_WIDE_MIN || wideValue == JIM_WIDE_MAX) &&
-	    errno == ERANGE) {
-		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;
-	return JIM_OK;
+    jim_wide wideValue;
+    char *str;
+
+    /* Get the string representation */
+    str = Jim_GetString(objPtr, NULL);
+    /* Try to convert into a jim_wide */
+    if (Jim_StringToWide(str, &wideValue, 0) != JIM_OK) {
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "expected integer but got \"", str, "\"", NULL);
+        return JIM_ERR;
+    }
+    if ((wideValue == JIM_WIDE_MIN || wideValue == JIM_WIDE_MAX) &&
+        errno == ERANGE) {
+        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;
+    return JIM_OK;
 }
 
 int Jim_GetWide(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide *widePtr)
 {
-	if (objPtr->typePtr != &intObjType &&
-		SetIntFromAny(interp, objPtr) == JIM_ERR)
-		return JIM_ERR;
-	*widePtr = objPtr->internalRep.wideValue;
-	return JIM_OK;
+    if (objPtr->typePtr != &intObjType &&
+        SetIntFromAny(interp, objPtr) == JIM_ERR)
+        return JIM_ERR;
+    *widePtr = objPtr->internalRep.wideValue;
+    return JIM_OK;
 }
 
 int Jim_GetLong(Jim_Interp *interp, Jim_Obj *objPtr, long *longPtr)
 {
-	jim_wide wideValue;
-	int retval;
+    jim_wide wideValue;
+    int retval;
 
-	retval = Jim_GetWide(interp, objPtr, &wideValue);
-	if (retval == JIM_OK) {
-		*longPtr = (long) wideValue;
-		return JIM_OK;
-	}
-	return JIM_ERR;
+    retval = Jim_GetWide(interp, objPtr, &wideValue);
+    if (retval == JIM_OK) {
+        *longPtr = (long) wideValue;
+        return JIM_OK;
+    }
+    return JIM_ERR;
 }
 
 void Jim_SetWide(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide wideValue)
 {
-	if (Jim_IsShared(objPtr))
-		Jim_Panic("Jim_SetWide called with shared object");
-	if (objPtr->typePtr != &intObjType) {
-		Jim_FreeIntRep(interp, objPtr);
-		objPtr->typePtr = &intObjType;
-	}
-	Jim_InvalidateStringRep(objPtr);
-	objPtr->internalRep.wideValue = wideValue;
+    if (Jim_IsShared(objPtr))
+        Jim_Panic("Jim_SetWide called with shared object");
+    if (objPtr->typePtr != &intObjType) {
+        Jim_FreeIntRep(interp, objPtr);
+        objPtr->typePtr = &intObjType;
+    }
+    Jim_InvalidateStringRep(objPtr);
+    objPtr->internalRep.wideValue = wideValue;
 }
 
 Jim_Obj *Jim_NewIntObj(Jim_Interp *interp, jim_wide wideValue)
 {
-	Jim_Obj *objPtr;
+    Jim_Obj *objPtr;
 
-	objPtr = Jim_NewObj(interp);
-	objPtr->typePtr = &intObjType;
-	objPtr->bytes = NULL;
-	objPtr->internalRep.wideValue = wideValue;
-	return objPtr;
+    objPtr = Jim_NewObj(interp);
+    objPtr->typePtr = &intObjType;
+    objPtr->bytes = NULL;
+    objPtr->internalRep.wideValue = wideValue;
+    return objPtr;
 }
 
 /* -----------------------------------------------------------------------------
@@ -3884,75 +3883,75 @@ static void UpdateStringOfDouble(struct Jim_Obj *objPtr);
 static int SetDoubleFromAny(Jim_Interp *interp, Jim_Obj *objPtr);
 
 static Jim_ObjType doubleObjType = {
-	"double",
-	NULL,
-	NULL,
-	UpdateStringOfDouble,
-	JIM_TYPE_NONE,
+    "double",
+    NULL,
+    NULL,
+    UpdateStringOfDouble,
+    JIM_TYPE_NONE,
 };
 
 void UpdateStringOfDouble(struct Jim_Obj *objPtr)
 {
-	int len;
-	char buf[JIM_DOUBLE_SPACE+1];
+    int len;
+    char buf[JIM_DOUBLE_SPACE+1];
 
-	len = Jim_DoubleToString(buf, objPtr->internalRep.doubleValue);
-	objPtr->bytes = Jim_Alloc(len+1);
-	memcpy(objPtr->bytes, buf, len+1);
-	objPtr->length = len;
+    len = Jim_DoubleToString(buf, objPtr->internalRep.doubleValue);
+    objPtr->bytes = Jim_Alloc(len+1);
+    memcpy(objPtr->bytes, buf, len+1);
+    objPtr->length = len;
 }
 
 int SetDoubleFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	double doubleValue;
-	char *str;
-
-	/* Get the string representation */
-	str = Jim_GetString(objPtr, NULL);
-	/* Try to convert into a double */
-	if (Jim_StringToDouble(str, &doubleValue) != JIM_OK) {
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"expected number but got '", str, "'", NULL);
-		return JIM_ERR;
-	}
-	/* Free the old internal repr and set the new one. */
-	Jim_FreeIntRep(interp, objPtr);
-	objPtr->typePtr = &doubleObjType;
-	objPtr->internalRep.doubleValue = doubleValue;
-	return JIM_OK;
+    double doubleValue;
+    char *str;
+
+    /* Get the string representation */
+    str = Jim_GetString(objPtr, NULL);
+    /* Try to convert into a double */
+    if (Jim_StringToDouble(str, &doubleValue) != JIM_OK) {
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "expected number but got '", str, "'", NULL);
+        return JIM_ERR;
+    }
+    /* Free the old internal repr and set the new one. */
+    Jim_FreeIntRep(interp, objPtr);
+    objPtr->typePtr = &doubleObjType;
+    objPtr->internalRep.doubleValue = doubleValue;
+    return JIM_OK;
 }
 
 int Jim_GetDouble(Jim_Interp *interp, Jim_Obj *objPtr, double *doublePtr)
 {
-	if (objPtr->typePtr != &doubleObjType &&
-		SetDoubleFromAny(interp, objPtr) == JIM_ERR)
-		return JIM_ERR;
-	*doublePtr = objPtr->internalRep.doubleValue;
-	return JIM_OK;
+    if (objPtr->typePtr != &doubleObjType &&
+        SetDoubleFromAny(interp, objPtr) == JIM_ERR)
+        return JIM_ERR;
+    *doublePtr = objPtr->internalRep.doubleValue;
+    return JIM_OK;
 }
 
 void Jim_SetDouble(Jim_Interp *interp, Jim_Obj *objPtr, double doubleValue)
 {
-	if (Jim_IsShared(objPtr))
-		Jim_Panic("Jim_SetDouble called with shared object");
-	if (objPtr->typePtr != &doubleObjType) {
-		Jim_FreeIntRep(interp, objPtr);
-		objPtr->typePtr = &doubleObjType;
-	}
-	Jim_InvalidateStringRep(objPtr);
-	objPtr->internalRep.doubleValue = doubleValue;
+    if (Jim_IsShared(objPtr))
+        Jim_Panic("Jim_SetDouble called with shared object");
+    if (objPtr->typePtr != &doubleObjType) {
+        Jim_FreeIntRep(interp, objPtr);
+        objPtr->typePtr = &doubleObjType;
+    }
+    Jim_InvalidateStringRep(objPtr);
+    objPtr->internalRep.doubleValue = doubleValue;
 }
 
 Jim_Obj *Jim_NewDoubleObj(Jim_Interp *interp, double doubleValue)
 {
-	Jim_Obj *objPtr;
+    Jim_Obj *objPtr;
 
-	objPtr = Jim_NewObj(interp);
-	objPtr->typePtr = &doubleObjType;
-	objPtr->bytes = NULL;
-	objPtr->internalRep.doubleValue = doubleValue;
-	return objPtr;
+    objPtr = Jim_NewObj(interp);
+    objPtr->typePtr = &doubleObjType;
+    objPtr->bytes = NULL;
+    objPtr->internalRep.doubleValue = doubleValue;
+    return objPtr;
 }
 
 /* -----------------------------------------------------------------------------
@@ -3969,40 +3968,40 @@ static int SetListFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
  * list object string representation as a whole can't contain references
  * that are not presents in the single elements. */
 static Jim_ObjType listObjType = {
-	"list",
-	FreeListInternalRep,
-	DupListInternalRep,
-	UpdateStringOfList,
-	JIM_TYPE_NONE,
+    "list",
+    FreeListInternalRep,
+    DupListInternalRep,
+    UpdateStringOfList,
+    JIM_TYPE_NONE,
 };
 
 void FreeListInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	int i;
+    int i;
 
-	for (i = 0; i < objPtr->internalRep.listValue.len; i++) {
-		Jim_DecrRefCount(interp, objPtr->internalRep.listValue.ele[i]);
-	}
-	Jim_Free(objPtr->internalRep.listValue.ele);
+    for (i = 0; i < objPtr->internalRep.listValue.len; i++) {
+        Jim_DecrRefCount(interp, objPtr->internalRep.listValue.ele[i]);
+    }
+    Jim_Free(objPtr->internalRep.listValue.ele);
 }
 
 void DupListInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
 {
-	int i;
-	interp = interp; /* unused */
-
-	dupPtr->internalRep.listValue.len = srcPtr->internalRep.listValue.len;
-	dupPtr->internalRep.listValue.maxLen =
-		srcPtr->internalRep.listValue.maxLen;
-	dupPtr->internalRep.listValue.ele =
-		Jim_Alloc(sizeof(Jim_Obj*)*srcPtr->internalRep.listValue.maxLen);
-	memcpy(dupPtr->internalRep.listValue.ele,
-			srcPtr->internalRep.listValue.ele,
-			sizeof(Jim_Obj*)*srcPtr->internalRep.listValue.len);
-	for (i = 0; i < dupPtr->internalRep.listValue.len; i++) {
-		Jim_IncrRefCount(dupPtr->internalRep.listValue.ele[i]);
-	}
-	dupPtr->typePtr = &listObjType;
+    int i;
+    interp = interp; /* unused */
+
+    dupPtr->internalRep.listValue.len = srcPtr->internalRep.listValue.len;
+    dupPtr->internalRep.listValue.maxLen =
+        srcPtr->internalRep.listValue.maxLen;
+    dupPtr->internalRep.listValue.ele =
+        Jim_Alloc(sizeof(Jim_Obj*)*srcPtr->internalRep.listValue.maxLen);
+    memcpy(dupPtr->internalRep.listValue.ele,
+            srcPtr->internalRep.listValue.ele,
+            sizeof(Jim_Obj*)*srcPtr->internalRep.listValue.len);
+    for (i = 0; i < dupPtr->internalRep.listValue.len; i++) {
+        Jim_IncrRefCount(dupPtr->internalRep.listValue.ele[i]);
+    }
+    dupPtr->typePtr = &listObjType;
 }
 
 /* The following function checks if a given string can be encoded
@@ -4013,234 +4012,234 @@ void DupListInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
 #define JIM_ELESTR_QUOTE 2
 static int ListElementQuotingType(char *s, int len)
 {
-	int i, level, trySimple = 1;
-
-	/* Try with the SIMPLE case */
-	if (len == 0) return JIM_ELESTR_BRACE;
-	if (s[0] == '"' || s[0] == '{') {
-		trySimple = 0;
-		goto testbrace;
-	}
-	for (i = 0; i < len; i++) {
-		switch(s[i]) {
-		case ' ':
-		case '$':
-		case '"':
-		case '[':
-		case ']':
-		case ';':
-		case '\\':
-		case '\r':
-		case '\n':
-		case '\t':
-		case '\f':
-		case '\v':
-			trySimple = 0;
-		case '{':
-		case '}':
-			goto testbrace;
-		}
-	}
-	return JIM_ELESTR_SIMPLE;
+    int i, level, trySimple = 1;
+
+    /* Try with the SIMPLE case */
+    if (len == 0) return JIM_ELESTR_BRACE;
+    if (s[0] == '"' || s[0] == '{') {
+        trySimple = 0;
+        goto testbrace;
+    }
+    for (i = 0; i < len; i++) {
+        switch(s[i]) {
+        case ' ':
+        case '$':
+        case '"':
+        case '[':
+        case ']':
+        case ';':
+        case '\\':
+        case '\r':
+        case '\n':
+        case '\t':
+        case '\f':
+        case '\v':
+            trySimple = 0;
+        case '{':
+        case '}':
+            goto testbrace;
+        }
+    }
+    return JIM_ELESTR_SIMPLE;
 
 testbrace:
-	/* Test if it's possible to do with braces */
-	if (s[len-1] == '\\' ||
-	    s[len-1] == ']') return JIM_ELESTR_QUOTE;
-	level = 0;
-	for (i = 0; i < len; i++) {
-		switch(s[i]) {
-		case '{': level++; break;
-		case '}': level--;
-			  if (level < 0) return JIM_ELESTR_QUOTE;
-			  break;
-		case '\\':
-			  if (s[i+1] == '\n')
-				  return JIM_ELESTR_QUOTE;
-			  else
-				  if (s[i+1] != '\0') i++;
-			  break;
-		}
-	}
-	if (level == 0) {
-		if (!trySimple) return JIM_ELESTR_BRACE;
-		for (i = 0; i < len; i++) {
-			switch(s[i]) {
-			case ' ':
-			case '$':
-			case '"':
-			case '[':
-			case ']':
-			case ';':
-			case '\\':
-			case '\r':
-			case '\n':
-			case '\t':
-			case '\f':
-			case '\v':
-				return JIM_ELESTR_BRACE;
-				break;
-			}
-		}
-		return JIM_ELESTR_SIMPLE;
-	}
-	return JIM_ELESTR_QUOTE;
+    /* Test if it's possible to do with braces */
+    if (s[len-1] == '\\' ||
+        s[len-1] == ']') return JIM_ELESTR_QUOTE;
+    level = 0;
+    for (i = 0; i < len; i++) {
+        switch(s[i]) {
+        case '{': level++; break;
+        case '}': level--;
+              if (level < 0) return JIM_ELESTR_QUOTE;
+              break;
+        case '\\':
+              if (s[i+1] == '\n')
+                  return JIM_ELESTR_QUOTE;
+              else
+                  if (s[i+1] != '\0') i++;
+              break;
+        }
+    }
+    if (level == 0) {
+        if (!trySimple) return JIM_ELESTR_BRACE;
+        for (i = 0; i < len; i++) {
+            switch(s[i]) {
+            case ' ':
+            case '$':
+            case '"':
+            case '[':
+            case ']':
+            case ';':
+            case '\\':
+            case '\r':
+            case '\n':
+            case '\t':
+            case '\f':
+            case '\v':
+                return JIM_ELESTR_BRACE;
+                break;
+            }
+        }
+        return JIM_ELESTR_SIMPLE;
+    }
+    return JIM_ELESTR_QUOTE;
 }
 
 /* Returns the malloc-ed representation of a string
  * using backslash to quote special chars. */
 char *BackslashQuoteString(char *s, int len, int *qlenPtr)
 {
-	char *q = Jim_Alloc(len*2+1), *p;
-
-	p = q;
-	while(*s) {
-		switch (*s) {
-		case ' ':
-		case '$':
-		case '"':
-		case '[':
-		case ']':
-		case '{':
-		case '}':
-		case ';':
-		case '\\':
-			*p++ = '\\';
-			*p++ = *s++;
-			break;
-		case '\n': *p++ = '\\'; *p++ = 'n'; s++; break;
-		case '\r': *p++ = '\\'; *p++ = 'r'; s++; break;
-		case '\t': *p++ = '\\'; *p++ = 't'; s++; break;
-		case '\f': *p++ = '\\'; *p++ = 'f'; s++; break;
-		case '\v': *p++ = '\\'; *p++ = 'v'; s++; break;
-		default:
-			*p++ = *s++;
-			break;
-		}
-	}
-	*p = '\0';
-	*qlenPtr = p-q;
-	return q;
+    char *q = Jim_Alloc(len*2+1), *p;
+
+    p = q;
+    while(*s) {
+        switch (*s) {
+        case ' ':
+        case '$':
+        case '"':
+        case '[':
+        case ']':
+        case '{':
+        case '}':
+        case ';':
+        case '\\':
+            *p++ = '\\';
+            *p++ = *s++;
+            break;
+        case '\n': *p++ = '\\'; *p++ = 'n'; s++; break;
+        case '\r': *p++ = '\\'; *p++ = 'r'; s++; break;
+        case '\t': *p++ = '\\'; *p++ = 't'; s++; break;
+        case '\f': *p++ = '\\'; *p++ = 'f'; s++; break;
+        case '\v': *p++ = '\\'; *p++ = 'v'; s++; break;
+        default:
+            *p++ = *s++;
+            break;
+        }
+    }
+    *p = '\0';
+    *qlenPtr = p-q;
+    return q;
 }
 
 void UpdateStringOfList(struct Jim_Obj *objPtr)
 {
-	int i, bufLen, realLength;
-	char *strRep, *p;
-	int *quotingType;
-	Jim_Obj **ele = objPtr->internalRep.listValue.ele;
-
-	/* (Over) Estimate the space needed. */
-	quotingType = Jim_Alloc(sizeof(int)*objPtr->internalRep.listValue.len);
-	bufLen = 0;
-	for (i = 0; i < objPtr->internalRep.listValue.len; i++) {
-		int len;
-
-		strRep = Jim_GetString(ele[i], &len);
-		quotingType[i] = ListElementQuotingType(strRep, len);
-		switch (quotingType[i]) {
-		case JIM_ELESTR_SIMPLE:
-			bufLen += len;
-			break;
-		case JIM_ELESTR_BRACE:
-			bufLen += len+2;
-			break;
-		case JIM_ELESTR_QUOTE:
-			bufLen += len*2;
-			break;
-		}
-		bufLen++; /* elements separator. */
-	}
-	bufLen++;
-
-	/* Generate the string rep. */
-	p = objPtr->bytes = Jim_Alloc(bufLen+1);
-	realLength = 0;
-	for (i = 0; i < objPtr->internalRep.listValue.len; i++) {
-		int len, qlen;
-		char *strRep = Jim_GetString(ele[i], &len), *q;
-
-		switch(quotingType[i]) {
-		case JIM_ELESTR_SIMPLE:
-			memcpy(p, strRep, len);
-			p += len;
-			realLength += len;
-			break;
-		case JIM_ELESTR_BRACE:
-			*p++ = '{';
-			memcpy(p, strRep, len);
-			p += len;
-			*p++ = '}';
-			realLength += len+2;
-			break;
-		case JIM_ELESTR_QUOTE:
-			q = BackslashQuoteString(strRep, len, &qlen);
-			memcpy(p, q, qlen);
-			Jim_Free(q);
-			p += qlen;
-			realLength += qlen;
-			break;
-		}
-		/* Add a separating space */
-		if (i+1 != objPtr->internalRep.listValue.len) {
-			*p++ = ' ';
-			realLength ++;
-		}
-	}
-	*p = '\0'; /* nul term. */
-	objPtr->length = realLength;
-	free(quotingType);
+    int i, bufLen, realLength;
+    char *strRep, *p;
+    int *quotingType;
+    Jim_Obj **ele = objPtr->internalRep.listValue.ele;
+
+    /* (Over) Estimate the space needed. */
+    quotingType = Jim_Alloc(sizeof(int)*objPtr->internalRep.listValue.len);
+    bufLen = 0;
+    for (i = 0; i < objPtr->internalRep.listValue.len; i++) {
+        int len;
+
+        strRep = Jim_GetString(ele[i], &len);
+        quotingType[i] = ListElementQuotingType(strRep, len);
+        switch (quotingType[i]) {
+        case JIM_ELESTR_SIMPLE:
+            bufLen += len;
+            break;
+        case JIM_ELESTR_BRACE:
+            bufLen += len+2;
+            break;
+        case JIM_ELESTR_QUOTE:
+            bufLen += len*2;
+            break;
+        }
+        bufLen++; /* elements separator. */
+    }
+    bufLen++;
+
+    /* Generate the string rep. */
+    p = objPtr->bytes = Jim_Alloc(bufLen+1);
+    realLength = 0;
+    for (i = 0; i < objPtr->internalRep.listValue.len; i++) {
+        int len, qlen;
+        char *strRep = Jim_GetString(ele[i], &len), *q;
+
+        switch(quotingType[i]) {
+        case JIM_ELESTR_SIMPLE:
+            memcpy(p, strRep, len);
+            p += len;
+            realLength += len;
+            break;
+        case JIM_ELESTR_BRACE:
+            *p++ = '{';
+            memcpy(p, strRep, len);
+            p += len;
+            *p++ = '}';
+            realLength += len+2;
+            break;
+        case JIM_ELESTR_QUOTE:
+            q = BackslashQuoteString(strRep, len, &qlen);
+            memcpy(p, q, qlen);
+            Jim_Free(q);
+            p += qlen;
+            realLength += qlen;
+            break;
+        }
+        /* Add a separating space */
+        if (i+1 != objPtr->internalRep.listValue.len) {
+            *p++ = ' ';
+            realLength ++;
+        }
+    }
+    *p = '\0'; /* nul term. */
+    objPtr->length = realLength;
+    free(quotingType);
 }
 
 int SetListFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
 {
-	struct JimParserCtx parser;
-	char *str;
-
-	/* Get the string representation */
-	str = Jim_GetString(objPtr, NULL);
-
-	/* 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, 1);
-	while(!JimParserEof(&parser)) {
-		char *token;
-		int tokenLen, type;
-		Jim_Obj *elementPtr;
-
-		JimParseList(&parser);
-		if (JimParserTtype(&parser) != JIM_TT_STR &&
-		    JimParserTtype(&parser) != JIM_TT_ESC)
-			continue;
-		token = JimParserGetToken(&parser, &tokenLen, &type, NULL);
-		elementPtr = Jim_NewStringObjNoAlloc(interp, token, tokenLen);
-		ListAppendElement(objPtr, elementPtr);
-	}
-	return JIM_OK;
+    struct JimParserCtx parser;
+    char *str;
+
+    /* Get the string representation */
+    str = Jim_GetString(objPtr, NULL);
+
+    /* 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, 1);
+    while(!JimParserEof(&parser)) {
+        char *token;
+        int tokenLen, type;
+        Jim_Obj *elementPtr;
+
+        JimParseList(&parser);
+        if (JimParserTtype(&parser) != JIM_TT_STR &&
+            JimParserTtype(&parser) != JIM_TT_ESC)
+            continue;
+        token = JimParserGetToken(&parser, &tokenLen, &type, NULL);
+        elementPtr = Jim_NewStringObjNoAlloc(interp, token, tokenLen);
+        ListAppendElement(objPtr, elementPtr);
+    }
+    return JIM_OK;
 }
 
 Jim_Obj *Jim_NewListObj(Jim_Interp *interp, Jim_Obj **elements, int len)
 {
-	Jim_Obj *objPtr;
-	int i;
-
-	objPtr = Jim_NewObj(interp);
-	objPtr->typePtr = &listObjType;
-	objPtr->bytes = NULL;
-	objPtr->internalRep.listValue.ele = NULL;
-	objPtr->internalRep.listValue.len = 0;
-	objPtr->internalRep.listValue.maxLen = 0;
-	for (i = 0; i < len; i++) {
-		ListAppendElement(objPtr, elements[i]);
-	}
-	return objPtr;
+    Jim_Obj *objPtr;
+    int i;
+
+    objPtr = Jim_NewObj(interp);
+    objPtr->typePtr = &listObjType;
+    objPtr->bytes = NULL;
+    objPtr->internalRep.listValue.ele = NULL;
+    objPtr->internalRep.listValue.len = 0;
+    objPtr->internalRep.listValue.maxLen = 0;
+    for (i = 0; i < len; i++) {
+        ListAppendElement(objPtr, elements[i]);
+    }
+    return objPtr;
 }
 
 /* This is the low-level function to append an element to a list.
@@ -4252,215 +4251,215 @@ Jim_Obj *Jim_NewListObj(Jim_Interp *interp, Jim_Obj **elements, int len)
  * with internal type of List. */
 void ListAppendElement(Jim_Obj *listPtr, Jim_Obj *objPtr)
 {
-	int requiredLen = listPtr->internalRep.listValue.len + 1;
+    int requiredLen = listPtr->internalRep.listValue.len + 1;
 
-	if (requiredLen > listPtr->internalRep.listValue.maxLen) {
-		int maxLen = requiredLen * 2;
+    if (requiredLen > listPtr->internalRep.listValue.maxLen) {
+        int maxLen = requiredLen * 2;
 
-		listPtr->internalRep.listValue.ele =
-			Jim_Realloc(listPtr->internalRep.listValue.ele,
-					sizeof(Jim_Obj*)*maxLen);
-		listPtr->internalRep.listValue.maxLen = maxLen;
-	}
-	listPtr->internalRep.listValue.ele[listPtr->internalRep.listValue.len] =
-		objPtr;
-	listPtr->internalRep.listValue.len ++;
-	Jim_IncrRefCount(objPtr);
+        listPtr->internalRep.listValue.ele =
+            Jim_Realloc(listPtr->internalRep.listValue.ele,
+                    sizeof(Jim_Obj*)*maxLen);
+        listPtr->internalRep.listValue.maxLen = maxLen;
+    }
+    listPtr->internalRep.listValue.ele[listPtr->internalRep.listValue.len] =
+        objPtr;
+    listPtr->internalRep.listValue.len ++;
+    Jim_IncrRefCount(objPtr);
 }
 
 /* Appends every element of appendListPtr into listPtr.
  * Both have to be of the list type. */
 void ListAppendList(Jim_Obj *listPtr, Jim_Obj *appendListPtr)
 {
-	int i, oldLen = listPtr->internalRep.listValue.len;
-	int appendLen = appendListPtr->internalRep.listValue.len;
-	int requiredLen = oldLen + appendLen;
+    int i, oldLen = listPtr->internalRep.listValue.len;
+    int appendLen = appendListPtr->internalRep.listValue.len;
+    int requiredLen = oldLen + appendLen;
 
-	if (requiredLen > listPtr->internalRep.listValue.maxLen) {
-		int maxLen = requiredLen * 2;
+    if (requiredLen > listPtr->internalRep.listValue.maxLen) {
+        int maxLen = requiredLen * 2;
 
-		listPtr->internalRep.listValue.ele =
-			Jim_Realloc(listPtr->internalRep.listValue.ele,
-					sizeof(Jim_Obj*)*maxLen);
-		listPtr->internalRep.listValue.maxLen = maxLen;
-	}
-	for (i = 0; i < appendLen; i++) {
-		Jim_Obj *objPtr = appendListPtr->internalRep.listValue.ele[i];
-		listPtr->internalRep.listValue.ele[oldLen+i] = objPtr;
-		Jim_IncrRefCount(objPtr);
-	}
-	listPtr->internalRep.listValue.len += appendLen;
+        listPtr->internalRep.listValue.ele =
+            Jim_Realloc(listPtr->internalRep.listValue.ele,
+                    sizeof(Jim_Obj*)*maxLen);
+        listPtr->internalRep.listValue.maxLen = maxLen;
+    }
+    for (i = 0; i < appendLen; i++) {
+        Jim_Obj *objPtr = appendListPtr->internalRep.listValue.ele[i];
+        listPtr->internalRep.listValue.ele[oldLen+i] = objPtr;
+        Jim_IncrRefCount(objPtr);
+    }
+    listPtr->internalRep.listValue.len += appendLen;
 }
 
 void Jim_ListAppendElement(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *objPtr)
 {
-	if (Jim_IsShared(listPtr))
-		Jim_Panic("Jim_ListAppendElement called with shared object");
-	if (listPtr->typePtr != &listObjType)
-		SetListFromAny(interp, listPtr);
-	Jim_InvalidateStringRep(listPtr);
-	ListAppendElement(listPtr, objPtr);
+    if (Jim_IsShared(listPtr))
+        Jim_Panic("Jim_ListAppendElement called with shared object");
+    if (listPtr->typePtr != &listObjType)
+        SetListFromAny(interp, listPtr);
+    Jim_InvalidateStringRep(listPtr);
+    ListAppendElement(listPtr, objPtr);
 }
 
 void Jim_ListAppendList(Jim_Interp *interp, Jim_Obj *listPtr, Jim_Obj *appendListPtr)
 {
-	if (Jim_IsShared(listPtr))
-		Jim_Panic("Jim_ListAppendList called with shared object");
-	if (listPtr->typePtr != &listObjType)
-		SetListFromAny(interp, listPtr);
-	Jim_InvalidateStringRep(listPtr);
-	ListAppendList(listPtr, appendListPtr);
+    if (Jim_IsShared(listPtr))
+        Jim_Panic("Jim_ListAppendList called with shared object");
+    if (listPtr->typePtr != &listObjType)
+        SetListFromAny(interp, listPtr);
+    Jim_InvalidateStringRep(listPtr);
+    ListAppendList(listPtr, appendListPtr);
 }
 
 void Jim_ListLength(Jim_Interp *interp, Jim_Obj *listPtr, int *intPtr)
 {
-	if (listPtr->typePtr != &listObjType)
-		SetListFromAny(interp, listPtr);
-	*intPtr = listPtr->internalRep.listValue.len;
+    if (listPtr->typePtr != &listObjType)
+        SetListFromAny(interp, listPtr);
+    *intPtr = listPtr->internalRep.listValue.len;
 }
 
 int Jim_ListIndex(Jim_Interp *interp, Jim_Obj *listPtr, int index,
-		Jim_Obj **objPtrPtr, int flags)
-{
-	if (listPtr->typePtr != &listObjType)
-		SetListFromAny(interp, listPtr);
-	if ((index >= 0 && index >= listPtr->internalRep.listValue.len) ||
-	    (index < 0 && (-index-1) >= listPtr->internalRep.listValue.len)) {
-		if (flags & JIM_ERRMSG) {
-			Jim_SetResultString(interp,
-				"list index out of range", -1);
-		}
-		return JIM_ERR;
-	}
-	if (index < 0)
-		index = listPtr->internalRep.listValue.len+index;
-	*objPtrPtr = listPtr->internalRep.listValue.ele[index];
-	return JIM_OK;
+        Jim_Obj **objPtrPtr, int flags)
+{
+    if (listPtr->typePtr != &listObjType)
+        SetListFromAny(interp, listPtr);
+    if ((index >= 0 && index >= listPtr->internalRep.listValue.len) ||
+        (index < 0 && (-index-1) >= listPtr->internalRep.listValue.len)) {
+        if (flags & JIM_ERRMSG) {
+            Jim_SetResultString(interp,
+                "list index out of range", -1);
+        }
+        return JIM_ERR;
+    }
+    if (index < 0)
+        index = listPtr->internalRep.listValue.len+index;
+    *objPtrPtr = listPtr->internalRep.listValue.ele[index];
+    return JIM_OK;
 }
 
 static int ListSetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int index,
-		Jim_Obj *newObjPtr, int flags)
-{
-	if (listPtr->typePtr != &listObjType)
-		SetListFromAny(interp, listPtr);
-	if ((index >= 0 && index >= listPtr->internalRep.listValue.len) ||
-	    (index < 0 && (-index-1) >= listPtr->internalRep.listValue.len)) {
-		if (flags & JIM_ERRMSG) {
-			Jim_SetResultString(interp,
-				"list index out of range", -1);
-		}
-		return JIM_ERR;
-	}
-	if (index < 0)
-		index = listPtr->internalRep.listValue.len+index;
-	Jim_DecrRefCount(interp, listPtr->internalRep.listValue.ele[index]);
-	listPtr->internalRep.listValue.ele[index] = newObjPtr;
-	Jim_IncrRefCount(newObjPtr);
-	return JIM_OK;
+        Jim_Obj *newObjPtr, int flags)
+{
+    if (listPtr->typePtr != &listObjType)
+        SetListFromAny(interp, listPtr);
+    if ((index >= 0 && index >= listPtr->internalRep.listValue.len) ||
+        (index < 0 && (-index-1) >= listPtr->internalRep.listValue.len)) {
+        if (flags & JIM_ERRMSG) {
+            Jim_SetResultString(interp,
+                "list index out of range", -1);
+        }
+        return JIM_ERR;
+    }
+    if (index < 0)
+        index = listPtr->internalRep.listValue.len+index;
+    Jim_DecrRefCount(interp, listPtr->internalRep.listValue.ele[index]);
+    listPtr->internalRep.listValue.ele[index] = newObjPtr;
+    Jim_IncrRefCount(newObjPtr);
+    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 **indexv,
-		int indexc, Jim_Obj *newObjPtr)
-{
-	Jim_Obj *varObjPtr, *objPtr, *listObjPtr;
-	int shared, i, index;
-
-	varObjPtr = objPtr = Jim_GetVariable(interp, varNamePtr, JIM_ERRMSG);
-	if (objPtr == NULL)
-		return JIM_ERR;
-	if ((shared = Jim_IsShared(objPtr)))
-		varObjPtr = objPtr = Jim_DuplicateObj(interp, objPtr);
-	for (i = 0; i < indexc-1; i++) {
-		listObjPtr = objPtr;
-		if (Jim_GetIndex(interp, indexv[i], &index) != JIM_OK)
-			goto err;
-		if (Jim_ListIndex(interp, listObjPtr, index, &objPtr,
-					JIM_ERRMSG) != JIM_OK) {
-			goto err;
-		}
-		if (Jim_IsShared(objPtr)) {
-			objPtr = Jim_DuplicateObj(interp, objPtr);
-			ListSetIndex(interp, listObjPtr, index, objPtr,
-					JIM_NONE);
-		}
-		Jim_InvalidateStringRep(listObjPtr);
-	}
-	if (Jim_GetIndex(interp, indexv[indexc-1], &index) != JIM_OK)
-		goto err;
-	if (ListSetIndex(interp, objPtr, index, newObjPtr, JIM_ERRMSG)
-			== JIM_ERR) goto err;
-	Jim_InvalidateStringRep(objPtr);
-	Jim_InvalidateStringRep(varObjPtr);
-	if (shared) {
-		if (Jim_SetVariable(interp, varNamePtr, varObjPtr) != JIM_OK)
-			goto err;
-	}
-	Jim_SetResult(interp, varObjPtr);
-	return JIM_OK;
+        int indexc, Jim_Obj *newObjPtr)
+{
+    Jim_Obj *varObjPtr, *objPtr, *listObjPtr;
+    int shared, i, index;
+
+    varObjPtr = objPtr = Jim_GetVariable(interp, varNamePtr, JIM_ERRMSG);
+    if (objPtr == NULL)
+        return JIM_ERR;
+    if ((shared = Jim_IsShared(objPtr)))
+        varObjPtr = objPtr = Jim_DuplicateObj(interp, objPtr);
+    for (i = 0; i < indexc-1; i++) {
+        listObjPtr = objPtr;
+        if (Jim_GetIndex(interp, indexv[i], &index) != JIM_OK)
+            goto err;
+        if (Jim_ListIndex(interp, listObjPtr, index, &objPtr,
+                    JIM_ERRMSG) != JIM_OK) {
+            goto err;
+        }
+        if (Jim_IsShared(objPtr)) {
+            objPtr = Jim_DuplicateObj(interp, objPtr);
+            ListSetIndex(interp, listObjPtr, index, objPtr,
+                    JIM_NONE);
+        }
+        Jim_InvalidateStringRep(listObjPtr);
+    }
+    if (Jim_GetIndex(interp, indexv[indexc-1], &index) != JIM_OK)
+        goto err;
+    if (ListSetIndex(interp, objPtr, index, newObjPtr, JIM_ERRMSG)
+            == JIM_ERR) goto err;
+    Jim_InvalidateStringRep(objPtr);
+    Jim_InvalidateStringRep(varObjPtr);
+    if (shared) {
+        if (Jim_SetVariable(interp, varNamePtr, varObjPtr) != JIM_OK)
+            goto err;
+    }
+    Jim_SetResult(interp, varObjPtr);
+    return JIM_OK;
 err:
-	if (shared) {
-		Jim_IncrRefCount(varObjPtr);
-		Jim_DecrRefCount(interp, varObjPtr);
-	}
-	return JIM_ERR;
+    if (shared) {
+        Jim_IncrRefCount(varObjPtr);
+        Jim_DecrRefCount(interp, varObjPtr);
+    }
+    return JIM_ERR;
 }
 
 Jim_Obj *Jim_ConcatObj(Jim_Interp *interp, int objc, Jim_Obj **objv)
 {
-	int i;
-
-	/* If all the objects in objv are lists without string rep.
-	 * it's possible to return a list as result, that's the
-	 * concatenation of all the lists. */
-	for (i = 0; i < objc; i++) {
-		if (objv[i]->typePtr != &listObjType || objv[i]->bytes)
-			break;
-	}
-	if (i == objc) {
-		Jim_Obj *objPtr = Jim_NewListObj(interp, NULL, 0);
-		for (i = 0; i < objc; i++)
-			Jim_ListAppendList(interp, objPtr, objv[i]);
-		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 stinrg object holding it. */
-		p = bytes = Jim_Alloc(len+1);
-		for (i = 0; i < objc; i++) {
-			char *s = Jim_GetString(objv[i], &objLen);
-			while (objLen && (*s == ' ' || *s == '\t' ||
-						*s == '\n'))
-			{
-				s++; objLen--; len--;
-			}
-			while (objLen && (s[objLen-1] == ' ' ||
-				s[objLen-1] == '\n' || s[objLen-1] == '\t')) {
-				objLen--; len--;
-			}
-			memcpy(p, s, objLen);
-			p += objLen;
-			if (objLen && i+1 != objc) {
-				*p++ = ' ';
-			} else if (i+1 != objc) {
-				/* Drop the space calcuated for this
-				 * element that is instead null. */
-				len--;
-			}
-		}
-		*p = '\0';
-		return Jim_NewStringObjNoAlloc(interp, bytes, len);
-	}
+    int i;
+
+    /* If all the objects in objv are lists without string rep.
+     * it's possible to return a list as result, that's the
+     * concatenation of all the lists. */
+    for (i = 0; i < objc; i++) {
+        if (objv[i]->typePtr != &listObjType || objv[i]->bytes)
+            break;
+    }
+    if (i == objc) {
+        Jim_Obj *objPtr = Jim_NewListObj(interp, NULL, 0);
+        for (i = 0; i < objc; i++)
+            Jim_ListAppendList(interp, objPtr, objv[i]);
+        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 stinrg object holding it. */
+        p = bytes = Jim_Alloc(len+1);
+        for (i = 0; i < objc; i++) {
+            char *s = Jim_GetString(objv[i], &objLen);
+            while (objLen && (*s == ' ' || *s == '\t' ||
+                        *s == '\n'))
+            {
+                s++; objLen--; len--;
+            }
+            while (objLen && (s[objLen-1] == ' ' ||
+                s[objLen-1] == '\n' || s[objLen-1] == '\t')) {
+                objLen--; len--;
+            }
+            memcpy(p, s, objLen);
+            p += objLen;
+            if (objLen && i+1 != objc) {
+                *p++ = ' ';
+            } else if (i+1 != objc) {
+                /* Drop the space calcuated for this
+                 * element that is instead null. */
+                len--;
+            }
+        }
+        *p = '\0';
+        return Jim_NewStringObjNoAlloc(interp, bytes, len);
+    }
 }
 
 /* -----------------------------------------------------------------------------
@@ -4477,34 +4476,34 @@ static int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
 unsigned int Jim_ObjectHT_HashFunction(void *key)
 {
-	char *str;
-	int len;
+    char *str;
+    int len;
 
-	str = Jim_GetString(key, &len);
-	return Jim_DjbHashFunction(str, len);
+    str = Jim_GetString(key, &len);
+    return Jim_DjbHashFunction(str, len);
 }
 
 int Jim_ObjectHT_KeyCompare(void *privdata, void *key1, void *key2)
 {
-	privdata = privdata; /* not used */
+    privdata = privdata; /* not used */
 
-	return Jim_StringEqObj(key1, key2, 0);
+    return Jim_StringEqObj(key1, key2, 0);
 }
 
 static void Jim_ObjectHT_KeyValDestructor(void *interp, void *val)
 {
-	Jim_Obj *objPtr = val;
+    Jim_Obj *objPtr = val;
 
-	Jim_DecrRefCount(interp, objPtr);
+    Jim_DecrRefCount(interp, objPtr);
 }
 
 static Jim_HashTableType Jim_DictHashTableType = {
-	Jim_ObjectHT_HashFunction,		/* hash function */
-	NULL,					/* key dup */
-	NULL,					/* val dup */
-	Jim_ObjectHT_KeyCompare,		/* key compare */
-	Jim_ObjectHT_KeyValDestructor,		/* key destructor */
-	Jim_ObjectHT_KeyValDestructor		/* val destructor */
+    Jim_ObjectHT_HashFunction,        /* hash function */
+    NULL,                    /* key dup */
+    NULL,                    /* val dup */
+    Jim_ObjectHT_KeyCompare,        /* key compare */
+    Jim_ObjectHT_KeyValDestructor,        /* key destructor */
+    Jim_ObjectHT_KeyValDestructor        /* val destructor */
 };
 
 /* Note that while the elements of the dict may contain references,
@@ -4512,188 +4511,188 @@ static Jim_HashTableType Jim_DictHashTableType = {
  * dict object string representation as a whole can't contain references
  * that are not presents in the single elements. */
 static Jim_ObjType dictObjType = {
-	"dict",
-	FreeDictInternalRep,
-	DupDictInternalRep,
-	UpdateStringOfDict,
-	JIM_TYPE_NONE,
+    "dict",
+    FreeDictInternalRep,
+    DupDictInternalRep,
+    UpdateStringOfDict,
+    JIM_TYPE_NONE,
 };
 
 void FreeDictInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	interp = interp; /* not used */
+    interp = interp; /* not used */
 
-	Jim_FreeHashTable(objPtr->internalRep.ptr);
-	Jim_Free(objPtr->internalRep.ptr);
+    Jim_FreeHashTable(objPtr->internalRep.ptr);
+    Jim_Free(objPtr->internalRep.ptr);
 }
 
 void DupDictInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
 {
-	Jim_HashTable *ht, *dupHt;
-	Jim_HashTableIterator *htiter;
-	Jim_HashEntry *he;
-
-	/* Create a new hash table */
-	ht = srcPtr->internalRep.ptr;
-	dupHt = Jim_Alloc(sizeof(*dupHt));
-	Jim_InitHashTable(dupHt, &Jim_DictHashTableType, 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) {
-		Jim_Obj *keyObjPtr = he->key;
-		Jim_Obj *valObjPtr = he->val;
-
-		Jim_IncrRefCount(keyObjPtr);
-		Jim_IncrRefCount(valObjPtr);
-		Jim_AddHashEntry(dupHt, keyObjPtr, valObjPtr);
-	}
-	Jim_FreeHashTableIterator(htiter);
+    Jim_HashTable *ht, *dupHt;
+    Jim_HashTableIterator *htiter;
+    Jim_HashEntry *he;
+
+    /* Create a new hash table */
+    ht = srcPtr->internalRep.ptr;
+    dupHt = Jim_Alloc(sizeof(*dupHt));
+    Jim_InitHashTable(dupHt, &Jim_DictHashTableType, 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) {
+        Jim_Obj *keyObjPtr = he->key;
+        Jim_Obj *valObjPtr = he->val;
+
+        Jim_IncrRefCount(keyObjPtr);
+        Jim_IncrRefCount(valObjPtr);
+        Jim_AddHashEntry(dupHt, keyObjPtr, valObjPtr);
+    }
+    Jim_FreeHashTableIterator(htiter);
 
-	dupPtr->internalRep.ptr = dupHt;
-	dupPtr->typePtr = &dictObjType;
+    dupPtr->internalRep.ptr = dupHt;
+    dupPtr->typePtr = &dictObjType;
 }
 
 void UpdateStringOfDict(struct Jim_Obj *objPtr)
 {
-	int i, bufLen, realLength;
-	char *strRep, *p;
-	int *quotingType, objc;
-	Jim_HashTable *ht;
-	Jim_HashTableIterator *htiter;
-	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++] = he->key;
-		objv[i++] = he->val;
-	}
-	Jim_FreeHashTableIterator(htiter);
-	/* (Over) Estimate the space needed. */
-	quotingType = Jim_Alloc(sizeof(int)*objc);
-	bufLen = 0;
-	for (i = 0; i < objc; i++) {
-		int len;
-
-		strRep = Jim_GetString(objv[i], &len);
-		quotingType[i] = ListElementQuotingType(strRep, len);
-		switch (quotingType[i]) {
-		case JIM_ELESTR_SIMPLE:
-			bufLen += len;
-			break;
-		case JIM_ELESTR_BRACE:
-			bufLen += len+2;
-			break;
-		case JIM_ELESTR_QUOTE:
-			bufLen += len*2;
-			break;
-		}
-		bufLen++; /* elements separator. */
-	}
-	bufLen++;
-
-	/* Generate the string rep. */
-	p = objPtr->bytes = Jim_Alloc(bufLen+1);
-	realLength = 0;
-	for (i = 0; i < objc; i++) {
-		int len, qlen;
-		char *strRep = Jim_GetString(objv[i], &len), *q;
-
-		switch(quotingType[i]) {
-		case JIM_ELESTR_SIMPLE:
-			memcpy(p, strRep, len);
-			p += len;
-			realLength += len;
-			break;
-		case JIM_ELESTR_BRACE:
-			*p++ = '{';
-			memcpy(p, strRep, len);
-			p += len;
-			*p++ = '}';
-			realLength += len+2;
-			break;
-		case JIM_ELESTR_QUOTE:
-			q = BackslashQuoteString(strRep, len, &qlen);
-			memcpy(p, q, qlen);
-			Jim_Free(q);
-			p += qlen;
-			realLength += qlen;
-			break;
-		}
-		/* Add a separating space */
-		if (i+1 != objc) {
-			*p++ = ' ';
-			realLength ++;
-		}
-	}
-	*p = '\0'; /* nul term. */
-	objPtr->length = realLength;
-	free(quotingType);
-	free(objv);
+    int i, bufLen, realLength;
+    char *strRep, *p;
+    int *quotingType, objc;
+    Jim_HashTable *ht;
+    Jim_HashTableIterator *htiter;
+    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++] = he->key;
+        objv[i++] = he->val;
+    }
+    Jim_FreeHashTableIterator(htiter);
+    /* (Over) Estimate the space needed. */
+    quotingType = Jim_Alloc(sizeof(int)*objc);
+    bufLen = 0;
+    for (i = 0; i < objc; i++) {
+        int len;
+
+        strRep = Jim_GetString(objv[i], &len);
+        quotingType[i] = ListElementQuotingType(strRep, len);
+        switch (quotingType[i]) {
+        case JIM_ELESTR_SIMPLE:
+            bufLen += len;
+            break;
+        case JIM_ELESTR_BRACE:
+            bufLen += len+2;
+            break;
+        case JIM_ELESTR_QUOTE:
+            bufLen += len*2;
+            break;
+        }
+        bufLen++; /* elements separator. */
+    }
+    bufLen++;
+
+    /* Generate the string rep. */
+    p = objPtr->bytes = Jim_Alloc(bufLen+1);
+    realLength = 0;
+    for (i = 0; i < objc; i++) {
+        int len, qlen;
+        char *strRep = Jim_GetString(objv[i], &len), *q;
+
+        switch(quotingType[i]) {
+        case JIM_ELESTR_SIMPLE:
+            memcpy(p, strRep, len);
+            p += len;
+            realLength += len;
+            break;
+        case JIM_ELESTR_BRACE:
+            *p++ = '{';
+            memcpy(p, strRep, len);
+            p += len;
+            *p++ = '}';
+            realLength += len+2;
+            break;
+        case JIM_ELESTR_QUOTE:
+            q = BackslashQuoteString(strRep, len, &qlen);
+            memcpy(p, q, qlen);
+            Jim_Free(q);
+            p += qlen;
+            realLength += qlen;
+            break;
+        }
+        /* Add a separating space */
+        if (i+1 != objc) {
+            *p++ = ' ';
+            realLength ++;
+        }
+    }
+    *p = '\0'; /* nul term. */
+    objPtr->length = realLength;
+    free(quotingType);
+    free(objv);
 }
 
 int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
 {
-	struct JimParserCtx parser;
-	Jim_HashTable *ht;
-	Jim_Obj *objv[2];
-	char *str;
-	int i;
-
-	/* Get the string representation */
-	str = Jim_GetString(objPtr, NULL);
-
-	/* 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);
-	ht = Jim_Alloc(sizeof(*ht));
-	Jim_InitHashTable(ht, &Jim_DictHashTableType, interp);
-	objPtr->typePtr = &dictObjType;
-	objPtr->internalRep.ptr = ht;
-
-	/* Convert into a dict */
-	JimParserInit(&parser, str, 1);
-	i = 0;
-	while(!JimParserEof(&parser)) {
-		char *token;
-		int tokenLen, type;
-
-		JimParseList(&parser);
-		if (JimParserTtype(&parser) != JIM_TT_STR &&
-		    JimParserTtype(&parser) != JIM_TT_ESC)
-			continue;
-		token = JimParserGetToken(&parser, &tokenLen, &type, NULL);
-		objv[i++] = Jim_NewStringObjNoAlloc(interp, token, tokenLen);
-		if (i == 2) {
-			i = 0;
-			Jim_IncrRefCount(objv[0]);
-			Jim_IncrRefCount(objv[1]);
-			if (Jim_AddHashEntry(ht, objv[0], objv[1]) != JIM_OK) {
-				Jim_HashEntry *he;
-
-				he = Jim_FindHashEntry(ht, objv[0]);
-				Jim_DecrRefCount(interp, objv[0]);
-				Jim_DecrRefCount(interp, (Jim_Obj*)he->val);
-				he->val = objv[1];
-			}
-		}
-	}
-	if (i) {
-		Jim_IncrRefCount(objv[0]);
-		Jim_DecrRefCount(interp, objv[0]);
-		objPtr->typePtr = NULL;
-		Jim_FreeHashTable(ht);
-		Jim_SetResultString(interp, "missing value to go with key", -1);
-		return JIM_ERR;
-	}
-	return JIM_OK;
+    struct JimParserCtx parser;
+    Jim_HashTable *ht;
+    Jim_Obj *objv[2];
+    char *str;
+    int i;
+
+    /* Get the string representation */
+    str = Jim_GetString(objPtr, NULL);
+
+    /* 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);
+    ht = Jim_Alloc(sizeof(*ht));
+    Jim_InitHashTable(ht, &Jim_DictHashTableType, interp);
+    objPtr->typePtr = &dictObjType;
+    objPtr->internalRep.ptr = ht;
+
+    /* Convert into a dict */
+    JimParserInit(&parser, str, 1);
+    i = 0;
+    while(!JimParserEof(&parser)) {
+        char *token;
+        int tokenLen, type;
+
+        JimParseList(&parser);
+        if (JimParserTtype(&parser) != JIM_TT_STR &&
+            JimParserTtype(&parser) != JIM_TT_ESC)
+            continue;
+        token = JimParserGetToken(&parser, &tokenLen, &type, NULL);
+        objv[i++] = Jim_NewStringObjNoAlloc(interp, token, tokenLen);
+        if (i == 2) {
+            i = 0;
+            Jim_IncrRefCount(objv[0]);
+            Jim_IncrRefCount(objv[1]);
+            if (Jim_AddHashEntry(ht, objv[0], objv[1]) != JIM_OK) {
+                Jim_HashEntry *he;
+
+                he = Jim_FindHashEntry(ht, objv[0]);
+                Jim_DecrRefCount(interp, objv[0]);
+                Jim_DecrRefCount(interp, (Jim_Obj*)he->val);
+                he->val = objv[1];
+            }
+        }
+    }
+    if (i) {
+        Jim_IncrRefCount(objv[0]);
+        Jim_DecrRefCount(interp, objv[0]);
+        objPtr->typePtr = NULL;
+        Jim_FreeHashTable(ht);
+        Jim_SetResultString(interp, "missing value to go with key", -1);
+        return JIM_ERR;
+    }
+    return JIM_OK;
 }
 
 /* Dict object API */
@@ -4705,104 +4704,104 @@ int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
  *
  * if valueObjPtr == NULL, the key is instead removed if it exists. */
 static void DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr,
-		Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr)
+        Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr)
 {
-	Jim_HashTable *ht = objPtr->internalRep.ptr;
+    Jim_HashTable *ht = objPtr->internalRep.ptr;
 
-	if (valueObjPtr == NULL) { /* unset */
-		Jim_DeleteHashEntry(ht, keyObjPtr);
-		return;
-	}
-	Jim_IncrRefCount(keyObjPtr);
-	Jim_IncrRefCount(valueObjPtr);
-	if (Jim_AddHashEntry(ht, keyObjPtr, valueObjPtr) != JIM_OK) {
-		Jim_HashEntry *he = Jim_FindHashEntry(ht, keyObjPtr);
-		Jim_DecrRefCount(interp, keyObjPtr);
-		Jim_DecrRefCount(interp, (Jim_Obj*)he->val);
-		he->val = valueObjPtr;
-	}
+    if (valueObjPtr == NULL) { /* unset */
+        Jim_DeleteHashEntry(ht, keyObjPtr);
+        return;
+    }
+    Jim_IncrRefCount(keyObjPtr);
+    Jim_IncrRefCount(valueObjPtr);
+    if (Jim_AddHashEntry(ht, keyObjPtr, valueObjPtr) != JIM_OK) {
+        Jim_HashEntry *he = Jim_FindHashEntry(ht, keyObjPtr);
+        Jim_DecrRefCount(interp, keyObjPtr);
+        Jim_DecrRefCount(interp, (Jim_Obj*)he->val);
+        he->val = valueObjPtr;
+    }
 }
 
 /* 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)
+        Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr)
 {
-	if (Jim_IsShared(objPtr))
-		Jim_Panic("Jim_DictAddElement called with shared object");
-	if (objPtr->typePtr != &dictObjType) {
-		if (SetDictFromAny(interp, objPtr) != JIM_OK)
-			return JIM_ERR;
-	}
-	DictAddElement(interp, objPtr, keyObjPtr, valueObjPtr);
-	Jim_InvalidateStringRep(objPtr);
-	return JIM_OK;
+    if (Jim_IsShared(objPtr))
+        Jim_Panic("Jim_DictAddElement called with shared object");
+    if (objPtr->typePtr != &dictObjType) {
+        if (SetDictFromAny(interp, objPtr) != JIM_OK)
+            return JIM_ERR;
+    }
+    DictAddElement(interp, objPtr, keyObjPtr, valueObjPtr);
+    Jim_InvalidateStringRep(objPtr);
+    return JIM_OK;
 }
 
 Jim_Obj *Jim_NewDictObj(Jim_Interp *interp, Jim_Obj **elements, int len)
 {
-	Jim_Obj *objPtr;
-	int i;
+    Jim_Obj *objPtr;
+    int i;
 
-	if (len % 2)
-		Jim_Panic("Jim_NewDicObj() 'len' argument must be even");
+    if (len % 2)
+        Jim_Panic("Jim_NewDicObj() 'len' argument must be even");
 
-	objPtr = Jim_NewObj(interp);
-	objPtr->typePtr = &dictObjType;
-	objPtr->bytes = NULL;
-	objPtr->internalRep.ptr = Jim_Alloc(sizeof(Jim_HashTable));
-	Jim_InitHashTable(objPtr->internalRep.ptr, &Jim_DictHashTableType,
-			interp);
-	for (i = 0; i < len; i += 2)
-		DictAddElement(interp, objPtr, elements[i], elements[i+1]);
-	return objPtr;
+    objPtr = Jim_NewObj(interp);
+    objPtr->typePtr = &dictObjType;
+    objPtr->bytes = NULL;
+    objPtr->internalRep.ptr = Jim_Alloc(sizeof(Jim_HashTable));
+    Jim_InitHashTable(objPtr->internalRep.ptr, &Jim_DictHashTableType,
+            interp);
+    for (i = 0; i < len; i += 2)
+        DictAddElement(interp, objPtr, elements[i], elements[i+1]);
+    return objPtr;
 }
 
 /* Return the value associated to the specified dict key */
 int Jim_DictKey(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj *keyPtr,
-		Jim_Obj **objPtrPtr, int flags)
-{
-	Jim_HashEntry *he;
-	Jim_HashTable *ht;
-
-	if (dictPtr->typePtr != &dictObjType) {
-		if (SetDictFromAny(interp, dictPtr) != JIM_OK)
-			return JIM_ERR;
-	}
-	ht = dictPtr->internalRep.ptr;
-	if ((he = Jim_FindHashEntry(ht, keyPtr)) == NULL) {
-		if (flags & JIM_ERRMSG) {
-			Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-			Jim_AppendStrings(interp, Jim_GetResult(interp),
-					"key \"", Jim_GetString(keyPtr, NULL),
-					"\" not found in dictionary", NULL);
-		}
-		return JIM_ERR;
-	}
-	*objPtrPtr = he->val;
-	return JIM_OK;
+        Jim_Obj **objPtrPtr, int flags)
+{
+    Jim_HashEntry *he;
+    Jim_HashTable *ht;
+
+    if (dictPtr->typePtr != &dictObjType) {
+        if (SetDictFromAny(interp, dictPtr) != JIM_OK)
+            return JIM_ERR;
+    }
+    ht = dictPtr->internalRep.ptr;
+    if ((he = Jim_FindHashEntry(ht, keyPtr)) == NULL) {
+        if (flags & JIM_ERRMSG) {
+            Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+            Jim_AppendStrings(interp, Jim_GetResult(interp),
+                    "key \"", Jim_GetString(keyPtr, NULL),
+                    "\" not found in dictionary", NULL);
+        }
+        return JIM_ERR;
+    }
+    *objPtrPtr = he->val;
+    return JIM_OK;
 }
 
 /* Return the value associated to the specified dict keys */
 int Jim_DictKeysVector(Jim_Interp *interp, Jim_Obj *dictPtr,
-		Jim_Obj **keyv, int keyc, Jim_Obj **objPtrPtr, int flags)
+        Jim_Obj **keyv, int keyc, Jim_Obj **objPtrPtr, int flags)
 {
-	Jim_Obj *objPtr;
-	int i;
+    Jim_Obj *objPtr;
+    int i;
 
-	if (keyc == 0) {
-		*objPtrPtr = dictPtr;
-		return JIM_OK;
-	}
+    if (keyc == 0) {
+        *objPtrPtr = dictPtr;
+        return JIM_OK;
+    }
 
-	for (i = 0; i < keyc; i++) {
-		if (Jim_DictKey(interp, dictPtr, keyv[i], &objPtr, flags)
-				!= JIM_OK)
-			return JIM_ERR;
-		dictPtr = objPtr;
-	}
-	*objPtrPtr = objPtr;
-	return JIM_OK;
+    for (i = 0; i < keyc; i++) {
+        if (Jim_DictKey(interp, dictPtr, keyv[i], &objPtr, flags)
+                != JIM_OK)
+            return JIM_ERR;
+        dictPtr = objPtr;
+    }
+    *objPtrPtr = objPtr;
+    return JIM_OK;
 }
 
 /* Modify the dict stored into the variable named 'varNamePtr'
@@ -4812,71 +4811,71 @@ int Jim_DictKeysVector(Jim_Interp *interp, Jim_Obj *dictPtr,
  * 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 **keyv, int keyc, Jim_Obj *newObjPtr)
-{
-	Jim_Obj *varObjPtr, *objPtr, *dictObjPtr;
-	int shared, i;
-
-	varObjPtr = objPtr = Jim_GetVariable(interp, varNamePtr, JIM_ERRMSG);
-	if (objPtr == NULL) {
-		varObjPtr = objPtr = Jim_NewDictObj(interp, NULL, 0);
-		if (Jim_SetVariable(interp, varNamePtr, objPtr) != JIM_OK) {
-			Jim_IncrRefCount(varObjPtr);
-			Jim_DecrRefCount(interp, varObjPtr);
-			return JIM_ERR;
-		}
-	}
-	if ((shared = Jim_IsShared(objPtr)))
-		varObjPtr = objPtr = Jim_DuplicateObj(interp, objPtr);
-	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)
-				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)
-				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;
-	Jim_InvalidateStringRep(objPtr);
-	Jim_InvalidateStringRep(varObjPtr);
-	if (shared) {
-		if (Jim_SetVariable(interp, varNamePtr, varObjPtr) != JIM_OK)
-			goto err;
-	}
-	Jim_SetResult(interp, varObjPtr);
-	return JIM_OK;
+        Jim_Obj **keyv, int keyc, Jim_Obj *newObjPtr)
+{
+    Jim_Obj *varObjPtr, *objPtr, *dictObjPtr;
+    int shared, i;
+
+    varObjPtr = objPtr = Jim_GetVariable(interp, varNamePtr, JIM_ERRMSG);
+    if (objPtr == NULL) {
+        varObjPtr = objPtr = Jim_NewDictObj(interp, NULL, 0);
+        if (Jim_SetVariable(interp, varNamePtr, objPtr) != JIM_OK) {
+            Jim_IncrRefCount(varObjPtr);
+            Jim_DecrRefCount(interp, varObjPtr);
+            return JIM_ERR;
+        }
+    }
+    if ((shared = Jim_IsShared(objPtr)))
+        varObjPtr = objPtr = Jim_DuplicateObj(interp, objPtr);
+    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)
+                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)
+                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;
+    Jim_InvalidateStringRep(objPtr);
+    Jim_InvalidateStringRep(varObjPtr);
+    if (shared) {
+        if (Jim_SetVariable(interp, varNamePtr, varObjPtr) != JIM_OK)
+            goto err;
+    }
+    Jim_SetResult(interp, varObjPtr);
+    return JIM_OK;
 err:
-	if (shared) {
-		Jim_IncrRefCount(varObjPtr);
-		Jim_DecrRefCount(interp, varObjPtr);
-	}
-	return JIM_ERR;
+    if (shared) {
+        Jim_IncrRefCount(varObjPtr);
+        Jim_DecrRefCount(interp, varObjPtr);
+    }
+    return JIM_ERR;
 }
 
 
@@ -4887,84 +4886,84 @@ static void UpdateStringOfIndex(struct Jim_Obj *objPtr);
 static int SetIndexFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
 static Jim_ObjType indexObjType = {
-	"index",
-	NULL,
-	NULL,
-	UpdateStringOfIndex,
-	JIM_TYPE_NONE,
+    "index",
+    NULL,
+    NULL,
+    UpdateStringOfIndex,
+    JIM_TYPE_NONE,
 };
 
 void UpdateStringOfIndex(struct Jim_Obj *objPtr)
 {
-	int len;
-	char buf[JIM_INTEGER_SPACE+1];
+    int len;
+    char buf[JIM_INTEGER_SPACE+1];
 
-	if (objPtr->internalRep.indexValue >= 0)
-		len = sprintf(buf, "%d", objPtr->internalRep.indexValue);
-	else if (objPtr->internalRep.indexValue == -1)
-		len = sprintf(buf, "end");
-	else {
-		len = sprintf(buf, "end%d", objPtr->internalRep.indexValue+1);
-	}
-	objPtr->bytes = Jim_Alloc(len+1);
-	memcpy(objPtr->bytes, buf, len+1);
-	objPtr->length = len;
+    if (objPtr->internalRep.indexValue >= 0)
+        len = sprintf(buf, "%d", objPtr->internalRep.indexValue);
+    else if (objPtr->internalRep.indexValue == -1)
+        len = sprintf(buf, "end");
+    else {
+        len = sprintf(buf, "end%d", objPtr->internalRep.indexValue+1);
+    }
+    objPtr->bytes = Jim_Alloc(len+1);
+    memcpy(objPtr->bytes, buf, len+1);
+    objPtr->length = len;
 }
 
 int SetIndexFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	int index, end = 0;
-	char *str;
-
-	/* Get the string representation */
-	str = Jim_GetString(objPtr, NULL);
-	/* Try to convert into an index */
-	if (!strcmp(str, "end")) {
-		index = 0;
-		end = 1;
-	} else {
-		if (!strncmp(str, "end-", 4)) {
-			str += 4;
-			end = 1;
-		}
-		if (Jim_StringToIndex(str, &index) != JIM_OK) {
-			Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-			Jim_AppendStrings(interp, Jim_GetResult(interp),
-					"bad index \"", Jim_GetString(objPtr, NULL), "\": "
-					"must be integer or end?-integer?",
-					NULL);
-			return JIM_ERR;
-		}
-	}
-	if (end) {
-		if (index < 0)
-			index = INT_MAX;
-		else
-			index = -(index+1);
-	} else if (!end && index < 0)
-		index = INT_MAX;
-	/* Free the old internal repr and set the new one. */
-	Jim_FreeIntRep(interp, objPtr);
-	objPtr->typePtr = &indexObjType;
-	objPtr->internalRep.indexValue = index;
-	return JIM_OK;
+    int index, end = 0;
+    char *str;
+
+    /* Get the string representation */
+    str = Jim_GetString(objPtr, NULL);
+    /* Try to convert into an index */
+    if (!strcmp(str, "end")) {
+        index = 0;
+        end = 1;
+    } else {
+        if (!strncmp(str, "end-", 4)) {
+            str += 4;
+            end = 1;
+        }
+        if (Jim_StringToIndex(str, &index) != JIM_OK) {
+            Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+            Jim_AppendStrings(interp, Jim_GetResult(interp),
+                    "bad index \"", Jim_GetString(objPtr, NULL), "\": "
+                    "must be integer or end?-integer?",
+                    NULL);
+            return JIM_ERR;
+        }
+    }
+    if (end) {
+        if (index < 0)
+            index = INT_MAX;
+        else
+            index = -(index+1);
+    } else if (!end && index < 0)
+        index = INT_MAX;
+    /* Free the old internal repr and set the new one. */
+    Jim_FreeIntRep(interp, objPtr);
+    objPtr->typePtr = &indexObjType;
+    objPtr->internalRep.indexValue = index;
+    return JIM_OK;
 }
 
 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 = objPtr->internalRep.wideValue;
-		if (!(val < LONG_MIN) && !(val > LONG_MAX)) {
-			*indexPtr = (val < 0) ? INT_MAX : (long)val;;
-			return JIM_OK;
-		}
-	}
-	if (objPtr->typePtr != &indexObjType &&
-		SetIndexFromAny(interp, objPtr) == JIM_ERR)
-		return JIM_ERR;
-	*indexPtr = objPtr->internalRep.indexValue;
-	return JIM_OK;
+    /* Avoid shimmering if the object is an integer. */
+    if (objPtr->typePtr == &intObjType) {
+        jim_wide val = objPtr->internalRep.wideValue;
+        if (!(val < LONG_MIN) && !(val > LONG_MAX)) {
+            *indexPtr = (val < 0) ? INT_MAX : (long)val;;
+            return JIM_OK;
+        }
+    }
+    if (objPtr->typePtr != &indexObjType &&
+        SetIndexFromAny(interp, objPtr) == JIM_ERR)
+        return JIM_ERR;
+    *indexPtr = objPtr->internalRep.indexValue;
+    return JIM_OK;
 }
 
 /* -----------------------------------------------------------------------------
@@ -4974,52 +4973,52 @@ int Jim_GetIndex(Jim_Interp *interp, Jim_Obj *objPtr, int *indexPtr)
 static int SetReturnCodeFromAny(Jim_Interp *interp, Jim_Obj *objPtr);
 
 static Jim_ObjType returnCodeObjType = {
-	"return-code",
-	NULL,
-	NULL,
-	NULL,
-	JIM_TYPE_NONE,
+    "return-code",
+    NULL,
+    NULL,
+    NULL,
+    JIM_TYPE_NONE,
 };
 
 int SetReturnCodeFromAny(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	char *str;
-	int returnCode;
-
-	/* Get the string representation */
-	str = Jim_GetString(objPtr, NULL);
-	/* Try to convert into a jim_wide */
-	if (!strcasecmp(str, "ok"))
-		returnCode = JIM_OK;
-	else if (!strcasecmp(str, "error"))
-		returnCode = JIM_ERR;
-	else if (!strcasecmp(str, "return"))
-		returnCode = JIM_RETURN;
-	else if (!strcasecmp(str, "break"))
-		returnCode = JIM_BREAK;
-	else if (!strcasecmp(str, "continue"))
-		returnCode = JIM_CONTINUE;
-	else {
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"expected return code but got '", str, "'",
-				NULL);
-		return JIM_ERR;
-	}
-	/* Free the old internal repr and set the new one. */
-	Jim_FreeIntRep(interp, objPtr);
-	objPtr->typePtr = &returnCodeObjType;
-	objPtr->internalRep.returnCode = returnCode;
-	return JIM_OK;
+    char *str;
+    int returnCode;
+
+    /* Get the string representation */
+    str = Jim_GetString(objPtr, NULL);
+    /* Try to convert into a jim_wide */
+    if (!strcasecmp(str, "ok"))
+        returnCode = JIM_OK;
+    else if (!strcasecmp(str, "error"))
+        returnCode = JIM_ERR;
+    else if (!strcasecmp(str, "return"))
+        returnCode = JIM_RETURN;
+    else if (!strcasecmp(str, "break"))
+        returnCode = JIM_BREAK;
+    else if (!strcasecmp(str, "continue"))
+        returnCode = JIM_CONTINUE;
+    else {
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "expected return code but got '", str, "'",
+                NULL);
+        return JIM_ERR;
+    }
+    /* Free the old internal repr and set the new one. */
+    Jim_FreeIntRep(interp, objPtr);
+    objPtr->typePtr = &returnCodeObjType;
+    objPtr->internalRep.returnCode = returnCode;
+    return JIM_OK;
 }
 
 int Jim_GetReturnCode(Jim_Interp *interp, Jim_Obj *objPtr, int *intPtr)
 {
-	if (objPtr->typePtr != &returnCodeObjType &&
-		SetReturnCodeFromAny(interp, objPtr) == JIM_ERR)
-		return JIM_ERR;
-	*intPtr = objPtr->internalRep.returnCode;
-	return JIM_OK;
+    if (objPtr->typePtr != &returnCodeObjType &&
+        SetReturnCodeFromAny(interp, objPtr) == JIM_ERR)
+        return JIM_ERR;
+    *intPtr = objPtr->internalRep.returnCode;
+    return JIM_OK;
 }
 
 /* -----------------------------------------------------------------------------
@@ -5031,10 +5030,10 @@ static int JimParseExprIrrational(struct JimParserCtx *pc);
 
 /* Operators table */
 typedef struct Jim_ExprOperator {
-	char *name;
-	int precedence;
-	int arity;
-	int opcode;
+    char *name;
+    int precedence;
+    int arity;
+    int opcode;
 } Jim_ExprOperator;
 
 /* Exrp's Stack machine operators opcodes. */
@@ -5086,132 +5085,132 @@ typedef struct Jim_ExprOperator {
 #define JIM_EXPROP_STRING 32
 
 static struct Jim_ExprOperator Jim_ExprOperators[] = {
-	{"!", 300, 1, JIM_EXPROP_NOT},
-	{"~", 300, 1, JIM_EXPROP_BITNOT},
-	{"unarymin", 300, 1, JIM_EXPROP_UNARYMINUS},
-	{"unaryplus", 300, 1, JIM_EXPROP_UNARYPLUS},
+    {"!", 300, 1, JIM_EXPROP_NOT},
+    {"~", 300, 1, JIM_EXPROP_BITNOT},
+    {"unarymin", 300, 1, JIM_EXPROP_UNARYMINUS},
+    {"unaryplus", 300, 1, JIM_EXPROP_UNARYPLUS},
 
-	{"*", 200, 2, JIM_EXPROP_MUL},
-	{"/", 200, 2, JIM_EXPROP_DIV},
-	{"%", 200, 2, JIM_EXPROP_MOD},
+    {"*", 200, 2, JIM_EXPROP_MUL},
+    {"/", 200, 2, JIM_EXPROP_DIV},
+    {"%", 200, 2, JIM_EXPROP_MOD},
 
-	{"-", 100, 2, JIM_EXPROP_SUB},
-	{"+", 100, 2, JIM_EXPROP_ADD},
+    {"-", 100, 2, JIM_EXPROP_SUB},
+    {"+", 100, 2, JIM_EXPROP_ADD},
 
-	{"<<<", 90, 3, JIM_EXPROP_ROTL},
-	{">>>", 90, 3, JIM_EXPROP_ROTR},
-	{"<<", 90, 2, JIM_EXPROP_LSHIFT},
-	{">>", 90, 2, JIM_EXPROP_RSHIFT},
+    {"<<<", 90, 3, JIM_EXPROP_ROTL},
+    {">>>", 90, 3, JIM_EXPROP_ROTR},
+    {"<<", 90, 2, JIM_EXPROP_LSHIFT},
+    {">>", 90, 2, JIM_EXPROP_RSHIFT},
 
-	{"<",  80, 2, JIM_EXPROP_LT},
-	{">",  80, 2, JIM_EXPROP_GT},
-	{"<=", 80, 2, JIM_EXPROP_LTE},
-	{">=", 80, 2, JIM_EXPROP_GTE},
+    {"<",  80, 2, JIM_EXPROP_LT},
+    {">",  80, 2, JIM_EXPROP_GT},
+    {"<=", 80, 2, JIM_EXPROP_LTE},
+    {">=", 80, 2, JIM_EXPROP_GTE},
 
-	{"==", 70, 2, JIM_EXPROP_NUMEQ},
-	{"!=", 70, 2, JIM_EXPROP_NUMNE},
+    {"==", 70, 2, JIM_EXPROP_NUMEQ},
+    {"!=", 70, 2, JIM_EXPROP_NUMNE},
 
-	{"eq", 60, 2, JIM_EXPROP_STREQ},
-	{"ne", 60, 2, JIM_EXPROP_STRNE},
+    {"eq", 60, 2, JIM_EXPROP_STREQ},
+    {"ne", 60, 2, JIM_EXPROP_STRNE},
 
-	{"&", 50, 2, JIM_EXPROP_BITAND},
-	{"^", 49, 2, JIM_EXPROP_BITXOR},
-	{"|", 48, 2, JIM_EXPROP_BITOR},
+    {"&", 50, 2, JIM_EXPROP_BITAND},
+    {"^", 49, 2, JIM_EXPROP_BITXOR},
+    {"|", 48, 2, JIM_EXPROP_BITOR},
 
-	{"&&", 10, 2, JIM_EXPROP_LOGICAND},
-	{"||", 10, 2, JIM_EXPROP_LOGICOR},
+    {"&&", 10, 2, JIM_EXPROP_LOGICAND},
+    {"||", 10, 2, JIM_EXPROP_LOGICOR},
 
-	{"?", 5, 3, JIM_EXPROP_TERNARY},
+    {"?", 5, 3, JIM_EXPROP_TERNARY},
 };
 
 #define JIM_EXPR_OPERATORS_NUM \
-	(sizeof(Jim_ExprOperators)/sizeof(struct Jim_ExprOperator))
+    (sizeof(Jim_ExprOperators)/sizeof(struct Jim_ExprOperator))
 
 int JimParseExpression(struct JimParserCtx *pc)
 {
-	/* Discard spaces and quoted newline */
-	while(*(pc->p) == ' ' ||
-	      *(pc->p) == '\t' ||
-	      *(pc->p) == '\r' ||
-	      *(pc->p) == '\n' ||
-		    (*(pc->p) == '\\' && *(pc->p+1) == '\n')) {
-		pc->p++;
-	}
-
-	switch(*(pc->p)) {
-	case '\0':
-		pc->tstart = pc->tend = pc->p;
-		pc->tline = pc->linenr;
-		pc->tt = JIM_TT_EOL;
-		pc->eof = 1;
-		break;
-	case '(':
-		pc->tstart = pc->tend = pc->p;
-		pc->tline = pc->linenr;
-		pc->tt = JIM_TT_SUBEXPR_START;
-		pc->p++;
-		break;
-	case ')':
-		pc->tstart = pc->tend = pc->p;
-		pc->tline = pc->linenr;
-		pc->tt = JIM_TT_SUBEXPR_END;
-		pc->p++;
-		break;
-	case '[':
-		return JimParseCmd(pc);
-		break;
-	case '$':
-		if (JimParseVar(pc) == JIM_ERR)
-			return JimParseExprOperator(pc);
-		else
-			return JIM_OK;
-		break;
-	case '-':
-		if ((pc->tt == JIM_TT_NONE || pc->tt == JIM_TT_EXPR_OPERATOR) &&
-		    isdigit((int)*(pc->p+1)))
-			return JimParseExprNumber(pc);
-		else
-			return JimParseExprOperator(pc);
-		break;
-	case '0': case '1': case '2': case '3': case '4':
-	case '5': case '6': case '7': case '8': case '9': case '.':
-		return JimParseExprNumber(pc);
-		break;
-	case '"':
-	case '{':
-		/* Here it's possible to reuse the List String parsing. */
-		pc->tt = JIM_TT_NONE; /* Make sure it's sensed as a new word. */
-		return JimParseListStr(pc);
-		break;
-	case 'N': case 'I':
-	case 'n': case 'i':
-		if (JimParseExprIrrational(pc) == JIM_ERR)
-		    return JimParseExprOperator(pc);
-		break;
-	default:
-		return JimParseExprOperator(pc);
-		break;
-	}
-	return JIM_OK;
+    /* Discard spaces and quoted newline */
+    while(*(pc->p) == ' ' ||
+          *(pc->p) == '\t' ||
+          *(pc->p) == '\r' ||
+          *(pc->p) == '\n' ||
+            (*(pc->p) == '\\' && *(pc->p+1) == '\n')) {
+        pc->p++;
+    }
+
+    switch(*(pc->p)) {
+    case '\0':
+        pc->tstart = pc->tend = pc->p;
+        pc->tline = pc->linenr;
+        pc->tt = JIM_TT_EOL;
+        pc->eof = 1;
+        break;
+    case '(':
+        pc->tstart = pc->tend = pc->p;
+        pc->tline = pc->linenr;
+        pc->tt = JIM_TT_SUBEXPR_START;
+        pc->p++;
+        break;
+    case ')':
+        pc->tstart = pc->tend = pc->p;
+        pc->tline = pc->linenr;
+        pc->tt = JIM_TT_SUBEXPR_END;
+        pc->p++;
+        break;
+    case '[':
+        return JimParseCmd(pc);
+        break;
+    case '$':
+        if (JimParseVar(pc) == JIM_ERR)
+            return JimParseExprOperator(pc);
+        else
+            return JIM_OK;
+        break;
+    case '-':
+        if ((pc->tt == JIM_TT_NONE || pc->tt == JIM_TT_EXPR_OPERATOR) &&
+            isdigit((int)*(pc->p+1)))
+            return JimParseExprNumber(pc);
+        else
+            return JimParseExprOperator(pc);
+        break;
+    case '0': case '1': case '2': case '3': case '4':
+    case '5': case '6': case '7': case '8': case '9': case '.':
+        return JimParseExprNumber(pc);
+        break;
+    case '"':
+    case '{':
+        /* Here it's possible to reuse the List String parsing. */
+        pc->tt = JIM_TT_NONE; /* Make sure it's sensed as a new word. */
+        return JimParseListStr(pc);
+        break;
+    case 'N': case 'I':
+    case 'n': case 'i':
+        if (JimParseExprIrrational(pc) == JIM_ERR)
+            return JimParseExprOperator(pc);
+        break;
+    default:
+        return JimParseExprOperator(pc);
+        break;
+    }
+    return JIM_OK;
 }
 
 int JimParseExprNumber(struct JimParserCtx *pc)
 {
-	int allowdot = 1;
-
-	pc->tstart = pc->p;
-	pc->tline = pc->linenr;
-	if (*pc->p == '-') pc->p++;
-	while (isdigit((int)*pc->p) || (allowdot && *pc->p == '.')) {
-		if (*pc->p == '.')
-			allowdot = 0;
-		pc->p++;
-		if (!allowdot && *pc->p == 'e' && *(pc->p+1) == '-')
-			pc->p += 2;
-	}
-	pc->tend = pc->p-1;
-	pc->tt = JIM_TT_EXPR_NUMBER;
-	return JIM_OK;
+    int allowdot = 1;
+
+    pc->tstart = pc->p;
+    pc->tline = pc->linenr;
+    if (*pc->p == '-') pc->p++;
+    while (isdigit((int)*pc->p) || (allowdot && *pc->p == '.')) {
+        if (*pc->p == '.')
+            allowdot = 0;
+        pc->p++;
+        if (!allowdot && *pc->p == 'e' && *(pc->p+1) == '-')
+            pc->p += 2;
+    }
+    pc->tend = pc->p-1;
+    pc->tt = JIM_TT_EXPR_NUMBER;
+    return JIM_OK;
 }
 
 int JimParseExprIrrational(struct JimParserCtx *pc)
@@ -5219,50 +5218,50 @@ int JimParseExprIrrational(struct JimParserCtx *pc)
     const char *Tokens[] = {"NaN", "nan", "NAN", "Inf", "inf", "INF", NULL};
     const char **token;
     for (token = Tokens; *token != NULL; token++) {
-	int len = strlen(*token);
-	if (strncmp(*token, pc->p, len) == 0) {
-	    pc->tstart = pc->p;
-	    pc->tend = pc->p + len - 1;
-	    pc->p += len;
-	    pc->tline = pc->linenr;
-	    pc->tt = JIM_TT_EXPR_NUMBER;
-	    return JIM_OK;
-	}
+    int len = strlen(*token);
+    if (strncmp(*token, pc->p, len) == 0) {
+        pc->tstart = pc->p;
+        pc->tend = pc->p + len - 1;
+        pc->p += len;
+        pc->tline = pc->linenr;
+        pc->tt = JIM_TT_EXPR_NUMBER;
+        return JIM_OK;
+    }
     }
     return JIM_ERR;
 }
 
 int JimParseExprOperator(struct JimParserCtx *pc)
 {
-	int i;
-	int bestIdx = -1, bestLen = 0;
+    int i;
+    int bestIdx = -1, bestLen = 0;
 
-	/* Try to get the longest match. */
-	for (i = 0; i < (signed)JIM_EXPR_OPERATORS_NUM; i++) {
-		char *opname = Jim_ExprOperators[i].name;
-		int oplen = strlen(opname);
+    /* Try to get the longest match. */
+    for (i = 0; i < (signed)JIM_EXPR_OPERATORS_NUM; i++) {
+        char *opname = Jim_ExprOperators[i].name;
+        int oplen = strlen(opname);
 
-		if (strncmp(opname, pc->p, oplen) == 0 && oplen > bestLen) {
-			bestIdx = i;
-			bestLen = oplen;
-		}
-	}
-	if (bestIdx == -1) return JIM_ERR;
-	pc->tstart = pc->p;
-	pc->tend = pc->p + bestLen - 1;
-	pc->p += bestLen;
-	pc->tline = pc->linenr;
-	pc->tt = JIM_TT_EXPR_OPERATOR;
-	return JIM_OK;
+        if (strncmp(opname, pc->p, oplen) == 0 && oplen > bestLen) {
+            bestIdx = i;
+            bestLen = oplen;
+        }
+    }
+    if (bestIdx == -1) return JIM_ERR;
+    pc->tstart = pc->p;
+    pc->tend = pc->p + bestLen - 1;
+    pc->p += bestLen;
+    pc->tline = pc->linenr;
+    pc->tt = JIM_TT_EXPR_OPERATOR;
+    return JIM_OK;
 }
 
 struct Jim_ExprOperator *Jim_ExprOperatorInfo(char *opname)
 {
-	int i;
-	for (i = 0; i < (signed)JIM_EXPR_OPERATORS_NUM; i++)
-		if (strcmp(opname, Jim_ExprOperators[i].name) == 0)
-			return &Jim_ExprOperators[i];
-	return NULL;
+    int i;
+    for (i = 0; i < (signed)JIM_EXPR_OPERATORS_NUM; i++)
+        if (strcmp(opname, Jim_ExprOperators[i].name) == 0)
+            return &Jim_ExprOperators[i];
+    return NULL;
 }
 
 /* -----------------------------------------------------------------------------
@@ -5273,312 +5272,312 @@ static void DupExprInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dup
 static int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr);
 
 static Jim_ObjType exprObjType = {
-	"expression",
-	FreeExprInternalRep,
-	DupExprInternalRep,
-	NULL,
-	JIM_TYPE_REFERENCES,
+    "expression",
+    FreeExprInternalRep,
+    DupExprInternalRep,
+    NULL,
+    JIM_TYPE_REFERENCES,
 };
 
 /* Expr bytecode structure */
 typedef struct ExprByteCode {
-	int *opcode;	/* Integer array of opcodes. */
-	Jim_Obj **obj;	/* Array of associated Jim Objects. */
-	int len;	/* Bytecode length */
-	int inUse;	/* Used for sharing. */
+    int *opcode;    /* Integer array of opcodes. */
+    Jim_Obj **obj;    /* Array of associated Jim Objects. */
+    int len;    /* Bytecode length */
+    int inUse;    /* Used for sharing. */
 } ExprByteCode;
 
 void FreeExprInternalRep(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	int i;
-	ExprByteCode *expr = (void*) objPtr->internalRep.ptr;
+    int i;
+    ExprByteCode *expr = (void*) objPtr->internalRep.ptr;
 
-	expr->inUse--;
-	if (expr->inUse != 0) return;
-	for (i = 0; i < expr->len; i++)
-		Jim_DecrRefCount(interp, expr->obj[i]);
-	Jim_Free(expr->opcode);
-	Jim_Free(expr->obj);
-	Jim_Free(expr);
+    expr->inUse--;
+    if (expr->inUse != 0) return;
+    for (i = 0; i < expr->len; i++)
+        Jim_DecrRefCount(interp, expr->obj[i]);
+    Jim_Free(expr->opcode);
+    Jim_Free(expr->obj);
+    Jim_Free(expr);
 }
 
 void DupExprInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
 {
-	interp = interp;
-	srcPtr = srcPtr;
+    interp = interp;
+    srcPtr = srcPtr;
 
-	/* Just returns an simple string. */
-	dupPtr->typePtr = NULL;
+    /* Just returns an simple string. */
+    dupPtr->typePtr = NULL;
 }
 
 /* Add a new instruction to an expression bytecode structure. */
 static void ExprObjAddInstr(Jim_Interp *interp, ExprByteCode *expr,
-		int opcode, char *str, int len)
+        int opcode, char *str, int len)
 {
-	expr->opcode = Jim_Realloc(expr->opcode, sizeof(int)*(expr->len+1));
-	expr->obj = Jim_Realloc(expr->obj, sizeof(Jim_Obj*)*(expr->len+1));
-	expr->opcode[expr->len] = opcode;
-	expr->obj[expr->len] = Jim_NewStringObjNoAlloc(interp, str, len);
-	Jim_IncrRefCount(expr->obj[expr->len]);
-	expr->len++;
+    expr->opcode = Jim_Realloc(expr->opcode, sizeof(int)*(expr->len+1));
+    expr->obj = Jim_Realloc(expr->obj, sizeof(Jim_Obj*)*(expr->len+1));
+    expr->opcode[expr->len] = opcode;
+    expr->obj[expr->len] = Jim_NewStringObjNoAlloc(interp, str, len);
+    Jim_IncrRefCount(expr->obj[expr->len]);
+    expr->len++;
 }
 
 /* Check if an expr program looks correct. */
 static int ExprCheckCorrectness(ExprByteCode *expr)
 {
-	int i;
-	int stacklen = 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++) {
-		switch(expr->opcode[i]) {
-		case JIM_EXPROP_NUMBER:
-		case JIM_EXPROP_STRING:
-		case JIM_EXPROP_SUBST:
-		case JIM_EXPROP_VARIABLE:
-		case JIM_EXPROP_DICTSUGAR:
-		case JIM_EXPROP_COMMAND:
-			stacklen++;
-			break;
-		case JIM_EXPROP_NOT:
-		case JIM_EXPROP_BITNOT:
-		case JIM_EXPROP_UNARYMINUS:
-		case JIM_EXPROP_UNARYPLUS:
-			/* Unary operations */
-			if (stacklen < 1) return JIM_ERR;
-			break;
-		case JIM_EXPROP_ADD:
-		case JIM_EXPROP_SUB:
-		case JIM_EXPROP_MUL:
-		case JIM_EXPROP_DIV:
-		case JIM_EXPROP_MOD:
-		case JIM_EXPROP_LT:
-		case JIM_EXPROP_GT:
-		case JIM_EXPROP_LTE:
-		case JIM_EXPROP_GTE:
-		case JIM_EXPROP_ROTL:
-		case JIM_EXPROP_ROTR:
-		case JIM_EXPROP_LSHIFT:
-		case JIM_EXPROP_RSHIFT:
-		case JIM_EXPROP_NUMEQ:
-		case JIM_EXPROP_NUMNE:
-		case JIM_EXPROP_STREQ:
-		case JIM_EXPROP_STRNE:
-		case JIM_EXPROP_BITAND:
-		case JIM_EXPROP_BITXOR:
-		case JIM_EXPROP_BITOR:
-		case JIM_EXPROP_LOGICAND:
-		case JIM_EXPROP_LOGICOR:
-			/* binary operations */
-			if (stacklen < 2) return JIM_ERR;
-			stacklen--;
-			break;
-		default:
-			Jim_Panic("Default opcode reached ExprCheckCorrectness");
-			break;
-		}
-	}
-	if (stacklen != 1) return JIM_ERR;
-	return JIM_OK;
+    int i;
+    int stacklen = 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++) {
+        switch(expr->opcode[i]) {
+        case JIM_EXPROP_NUMBER:
+        case JIM_EXPROP_STRING:
+        case JIM_EXPROP_SUBST:
+        case JIM_EXPROP_VARIABLE:
+        case JIM_EXPROP_DICTSUGAR:
+        case JIM_EXPROP_COMMAND:
+            stacklen++;
+            break;
+        case JIM_EXPROP_NOT:
+        case JIM_EXPROP_BITNOT:
+        case JIM_EXPROP_UNARYMINUS:
+        case JIM_EXPROP_UNARYPLUS:
+            /* Unary operations */
+            if (stacklen < 1) return JIM_ERR;
+            break;
+        case JIM_EXPROP_ADD:
+        case JIM_EXPROP_SUB:
+        case JIM_EXPROP_MUL:
+        case JIM_EXPROP_DIV:
+        case JIM_EXPROP_MOD:
+        case JIM_EXPROP_LT:
+        case JIM_EXPROP_GT:
+        case JIM_EXPROP_LTE:
+        case JIM_EXPROP_GTE:
+        case JIM_EXPROP_ROTL:
+        case JIM_EXPROP_ROTR:
+        case JIM_EXPROP_LSHIFT:
+        case JIM_EXPROP_RSHIFT:
+        case JIM_EXPROP_NUMEQ:
+        case JIM_EXPROP_NUMNE:
+        case JIM_EXPROP_STREQ:
+        case JIM_EXPROP_STRNE:
+        case JIM_EXPROP_BITAND:
+        case JIM_EXPROP_BITXOR:
+        case JIM_EXPROP_BITOR:
+        case JIM_EXPROP_LOGICAND:
+        case JIM_EXPROP_LOGICOR:
+            /* binary operations */
+            if (stacklen < 2) return JIM_ERR;
+            stacklen--;
+            break;
+        default:
+            Jim_Panic("Default opcode reached ExprCheckCorrectness");
+            break;
+        }
+    }
+    if (stacklen != 1) return JIM_ERR;
+    return JIM_OK;
 }
 
 static void ExprShareLiterals(Jim_Interp *interp, ExprByteCode *expr,
-		ScriptObj *topLevelScript)
+        ScriptObj *topLevelScript)
 {
-	int i;
+    int i;
 
-	for (i = 0; i < expr->len; i++) {
-		Jim_Obj *foundObjPtr;
+    for (i = 0; i < expr->len; i++) {
+        Jim_Obj *foundObjPtr;
 
-		if (expr->obj[i] == NULL) continue;
-		foundObjPtr = ScriptSearchLiteral(interp, topLevelScript,
-				expr->obj[i]);
-		if (foundObjPtr != NULL) {
-			Jim_IncrRefCount(foundObjPtr);
-			Jim_DecrRefCount(interp, expr->obj[i]);
-			expr->obj[i] = foundObjPtr;
-		}
-	}
+        if (expr->obj[i] == NULL) continue;
+        foundObjPtr = ScriptSearchLiteral(interp, topLevelScript,
+                expr->obj[i]);
+        if (foundObjPtr != NULL) {
+            Jim_IncrRefCount(foundObjPtr);
+            Jim_DecrRefCount(interp, expr->obj[i]);
+            expr->obj[i] = foundObjPtr;
+        }
+    }
 }
 
 /* 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)
 {
-	char *exprText = Jim_GetString(objPtr, NULL);
-	struct JimParserCtx parser;
-	int i, shareLiterals;
-	ExprByteCode *expr = Jim_Alloc(sizeof(*expr));
-	Jim_Stack stack;
-	Jim_ExprOperator *op;
-
-	/* Perform literal sharing with the current procedure
-	 * running only if this expression appears to be not generated
-	 * at runtime. */
-	shareLiterals = objPtr->typePtr == &sourceObjType;
-
-	expr->opcode = NULL;
-	expr->obj = NULL;
-	expr->len = 0;
-	expr->inUse = 1;
-
-	Jim_InitStack(&stack);
-	JimParserInit(&parser, exprText, 1);
-	while(!JimParserEof(&parser)) {
-		char *token;
-		int len, type;
-
-		if (JimParseExpression(&parser) != JIM_OK) {
-			Jim_SetResultString(interp,
-				"Syntax error in expression", -1);
-			goto err;
-		}
-		token = JimParserGetToken(&parser, &len, &type, NULL);
-		if (type == JIM_TT_EOL) {
-			Jim_Free(token);
-			break;
-		}
-		switch(type) {
-		case JIM_TT_STR:
-			ExprObjAddInstr(interp, expr,
-					JIM_EXPROP_STRING, token, len);
-		case JIM_TT_ESC:
-			ExprObjAddInstr(interp, expr,
-					JIM_EXPROP_SUBST, token, len);
-			break;
-		case JIM_TT_VAR:
-			ExprObjAddInstr(interp, expr,
-					JIM_EXPROP_VARIABLE, token, len);
-			break;
-		case JIM_TT_DICTSUGAR:
-			ExprObjAddInstr(interp, expr,
-					JIM_EXPROP_DICTSUGAR, token, len);
-			break;
-		case JIM_TT_CMD:
-			ExprObjAddInstr(interp, expr,
-					JIM_EXPROP_COMMAND, token, len);
-			break;
-		case JIM_TT_EXPR_NUMBER:
-			ExprObjAddInstr(interp, expr,
-					JIM_EXPROP_NUMBER, token, len);
-			break;
-		case JIM_TT_EXPR_OPERATOR:
-			op = Jim_ExprOperatorInfo(token);
-			while(1) {
-				Jim_ExprOperator *stackTopOp;
-
-				if (Jim_StackPeek(&stack) != NULL) {
-					stackTopOp =
-					  Jim_ExprOperatorInfo(Jim_StackPeek(&stack));
-				} else {
-					stackTopOp = NULL;
-				}
-				if (Jim_StackLen(&stack) &&
-				    op->arity != 1 &&
-				    stackTopOp &&
-				    stackTopOp->precedence >= op->precedence)
-				{
-					ExprObjAddInstr(interp, expr,
-						stackTopOp->opcode,
-						Jim_StackPeek(&stack), -1);
-					Jim_StackPop(&stack);
-				} else {
-					break;
-				}
-			}
-			Jim_StackPush(&stack, token);
-			break;
-		case JIM_TT_SUBEXPR_START:
-			Jim_StackPush(&stack, Jim_StrDup("("));
-			Jim_Free(token);
-			break;
-		case JIM_TT_SUBEXPR_END:
-			{
-				int found = 0;
-				while(Jim_StackLen(&stack)) {
-					char *opstr = Jim_StackPop(&stack);
-					if (!strcmp(opstr, "(")) {
-						Jim_Free(opstr);
-						found = 1;
-						break;
-					}
-					op = Jim_ExprOperatorInfo(opstr);
-					ExprObjAddInstr(interp, expr,
-							op->opcode, opstr, -1);
-				}
-				if (!found) {
-					Jim_SetResultString(interp,
-					  "Unexpected close parenthesis", -1);
-					goto err;
-				}
-			}
-			Jim_Free(token);
-			break;
-		default:
-			Jim_Panic("Default reached in SetExprFromAny()");
-			break;
-		}
-	}
-	while (Jim_StackLen(&stack)) {
-		char *opstr = Jim_StackPop(&stack);
-		op = Jim_ExprOperatorInfo(opstr);
-		if (op == NULL && !strcmp(opstr, "(")) {
-			Jim_Free(opstr);
-			Jim_SetResultString(interp,
-				"Missing close parenthesis", -1);
-			goto err;
-		}
-		ExprObjAddInstr(interp, expr, op->opcode,
-			opstr, -1);
-	}
-	/* Check program correctness. */
-	if (ExprCheckCorrectness(expr) != JIM_OK) {
-		Jim_SetResultString(interp,
-			"Invalid expression", -1);
-		goto err;
-	}
-
-	/* Free the stack used for the compilation. */
-	Jim_FreeStackElements(&stack, Jim_Free);
-	Jim_FreeStack(&stack);
-
-	/* Perform literal sharing */
-	if (shareLiterals && interp->framePtr->procBodyObjPtr) {
-		Jim_Obj *bodyObjPtr = interp->framePtr->procBodyObjPtr;
-		if (bodyObjPtr->typePtr == &scriptObjType) {
-			ScriptObj *bodyScript =
-				bodyObjPtr->internalRep.ptr;
-			ExprShareLiterals(interp, expr, bodyScript);
-		}
-	}
-
-	/* Free the old internal rep and set the new one. */
-	Jim_FreeIntRep(interp, objPtr);
-	Jim_SetIntRepPtr(objPtr, expr);
-	objPtr->typePtr = &exprObjType;
-	return JIM_OK;
-
-err:	/* we jump here on syntax/compile errors. */
-	Jim_FreeStackElements(&stack, Jim_Free);
-	Jim_FreeStack(&stack);
-	Jim_Free(expr->opcode);
-	for (i = 0; i < expr->len; i++) {
-		Jim_DecrRefCount(interp,expr->obj[i]);
-	}
-	Jim_Free(expr->obj);
-	Jim_Free(expr);
-	return JIM_ERR;
+    char *exprText = Jim_GetString(objPtr, NULL);
+    struct JimParserCtx parser;
+    int i, shareLiterals;
+    ExprByteCode *expr = Jim_Alloc(sizeof(*expr));
+    Jim_Stack stack;
+    Jim_ExprOperator *op;
+
+    /* Perform literal sharing with the current procedure
+     * running only if this expression appears to be not generated
+     * at runtime. */
+    shareLiterals = objPtr->typePtr == &sourceObjType;
+
+    expr->opcode = NULL;
+    expr->obj = NULL;
+    expr->len = 0;
+    expr->inUse = 1;
+
+    Jim_InitStack(&stack);
+    JimParserInit(&parser, exprText, 1);
+    while(!JimParserEof(&parser)) {
+        char *token;
+        int len, type;
+
+        if (JimParseExpression(&parser) != JIM_OK) {
+            Jim_SetResultString(interp,
+                "Syntax error in expression", -1);
+            goto err;
+        }
+        token = JimParserGetToken(&parser, &len, &type, NULL);
+        if (type == JIM_TT_EOL) {
+            Jim_Free(token);
+            break;
+        }
+        switch(type) {
+        case JIM_TT_STR:
+            ExprObjAddInstr(interp, expr,
+                    JIM_EXPROP_STRING, token, len);
+        case JIM_TT_ESC:
+            ExprObjAddInstr(interp, expr,
+                    JIM_EXPROP_SUBST, token, len);
+            break;
+        case JIM_TT_VAR:
+            ExprObjAddInstr(interp, expr,
+                    JIM_EXPROP_VARIABLE, token, len);
+            break;
+        case JIM_TT_DICTSUGAR:
+            ExprObjAddInstr(interp, expr,
+                    JIM_EXPROP_DICTSUGAR, token, len);
+            break;
+        case JIM_TT_CMD:
+            ExprObjAddInstr(interp, expr,
+                    JIM_EXPROP_COMMAND, token, len);
+            break;
+        case JIM_TT_EXPR_NUMBER:
+            ExprObjAddInstr(interp, expr,
+                    JIM_EXPROP_NUMBER, token, len);
+            break;
+        case JIM_TT_EXPR_OPERATOR:
+            op = Jim_ExprOperatorInfo(token);
+            while(1) {
+                Jim_ExprOperator *stackTopOp;
+
+                if (Jim_StackPeek(&stack) != NULL) {
+                    stackTopOp =
+                      Jim_ExprOperatorInfo(Jim_StackPeek(&stack));
+                } else {
+                    stackTopOp = NULL;
+                }
+                if (Jim_StackLen(&stack) &&
+                    op->arity != 1 &&
+                    stackTopOp &&
+                    stackTopOp->precedence >= op->precedence)
+                {
+                    ExprObjAddInstr(interp, expr,
+                        stackTopOp->opcode,
+                        Jim_StackPeek(&stack), -1);
+                    Jim_StackPop(&stack);
+                } else {
+                    break;
+                }
+            }
+            Jim_StackPush(&stack, token);
+            break;
+        case JIM_TT_SUBEXPR_START:
+            Jim_StackPush(&stack, Jim_StrDup("("));
+            Jim_Free(token);
+            break;
+        case JIM_TT_SUBEXPR_END:
+            {
+                int found = 0;
+                while(Jim_StackLen(&stack)) {
+                    char *opstr = Jim_StackPop(&stack);
+                    if (!strcmp(opstr, "(")) {
+                        Jim_Free(opstr);
+                        found = 1;
+                        break;
+                    }
+                    op = Jim_ExprOperatorInfo(opstr);
+                    ExprObjAddInstr(interp, expr,
+                            op->opcode, opstr, -1);
+                }
+                if (!found) {
+                    Jim_SetResultString(interp,
+                      "Unexpected close parenthesis", -1);
+                    goto err;
+                }
+            }
+            Jim_Free(token);
+            break;
+        default:
+            Jim_Panic("Default reached in SetExprFromAny()");
+            break;
+        }
+    }
+    while (Jim_StackLen(&stack)) {
+        char *opstr = Jim_StackPop(&stack);
+        op = Jim_ExprOperatorInfo(opstr);
+        if (op == NULL && !strcmp(opstr, "(")) {
+            Jim_Free(opstr);
+            Jim_SetResultString(interp,
+                "Missing close parenthesis", -1);
+            goto err;
+        }
+        ExprObjAddInstr(interp, expr, op->opcode,
+            opstr, -1);
+    }
+    /* Check program correctness. */
+    if (ExprCheckCorrectness(expr) != JIM_OK) {
+        Jim_SetResultString(interp,
+            "Invalid expression", -1);
+        goto err;
+    }
+
+    /* Free the stack used for the compilation. */
+    Jim_FreeStackElements(&stack, Jim_Free);
+    Jim_FreeStack(&stack);
+
+    /* Perform literal sharing */
+    if (shareLiterals && interp->framePtr->procBodyObjPtr) {
+        Jim_Obj *bodyObjPtr = interp->framePtr->procBodyObjPtr;
+        if (bodyObjPtr->typePtr == &scriptObjType) {
+            ScriptObj *bodyScript =
+                bodyObjPtr->internalRep.ptr;
+            ExprShareLiterals(interp, expr, bodyScript);
+        }
+    }
+
+    /* Free the old internal rep and set the new one. */
+    Jim_FreeIntRep(interp, objPtr);
+    Jim_SetIntRepPtr(objPtr, expr);
+    objPtr->typePtr = &exprObjType;
+    return JIM_OK;
+
+err:    /* we jump here on syntax/compile errors. */
+    Jim_FreeStackElements(&stack, Jim_Free);
+    Jim_FreeStack(&stack);
+    Jim_Free(expr->opcode);
+    for (i = 0; i < expr->len; i++) {
+        Jim_DecrRefCount(interp,expr->obj[i]);
+    }
+    Jim_Free(expr->obj);
+    Jim_Free(expr);
+    return JIM_ERR;
 }
 
 ExprByteCode *Jim_GetExpression(Jim_Interp *interp, Jim_Obj *objPtr)
 {
-	if (objPtr->typePtr != &exprObjType) {
-		if (SetExprFromAny(interp, objPtr) != JIM_OK)
-			return NULL;
-	}
-	return (ExprByteCode*) Jim_GetIntRepPtr(objPtr);
+    if (objPtr->typePtr != &exprObjType) {
+        if (SetExprFromAny(interp, objPtr) != JIM_OK)
+            return NULL;
+    }
+    return (ExprByteCode*) Jim_GetIntRepPtr(objPtr);
 }
 
 /* -----------------------------------------------------------------------------
@@ -5599,360 +5598,360 @@ ExprByteCode *Jim_GetExpression(Jim_Interp *interp, Jim_Obj *objPtr)
 #define JIM_EE_STATICSTACK_LEN 10
 
 int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr,
-		Jim_Obj **exprResultPtrPtr)
-{
-	ExprByteCode *expr;
-	Jim_Obj **stack, *staticStack[JIM_EE_STATICSTACK_LEN];
-	int stacklen = 0, i, error = 0, errRetCode = JIM_ERR;
-
-	Jim_IncrRefCount(exprObjPtr);
-	expr = Jim_GetExpression(interp, exprObjPtr);
-	if (!expr) {
-		Jim_DecrRefCount(interp, exprObjPtr);
-		return JIM_ERR; /* error in expression. */
-	}
-	/* 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)
-		stack = Jim_Alloc(sizeof(Jim_Obj*)*expr->len);
-	else
-		stack = staticStack;
-
-	/* Execute every istruction */
-	for (i = 0; i < expr->len; i++) {
-		Jim_Obj *A, *B, *objPtr;
-		jim_wide wA, wB, wC;
-		double dA, dB, dC;
-		char *sA, *sB;
-		int Alen, Blen, retcode;
-
-		switch(expr->opcode[i]) {
-		case JIM_EXPROP_SUBST:
-			if ((retcode = Jim_SubstObj(interp, expr->obj[i],
-						&objPtr, JIM_NONE)) != JIM_OK)
-			{
-				error = 1;
-				errRetCode = retcode;
-				goto err;
-			}
-			stack[stacklen++] = objPtr;
-			Jim_IncrRefCount(objPtr);
-			break;
-		case JIM_EXPROP_NUMBER:
-		case JIM_EXPROP_STRING:
-			stack[stacklen++] = expr->obj[i];
-			Jim_IncrRefCount(expr->obj[i]);
-			break;
-		case JIM_EXPROP_VARIABLE:
-			objPtr = Jim_GetVariable(interp, expr->obj[i],
-					JIM_ERRMSG);
-			if (objPtr == NULL) {
-				error = 1;
-				goto err;
-			}
-			stack[stacklen++] = objPtr;
-			Jim_IncrRefCount(objPtr);
-			break;
-		case JIM_EXPROP_DICTSUGAR:
-			objPtr = Jim_ExpandDictSugar(interp, expr->obj[i]);
-			if (objPtr == NULL) {
-				error = 1;
-				goto err;
-			}
-			stack[stacklen++] = objPtr;
-			Jim_IncrRefCount(objPtr);
-			break;
-		case JIM_EXPROP_COMMAND:
-			if ((retcode = Jim_EvalObj(interp, expr->obj[i]))
-					!= JIM_OK)
-			{
-				error = 1;
-				errRetCode = retcode;
-				goto err;
-			}
-			stack[stacklen++] = interp->result;
-			Jim_IncrRefCount(interp->result);
-			break;
-		case JIM_EXPROP_ADD:
-		case JIM_EXPROP_SUB:
-		case JIM_EXPROP_MUL:
-		case JIM_EXPROP_DIV:
-		case JIM_EXPROP_MOD:
-		case JIM_EXPROP_LT:
-		case JIM_EXPROP_GT:
-		case JIM_EXPROP_LTE:
-		case JIM_EXPROP_GTE:
-		case JIM_EXPROP_ROTL:
-		case JIM_EXPROP_ROTR:
-		case JIM_EXPROP_LSHIFT:
-		case JIM_EXPROP_RSHIFT:
-		case JIM_EXPROP_NUMEQ:
-		case JIM_EXPROP_NUMNE:
-		case JIM_EXPROP_BITAND:
-		case JIM_EXPROP_BITXOR:
-		case JIM_EXPROP_BITOR:
-		case JIM_EXPROP_LOGICAND:
-		case JIM_EXPROP_LOGICOR:
-			/* Note that there isn't to increment the
-			 * refcount of objects. the references are moved
-			 * from stack to A and B. */
-			B = stack[--stacklen];
-			A = stack[--stacklen];
-
-			/* --- Integer --- */
-			if ((A->typePtr == &doubleObjType && !A->bytes) ||
-			    (B->typePtr == &doubleObjType && !B->bytes) ||
-			    Jim_GetWide(interp, A, &wA) != JIM_OK ||
-			    Jim_GetWide(interp, B, &wB) != JIM_OK) {
-				goto trydouble;
-			}
-			Jim_DecrRefCount(interp, A);
-			Jim_DecrRefCount(interp, B);
-			switch(expr->opcode[i]) {
-			case JIM_EXPROP_ADD: wC = wA+wB; break;
-			case JIM_EXPROP_SUB: wC = wA-wB; break;
-			case JIM_EXPROP_MUL: wC = wA*wB; break;
-			case JIM_EXPROP_LT: wC = wA<wB; break;
-			case JIM_EXPROP_GT: wC = wA>wB; break;
-			case JIM_EXPROP_LTE: wC = wA<=wB; break;
-			case JIM_EXPROP_GTE: wC = wA>=wB; break;
-			case JIM_EXPROP_LSHIFT: wC = wA<<wB; break;
-			case JIM_EXPROP_RSHIFT: wC = wA>>wB; break;
-			case JIM_EXPROP_NUMEQ: wC = wA==wB; break;
-			case JIM_EXPROP_NUMNE: wC = wA!=wB; break;
-			case JIM_EXPROP_BITAND: wC = wA&wB; break;
-			case JIM_EXPROP_BITXOR: wC = wA^wB; break;
-			case JIM_EXPROP_BITOR: wC = wA|wB; break;
-			case JIM_EXPROP_LOGICAND: wC = wA&&wB; break;
-			case JIM_EXPROP_LOGICOR: wC = wA||wB; break;
-			case JIM_EXPROP_DIV:
-				if (wB == 0) goto divbyzero;
-				wC = wA/wB;
-				break;
-			case JIM_EXPROP_MOD:
-				if (wB == 0) goto divbyzero;
-				wC = wA%wB;
-				break;
-			case JIM_EXPROP_ROTL: {
+        Jim_Obj **exprResultPtrPtr)
+{
+    ExprByteCode *expr;
+    Jim_Obj **stack, *staticStack[JIM_EE_STATICSTACK_LEN];
+    int stacklen = 0, i, error = 0, errRetCode = JIM_ERR;
+
+    Jim_IncrRefCount(exprObjPtr);
+    expr = Jim_GetExpression(interp, exprObjPtr);
+    if (!expr) {
+        Jim_DecrRefCount(interp, exprObjPtr);
+        return JIM_ERR; /* error in expression. */
+    }
+    /* 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)
+        stack = Jim_Alloc(sizeof(Jim_Obj*)*expr->len);
+    else
+        stack = staticStack;
+
+    /* Execute every istruction */
+    for (i = 0; i < expr->len; i++) {
+        Jim_Obj *A, *B, *objPtr;
+        jim_wide wA, wB, wC;
+        double dA, dB, dC;
+        char *sA, *sB;
+        int Alen, Blen, retcode;
+
+        switch(expr->opcode[i]) {
+        case JIM_EXPROP_SUBST:
+            if ((retcode = Jim_SubstObj(interp, expr->obj[i],
+                        &objPtr, JIM_NONE)) != JIM_OK)
+            {
+                error = 1;
+                errRetCode = retcode;
+                goto err;
+            }
+            stack[stacklen++] = objPtr;
+            Jim_IncrRefCount(objPtr);
+            break;
+        case JIM_EXPROP_NUMBER:
+        case JIM_EXPROP_STRING:
+            stack[stacklen++] = expr->obj[i];
+            Jim_IncrRefCount(expr->obj[i]);
+            break;
+        case JIM_EXPROP_VARIABLE:
+            objPtr = Jim_GetVariable(interp, expr->obj[i],
+                    JIM_ERRMSG);
+            if (objPtr == NULL) {
+                error = 1;
+                goto err;
+            }
+            stack[stacklen++] = objPtr;
+            Jim_IncrRefCount(objPtr);
+            break;
+        case JIM_EXPROP_DICTSUGAR:
+            objPtr = Jim_ExpandDictSugar(interp, expr->obj[i]);
+            if (objPtr == NULL) {
+                error = 1;
+                goto err;
+            }
+            stack[stacklen++] = objPtr;
+            Jim_IncrRefCount(objPtr);
+            break;
+        case JIM_EXPROP_COMMAND:
+            if ((retcode = Jim_EvalObj(interp, expr->obj[i]))
+                    != JIM_OK)
+            {
+                error = 1;
+                errRetCode = retcode;
+                goto err;
+            }
+            stack[stacklen++] = interp->result;
+            Jim_IncrRefCount(interp->result);
+            break;
+        case JIM_EXPROP_ADD:
+        case JIM_EXPROP_SUB:
+        case JIM_EXPROP_MUL:
+        case JIM_EXPROP_DIV:
+        case JIM_EXPROP_MOD:
+        case JIM_EXPROP_LT:
+        case JIM_EXPROP_GT:
+        case JIM_EXPROP_LTE:
+        case JIM_EXPROP_GTE:
+        case JIM_EXPROP_ROTL:
+        case JIM_EXPROP_ROTR:
+        case JIM_EXPROP_LSHIFT:
+        case JIM_EXPROP_RSHIFT:
+        case JIM_EXPROP_NUMEQ:
+        case JIM_EXPROP_NUMNE:
+        case JIM_EXPROP_BITAND:
+        case JIM_EXPROP_BITXOR:
+        case JIM_EXPROP_BITOR:
+        case JIM_EXPROP_LOGICAND:
+        case JIM_EXPROP_LOGICOR:
+            /* Note that there isn't to increment the
+             * refcount of objects. the references are moved
+             * from stack to A and B. */
+            B = stack[--stacklen];
+            A = stack[--stacklen];
+
+            /* --- Integer --- */
+            if ((A->typePtr == &doubleObjType && !A->bytes) ||
+                (B->typePtr == &doubleObjType && !B->bytes) ||
+                Jim_GetWide(interp, A, &wA) != JIM_OK ||
+                Jim_GetWide(interp, B, &wB) != JIM_OK) {
+                goto trydouble;
+            }
+            Jim_DecrRefCount(interp, A);
+            Jim_DecrRefCount(interp, B);
+            switch(expr->opcode[i]) {
+            case JIM_EXPROP_ADD: wC = wA+wB; break;
+            case JIM_EXPROP_SUB: wC = wA-wB; break;
+            case JIM_EXPROP_MUL: wC = wA*wB; break;
+            case JIM_EXPROP_LT: wC = wA<wB; break;
+            case JIM_EXPROP_GT: wC = wA>wB; break;
+            case JIM_EXPROP_LTE: wC = wA<=wB; break;
+            case JIM_EXPROP_GTE: wC = wA>=wB; break;
+            case JIM_EXPROP_LSHIFT: wC = wA<<wB; break;
+            case JIM_EXPROP_RSHIFT: wC = wA>>wB; break;
+            case JIM_EXPROP_NUMEQ: wC = wA==wB; break;
+            case JIM_EXPROP_NUMNE: wC = wA!=wB; break;
+            case JIM_EXPROP_BITAND: wC = wA&wB; break;
+            case JIM_EXPROP_BITXOR: wC = wA^wB; break;
+            case JIM_EXPROP_BITOR: wC = wA|wB; break;
+            case JIM_EXPROP_LOGICAND: wC = wA&&wB; break;
+            case JIM_EXPROP_LOGICOR: wC = wA||wB; break;
+            case JIM_EXPROP_DIV:
+                if (wB == 0) goto divbyzero;
+                wC = wA/wB;
+                break;
+            case JIM_EXPROP_MOD:
+                if (wB == 0) goto divbyzero;
+                wC = wA%wB;
+                break;
+            case JIM_EXPROP_ROTL: {
                 /* uint32_t would be better. But not everyone has inttypes.h?*/
-			    unsigned long uA = (unsigned long)wA;
+                unsigned long uA = (unsigned long)wA;
 #ifdef _MSC_VER
-			    wC = _rotl(uA,(unsigned long)wB);
+                wC = _rotl(uA,(unsigned long)wB);
 #else
-			    const unsigned int S = sizeof(unsigned long) * 8;
-			    wC = (unsigned long)((uA<<wB)|(uA>>(S-wB)));
+                const unsigned int S = sizeof(unsigned long) * 8;
+                wC = (unsigned long)((uA<<wB)|(uA>>(S-wB)));
 #endif
-			    break;
-			}
-			case JIM_EXPROP_ROTR: {
-			    unsigned long uA = (unsigned long)wA;
+                break;
+            }
+            case JIM_EXPROP_ROTR: {
+                unsigned long uA = (unsigned long)wA;
 #ifdef _MSC_VER
-			    wC = _rotr(uA,(unsigned long)wB);
+                wC = _rotr(uA,(unsigned long)wB);
 #else
-			    const unsigned int S = sizeof(unsigned long) * 8;
-			    wC = (unsigned long)((uA>>wB)|(uA<<(S-wB)));
+                const unsigned int S = sizeof(unsigned long) * 8;
+                wC = (unsigned long)((uA>>wB)|(uA<<(S-wB)));
 #endif
-			    break;
-			}
-
-			default:
-				wC = 0; /* avoid gcc warning */
-				break;
-			}
-			stack[stacklen] = Jim_NewIntObj(interp, wC);
-			Jim_IncrRefCount(stack[stacklen]);
-			stacklen++;
-			break;
+                break;
+            }
+
+            default:
+                wC = 0; /* avoid gcc warning */
+                break;
+            }
+            stack[stacklen] = Jim_NewIntObj(interp, wC);
+            Jim_IncrRefCount(stack[stacklen]);
+            stacklen++;
+            break;
 trydouble:
-			/* --- Double --- */
-			if (Jim_GetDouble(interp, A, &dA) != JIM_OK ||
-			    Jim_GetDouble(interp, B, &dB) != JIM_OK) {
-				Jim_DecrRefCount(interp, A);
-				Jim_DecrRefCount(interp, B);
-				error = 1;
-				goto err;
-			}
-			Jim_DecrRefCount(interp, A);
-			Jim_DecrRefCount(interp, B);
-			switch(expr->opcode[i]) {
-			case JIM_EXPROP_ROTL:
-			case JIM_EXPROP_ROTR:
-			case JIM_EXPROP_LSHIFT:
-			case JIM_EXPROP_RSHIFT:
-			case JIM_EXPROP_BITAND:
-			case JIM_EXPROP_BITXOR:
-			case JIM_EXPROP_BITOR:
-			case JIM_EXPROP_MOD:
-				Jim_SetResultString(interp,
-					"Got floating-point value where "
-					"integer was expected", -1);
-				error = 1;
-				goto err;
-				break;
-			case JIM_EXPROP_ADD: dC = dA+dB; break;
-			case JIM_EXPROP_SUB: dC = dA-dB; break;
-			case JIM_EXPROP_MUL: dC = dA*dB; break;
-			case JIM_EXPROP_LT: dC = dA<dB; break;
-			case JIM_EXPROP_GT: dC = dA>dB; break;
-			case JIM_EXPROP_LTE: dC = dA<=dB; break;
-			case JIM_EXPROP_GTE: dC = dA>=dB; break;
-			case JIM_EXPROP_NUMEQ: dC = dA==dB; break;
-			case JIM_EXPROP_NUMNE: dC = dA!=dB; break;
-			case JIM_EXPROP_LOGICAND: dC = dA&&dB; break;
-			case JIM_EXPROP_LOGICOR: dC = dA||dB; break;
-			case JIM_EXPROP_DIV:
-				if (dB == 0) goto divbyzero;
-				dC = dA/dB;
-				break;
-			default:
-				dC = 0; /* avoid gcc warning */
-				break;
-			}
-			stack[stacklen] = Jim_NewDoubleObj(interp, dC);
-			Jim_IncrRefCount(stack[stacklen]);
-			stacklen++;
-			break;
-		case JIM_EXPROP_STREQ:
-		case JIM_EXPROP_STRNE:
-			B = stack[--stacklen];
-			A = stack[--stacklen];
-			sA = Jim_GetString(A, &Alen);
-			sB = Jim_GetString(B, &Blen);
-			switch(expr->opcode[i]) {
-			case JIM_EXPROP_STREQ:
-				if (Alen == Blen &&
-				    memcmp(sA, sB, Alen) ==0)
-					wC = 1;
-				else
-					wC = 0;
-				break;
-			case JIM_EXPROP_STRNE:
-				if (Alen != Blen ||
-				    memcmp(sA, sB, Alen) != 0)
-					wC = 1;
-				else
-					wC = 0;
-				break;
-			default:
-				wC = 0; /* avoid gcc warning */
-				break;
-			}
-			Jim_DecrRefCount(interp, A);
-			Jim_DecrRefCount(interp, B);
-			stack[stacklen] = Jim_NewIntObj(interp, wC);
-			Jim_IncrRefCount(stack[stacklen]);
-			stacklen++;
-			break;
-		case JIM_EXPROP_NOT:
-		case JIM_EXPROP_BITNOT:
-			/* Note that there isn't to increment the
-			 * refcount of objects. the references are moved
-			 * from stack to A and B. */
-			A = stack[--stacklen];
-
-			/* --- Integer --- */
-			if ((A->typePtr == &doubleObjType && !A->bytes) ||
-			    Jim_GetWide(interp, A, &wA) != JIM_OK) {
-				goto trydouble_unary;
-			}
-			Jim_DecrRefCount(interp, A);
-			switch(expr->opcode[i]) {
-			case JIM_EXPROP_NOT: wC = !wA; break;
-			case JIM_EXPROP_BITNOT: wC = ~wA; break;
-			default:
-				wC = 0; /* avoid gcc warning */
-				break;
-			}
-			stack[stacklen] = Jim_NewIntObj(interp, wC);
-			Jim_IncrRefCount(stack[stacklen]);
-			stacklen++;
-			break;
+            /* --- Double --- */
+            if (Jim_GetDouble(interp, A, &dA) != JIM_OK ||
+                Jim_GetDouble(interp, B, &dB) != JIM_OK) {
+                Jim_DecrRefCount(interp, A);
+                Jim_DecrRefCount(interp, B);
+                error = 1;
+                goto err;
+            }
+            Jim_DecrRefCount(interp, A);
+            Jim_DecrRefCount(interp, B);
+            switch(expr->opcode[i]) {
+            case JIM_EXPROP_ROTL:
+            case JIM_EXPROP_ROTR:
+            case JIM_EXPROP_LSHIFT:
+            case JIM_EXPROP_RSHIFT:
+            case JIM_EXPROP_BITAND:
+            case JIM_EXPROP_BITXOR:
+            case JIM_EXPROP_BITOR:
+            case JIM_EXPROP_MOD:
+                Jim_SetResultString(interp,
+                    "Got floating-point value where "
+                    "integer was expected", -1);
+                error = 1;
+                goto err;
+                break;
+            case JIM_EXPROP_ADD: dC = dA+dB; break;
+            case JIM_EXPROP_SUB: dC = dA-dB; break;
+            case JIM_EXPROP_MUL: dC = dA*dB; break;
+            case JIM_EXPROP_LT: dC = dA<dB; break;
+            case JIM_EXPROP_GT: dC = dA>dB; break;
+            case JIM_EXPROP_LTE: dC = dA<=dB; break;
+            case JIM_EXPROP_GTE: dC = dA>=dB; break;
+            case JIM_EXPROP_NUMEQ: dC = dA==dB; break;
+            case JIM_EXPROP_NUMNE: dC = dA!=dB; break;
+            case JIM_EXPROP_LOGICAND: dC = dA&&dB; break;
+            case JIM_EXPROP_LOGICOR: dC = dA||dB; break;
+            case JIM_EXPROP_DIV:
+                if (dB == 0) goto divbyzero;
+                dC = dA/dB;
+                break;
+            default:
+                dC = 0; /* avoid gcc warning */
+                break;
+            }
+            stack[stacklen] = Jim_NewDoubleObj(interp, dC);
+            Jim_IncrRefCount(stack[stacklen]);
+            stacklen++;
+            break;
+        case JIM_EXPROP_STREQ:
+        case JIM_EXPROP_STRNE:
+            B = stack[--stacklen];
+            A = stack[--stacklen];
+            sA = Jim_GetString(A, &Alen);
+            sB = Jim_GetString(B, &Blen);
+            switch(expr->opcode[i]) {
+            case JIM_EXPROP_STREQ:
+                if (Alen == Blen &&
+                    memcmp(sA, sB, Alen) ==0)
+                    wC = 1;
+                else
+                    wC = 0;
+                break;
+            case JIM_EXPROP_STRNE:
+                if (Alen != Blen ||
+                    memcmp(sA, sB, Alen) != 0)
+                    wC = 1;
+                else
+                    wC = 0;
+                break;
+            default:
+                wC = 0; /* avoid gcc warning */
+                break;
+            }
+            Jim_DecrRefCount(interp, A);
+            Jim_DecrRefCount(interp, B);
+            stack[stacklen] = Jim_NewIntObj(interp, wC);
+            Jim_IncrRefCount(stack[stacklen]);
+            stacklen++;
+            break;
+        case JIM_EXPROP_NOT:
+        case JIM_EXPROP_BITNOT:
+            /* Note that there isn't to increment the
+             * refcount of objects. the references are moved
+             * from stack to A and B. */
+            A = stack[--stacklen];
+
+            /* --- Integer --- */
+            if ((A->typePtr == &doubleObjType && !A->bytes) ||
+                Jim_GetWide(interp, A, &wA) != JIM_OK) {
+                goto trydouble_unary;
+            }
+            Jim_DecrRefCount(interp, A);
+            switch(expr->opcode[i]) {
+            case JIM_EXPROP_NOT: wC = !wA; break;
+            case JIM_EXPROP_BITNOT: wC = ~wA; break;
+            default:
+                wC = 0; /* avoid gcc warning */
+                break;
+            }
+            stack[stacklen] = Jim_NewIntObj(interp, wC);
+            Jim_IncrRefCount(stack[stacklen]);
+            stacklen++;
+            break;
 trydouble_unary:
-			/* --- Double --- */
-			if (Jim_GetDouble(interp, A, &dA) != JIM_OK) {
-				Jim_DecrRefCount(interp, A);
-				error = 1;
-				goto err;
-			}
-			Jim_DecrRefCount(interp, A);
-			switch(expr->opcode[i]) {
-			case JIM_EXPROP_NOT: dC = !dA; break;
-			case JIM_EXPROP_BITNOT:
-				Jim_SetResultString(interp,
-					"Got floating-point value where "
-					"integer was expected", -1);
-				error = 1;
-				goto err;
-				break;
-			default:
-				dC = 0; /* avoid gcc warning */
-				break;
-			}
-			stack[stacklen] = Jim_NewDoubleObj(interp, dC);
-			Jim_IncrRefCount(stack[stacklen]);
-			stacklen++;
-			break;
-		default:
-			Jim_Panic("Default opcode reached Jim_EvalExpression");
-			break;
-		}
-	}
+            /* --- Double --- */
+            if (Jim_GetDouble(interp, A, &dA) != JIM_OK) {
+                Jim_DecrRefCount(interp, A);
+                error = 1;
+                goto err;
+            }
+            Jim_DecrRefCount(interp, A);
+            switch(expr->opcode[i]) {
+            case JIM_EXPROP_NOT: dC = !dA; break;
+            case JIM_EXPROP_BITNOT:
+                Jim_SetResultString(interp,
+                    "Got floating-point value where "
+                    "integer was expected", -1);
+                error = 1;
+                goto err;
+                break;
+            default:
+                dC = 0; /* avoid gcc warning */
+                break;
+            }
+            stack[stacklen] = Jim_NewDoubleObj(interp, dC);
+            Jim_IncrRefCount(stack[stacklen]);
+            stacklen++;
+            break;
+        default:
+            Jim_Panic("Default opcode reached Jim_EvalExpression");
+            break;
+        }
+    }
 err:
-	/* There is no need to decerement the inUse field because
-	 * this reference is transfered back into the exprObjPtr. */
-	Jim_FreeIntRep(interp, exprObjPtr);
-	exprObjPtr->typePtr = &exprObjType;
-	Jim_SetIntRepPtr(exprObjPtr, expr);
-	Jim_DecrRefCount(interp, exprObjPtr);
-	if (!error) {
-		*exprResultPtrPtr = stack[0];
-		Jim_IncrRefCount(stack[0]);
-		errRetCode = JIM_OK;
-	}
-	for (i = 0; i < stacklen; i++) {
-		Jim_DecrRefCount(interp, stack[i]);
-	}
-	if (stack != staticStack)
-		Jim_Free(stack);
-	return errRetCode;
+    /* There is no need to decerement the inUse field because
+     * this reference is transfered back into the exprObjPtr. */
+    Jim_FreeIntRep(interp, exprObjPtr);
+    exprObjPtr->typePtr = &exprObjType;
+    Jim_SetIntRepPtr(exprObjPtr, expr);
+    Jim_DecrRefCount(interp, exprObjPtr);
+    if (!error) {
+        *exprResultPtrPtr = stack[0];
+        Jim_IncrRefCount(stack[0]);
+        errRetCode = JIM_OK;
+    }
+    for (i = 0; i < stacklen; i++) {
+        Jim_DecrRefCount(interp, stack[i]);
+    }
+    if (stack != staticStack)
+        Jim_Free(stack);
+    return errRetCode;
 divbyzero:
-	error = 1;
-	Jim_SetResultString(interp, "Division by zero", -1);
-	goto err;
+    error = 1;
+    Jim_SetResultString(interp, "Division by zero", -1);
+    goto err;
 }
 
 int Jim_GetBoolFromExpr(Jim_Interp *interp, Jim_Obj *exprObjPtr, int *boolPtr)
 {
-	int retcode;
-	jim_wide wideValue;
-	double doubleValue;
-	Jim_Obj *exprResultPtr;
-
-	retcode = Jim_EvalExpression(interp, exprObjPtr, &exprResultPtr);
-	if (retcode != JIM_OK)
-		return retcode;
-	if (Jim_GetWide(interp, exprResultPtr, &wideValue) != JIM_OK) {
-		if (Jim_GetDouble(interp, exprResultPtr, &doubleValue) != JIM_OK)
-		{
-			Jim_DecrRefCount(interp, exprResultPtr);
-			return JIM_ERR;
-		} else {
-			Jim_DecrRefCount(interp, exprResultPtr);
-			*boolPtr = doubleValue != 0;
-			return JIM_OK;
-		}
-	}
-	Jim_DecrRefCount(interp, exprResultPtr);
-	*boolPtr = wideValue != 0;
-	return JIM_OK;
+    int retcode;
+    jim_wide wideValue;
+    double doubleValue;
+    Jim_Obj *exprResultPtr;
+
+    retcode = Jim_EvalExpression(interp, exprObjPtr, &exprResultPtr);
+    if (retcode != JIM_OK)
+        return retcode;
+    if (Jim_GetWide(interp, exprResultPtr, &wideValue) != JIM_OK) {
+        if (Jim_GetDouble(interp, exprResultPtr, &doubleValue) != JIM_OK)
+        {
+            Jim_DecrRefCount(interp, exprResultPtr);
+            return JIM_ERR;
+        } else {
+            Jim_DecrRefCount(interp, exprResultPtr);
+            *boolPtr = doubleValue != 0;
+            return JIM_OK;
+        }
+    }
+    Jim_DecrRefCount(interp, exprResultPtr);
+    *boolPtr = wideValue != 0;
+    return JIM_OK;
 }
 
 /* -----------------------------------------------------------------------------
@@ -5987,75 +5986,75 @@ const char *dlerror()
 #define JIM_LIBPATH_LEN 1024
 int Jim_LoadLibrary(Jim_Interp *interp, char *pathName)
 {
-	Jim_Obj *libPathObjPtr;
-	int prefixc, i;
-	void *handle;
-	int (*onload)(Jim_Interp *interp);
-
-	libPathObjPtr = Jim_GetVariableString(interp, "jim::libpath", JIM_NONE);
-	if (libPathObjPtr == NULL) {
-		prefixc = 0;
-		libPathObjPtr = NULL;
-	} else {
-		Jim_IncrRefCount(libPathObjPtr);
-		Jim_ListLength(interp, libPathObjPtr, &prefixc);
-	}
-
-	for (i = -1; i < prefixc; i++) {
-		if (i < 0) {
-			handle = dlopen(pathName, RTLD_LAZY);
-		} else {
-			FILE *fp;
-			char buf[JIM_LIBPATH_LEN];
-			char *prefix;
-			int prefixlen;
-			Jim_Obj *prefixObjPtr;
-			
-			buf[0] = '\0';
-			if (Jim_ListIndex(interp, libPathObjPtr, i,
-					&prefixObjPtr, JIM_NONE) != JIM_OK)
-				continue;
-			prefix = Jim_GetString(prefixObjPtr, NULL);
-			prefixlen = strlen(prefix);
-			if (prefixlen+strlen(pathName)+1 >=
-					JIM_LIBPATH_LEN)
-				continue;
-			if (prefixlen && prefix[prefixlen-1] == '/')
-				sprintf(buf, "%s%s", prefix, pathName);
-			else
-				sprintf(buf, "%s/%s", prefix, pathName);
-			fp = fopen(buf, "r");
-			if (fp == NULL)
-				continue;
-			fclose(fp);
-			handle = dlopen(buf, RTLD_LAZY);
-		}
-		if (handle == NULL) {
-			Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-			Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"error loading extension \"", pathName,
-				"\": ", dlerror(), NULL);
-			if (i < 0)
-				continue;
-			goto err;
-		}
-		if ((onload = dlsym(handle, "Jim_OnLoad")) == NULL) {
-			Jim_SetResultString(interp,
-					"No Jim_OnLoad symbol found on extension", -1);
-			goto err;
-		}
-		if (onload(interp) == JIM_ERR) {
-			dlclose(handle);
-			goto err;
-		}
-		if (libPathObjPtr != NULL)
-			Jim_DecrRefCount(interp, libPathObjPtr);
-		return JIM_OK;
-	}
+    Jim_Obj *libPathObjPtr;
+    int prefixc, i;
+    void *handle;
+    int (*onload)(Jim_Interp *interp);
+
+    libPathObjPtr = Jim_GetVariableString(interp, "jim::libpath", JIM_NONE);
+    if (libPathObjPtr == NULL) {
+        prefixc = 0;
+        libPathObjPtr = NULL;
+    } else {
+        Jim_IncrRefCount(libPathObjPtr);
+        Jim_ListLength(interp, libPathObjPtr, &prefixc);
+    }
+
+    for (i = -1; i < prefixc; i++) {
+        if (i < 0) {
+            handle = dlopen(pathName, RTLD_LAZY);
+        } else {
+            FILE *fp;
+            char buf[JIM_LIBPATH_LEN];
+            char *prefix;
+            int prefixlen;
+            Jim_Obj *prefixObjPtr;
+            
+            buf[0] = '\0';
+            if (Jim_ListIndex(interp, libPathObjPtr, i,
+                    &prefixObjPtr, JIM_NONE) != JIM_OK)
+                continue;
+            prefix = Jim_GetString(prefixObjPtr, NULL);
+            prefixlen = strlen(prefix);
+            if (prefixlen+strlen(pathName)+1 >=
+                    JIM_LIBPATH_LEN)
+                continue;
+            if (prefixlen && prefix[prefixlen-1] == '/')
+                sprintf(buf, "%s%s", prefix, pathName);
+            else
+                sprintf(buf, "%s/%s", prefix, pathName);
+            fp = fopen(buf, "r");
+            if (fp == NULL)
+                continue;
+            fclose(fp);
+            handle = dlopen(buf, RTLD_LAZY);
+        }
+        if (handle == NULL) {
+            Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+            Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "error loading extension \"", pathName,
+                "\": ", dlerror(), NULL);
+            if (i < 0)
+                continue;
+            goto err;
+        }
+        if ((onload = dlsym(handle, "Jim_OnLoad")) == NULL) {
+            Jim_SetResultString(interp,
+                    "No Jim_OnLoad symbol found on extension", -1);
+            goto err;
+        }
+        if (onload(interp) == JIM_ERR) {
+            dlclose(handle);
+            goto err;
+        }
+        if (libPathObjPtr != NULL)
+            Jim_DecrRefCount(interp, libPathObjPtr);
+        return JIM_OK;
+    }
 err:
-	if (libPathObjPtr != NULL)
-		Jim_DecrRefCount(interp, libPathObjPtr);
-	return JIM_ERR;
+    if (libPathObjPtr != NULL)
+        Jim_DecrRefCount(interp, libPathObjPtr);
+    return JIM_ERR;
 }
 
 /* -----------------------------------------------------------------------------
@@ -6065,39 +6064,39 @@ err:
 #define JIM_EVAL_SINTV_LEN 8 /* static interpolation vector length */
 
 static int Jim_CallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, int argc,
-		Jim_Obj **argv);
+        Jim_Obj **argv);
 
 /* Hanlde class to the [unknown] command */
 static int Jim_Unknown(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	Jim_Obj **v, *sv[JIM_EVAL_SARGV_LEN];
-	int retCode;
-
-	/* 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
-	 * [unknonw] call. */
-	memcpy(v+1, argv, sizeof(Jim_Obj*)*argc);
-	v[0] = interp->unknown;
-	/* Call it */
-	retCode = Jim_EvalObjVector(interp, argc+1, v);
-	/* Clean up */
-	if (v != sv)
-		Jim_Free(v);
-	return retCode;
+    Jim_Obj **v, *sv[JIM_EVAL_SARGV_LEN];
+    int retCode;
+
+    /* 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
+     * [unknonw] call. */
+    memcpy(v+1, argv, sizeof(Jim_Obj*)*argc);
+    v[0] = interp->unknown;
+    /* Call it */
+    retCode = Jim_EvalObjVector(interp, argc+1, v);
+    /* Clean up */
+    if (v != sv)
+        Jim_Free(v);
+    return retCode;
 }
 
 /* Eval the object vector 'objv' composed of 'objc' elements.
@@ -6111,117 +6110,117 @@ static int Jim_Unknown(Jim_Interp *interp, int argc, Jim_Obj **argv)
  * command argument. */
 int Jim_EvalObjVector(Jim_Interp *interp, int objc, Jim_Obj **objv)
 {
-	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 = Jim_Unknown(interp, objc, objv);
-	} else {
-		/* Call it -- Make sure result is an empty object. */
-		Jim_SetEmptyResult(interp);
-		if (cmdPtr->cmdProc) {
-			interp->cmdPrivData = cmdPtr->privData;
-			retcode = cmdPtr->cmdProc(interp, objc, objv);
-		} else {
-			retcode = Jim_CallProcedure(interp, cmdPtr, objc, objv);
-			if (retcode == JIM_ERR) {
-				Jim_AppendStackTrace(interp,
-					Jim_GetString(objv[0], NULL),
-					"?", 1);
-			}
-		}
-	}
-	/* Decr refcount of arguments and return the retcode */
-	for (i = 0; i < objc; i++)
-		Jim_DecrRefCount(interp, objv[i]);
-	return retcode;
+    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 = Jim_Unknown(interp, objc, objv);
+    } else {
+        /* Call it -- Make sure result is an empty object. */
+        Jim_SetEmptyResult(interp);
+        if (cmdPtr->cmdProc) {
+            interp->cmdPrivData = cmdPtr->privData;
+            retcode = cmdPtr->cmdProc(interp, objc, objv);
+        } else {
+            retcode = Jim_CallProcedure(interp, cmdPtr, objc, objv);
+            if (retcode == JIM_ERR) {
+                Jim_AppendStackTrace(interp,
+                    Jim_GetString(objv[0], NULL),
+                    "?", 1);
+            }
+        }
+    }
+    /* Decr refcount of arguments and return the retcode */
+    for (i = 0; i < objc; i++)
+        Jim_DecrRefCount(interp, objv[i]);
+    return retcode;
 }
 
 /* Interpolate the given tokens into a unique Jim_Obj returned by reference
  * via *objPtrPtr. This function is only called by Jim_EvalObj().
  * The returned object has refcount = 0. */
 int Jim_InterpolateTokens(Jim_Interp *interp, ScriptToken *token,
-		int tokens, Jim_Obj **objPtrPtr)
-{
-	int totlen = 0, i, retcode;
-	Jim_Obj **intv;
-	Jim_Obj *sintv[JIM_EVAL_SINTV_LEN];
-	Jim_Obj *objPtr;
-	char *s;
-
-	if (tokens <= JIM_EVAL_SINTV_LEN)
-		intv = sintv;
-	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(token[i].type) {
-		case JIM_TT_ESC:
-		case JIM_TT_STR:
-			intv[i] = token[i].objPtr;
-			break;
-		case JIM_TT_VAR:
-			intv[i] = Jim_GetVariable(
-					interp,
-					token[i].objPtr,
-					JIM_ERRMSG);
-			if (!intv[i]) {
-				retcode = JIM_ERR;
-				goto err;
-			}
-			break;
-		case JIM_TT_CMD:
-			retcode = Jim_EvalObj(interp,
-					token[i].objPtr);
-			if (retcode != JIM_OK)
-				goto err;
-			intv[i] = Jim_GetResult(interp);
-			break;
-		default:
-			Jim_Panic(
-			  "default token type reached "
-			  "in Jim_EvalObj().");
-			break;
-		}
-		Jim_IncrRefCount(intv[i]);
-		/* Make sure there is a valid
-		 * string rep, and add the string
-		 * length to the total legnth. */
-		Jim_GetString(intv[i], NULL);
-		totlen += intv[i]->length;
-	}
-	/* Concatenate every token in an unique
-	 * object. */
-	objPtr = Jim_NewStringObjNoAlloc(interp,
-			NULL, 0);
-	s = objPtr->bytes = Jim_Alloc(totlen+1);
-	objPtr->length = totlen;
-	for (i = 0; i < tokens; i++) {
-		memcpy(s, intv[i]->bytes,
-				intv[i]->length);
-		s += intv[i]->length;
-		Jim_DecrRefCount(interp, intv[i]);
-	}
-	objPtr->bytes[totlen] = '\0';
-	/* Free the intv vector if not static. */
-	if (tokens > JIM_EVAL_SINTV_LEN)
-		Jim_Free(intv);
-	*objPtrPtr = objPtr;
-	return JIM_OK;
+        int tokens, Jim_Obj **objPtrPtr)
+{
+    int totlen = 0, i, retcode;
+    Jim_Obj **intv;
+    Jim_Obj *sintv[JIM_EVAL_SINTV_LEN];
+    Jim_Obj *objPtr;
+    char *s;
+
+    if (tokens <= JIM_EVAL_SINTV_LEN)
+        intv = sintv;
+    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(token[i].type) {
+        case JIM_TT_ESC:
+        case JIM_TT_STR:
+            intv[i] = token[i].objPtr;
+            break;
+        case JIM_TT_VAR:
+            intv[i] = Jim_GetVariable(
+                    interp,
+                    token[i].objPtr,
+                    JIM_ERRMSG);
+            if (!intv[i]) {
+                retcode = JIM_ERR;
+                goto err;
+            }
+            break;
+        case JIM_TT_CMD:
+            retcode = Jim_EvalObj(interp,
+                    token[i].objPtr);
+            if (retcode != JIM_OK)
+                goto err;
+            intv[i] = Jim_GetResult(interp);
+            break;
+        default:
+            Jim_Panic(
+              "default token type reached "
+              "in Jim_EvalObj().");
+            break;
+        }
+        Jim_IncrRefCount(intv[i]);
+        /* Make sure there is a valid
+         * string rep, and add the string
+         * length to the total legnth. */
+        Jim_GetString(intv[i], NULL);
+        totlen += intv[i]->length;
+    }
+    /* Concatenate every token in an unique
+     * object. */
+    objPtr = Jim_NewStringObjNoAlloc(interp,
+            NULL, 0);
+    s = objPtr->bytes = Jim_Alloc(totlen+1);
+    objPtr->length = totlen;
+    for (i = 0; i < tokens; i++) {
+        memcpy(s, intv[i]->bytes,
+                intv[i]->length);
+        s += intv[i]->length;
+        Jim_DecrRefCount(interp, intv[i]);
+    }
+    objPtr->bytes[totlen] = '\0';
+    /* Free the intv vector if not static. */
+    if (tokens > JIM_EVAL_SINTV_LEN)
+        Jim_Free(intv);
+    *objPtrPtr = objPtr;
+    return JIM_OK;
 err:
-	i--;
-	for (; i >= 0; i--)
-		Jim_DecrRefCount(interp, intv[i]);
-	if (tokens > JIM_EVAL_SINTV_LEN)
-		Jim_Free(intv);
-	return retcode;
+    i--;
+    for (; i >= 0; i--)
+        Jim_DecrRefCount(interp, intv[i]);
+    if (tokens > JIM_EVAL_SINTV_LEN)
+        Jim_Free(intv);
+    return retcode;
 }
 
 /* Helper of Jim_EvalObj() to perform argument expansion.
@@ -6230,246 +6229,246 @@ err:
  * expansion of the list object if 'expand' is non-zero, or
  * just adding objPtr to argv if 'expand' is zero. */
 void Jim_ExpandArgument(Jim_Interp *interp, Jim_Obj ***argv,
-		int *argcPtr, int expand, Jim_Obj *objPtr)
-{
-	if (!expand) {
-		(*argv) = Jim_Realloc(*argv, sizeof(Jim_Obj*)*((*argcPtr)+1));
-		/* refcount of objPtr not incremented because
-		 * we are actually transfering a reference from
-		 * the old 'argv' to the expanded one. */
-		(*argv)[*argcPtr] = objPtr;
-		(*argcPtr)++;
-	} else {
-		int len, i;
-
-		Jim_ListLength(interp, objPtr, &len);
-		(*argv) = Jim_Realloc(*argv, sizeof(Jim_Obj*)*((*argcPtr)+len));
-		for (i = 0; i < len; i++) {
-			(*argv)[*argcPtr] = objPtr->internalRep.listValue.ele[i];
-			Jim_IncrRefCount(objPtr->internalRep.listValue.ele[i]);
-			(*argcPtr)++;
-		}
-		/* 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, objPtr);
-	}
+        int *argcPtr, int expand, Jim_Obj *objPtr)
+{
+    if (!expand) {
+        (*argv) = Jim_Realloc(*argv, sizeof(Jim_Obj*)*((*argcPtr)+1));
+        /* refcount of objPtr not incremented because
+         * we are actually transfering a reference from
+         * the old 'argv' to the expanded one. */
+        (*argv)[*argcPtr] = objPtr;
+        (*argcPtr)++;
+    } else {
+        int len, i;
+
+        Jim_ListLength(interp, objPtr, &len);
+        (*argv) = Jim_Realloc(*argv, sizeof(Jim_Obj*)*((*argcPtr)+len));
+        for (i = 0; i < len; i++) {
+            (*argv)[*argcPtr] = objPtr->internalRep.listValue.ele[i];
+            Jim_IncrRefCount(objPtr->internalRep.listValue.ele[i]);
+            (*argcPtr)++;
+        }
+        /* 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, objPtr);
+    }
 }
 
 int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr)
 {
-	int i, j = 0, len;
-	ScriptObj *script;
-	ScriptToken *token;
-	int *cs; /* command structure array */
-	int retcode = JIM_OK;
-	Jim_Obj *sargv[JIM_EVAL_SARGV_LEN], **argv = NULL, *tmpObjPtr;
-
-	interp->errorFlag = 0;
-
-	/* If the object is of type "list" and there is no
-	 * string representation for this object, we can call
-	 * a specialized version of Jim_EvalObj() */
-	if (scriptObjPtr->typePtr == &listObjType &&
-	    scriptObjPtr->internalRep.listValue.len &&
-	    scriptObjPtr->bytes == NULL) {
-		Jim_IncrRefCount(scriptObjPtr);
-		retcode = Jim_EvalObjVector(interp,
-				scriptObjPtr->internalRep.listValue.len,
-				scriptObjPtr->internalRep.listValue.ele);
-		Jim_DecrRefCount(interp, scriptObjPtr);
-		return retcode;
-	}
-
-	Jim_IncrRefCount(scriptObjPtr); /* Make sure it's shared. */
-	script = Jim_GetScript(interp, scriptObjPtr);
-	/* 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;
-	len = script->len;
-	cs = script->cmdStruct;
-	i = 0; /* 'i' is the current token index. */
-
-	/* Reset the interpreter result. This is useful to
-	 * return the emtpy result in the case of empty program. */
-	Jim_SetEmptyResult(interp);
-
-	/* Execute every command sequentially, returns on
-	 * error (i.e. if a command does not return JIM_OK) */
-	while (i < len) {
-		int expand = 0;
-		int argc = *cs++; /* Get the number of arguments */
-		Jim_Cmd *cmd;
-
-		/* Set the expand flag if needed. */
-		if (argc == -1) {
-			expand++;
-			argc = *cs++;
-		}
-		/* Allocate the arguments vector */
-		if (argc <= JIM_EVAL_SARGV_LEN)
-			argv = sargv;
-		else
-			argv = Jim_Alloc(sizeof(Jim_Obj*)*argc);
-		/* Populate the arguments objects. */
-		for (j = 0; j < argc; j++) {
-			int tokens = *cs++;
-
-			/* tokens is negative if expansion is needed.
-			 * for this argument. */
-			if (tokens < 0) {
-				tokens = (-tokens)-1;
-				i++;
-			}
-			if (tokens == 1) {
-				/* Fast path if the token does not
-				 * need interpolation */
-				switch(token[i].type) {
-				case JIM_TT_ESC:
-				case JIM_TT_STR:
-					argv[j] = token[i].objPtr;
-					break;
-				case JIM_TT_VAR:
-					tmpObjPtr = Jim_GetVariable(
-							interp,
-							token[i].objPtr,
-							JIM_ERRMSG);
-					if (!tmpObjPtr) {
-						retcode = JIM_ERR;
-						goto err;
-					}
-					argv[j] = tmpObjPtr;
-					break;
-				case JIM_TT_DICTSUGAR:
-					tmpObjPtr = Jim_ExpandDictSugar(
-							interp,
-							token[i].objPtr);
-					if (!tmpObjPtr) {
-						retcode = JIM_ERR;
-						goto err;
-					}
-					argv[j] = tmpObjPtr;
-					break;
-				case JIM_TT_CMD:
-					retcode = Jim_EvalObj(interp,
-							token[i].objPtr);
-					if (retcode != JIM_OK) {
-						goto err;
-					}
-					argv[j] = Jim_GetResult(interp);
-					break;
-				default:
-					Jim_Panic(
-					  "default token type reached "
-					  "in Jim_EvalObj().");
-					break;
-				}
-				Jim_IncrRefCount(argv[j]);
-				i += 2;
-			} else {
-				/* For interpolation we call an helper
-				 * function doing the work for us. */
-				if ((retcode = Jim_InterpolateTokens(interp,
-						token+i, tokens, &tmpObjPtr)) !=
-						JIM_OK)
-				{
-					goto err;
-				}
-				argv[j] = tmpObjPtr;
-				Jim_IncrRefCount(argv[j]);
-				i += tokens+1;
-			}
-		}
-		/* Handle {expand} expansion */
-		if (expand) {
-			int *ecs = cs - argc;
-			int eargc = 0;
-			Jim_Obj **eargv = NULL;
-
-			for (j = 0; j < argc; j++) {
-				Jim_ExpandArgument(
-						interp, &eargv, &eargc,
-						ecs[j] < 0, argv[j]);
-			}
-			if (argv != sargv)
-				Jim_Free(argv);
-			argc = eargc;
-			argv = eargv;
-			j = argc;
-			if (argc == 0) {
-				/* Nothing to do with zero args. */
-				Jim_Free(eargv);
-				continue;
-			}
-		}
-		/* 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. */
-			Jim_SetEmptyResult(interp);
-			if (cmd->cmdProc) {
-				interp->cmdPrivData = cmd->privData;
-				retcode = cmd->cmdProc(interp, argc, argv);
-			} else {
-				retcode = Jim_CallProcedure(interp, cmd,
-						argc, argv);
-				if (retcode == JIM_ERR) {
-					Jim_AppendStackTrace(interp,
-						Jim_GetString(argv[0], NULL),
-						script->fileName,
-						token[i-argc*2].linenr);
-				}
-			}
-		} else {
-			/* Call [unknown] */
-			retcode = Jim_Unknown(interp, argc, argv);
-		}
-		if (retcode != JIM_OK) {
-			i -= argc*2; /* point to the command name. */
-			goto err;
-		}
-		/* Decrement the arguments count */
-		for (j = 0; j < argc; j++) {
-			Jim_DecrRefCount(interp, argv[j]);
-		}
-
-		if (argv != sargv) {
-			Jim_Free(argv);
-			argv = NULL;
-		}
-	}
-	/* Note that we don't have to decrement inUse, because the
-	 * following code transfers our use of the reference again to
-	 * the script object. */
-	j = 0; /* on normal termination, the argv array is already
-		  Jim_DecrRefCount-ed. */
+    int i, j = 0, len;
+    ScriptObj *script;
+    ScriptToken *token;
+    int *cs; /* command structure array */
+    int retcode = JIM_OK;
+    Jim_Obj *sargv[JIM_EVAL_SARGV_LEN], **argv = NULL, *tmpObjPtr;
+
+    interp->errorFlag = 0;
+
+    /* If the object is of type "list" and there is no
+     * string representation for this object, we can call
+     * a specialized version of Jim_EvalObj() */
+    if (scriptObjPtr->typePtr == &listObjType &&
+        scriptObjPtr->internalRep.listValue.len &&
+        scriptObjPtr->bytes == NULL) {
+        Jim_IncrRefCount(scriptObjPtr);
+        retcode = Jim_EvalObjVector(interp,
+                scriptObjPtr->internalRep.listValue.len,
+                scriptObjPtr->internalRep.listValue.ele);
+        Jim_DecrRefCount(interp, scriptObjPtr);
+        return retcode;
+    }
+
+    Jim_IncrRefCount(scriptObjPtr); /* Make sure it's shared. */
+    script = Jim_GetScript(interp, scriptObjPtr);
+    /* 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;
+    len = script->len;
+    cs = script->cmdStruct;
+    i = 0; /* 'i' is the current token index. */
+
+    /* Reset the interpreter result. This is useful to
+     * return the emtpy result in the case of empty program. */
+    Jim_SetEmptyResult(interp);
+
+    /* Execute every command sequentially, returns on
+     * error (i.e. if a command does not return JIM_OK) */
+    while (i < len) {
+        int expand = 0;
+        int argc = *cs++; /* Get the number of arguments */
+        Jim_Cmd *cmd;
+
+        /* Set the expand flag if needed. */
+        if (argc == -1) {
+            expand++;
+            argc = *cs++;
+        }
+        /* Allocate the arguments vector */
+        if (argc <= JIM_EVAL_SARGV_LEN)
+            argv = sargv;
+        else
+            argv = Jim_Alloc(sizeof(Jim_Obj*)*argc);
+        /* Populate the arguments objects. */
+        for (j = 0; j < argc; j++) {
+            int tokens = *cs++;
+
+            /* tokens is negative if expansion is needed.
+             * for this argument. */
+            if (tokens < 0) {
+                tokens = (-tokens)-1;
+                i++;
+            }
+            if (tokens == 1) {
+                /* Fast path if the token does not
+                 * need interpolation */
+                switch(token[i].type) {
+                case JIM_TT_ESC:
+                case JIM_TT_STR:
+                    argv[j] = token[i].objPtr;
+                    break;
+                case JIM_TT_VAR:
+                    tmpObjPtr = Jim_GetVariable(
+                            interp,
+                            token[i].objPtr,
+                            JIM_ERRMSG);
+                    if (!tmpObjPtr) {
+                        retcode = JIM_ERR;
+                        goto err;
+                    }
+                    argv[j] = tmpObjPtr;
+                    break;
+                case JIM_TT_DICTSUGAR:
+                    tmpObjPtr = Jim_ExpandDictSugar(
+                            interp,
+                            token[i].objPtr);
+                    if (!tmpObjPtr) {
+                        retcode = JIM_ERR;
+                        goto err;
+                    }
+                    argv[j] = tmpObjPtr;
+                    break;
+                case JIM_TT_CMD:
+                    retcode = Jim_EvalObj(interp,
+                            token[i].objPtr);
+                    if (retcode != JIM_OK) {
+                        goto err;
+                    }
+                    argv[j] = Jim_GetResult(interp);
+                    break;
+                default:
+                    Jim_Panic(
+                      "default token type reached "
+                      "in Jim_EvalObj().");
+                    break;
+                }
+                Jim_IncrRefCount(argv[j]);
+                i += 2;
+            } else {
+                /* For interpolation we call an helper
+                 * function doing the work for us. */
+                if ((retcode = Jim_InterpolateTokens(interp,
+                        token+i, tokens, &tmpObjPtr)) !=
+                        JIM_OK)
+                {
+                    goto err;
+                }
+                argv[j] = tmpObjPtr;
+                Jim_IncrRefCount(argv[j]);
+                i += tokens+1;
+            }
+        }
+        /* Handle {expand} expansion */
+        if (expand) {
+            int *ecs = cs - argc;
+            int eargc = 0;
+            Jim_Obj **eargv = NULL;
+
+            for (j = 0; j < argc; j++) {
+                Jim_ExpandArgument(
+                        interp, &eargv, &eargc,
+                        ecs[j] < 0, argv[j]);
+            }
+            if (argv != sargv)
+                Jim_Free(argv);
+            argc = eargc;
+            argv = eargv;
+            j = argc;
+            if (argc == 0) {
+                /* Nothing to do with zero args. */
+                Jim_Free(eargv);
+                continue;
+            }
+        }
+        /* 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. */
+            Jim_SetEmptyResult(interp);
+            if (cmd->cmdProc) {
+                interp->cmdPrivData = cmd->privData;
+                retcode = cmd->cmdProc(interp, argc, argv);
+            } else {
+                retcode = Jim_CallProcedure(interp, cmd,
+                        argc, argv);
+                if (retcode == JIM_ERR) {
+                    Jim_AppendStackTrace(interp,
+                        Jim_GetString(argv[0], NULL),
+                        script->fileName,
+                        token[i-argc*2].linenr);
+                }
+            }
+        } else {
+            /* Call [unknown] */
+            retcode = Jim_Unknown(interp, argc, argv);
+        }
+        if (retcode != JIM_OK) {
+            i -= argc*2; /* point to the command name. */
+            goto err;
+        }
+        /* Decrement the arguments count */
+        for (j = 0; j < argc; j++) {
+            Jim_DecrRefCount(interp, argv[j]);
+        }
+
+        if (argv != sargv) {
+            Jim_Free(argv);
+            argv = NULL;
+        }
+    }
+    /* Note that we don't have to decrement inUse, because the
+     * following code transfers our use of the reference again to
+     * the script object. */
+    j = 0; /* on normal termination, the argv array is already
+          Jim_DecrRefCount-ed. */
 err:
-	if (retcode == JIM_ERR && !interp->errorFlag) {
-		interp->errorFlag = 1;
-		Jim_SetErrorFileName(interp, script->fileName);
-		Jim_SetErrorLineNumber(interp, token[i].linenr);
-		Jim_ResetStackTrace(interp);
-	}
-	Jim_FreeIntRep(interp, scriptObjPtr);
-	scriptObjPtr->typePtr = &scriptObjType;
-	Jim_SetIntRepPtr(scriptObjPtr, script);
-	Jim_DecrRefCount(interp, scriptObjPtr);
-	for (i = 0; i < j; i++) {
-		Jim_DecrRefCount(interp, argv[i]);
-	}
-	if (argv != sargv)
-		Jim_Free(argv);
-	return retcode;
+    if (retcode == JIM_ERR && !interp->errorFlag) {
+        interp->errorFlag = 1;
+        Jim_SetErrorFileName(interp, script->fileName);
+        Jim_SetErrorLineNumber(interp, token[i].linenr);
+        Jim_ResetStackTrace(interp);
+    }
+    Jim_FreeIntRep(interp, scriptObjPtr);
+    scriptObjPtr->typePtr = &scriptObjType;
+    Jim_SetIntRepPtr(scriptObjPtr, script);
+    Jim_DecrRefCount(interp, scriptObjPtr);
+    for (i = 0; i < j; i++) {
+        Jim_DecrRefCount(interp, argv[i]);
+    }
+    if (argv != sargv)
+        Jim_Free(argv);
+    return retcode;
 }
 
 /* Call a procedure implemented in Tcl.
@@ -6481,118 +6480,118 @@ err:
  * This can be fixed just implementing callframes caching
  * in Jim_CreateCallFrame() and Jim_FreeCallFrame(). */
 int Jim_CallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, int argc,
-		Jim_Obj **argv)
-{
-	int i, retcode;
-	Jim_CallFrame *callFramePtr;
-
-	/* Check arity */
-	if (argc < cmd->arityMin || (cmd->arityMax != -1 &&
-	    argc > cmd->arityMax)) {
-		Jim_Obj *objPtr = Jim_NewEmptyStringObj(interp);
-		Jim_AppendStrings(interp, objPtr,
-			"wrong # args: should be \"",
-			Jim_GetString(argv[0], NULL),
-			(cmd->arityMin > 1) ? " " : "",
-			Jim_GetString(cmd->argListObjPtr, NULL),
-			"\"", NULL);
-		Jim_SetResult(interp, objPtr);
-		return JIM_ERR;
-	}
-	/* Check if there are too nested calls */
-	if (interp->numLevels == interp->maxNestingDepth) {
-		Jim_SetResultString(interp,
-			"Too many nested calls. Infinite recursion?", -1);
-		return JIM_ERR;
-	}
-	/* Create a new callframe */
-	callFramePtr = Jim_CreateCallFrame(interp);
-	callFramePtr->parentCallFrame = interp->framePtr;
-	callFramePtr->argv = argv;
-	callFramePtr->argc = argc;
-	callFramePtr->procArgsObjPtr = cmd->argListObjPtr;
-	callFramePtr->procBodyObjPtr = cmd->bodyObjPtr;
-	Jim_IncrRefCount(cmd->argListObjPtr);
-	Jim_IncrRefCount(cmd->bodyObjPtr);
-	interp->framePtr = callFramePtr;
-	interp->numLevels ++;
-	/* Set arguments */
-	for (i = 0; i < cmd->arityMin-1; i++) {
-		Jim_Obj *objPtr;
-
-		Jim_ListIndex(interp, cmd->argListObjPtr, i, &objPtr, JIM_NONE);
-		Jim_SetVariable(interp, objPtr, argv[i+1]);
-	}
-	if (cmd->arityMax == -1) {
-		Jim_Obj *listObjPtr, *objPtr;
-
-		listObjPtr = Jim_NewListObj(interp, argv+cmd->arityMin,
-				argc-cmd->arityMin);
-		Jim_ListIndex(interp, cmd->argListObjPtr, i, &objPtr, JIM_NONE);
-		Jim_SetVariable(interp, objPtr, listObjPtr);
-	}
-	/* Eval the body */
-	retcode = Jim_EvalObj(interp, cmd->bodyObjPtr);
-
-	/* Destroy the callframe */
-	interp->numLevels --;
-	interp->framePtr = interp->framePtr->parentCallFrame;
-	Jim_FreeCallFrame(interp, callFramePtr);
-
-	/* Handle the return code */
-	if (retcode == JIM_RETURN) {
-		int returnCode = interp->returnCode;
-		interp->returnCode = JIM_OK;
-		return returnCode;
-	}
-	return retcode;
+        Jim_Obj **argv)
+{
+    int i, retcode;
+    Jim_CallFrame *callFramePtr;
+
+    /* Check arity */
+    if (argc < cmd->arityMin || (cmd->arityMax != -1 &&
+        argc > cmd->arityMax)) {
+        Jim_Obj *objPtr = Jim_NewEmptyStringObj(interp);
+        Jim_AppendStrings(interp, objPtr,
+            "wrong # args: should be \"",
+            Jim_GetString(argv[0], NULL),
+            (cmd->arityMin > 1) ? " " : "",
+            Jim_GetString(cmd->argListObjPtr, NULL),
+            "\"", NULL);
+        Jim_SetResult(interp, objPtr);
+        return JIM_ERR;
+    }
+    /* Check if there are too nested calls */
+    if (interp->numLevels == interp->maxNestingDepth) {
+        Jim_SetResultString(interp,
+            "Too many nested calls. Infinite recursion?", -1);
+        return JIM_ERR;
+    }
+    /* Create a new callframe */
+    callFramePtr = Jim_CreateCallFrame(interp);
+    callFramePtr->parentCallFrame = interp->framePtr;
+    callFramePtr->argv = argv;
+    callFramePtr->argc = argc;
+    callFramePtr->procArgsObjPtr = cmd->argListObjPtr;
+    callFramePtr->procBodyObjPtr = cmd->bodyObjPtr;
+    Jim_IncrRefCount(cmd->argListObjPtr);
+    Jim_IncrRefCount(cmd->bodyObjPtr);
+    interp->framePtr = callFramePtr;
+    interp->numLevels ++;
+    /* Set arguments */
+    for (i = 0; i < cmd->arityMin-1; i++) {
+        Jim_Obj *objPtr;
+
+        Jim_ListIndex(interp, cmd->argListObjPtr, i, &objPtr, JIM_NONE);
+        Jim_SetVariable(interp, objPtr, argv[i+1]);
+    }
+    if (cmd->arityMax == -1) {
+        Jim_Obj *listObjPtr, *objPtr;
+
+        listObjPtr = Jim_NewListObj(interp, argv+cmd->arityMin,
+                argc-cmd->arityMin);
+        Jim_ListIndex(interp, cmd->argListObjPtr, i, &objPtr, JIM_NONE);
+        Jim_SetVariable(interp, objPtr, listObjPtr);
+    }
+    /* Eval the body */
+    retcode = Jim_EvalObj(interp, cmd->bodyObjPtr);
+
+    /* Destroy the callframe */
+    interp->numLevels --;
+    interp->framePtr = interp->framePtr->parentCallFrame;
+    Jim_FreeCallFrame(interp, callFramePtr);
+
+    /* Handle the return code */
+    if (retcode == JIM_RETURN) {
+        int returnCode = interp->returnCode;
+        interp->returnCode = JIM_OK;
+        return returnCode;
+    }
+    return retcode;
 }
 
 int Jim_Eval(Jim_Interp *interp, char *script)
 {
-	Jim_Obj *scriptObjPtr = Jim_NewStringObj(interp, script, -1);
-	int retval;
+    Jim_Obj *scriptObjPtr = Jim_NewStringObj(interp, script, -1);
+    int retval;
 
-	Jim_IncrRefCount(scriptObjPtr);
-	retval = Jim_EvalObj(interp, scriptObjPtr);
-	Jim_DecrRefCount(interp, scriptObjPtr);
-	return retval;
+    Jim_IncrRefCount(scriptObjPtr);
+    retval = Jim_EvalObj(interp, scriptObjPtr);
+    Jim_DecrRefCount(interp, scriptObjPtr);
+    return retval;
 }
 
 int Jim_EvalFile(Jim_Interp *interp, char *filename)
 {
-	char *prg = NULL;
-	FILE *fp;
-	int nread, totread, maxlen, buflen;
-	int retval;
-	Jim_Obj *scriptObjPtr;
-	
-	if ((fp = fopen(filename, "r")) == NULL) {
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-			"Error loading script \"", filename, "\": ",
-			strerror(errno), NULL);
-		return JIM_ERR;
-	}
-	buflen = 1024;
-	maxlen = totread = 0;
-	while (1) {
-		if (maxlen < totread+buflen+1) {
-			maxlen = totread+buflen+1;
-			prg = Jim_Realloc(prg, maxlen);
-		}
-		if ((nread = fread(prg+totread, 1, buflen, fp)) == 0) break;
-		totread += nread;
-	}
-	prg[totread] = '\0';
-	fclose(fp);
-
-	scriptObjPtr = Jim_NewStringObjNoAlloc(interp, prg, totread);
-	Jim_SetSourceInfo(interp, scriptObjPtr, filename, 1);
-	Jim_IncrRefCount(scriptObjPtr);
-	retval = Jim_EvalObj(interp, scriptObjPtr);
-	Jim_DecrRefCount(interp, scriptObjPtr);
-	return retval;
+    char *prg = NULL;
+    FILE *fp;
+    int nread, totread, maxlen, buflen;
+    int retval;
+    Jim_Obj *scriptObjPtr;
+    
+    if ((fp = fopen(filename, "r")) == NULL) {
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+            "Error loading script \"", filename, "\": ",
+            strerror(errno), NULL);
+        return JIM_ERR;
+    }
+    buflen = 1024;
+    maxlen = totread = 0;
+    while (1) {
+        if (maxlen < totread+buflen+1) {
+            maxlen = totread+buflen+1;
+            prg = Jim_Realloc(prg, maxlen);
+        }
+        if ((nread = fread(prg+totread, 1, buflen, fp)) == 0) break;
+        totread += nread;
+    }
+    prg[totread] = '\0';
+    fclose(fp);
+
+    scriptObjPtr = Jim_NewStringObjNoAlloc(interp, prg, totread);
+    Jim_SetSourceInfo(interp, scriptObjPtr, filename, 1);
+    Jim_IncrRefCount(scriptObjPtr);
+    retval = Jim_EvalObj(interp, scriptObjPtr);
+    Jim_DecrRefCount(interp, scriptObjPtr);
+    return retval;
 }
 
 /* -----------------------------------------------------------------------------
@@ -6600,64 +6599,64 @@ int Jim_EvalFile(Jim_Interp *interp, char *filename)
  * ---------------------------------------------------------------------------*/
 static int JimParseSubstStr(struct JimParserCtx *pc)
 {
-	pc->tstart = pc->p;
-	pc->tline = pc->linenr;
-	while (*pc->p && *pc->p != '$' && *pc->p != '[')
-		pc->p++;
-	pc->tend = pc->p-1;
-	pc->tt = JIM_TT_ESC;
-	return JIM_OK;
+    pc->tstart = pc->p;
+    pc->tline = pc->linenr;
+    while (*pc->p && *pc->p != '$' && *pc->p != '[')
+        pc->p++;
+    pc->tend = pc->p-1;
+    pc->tt = JIM_TT_ESC;
+    return JIM_OK;
 }
 
 static int JimParseSubst(struct JimParserCtx *pc, int flags)
 {
-	int retval;
-
-	switch(*pc->p) {
-	case '\0':
-		pc->tstart = pc->tend = pc->p;
-		pc->tline = pc->linenr;
-		pc->tt = JIM_TT_EOL;
-		pc->eof = 1;
-		break;
-	case '[':
-		retval = JimParseCmd(pc);
-		if (flags & JIM_SUBST_NOCMD) {
-			pc->tstart--;
-			pc->tend++;
-			pc->tt = (flags & JIM_SUBST_NOESC) ?
-				JIM_TT_STR : JIM_TT_ESC;
-		}
-		return retval;
-		break;
-	case '$':
-		if (JimParseVar(pc) == JIM_ERR) {
-			pc->tstart = pc->tend = pc->p++;
-			pc->tline = pc->linenr;
-			pc->tt = JIM_TT_STR;
-		} else {
-			if (flags & JIM_SUBST_NOVAR) {
-				pc->tstart--;
-				if (flags & JIM_SUBST_NOESC)
-					pc->tt = JIM_TT_STR;
-				else
-					pc->tt = JIM_TT_ESC;
-				if (*pc->tstart == '{') {
-					pc->tstart--;
-					if (*(pc->tend+1))
-						pc->tend++;
-				}
-			}
-		}
-		break;
-	default:
-		retval = JimParseSubstStr(pc);
-		if (flags & JIM_SUBST_NOESC)
-			pc->tt = JIM_TT_STR;
-		return retval;
-		break;
-	}
-	return JIM_OK;
+    int retval;
+
+    switch(*pc->p) {
+    case '\0':
+        pc->tstart = pc->tend = pc->p;
+        pc->tline = pc->linenr;
+        pc->tt = JIM_TT_EOL;
+        pc->eof = 1;
+        break;
+    case '[':
+        retval = JimParseCmd(pc);
+        if (flags & JIM_SUBST_NOCMD) {
+            pc->tstart--;
+            pc->tend++;
+            pc->tt = (flags & JIM_SUBST_NOESC) ?
+                JIM_TT_STR : JIM_TT_ESC;
+        }
+        return retval;
+        break;
+    case '$':
+        if (JimParseVar(pc) == JIM_ERR) {
+            pc->tstart = pc->tend = pc->p++;
+            pc->tline = pc->linenr;
+            pc->tt = JIM_TT_STR;
+        } else {
+            if (flags & JIM_SUBST_NOVAR) {
+                pc->tstart--;
+                if (flags & JIM_SUBST_NOESC)
+                    pc->tt = JIM_TT_STR;
+                else
+                    pc->tt = JIM_TT_ESC;
+                if (*pc->tstart == '{') {
+                    pc->tstart--;
+                    if (*(pc->tend+1))
+                        pc->tend++;
+                }
+            }
+        }
+        break;
+    default:
+        retval = JimParseSubstStr(pc);
+        if (flags & JIM_SUBST_NOESC)
+            pc->tt = JIM_TT_STR;
+        return retval;
+        break;
+    }
+    return JIM_OK;
 }
 
 /* The subst object type reuses most of the data structures and functions
@@ -6666,11 +6665,11 @@ static int JimParseSubst(struct JimParserCtx *pc, int flags)
  * deal with a single data structure at the cost of some more memory
  * usage for substitutions. */
 static Jim_ObjType substObjType = {
-	"subst",
-	FreeScriptInternalRep,
-	DupScriptInternalRep,
-	NULL,
-	JIM_TYPE_REFERENCES,
+    "subst",
+    FreeScriptInternalRep,
+    DupScriptInternalRep,
+    NULL,
+    JIM_TYPE_REFERENCES,
 };
 
 /* This method takes the string representation of an object
@@ -6678,124 +6677,124 @@ static Jim_ObjType substObjType = {
  * the pre-parsed internal representation. */
 int SetSubstFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr, int flags)
 {
-	char *scriptText = Jim_GetString(objPtr, NULL);
-	struct JimParserCtx parser;
-	struct ScriptObj *script = Jim_Alloc(sizeof(*script));
-
-	script->len = 0;
-	script->csLen = 0;
-	script->commands = 0;
-	script->token = NULL;
-	script->cmdStruct = NULL;
-	script->inUse = 1;
-	script->substFlags = flags;
-	script->fileName = NULL;
-
-	JimParserInit(&parser, scriptText, 1);
-	while(!JimParserEof(&parser)) {
-		char *token;
-		int len, type, linenr;
-
-		JimParseSubst(&parser, flags);
-		token = JimParserGetToken(&parser, &len, &type, &linenr);
-		ScriptObjAddToken(interp, script, token, len, type,
-				NULL, linenr);
-	}
-	/* Free the old internal rep and set the new one. */
-	Jim_FreeIntRep(interp, objPtr);
-	Jim_SetIntRepPtr(objPtr, script);
-	objPtr->typePtr = &scriptObjType;
-	return JIM_OK;
+    char *scriptText = Jim_GetString(objPtr, NULL);
+    struct JimParserCtx parser;
+    struct ScriptObj *script = Jim_Alloc(sizeof(*script));
+
+    script->len = 0;
+    script->csLen = 0;
+    script->commands = 0;
+    script->token = NULL;
+    script->cmdStruct = NULL;
+    script->inUse = 1;
+    script->substFlags = flags;
+    script->fileName = NULL;
+
+    JimParserInit(&parser, scriptText, 1);
+    while(!JimParserEof(&parser)) {
+        char *token;
+        int len, type, linenr;
+
+        JimParseSubst(&parser, flags);
+        token = JimParserGetToken(&parser, &len, &type, &linenr);
+        ScriptObjAddToken(interp, script, token, len, type,
+                NULL, linenr);
+    }
+    /* Free the old internal rep and set the new one. */
+    Jim_FreeIntRep(interp, objPtr);
+    Jim_SetIntRepPtr(objPtr, script);
+    objPtr->typePtr = &scriptObjType;
+    return JIM_OK;
 }
 
 ScriptObj *Jim_GetSubst(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
 {
-	struct ScriptObj *script = Jim_GetIntRepPtr(objPtr);
+    struct ScriptObj *script = Jim_GetIntRepPtr(objPtr);
 
-	if (objPtr->typePtr != &substObjType ||
-	    script->substFlags != flags) {
-		SetSubstFromAny(interp, objPtr, flags);
-	}
-	return (ScriptObj*) Jim_GetIntRepPtr(objPtr);
+    if (objPtr->typePtr != &substObjType ||
+        script->substFlags != flags) {
+        SetSubstFromAny(interp, objPtr, 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;
-	ScriptToken *token;
-	int i, len, retcode = JIM_OK;
-	Jim_Obj *resObjPtr, *savedResultObjPtr;
-
-	Jim_IncrRefCount(substObjPtr); /* Make sure it's shared. */
-	script = Jim_GetSubst(interp, substObjPtr, flags);
-	/* In order to preserve the internal rep, we increment the
-	 * inUse field of the script internal rep structure. */
-	script->inUse++;
-
-	token = script->token;
-	len = script->len;
-
-	/* Save the interp old result, to set it again before
-	 * to return. */
-	savedResultObjPtr = interp->result;
-	Jim_IncrRefCount(savedResultObjPtr);
-	
-	/* Perform the substitution. Starts with an empty object
-	 * and adds every token (performing the appropriate
-	 * var/command/escape substitution). */
-	resObjPtr = Jim_NewStringObj(interp, "", 0);
-	for (i = 0; i < len; i++) {
-		Jim_Obj *objPtr;
-
-		switch(token[i].type) {
-		case JIM_TT_STR:
-		case JIM_TT_ESC:
-			Jim_AppendObj(interp, resObjPtr, token[i].objPtr);
-			break;
-		case JIM_TT_VAR:
-			objPtr = Jim_GetVariable(interp, token[i].objPtr,
-					JIM_ERRMSG);
-			if (objPtr == NULL) goto err;
-			Jim_IncrRefCount(objPtr);
-			Jim_AppendObj(interp, resObjPtr, objPtr);
-			Jim_DecrRefCount(interp, objPtr);
-			break;
-		case JIM_TT_CMD:
-			if (Jim_EvalObj(interp, token[i].objPtr) != JIM_OK)
-				goto err;
-			Jim_AppendObj(interp, resObjPtr, interp->result);
-			break;
-		case JIM_TT_EOL:
-			break;
-		default:
-			Jim_Panic(
-			  "default token type (%d) reached "
-			  "in Jim_SubstObj().", token[i].type);
-			break;
-		}
-	}
+        Jim_Obj **resObjPtrPtr, int flags)
+{
+    ScriptObj *script;
+    ScriptToken *token;
+    int i, len, retcode = JIM_OK;
+    Jim_Obj *resObjPtr, *savedResultObjPtr;
+
+    Jim_IncrRefCount(substObjPtr); /* Make sure it's shared. */
+    script = Jim_GetSubst(interp, substObjPtr, flags);
+    /* In order to preserve the internal rep, we increment the
+     * inUse field of the script internal rep structure. */
+    script->inUse++;
+
+    token = script->token;
+    len = script->len;
+
+    /* Save the interp old result, to set it again before
+     * to return. */
+    savedResultObjPtr = interp->result;
+    Jim_IncrRefCount(savedResultObjPtr);
+    
+    /* Perform the substitution. Starts with an empty object
+     * and adds every token (performing the appropriate
+     * var/command/escape substitution). */
+    resObjPtr = Jim_NewStringObj(interp, "", 0);
+    for (i = 0; i < len; i++) {
+        Jim_Obj *objPtr;
+
+        switch(token[i].type) {
+        case JIM_TT_STR:
+        case JIM_TT_ESC:
+            Jim_AppendObj(interp, resObjPtr, token[i].objPtr);
+            break;
+        case JIM_TT_VAR:
+            objPtr = Jim_GetVariable(interp, token[i].objPtr,
+                    JIM_ERRMSG);
+            if (objPtr == NULL) goto err;
+            Jim_IncrRefCount(objPtr);
+            Jim_AppendObj(interp, resObjPtr, objPtr);
+            Jim_DecrRefCount(interp, objPtr);
+            break;
+        case JIM_TT_CMD:
+            if (Jim_EvalObj(interp, token[i].objPtr) != JIM_OK)
+                goto err;
+            Jim_AppendObj(interp, resObjPtr, interp->result);
+            break;
+        case JIM_TT_EOL:
+            break;
+        default:
+            Jim_Panic(
+              "default token type (%d) reached "
+              "in Jim_SubstObj().", token[i].type);
+            break;
+        }
+    }
 ok:
-	if (retcode == JIM_OK)
-		Jim_SetResult(interp, savedResultObjPtr);
-	Jim_DecrRefCount(interp, savedResultObjPtr);
-	/* 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, substObjPtr);
-	substObjPtr->typePtr = &scriptObjType;
-	Jim_SetIntRepPtr(substObjPtr, script);
-	Jim_DecrRefCount(interp, substObjPtr);
-	*resObjPtrPtr = resObjPtr;
-	return retcode;
+    if (retcode == JIM_OK)
+        Jim_SetResult(interp, savedResultObjPtr);
+    Jim_DecrRefCount(interp, savedResultObjPtr);
+    /* 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, substObjPtr);
+    substObjPtr->typePtr = &scriptObjType;
+    Jim_SetIntRepPtr(substObjPtr, script);
+    Jim_DecrRefCount(interp, substObjPtr);
+    *resObjPtrPtr = resObjPtr;
+    return retcode;
 err:
-	Jim_IncrRefCount(resObjPtr);
-	Jim_DecrRefCount(interp, resObjPtr);
-	retcode = JIM_ERR;
-	goto ok;
+    Jim_IncrRefCount(resObjPtr);
+    Jim_DecrRefCount(interp, resObjPtr);
+    retcode = JIM_ERR;
+    goto ok;
 }
 
 /* -----------------------------------------------------------------------------
@@ -6804,17 +6803,17 @@ err:
 
 void *Jim_GetApi(Jim_Interp *interp, char *funcname)
 {
-	Jim_HashEntry *he;
+    Jim_HashEntry *he;
 
-	he = Jim_FindHashEntry(&interp->stub, funcname);
-	if (!he)
-		return NULL;
-	return he->val;
+    he = Jim_FindHashEntry(&interp->stub, funcname);
+    if (!he)
+        return NULL;
+    return he->val;
 }
 
 int Jim_RegisterApi(Jim_Interp *interp, char *funcname, void *funcptr)
 {
-	return Jim_AddHashEntry(&interp->stub, funcname, funcptr);
+    return Jim_AddHashEntry(&interp->stub, funcname, funcptr);
 }
 
 void Jim_RegisterCoreApi(Jim_Interp *interp)
@@ -6896,59 +6895,59 @@ void Jim_RegisterCoreApi(Jim_Interp *interp)
  * ---------------------------------------------------------------------------*/
 void Jim_WrongNumArgs(Jim_Interp *interp, int argc, Jim_Obj **argv, char *msg)
 {
-	int i;
-	Jim_Obj *objPtr = Jim_NewEmptyStringObj(interp);
+    int i;
+    Jim_Obj *objPtr = Jim_NewEmptyStringObj(interp);
 
-	Jim_AppendString(interp, objPtr, "wrong # args: should be \"", -1);
-	for (i = 0; i < argc; i++) {
-		Jim_AppendObj(interp, objPtr, argv[i]);
-		if (!(i+1 == argc && msg[0] == '\0'))
-			Jim_AppendString(interp, objPtr, " ", 1);
-	}
-	Jim_AppendString(interp, objPtr, msg, -1);
-	Jim_AppendString(interp, objPtr, "\"", 1);
-	Jim_SetResult(interp, objPtr);
+    Jim_AppendString(interp, objPtr, "wrong # args: should be \"", -1);
+    for (i = 0; i < argc; i++) {
+        Jim_AppendObj(interp, objPtr, argv[i]);
+        if (!(i+1 == argc && msg[0] == '\0'))
+            Jim_AppendString(interp, objPtr, " ", 1);
+    }
+    Jim_AppendString(interp, objPtr, msg, -1);
+    Jim_AppendString(interp, objPtr, "\"", 1);
+    Jim_SetResult(interp, objPtr);
 }
 
 static Jim_Obj *Jim_CommandsList(Jim_Interp *interp, Jim_Obj *patternObjPtr)
 {
-	Jim_HashTableIterator *htiter;
-	Jim_HashEntry *he;
-	Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);
-	char *pattern;
-	
-	pattern = patternObjPtr ? Jim_GetString(patternObjPtr, NULL) : NULL;
-	htiter = Jim_GetHashTableIterator(&interp->commands);
-	while ((he = Jim_NextHashEntry(htiter)) != NULL) {
-		if (pattern && !Jim_StringMatch(pattern, he->key, 0))
-			continue;
-		Jim_ListAppendElement(interp, listObjPtr,
-				Jim_NewStringObj(interp, he->key, -1));
-	}
-	Jim_FreeHashTableIterator(htiter);
-	return listObjPtr;
+    Jim_HashTableIterator *htiter;
+    Jim_HashEntry *he;
+    Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);
+    char *pattern;
+    
+    pattern = patternObjPtr ? Jim_GetString(patternObjPtr, NULL) : NULL;
+    htiter = Jim_GetHashTableIterator(&interp->commands);
+    while ((he = Jim_NextHashEntry(htiter)) != NULL) {
+        if (pattern && !Jim_StringMatch(pattern, he->key, 0))
+            continue;
+        Jim_ListAppendElement(interp, listObjPtr,
+                Jim_NewStringObj(interp, he->key, -1));
+    }
+    Jim_FreeHashTableIterator(htiter);
+    return listObjPtr;
 }
 
 static int Jim_InfoLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr,
-		Jim_Obj **objPtrPtr)
-{
-	Jim_CallFrame *targetCallFrame;
-
-	if (Jim_GetCallFrameByLevel(interp, levelObjPtr, &targetCallFrame, NULL)
-			!= JIM_OK)
-		return JIM_ERR;
-	/* No proc call at toplevel callframe */
-	if (targetCallFrame == interp->topFramePtr) {
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"bad level \"",
-				Jim_GetString(levelObjPtr, NULL), "\"", NULL);
-		return JIM_ERR;
-	}
-	*objPtrPtr = Jim_NewListObj(interp,
-			targetCallFrame->argv,
-			targetCallFrame->argc);
-	return JIM_OK;
+        Jim_Obj **objPtrPtr)
+{
+    Jim_CallFrame *targetCallFrame;
+
+    if (Jim_GetCallFrameByLevel(interp, levelObjPtr, &targetCallFrame, NULL)
+            != JIM_OK)
+        return JIM_ERR;
+    /* No proc call at toplevel callframe */
+    if (targetCallFrame == interp->topFramePtr) {
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "bad level \"",
+                Jim_GetString(levelObjPtr, NULL), "\"", NULL);
+        return JIM_ERR;
+    }
+    *objPtrPtr = Jim_NewListObj(interp,
+            targetCallFrame->argv,
+            targetCallFrame->argc);
+    return JIM_OK;
 }
 
 /* -----------------------------------------------------------------------------
@@ -6958,1105 +6957,1105 @@ static int Jim_InfoLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr,
 /* fake [puts] -- not the real puts, just for debugging. */
 int Jim_PutsCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	char *str;
-	int len, nonewline = 0;
-	
-	if (argc != 2 && argc != 3) {
-		Jim_WrongNumArgs(interp, 1, argv, "-nonewline string");
-		return JIM_ERR;
-	}
-	if (argc == 3) {
-		if (!Jim_CompareStringImmediate(interp, argv[1], "-nonewline"))
-		{
-			Jim_SetResultString(interp, "The second argument must "
-					"be -nonewline", -1);
-			return JIM_OK;
-		} else {
-			nonewline = 1;
-			argv++;
-		}
-	}
-	str = Jim_GetString(argv[1], &len);
-	fwrite(str, 1, len, stdout);
-	if (!nonewline) printf("\n");
-	return JIM_OK;
+    char *str;
+    int len, nonewline = 0;
+    
+    if (argc != 2 && argc != 3) {
+        Jim_WrongNumArgs(interp, 1, argv, "-nonewline string");
+        return JIM_ERR;
+    }
+    if (argc == 3) {
+        if (!Jim_CompareStringImmediate(interp, argv[1], "-nonewline"))
+        {
+            Jim_SetResultString(interp, "The second argument must "
+                    "be -nonewline", -1);
+            return JIM_OK;
+        } else {
+            nonewline = 1;
+            argv++;
+        }
+    }
+    str = Jim_GetString(argv[1], &len);
+    fwrite(str, 1, len, stdout);
+    if (!nonewline) printf("\n");
+    return JIM_OK;
 }
 
 /* Helper for [+] and [*] */
 static int Jim_AddMulHelper(Jim_Interp *interp, int argc, Jim_Obj **argv,
-		int op)
-{
-	jim_wide wideValue, res;
-	double doubleValue, doubleRes;
-	int i;
-
-	res = (op == JIM_EXPROP_ADD) ? 0 : 1;
-	
-	for (i = 1; i < argc; i++) {
-		if (Jim_GetWide(interp, argv[i], &wideValue) != JIM_OK)
-			goto trydouble;
-		if (op == JIM_EXPROP_ADD)
-			res += wideValue;
-		else
-			res *= wideValue;
-	}
-	Jim_SetResult(interp, Jim_NewIntObj(interp, res));
-	return JIM_OK;
+        int op)
+{
+    jim_wide wideValue, res;
+    double doubleValue, doubleRes;
+    int i;
+
+    res = (op == JIM_EXPROP_ADD) ? 0 : 1;
+    
+    for (i = 1; i < argc; i++) {
+        if (Jim_GetWide(interp, argv[i], &wideValue) != JIM_OK)
+            goto trydouble;
+        if (op == JIM_EXPROP_ADD)
+            res += wideValue;
+        else
+            res *= wideValue;
+    }
+    Jim_SetResult(interp, Jim_NewIntObj(interp, res));
+    return JIM_OK;
 trydouble:
-	doubleRes = (double) res;
-	for (;i < argc; i++) {
-		if (Jim_GetDouble(interp, argv[i], &doubleValue) != JIM_OK)
-			return JIM_ERR;
-		if (op == JIM_EXPROP_ADD)
-			doubleRes += doubleValue;
-		else
-			doubleRes *= doubleValue;
-	}
-	Jim_SetResult(interp, Jim_NewDoubleObj(interp, doubleRes));
-	return JIM_OK;
+    doubleRes = (double) res;
+    for (;i < argc; i++) {
+        if (Jim_GetDouble(interp, argv[i], &doubleValue) != JIM_OK)
+            return JIM_ERR;
+        if (op == JIM_EXPROP_ADD)
+            doubleRes += doubleValue;
+        else
+            doubleRes *= doubleValue;
+    }
+    Jim_SetResult(interp, Jim_NewDoubleObj(interp, doubleRes));
+    return JIM_OK;
 }
 
 /* Helper for [-] and [/] */
 static int Jim_SubDivHelper(Jim_Interp *interp, int argc, Jim_Obj **argv,
-		int op)
-{
-	jim_wide wideValue, res = 0;
-	double doubleValue, doubleRes = 0;
-	int i = 2;
-
-	/* The arity = 2 case is different. For [- x] returns -x,
-	 * while [/ x] returns 1/x. */
-	if (argc == 2) {
-		if (Jim_GetWide(interp, argv[1], &wideValue) != JIM_OK) {
-			if (Jim_GetDouble(interp, argv[1], &doubleValue) !=
-					JIM_OK)
-			{
-				return JIM_ERR;
-			} else {
-				if (op == JIM_EXPROP_SUB)
-					doubleRes = -doubleValue;
-				else
-					doubleRes = 1.0/doubleValue;
-				Jim_SetResult(interp, Jim_NewDoubleObj(interp,
-							doubleRes));
-				return JIM_OK;
-			}
-		}
-		if (op == JIM_EXPROP_SUB) {
-			res = -wideValue;
-			Jim_SetResult(interp, Jim_NewIntObj(interp, res));
-		} else {
-			doubleRes = 1.0/wideValue;
-			Jim_SetResult(interp, Jim_NewDoubleObj(interp,
-						doubleRes));
-		}
-		return JIM_OK;
-	} else {
-		if (Jim_GetWide(interp, argv[1], &res) != JIM_OK) {
-			if (Jim_GetDouble(interp, argv[1], &doubleRes)
-					!= JIM_OK) {
-				return JIM_ERR;
-			} else {
-				goto trydouble;
-			}
-		}
-	}
-	for (i = 2; i < argc; i++) {
-		if (Jim_GetWide(interp, argv[i], &wideValue) != JIM_OK) {
-			doubleRes = (double) res;
-			goto trydouble;
-		}
-		if (op == JIM_EXPROP_SUB)
-			res -= wideValue;
-		else
-			res /= wideValue;
-	}
-	Jim_SetResult(interp, Jim_NewIntObj(interp, res));
-	return JIM_OK;
+        int op)
+{
+    jim_wide wideValue, res = 0;
+    double doubleValue, doubleRes = 0;
+    int i = 2;
+
+    /* The arity = 2 case is different. For [- x] returns -x,
+     * while [/ x] returns 1/x. */
+    if (argc == 2) {
+        if (Jim_GetWide(interp, argv[1], &wideValue) != JIM_OK) {
+            if (Jim_GetDouble(interp, argv[1], &doubleValue) !=
+                    JIM_OK)
+            {
+                return JIM_ERR;
+            } else {
+                if (op == JIM_EXPROP_SUB)
+                    doubleRes = -doubleValue;
+                else
+                    doubleRes = 1.0/doubleValue;
+                Jim_SetResult(interp, Jim_NewDoubleObj(interp,
+                            doubleRes));
+                return JIM_OK;
+            }
+        }
+        if (op == JIM_EXPROP_SUB) {
+            res = -wideValue;
+            Jim_SetResult(interp, Jim_NewIntObj(interp, res));
+        } else {
+            doubleRes = 1.0/wideValue;
+            Jim_SetResult(interp, Jim_NewDoubleObj(interp,
+                        doubleRes));
+        }
+        return JIM_OK;
+    } else {
+        if (Jim_GetWide(interp, argv[1], &res) != JIM_OK) {
+            if (Jim_GetDouble(interp, argv[1], &doubleRes)
+                    != JIM_OK) {
+                return JIM_ERR;
+            } else {
+                goto trydouble;
+            }
+        }
+    }
+    for (i = 2; i < argc; i++) {
+        if (Jim_GetWide(interp, argv[i], &wideValue) != JIM_OK) {
+            doubleRes = (double) res;
+            goto trydouble;
+        }
+        if (op == JIM_EXPROP_SUB)
+            res -= wideValue;
+        else
+            res /= wideValue;
+    }
+    Jim_SetResult(interp, Jim_NewIntObj(interp, res));
+    return JIM_OK;
 trydouble:
-	for (;i < argc; i++) {
-		if (Jim_GetDouble(interp, argv[i], &doubleValue) != JIM_OK)
-			return JIM_ERR;
-		if (op == JIM_EXPROP_SUB)
-			doubleRes -= doubleValue;
-		else
-			doubleRes /= doubleValue;
-	}
-	Jim_SetResult(interp, Jim_NewDoubleObj(interp, doubleRes));
-	return JIM_OK;
+    for (;i < argc; i++) {
+        if (Jim_GetDouble(interp, argv[i], &doubleValue) != JIM_OK)
+            return JIM_ERR;
+        if (op == JIM_EXPROP_SUB)
+            doubleRes -= doubleValue;
+        else
+            doubleRes /= doubleValue;
+    }
+    Jim_SetResult(interp, Jim_NewDoubleObj(interp, doubleRes));
+    return JIM_OK;
 }
 
 
 /* [+] */
 int Jim_AddCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	return Jim_AddMulHelper(interp, argc, argv, JIM_EXPROP_ADD);
+    return Jim_AddMulHelper(interp, argc, argv, JIM_EXPROP_ADD);
 }
 
 /* [*] */
 int Jim_MulCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	return Jim_AddMulHelper(interp, argc, argv, JIM_EXPROP_MUL);
+    return Jim_AddMulHelper(interp, argc, argv, JIM_EXPROP_MUL);
 }
 
 /* [-] */
 int Jim_SubCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	return Jim_SubDivHelper(interp, argc, argv, JIM_EXPROP_SUB);
+    return Jim_SubDivHelper(interp, argc, argv, JIM_EXPROP_SUB);
 }
 
 /* [/] */
 int Jim_DivCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	return Jim_SubDivHelper(interp, argc, argv, JIM_EXPROP_DIV);
+    return Jim_SubDivHelper(interp, argc, argv, JIM_EXPROP_DIV);
 }
 
 /* [set] */
 int Jim_SetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc != 2 && argc != 3) {
-		Jim_WrongNumArgs(interp, 1, argv, "varName ?newValue?");
-		return JIM_ERR;
-	}
-	if (argc == 2) {
-		Jim_Obj *objPtr;
-		objPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
-		if (!objPtr)
-			return JIM_ERR;
-		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;
+    if (argc != 2 && argc != 3) {
+        Jim_WrongNumArgs(interp, 1, argv, "varName ?newValue?");
+        return JIM_ERR;
+    }
+    if (argc == 2) {
+        Jim_Obj *objPtr;
+        objPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
+        if (!objPtr)
+            return JIM_ERR;
+        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] */
 int Jim_UnsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	int i;
+    int i;
 
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "varName ?varName ...?");
-		return JIM_ERR;
-	}
-	for (i = 1; i < argc; i++) {
-		if (Jim_UnsetVariable(interp, argv[i], JIM_ERRMSG) != JIM_OK)
-			return JIM_ERR;
-	}
-	return JIM_OK;
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "varName ?varName ...?");
+        return JIM_ERR;
+    }
+    for (i = 1; i < argc; i++) {
+        if (Jim_UnsetVariable(interp, argv[i], JIM_ERRMSG) != JIM_OK)
+            return JIM_ERR;
+    }
+    return JIM_OK;
 }
 
 /* [incr] */
 int Jim_IncrCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	jim_wide wideValue, increment = 1;
-	Jim_Obj *intObjPtr;
-
-	if (argc != 2 && argc != 3) {
-		Jim_WrongNumArgs(interp, 1, argv, "varName ?increment?");
-		return JIM_ERR;
-	}
-	if (argc == 3) {
-		if (Jim_GetWide(interp, argv[2], &increment) != JIM_OK)
-			return JIM_ERR;
-	}
-	intObjPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
-	if (!intObjPtr) return JIM_ERR;
-	if (Jim_GetWide(interp, intObjPtr, &wideValue) != JIM_OK)
-		return JIM_ERR;
-	if (Jim_IsShared(intObjPtr)) {
-		intObjPtr = Jim_NewIntObj(interp, wideValue+increment);
-		if (Jim_SetVariable(interp, argv[1], intObjPtr) != JIM_OK) {
-			Jim_IncrRefCount(intObjPtr);
-			Jim_DecrRefCount(interp, intObjPtr);
-			return JIM_ERR;
-		}
-	} else {
-		Jim_SetWide(interp, intObjPtr, wideValue+increment);
-	}
-	Jim_SetResult(interp, intObjPtr);
-	return JIM_OK;
+    jim_wide wideValue, increment = 1;
+    Jim_Obj *intObjPtr;
+
+    if (argc != 2 && argc != 3) {
+        Jim_WrongNumArgs(interp, 1, argv, "varName ?increment?");
+        return JIM_ERR;
+    }
+    if (argc == 3) {
+        if (Jim_GetWide(interp, argv[2], &increment) != JIM_OK)
+            return JIM_ERR;
+    }
+    intObjPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
+    if (!intObjPtr) return JIM_ERR;
+    if (Jim_GetWide(interp, intObjPtr, &wideValue) != JIM_OK)
+        return JIM_ERR;
+    if (Jim_IsShared(intObjPtr)) {
+        intObjPtr = Jim_NewIntObj(interp, wideValue+increment);
+        if (Jim_SetVariable(interp, argv[1], intObjPtr) != JIM_OK) {
+            Jim_IncrRefCount(intObjPtr);
+            Jim_DecrRefCount(interp, intObjPtr);
+            return JIM_ERR;
+        }
+    } else {
+        Jim_SetWide(interp, intObjPtr, wideValue+increment);
+    }
+    Jim_SetResult(interp, intObjPtr);
+    return JIM_OK;
 }
 
 /* [while] */
 int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc != 3) {
-		Jim_WrongNumArgs(interp, 1, argv, "condition body");
-		return JIM_ERR;
-	}
-	while (1) {
-		int boolean, retval;
-
-		if ((retval = Jim_GetBoolFromExpr(interp, argv[1],
-						&boolean)) != JIM_OK)
-			return retval;
-		if (!boolean) break;
-		if ((retval = Jim_EvalObj(interp, argv[2])) != JIM_OK) {
-			switch(retval) {
-			case JIM_BREAK:
-				goto out;
-				break;
-			case JIM_CONTINUE:
-				continue;
-				break;
-			default:
-				return retval;
-			}
-		}
-	}
+    if (argc != 3) {
+        Jim_WrongNumArgs(interp, 1, argv, "condition body");
+        return JIM_ERR;
+    }
+    while (1) {
+        int boolean, retval;
+
+        if ((retval = Jim_GetBoolFromExpr(interp, argv[1],
+                        &boolean)) != JIM_OK)
+            return retval;
+        if (!boolean) break;
+        if ((retval = Jim_EvalObj(interp, argv[2])) != JIM_OK) {
+            switch(retval) {
+            case JIM_BREAK:
+                goto out;
+                break;
+            case JIM_CONTINUE:
+                continue;
+                break;
+            default:
+                return retval;
+            }
+        }
+    }
 out:
-	Jim_SetEmptyResult(interp);
-	return JIM_OK;
+    Jim_SetEmptyResult(interp);
+    return JIM_OK;
 }
 
 /* [for] */
 int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	int retval;
-
-	if (argc != 5) {
-		Jim_WrongNumArgs(interp, 1, argv, "start test next body");
-		return JIM_ERR;
-	}
-	/* Eval start */
-	if ((retval = Jim_EvalObj(interp, argv[1])) != JIM_OK)
-		return retval;
-	while (1) {
-		int boolean;
-		/* Test the condition */
-		if ((retval = Jim_GetBoolFromExpr(interp, argv[2], &boolean))
-				!= JIM_OK)
-			return retval;
-		if (!boolean) break;
-		/* Eval body */
-		if ((retval = Jim_EvalObj(interp, argv[4])) != JIM_OK) {
-			switch(retval) {
-			case JIM_BREAK:
-				goto out;
-				break;
-			case JIM_CONTINUE:
-				continue;
-				break;
-			default:
-				return retval;
-			}
-		}
-		/* Eval next */
-		if ((retval = Jim_EvalObj(interp, argv[3])) != JIM_OK) {
-			switch(retval) {
-			case JIM_BREAK:
-				goto out;
-				break;
-			case JIM_CONTINUE:
-				continue;
-				break;
-			default:
-				return retval;
-			}
-		}
-	}
+    int retval;
+
+    if (argc != 5) {
+        Jim_WrongNumArgs(interp, 1, argv, "start test next body");
+        return JIM_ERR;
+    }
+    /* Eval start */
+    if ((retval = Jim_EvalObj(interp, argv[1])) != JIM_OK)
+        return retval;
+    while (1) {
+        int boolean;
+        /* Test the condition */
+        if ((retval = Jim_GetBoolFromExpr(interp, argv[2], &boolean))
+                != JIM_OK)
+            return retval;
+        if (!boolean) break;
+        /* Eval body */
+        if ((retval = Jim_EvalObj(interp, argv[4])) != JIM_OK) {
+            switch(retval) {
+            case JIM_BREAK:
+                goto out;
+                break;
+            case JIM_CONTINUE:
+                continue;
+                break;
+            default:
+                return retval;
+            }
+        }
+        /* Eval next */
+        if ((retval = Jim_EvalObj(interp, argv[3])) != JIM_OK) {
+            switch(retval) {
+            case JIM_BREAK:
+                goto out;
+                break;
+            case JIM_CONTINUE:
+                continue;
+                break;
+            default:
+                return retval;
+            }
+        }
+    }
 out:
-	Jim_SetEmptyResult(interp);
-	return JIM_OK;
+    Jim_SetEmptyResult(interp);
+    return JIM_OK;
 }
 
 /* [foreach] */
 int Jim_ForeachCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	int result = JIM_ERR, i, nbrOfLists, *listsIdx, *listsEnd;
-	int nbrOfLoops = 0;
-	Jim_Obj *emptyStr, *script;
-	if (argc < 4 || argc % 2 != 0) {
-		Jim_WrongNumArgs(interp, 1, argv, "varList list ?varList list ...? script");
-		return JIM_ERR;
-	}
-	emptyStr = Jim_NewEmptyStringObj(interp);
-	Jim_IncrRefCount(emptyStr);
-	script = argv[argc-1];            /* Last argument is a script */
-	nbrOfLists = (argc - 1 - 1) / 2;  /* argc - 'foreach' - script */
-	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;
-		Jim_ListLength(interp, argv[i+1], &listsEnd[i]);
-		Jim_ListLength(interp, argv[i+2], &listsEnd[i+1]);
-		if (listsEnd[i] == 0) {
-			Jim_SetResultString(interp, "foreach varlist is empty", -1);
-			goto err;
-		}
-		cnt = div(listsEnd[i+1], listsEnd[i]);
-		count = cnt.quot + (cnt.rem ? 1 : 0);
-		if (count > nbrOfLoops)
-			nbrOfLoops = count;
-	}
-	for (; nbrOfLoops-- > 0; ) {
-		for (i=0; i < nbrOfLists; ++i) {
-			int varIdx = 0, var = i * 2;
-			while (varIdx < listsEnd[var]) {
-				Jim_Obj *varName, *ele;
-				int lst = i * 2 + 1;
-				if (Jim_ListIndex(interp, argv[var+1], varIdx, &varName, JIM_ERRMSG)
-						!= JIM_OK)
-						goto err;
-				if (listsIdx[i] < listsEnd[lst]) {
-					if (Jim_ListIndex(interp, argv[lst+1], listsIdx[i], &ele, JIM_ERRMSG)
-						!= JIM_OK)
-						goto err;
-					if (Jim_SetVariable(interp, varName, ele) != JIM_OK) {
-						Jim_SetResultString(interp, "couldn't set loop variable: ", -1);
-						goto err;
-					}
-					++listsIdx[i];  /* Remember next iterator of current list */ 
-				} else if (Jim_SetVariable(interp, varName, emptyStr) != JIM_OK) {
-					Jim_SetResultString(interp, "couldn't set loop variable: ", -1);
-					goto err;
-				}
-				++varIdx;  /* Next variable */
-			}
-		}
-		switch (result = Jim_EvalObj(interp, script)) {
-			case JIM_OK: case JIM_CONTINUE: break;
-			case JIM_BREAK: goto out; break;
-			default: goto err;
-		}
-	}
+    int result = JIM_ERR, i, nbrOfLists, *listsIdx, *listsEnd;
+    int nbrOfLoops = 0;
+    Jim_Obj *emptyStr, *script;
+    if (argc < 4 || argc % 2 != 0) {
+        Jim_WrongNumArgs(interp, 1, argv, "varList list ?varList list ...? script");
+        return JIM_ERR;
+    }
+    emptyStr = Jim_NewEmptyStringObj(interp);
+    Jim_IncrRefCount(emptyStr);
+    script = argv[argc-1];            /* Last argument is a script */
+    nbrOfLists = (argc - 1 - 1) / 2;  /* argc - 'foreach' - script */
+    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;
+        Jim_ListLength(interp, argv[i+1], &listsEnd[i]);
+        Jim_ListLength(interp, argv[i+2], &listsEnd[i+1]);
+        if (listsEnd[i] == 0) {
+            Jim_SetResultString(interp, "foreach varlist is empty", -1);
+            goto err;
+        }
+        cnt = div(listsEnd[i+1], listsEnd[i]);
+        count = cnt.quot + (cnt.rem ? 1 : 0);
+        if (count > nbrOfLoops)
+            nbrOfLoops = count;
+    }
+    for (; nbrOfLoops-- > 0; ) {
+        for (i=0; i < nbrOfLists; ++i) {
+            int varIdx = 0, var = i * 2;
+            while (varIdx < listsEnd[var]) {
+                Jim_Obj *varName, *ele;
+                int lst = i * 2 + 1;
+                if (Jim_ListIndex(interp, argv[var+1], varIdx, &varName, JIM_ERRMSG)
+                        != JIM_OK)
+                        goto err;
+                if (listsIdx[i] < listsEnd[lst]) {
+                    if (Jim_ListIndex(interp, argv[lst+1], listsIdx[i], &ele, JIM_ERRMSG)
+                        != JIM_OK)
+                        goto err;
+                    if (Jim_SetVariable(interp, varName, ele) != JIM_OK) {
+                        Jim_SetResultString(interp, "couldn't set loop variable: ", -1);
+                        goto err;
+                    }
+                    ++listsIdx[i];  /* Remember next iterator of current list */ 
+                } else if (Jim_SetVariable(interp, varName, emptyStr) != JIM_OK) {
+                    Jim_SetResultString(interp, "couldn't set loop variable: ", -1);
+                    goto err;
+                }
+                ++varIdx;  /* Next variable */
+            }
+        }
+        switch (result = Jim_EvalObj(interp, script)) {
+            case JIM_OK: case JIM_CONTINUE: break;
+            case JIM_BREAK: goto out; break;
+            default: goto err;
+        }
+    }
 out:
-	result = JIM_OK;
-	Jim_SetEmptyResult(interp);
+    result = JIM_OK;
+    Jim_SetEmptyResult(interp);
 err:
-	Jim_DecrRefCount(interp, emptyStr);
-	Jim_Free(listsIdx);
-	Jim_Free(listsEnd);
-	return result;
+    Jim_DecrRefCount(interp, emptyStr);
+    Jim_Free(listsIdx);
+    Jim_Free(listsEnd);
+    return result;
 }
 
 /* [if] */
 int Jim_IfCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **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) 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]);
-		}
-		return JIM_OK;
-	}
+    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) 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]);
+        }
+        return JIM_OK;
+    }
 err:
-	Jim_WrongNumArgs(interp, 1, argv, "condition ?then? trueBody ?elseif ...? ?else? falseBody");
-	return JIM_ERR;
+    Jim_WrongNumArgs(interp, 1, argv, "condition ?then? trueBody ?elseif ...? ?else? falseBody");
+    return JIM_ERR;
 }
 
 /* [list] */
 int Jim_ListCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	Jim_Obj *listObjPtr;
+    Jim_Obj *listObjPtr;
 
-	listObjPtr = Jim_NewListObj(interp, argv+1, argc-1);
-	Jim_SetResult(interp, listObjPtr);
-	return JIM_OK;
+    listObjPtr = Jim_NewListObj(interp, argv+1, argc-1);
+    Jim_SetResult(interp, listObjPtr);
+    return JIM_OK;
 }
 
 /* [lindex] */
 int Jim_LindexCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	Jim_Obj *objPtr, *listObjPtr;
-	int i;
-	int index;
-
-	if (argc < 3) {
-		Jim_WrongNumArgs(interp, 1, argv, "list index ?...?");
-		return JIM_ERR;
-	}
-	objPtr = argv[1];
-	Jim_IncrRefCount(objPtr);
-	for (i = 2; i < argc; i++) {
-		listObjPtr = objPtr;
-		if (Jim_GetIndex(interp, argv[i], &index) != JIM_OK) {
-			Jim_DecrRefCount(interp, listObjPtr);
-			return JIM_ERR;
-		}
-		if (Jim_ListIndex(interp, listObjPtr, index, &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;
-		}
-		Jim_IncrRefCount(objPtr);
-		Jim_DecrRefCount(interp, listObjPtr);
-	}
-	Jim_SetResult(interp, objPtr);
-	Jim_DecrRefCount(interp, objPtr);
-	return JIM_OK;
+    Jim_Obj *objPtr, *listObjPtr;
+    int i;
+    int index;
+
+    if (argc < 3) {
+        Jim_WrongNumArgs(interp, 1, argv, "list index ?...?");
+        return JIM_ERR;
+    }
+    objPtr = argv[1];
+    Jim_IncrRefCount(objPtr);
+    for (i = 2; i < argc; i++) {
+        listObjPtr = objPtr;
+        if (Jim_GetIndex(interp, argv[i], &index) != JIM_OK) {
+            Jim_DecrRefCount(interp, listObjPtr);
+            return JIM_ERR;
+        }
+        if (Jim_ListIndex(interp, listObjPtr, index, &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;
+        }
+        Jim_IncrRefCount(objPtr);
+        Jim_DecrRefCount(interp, listObjPtr);
+    }
+    Jim_SetResult(interp, objPtr);
+    Jim_DecrRefCount(interp, objPtr);
+    return JIM_OK;
 }
 
 /* [llenght] */
 int Jim_LlengthCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	int len;
+    int len;
 
-	if (argc != 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "list");
-		return JIM_ERR;
-	}
-	Jim_ListLength(interp, argv[1], &len);
-	Jim_SetResult(interp, Jim_NewIntObj(interp, len));
-	return JIM_OK;
+    if (argc != 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "list");
+        return JIM_ERR;
+    }
+    Jim_ListLength(interp, argv[1], &len);
+    Jim_SetResult(interp, Jim_NewIntObj(interp, len));
+    return JIM_OK;
 }
 
 /* [lappend] */
 int Jim_LappendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	Jim_Obj *listObjPtr;
-	int shared, i;
-
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "varName ?value value ...?");
-		return JIM_ERR;
-	}
-	listObjPtr = Jim_GetVariable(interp, argv[1], JIM_NONE);
-	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_IncrRefCount(listObjPtr);
-			Jim_DecrRefCount(interp, listObjPtr);
-			return JIM_ERR;
-		}
-	}
-	shared = Jim_IsShared(listObjPtr);
-	if (shared)
-		listObjPtr = Jim_DuplicateObj(interp, listObjPtr);
-	for (i = 2; i < argc; i++)
-		Jim_ListAppendElement(interp, listObjPtr, argv[i]);
-	if (shared) {
-		if (Jim_SetVariable(interp, argv[1], listObjPtr) != JIM_OK) {
-			Jim_IncrRefCount(listObjPtr);
-			Jim_DecrRefCount(interp, listObjPtr);
-			return JIM_ERR;
-		}
-	}
-	Jim_SetResult(interp, listObjPtr);
-	return JIM_OK;
+    Jim_Obj *listObjPtr;
+    int shared, i;
+
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "varName ?value value ...?");
+        return JIM_ERR;
+    }
+    listObjPtr = Jim_GetVariable(interp, argv[1], JIM_NONE);
+    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_IncrRefCount(listObjPtr);
+            Jim_DecrRefCount(interp, listObjPtr);
+            return JIM_ERR;
+        }
+    }
+    shared = Jim_IsShared(listObjPtr);
+    if (shared)
+        listObjPtr = Jim_DuplicateObj(interp, listObjPtr);
+    for (i = 2; i < argc; i++)
+        Jim_ListAppendElement(interp, listObjPtr, argv[i]);
+    if (shared) {
+        if (Jim_SetVariable(interp, argv[1], listObjPtr) != JIM_OK) {
+            Jim_IncrRefCount(listObjPtr);
+            Jim_DecrRefCount(interp, listObjPtr);
+            return JIM_ERR;
+        }
+    }
+    Jim_SetResult(interp, listObjPtr);
+    return JIM_OK;
 }
 
 /* [lset] */
 int Jim_LsetCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc < 3) {
-		Jim_WrongNumArgs(interp, 1, argv, "listVar ?index...? newVal");
-		return JIM_ERR;
-	} else if (argc == 3) {
-		if (Jim_SetVariable(interp, argv[1], argv[2]) != JIM_OK)
-			return JIM_ERR;
-		Jim_SetResult(interp, argv[2]);
-		return JIM_OK;
-	}
-	if (Jim_SetListIndex(interp, argv[1], argv+2, argc-3, argv[argc-1])
-			== JIM_ERR) return JIM_ERR;
-	return JIM_OK;
+    if (argc < 3) {
+        Jim_WrongNumArgs(interp, 1, argv, "listVar ?index...? newVal");
+        return JIM_ERR;
+    } else if (argc == 3) {
+        if (Jim_SetVariable(interp, argv[1], argv[2]) != JIM_OK)
+            return JIM_ERR;
+        Jim_SetResult(interp, argv[2]);
+        return JIM_OK;
+    }
+    if (Jim_SetListIndex(interp, argv[1], argv+2, argc-3, argv[argc-1])
+            == JIM_ERR) return JIM_ERR;
+    return JIM_OK;
 }
 
 /* [append] */
 int Jim_AppendCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	Jim_Obj *stringObjPtr;
-	int shared, i;
-
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "varName ?value value ...?");
-		return JIM_ERR;
-	}
-	if (argc == 2) {
-		stringObjPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
-		if (!stringObjPtr) return JIM_ERR;
-	} else {
-		stringObjPtr = Jim_GetVariable(interp, argv[1], JIM_NONE);
-		if (!stringObjPtr) {
-			/* Create the string if it does not exists */
-			stringObjPtr = Jim_NewEmptyStringObj(interp);
-			if (Jim_SetVariable(interp, argv[1], stringObjPtr)
-					!= JIM_OK) {
-				Jim_IncrRefCount(stringObjPtr);
-				Jim_DecrRefCount(interp, stringObjPtr);
-				return JIM_ERR;
-			}
-		}
-	}
-	shared = Jim_IsShared(stringObjPtr);
-	if (shared)
-		stringObjPtr = Jim_DuplicateObj(interp, stringObjPtr);
-	for (i = 2; i < argc; i++)
-		Jim_AppendObj(interp, stringObjPtr, argv[i]);
-	if (shared) {
-		if (Jim_SetVariable(interp, argv[1], stringObjPtr) != JIM_OK) {
-			Jim_IncrRefCount(stringObjPtr);
-			Jim_DecrRefCount(interp, stringObjPtr);
-			return JIM_ERR;
-		}
-	}
-	Jim_SetResult(interp, stringObjPtr);
-	return JIM_OK;
+    Jim_Obj *stringObjPtr;
+    int shared, i;
+
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "varName ?value value ...?");
+        return JIM_ERR;
+    }
+    if (argc == 2) {
+        stringObjPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG);
+        if (!stringObjPtr) return JIM_ERR;
+    } else {
+        stringObjPtr = Jim_GetVariable(interp, argv[1], JIM_NONE);
+        if (!stringObjPtr) {
+            /* Create the string if it does not exists */
+            stringObjPtr = Jim_NewEmptyStringObj(interp);
+            if (Jim_SetVariable(interp, argv[1], stringObjPtr)
+                    != JIM_OK) {
+                Jim_IncrRefCount(stringObjPtr);
+                Jim_DecrRefCount(interp, stringObjPtr);
+                return JIM_ERR;
+            }
+        }
+    }
+    shared = Jim_IsShared(stringObjPtr);
+    if (shared)
+        stringObjPtr = Jim_DuplicateObj(interp, stringObjPtr);
+    for (i = 2; i < argc; i++)
+        Jim_AppendObj(interp, stringObjPtr, argv[i]);
+    if (shared) {
+        if (Jim_SetVariable(interp, argv[1], stringObjPtr) != JIM_OK) {
+            Jim_IncrRefCount(stringObjPtr);
+            Jim_DecrRefCount(interp, stringObjPtr);
+            return JIM_ERR;
+        }
+    }
+    Jim_SetResult(interp, stringObjPtr);
+    return JIM_OK;
 }
 
 /* [debug] */
 int Jim_DebugCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	char *subcommand;
-
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "option ?...?");
-		return JIM_ERR;
-	}
-	subcommand = Jim_GetString(argv[1], NULL);
-	if (!strcmp(subcommand, "refcount")) {
-		if (argc != 3) {
-			Jim_WrongNumArgs(interp, 2, argv, "object");
-			return JIM_ERR;
-		}
-		Jim_SetResult(interp, Jim_NewIntObj(interp, argv[2]->refCount));
-		return JIM_OK;
-	} else if (!strcmp(subcommand, "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 (!strcmp(subcommand, "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];
-			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 (!strcmp(subcommand, "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 {
-		Jim_SetResultString(interp,
-			"bad option. Valid options are refcount, "
-			"objcount, objects, invstr", -1);
-		return JIM_ERR;
-	}
-	return JIM_OK; /* unreached */
+    char *subcommand;
+
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "option ?...?");
+        return JIM_ERR;
+    }
+    subcommand = Jim_GetString(argv[1], NULL);
+    if (!strcmp(subcommand, "refcount")) {
+        if (argc != 3) {
+            Jim_WrongNumArgs(interp, 2, argv, "object");
+            return JIM_ERR;
+        }
+        Jim_SetResult(interp, Jim_NewIntObj(interp, argv[2]->refCount));
+        return JIM_OK;
+    } else if (!strcmp(subcommand, "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 (!strcmp(subcommand, "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];
+            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 (!strcmp(subcommand, "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 {
+        Jim_SetResultString(interp,
+            "bad option. Valid options are refcount, "
+            "objcount, objects, invstr", -1);
+        return JIM_ERR;
+    }
+    return JIM_OK; /* unreached */
 }
 
 /* [eval] */
 int Jim_EvalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc == 2) {
-		return Jim_EvalObj(interp, argv[1]);
-	} else if (argc > 2) {
-		Jim_Obj *objPtr;
-		int retcode;
-
-		objPtr = Jim_ConcatObj(interp, argc-1, argv+1);
-		Jim_IncrRefCount(objPtr);
-		retcode = Jim_EvalObj(interp, objPtr);
-		Jim_DecrRefCount(interp, objPtr);
-		return retcode;
-	} else {
-		Jim_WrongNumArgs(interp, 1, argv, "script ?...?");
-		return JIM_ERR;
-	}
+    if (argc == 2) {
+        return Jim_EvalObj(interp, argv[1]);
+    } else if (argc > 2) {
+        Jim_Obj *objPtr;
+        int retcode;
+
+        objPtr = Jim_ConcatObj(interp, argc-1, argv+1);
+        Jim_IncrRefCount(objPtr);
+        retcode = Jim_EvalObj(interp, objPtr);
+        Jim_DecrRefCount(interp, objPtr);
+        return retcode;
+    } else {
+        Jim_WrongNumArgs(interp, 1, argv, "script ?...?");
+        return JIM_ERR;
+    }
 }
 
 /* [uplevel] */
 int Jim_UplevelCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc >= 2) {
-		int retcode, newLevel, oldLevel;
-		Jim_CallFrame *savedCallFrame, *targetCallFrame;
-		Jim_Obj *objPtr;
-		char *str;
-
-		/* Save the old callframe pointer */
-		savedCallFrame = interp->framePtr;
-
-		/* Lookup the target frame pointer */
-		str = Jim_GetString(argv[1], NULL);
-		if ((str[0] >= '0' && str[0] <= '9') || str[0] == '#')
-		{
-			if (Jim_GetCallFrameByLevel(interp, argv[1],
-						&targetCallFrame,
-						&newLevel) != JIM_OK)
-				return JIM_ERR;
-			argc--;
-			argv++;
-		} else {
-			if (Jim_GetCallFrameByLevel(interp, NULL,
-						&targetCallFrame,
-						&newLevel) != JIM_OK)
-				return JIM_ERR;
-		}
-		if (argc < 2) {
-			argc++;
-			argv--;
-			Jim_WrongNumArgs(interp, 1, argv,
-					"?level? command ?arg ...?");
-			return JIM_ERR;
-		}
-		/* Eval the code in the target callframe. */
-		interp->framePtr = targetCallFrame;
-		oldLevel = interp->numLevels;
-		interp->numLevels = newLevel;
-		if (argc == 2) {
-			retcode = Jim_EvalObj(interp, argv[1]);
-		} else {
-			objPtr = Jim_ConcatObj(interp, argc-1, argv+1);
-			Jim_IncrRefCount(objPtr);
-			retcode = Jim_EvalObj(interp, objPtr);
-			Jim_DecrRefCount(interp, objPtr);
-		}
-		interp->numLevels = oldLevel;
-		interp->framePtr = savedCallFrame;
-		return retcode;
-	} else {
-		Jim_WrongNumArgs(interp, 1, argv, "?level? command ?arg ...?");
-		return JIM_ERR;
-	}
+    if (argc >= 2) {
+        int retcode, newLevel, oldLevel;
+        Jim_CallFrame *savedCallFrame, *targetCallFrame;
+        Jim_Obj *objPtr;
+        char *str;
+
+        /* Save the old callframe pointer */
+        savedCallFrame = interp->framePtr;
+
+        /* Lookup the target frame pointer */
+        str = Jim_GetString(argv[1], NULL);
+        if ((str[0] >= '0' && str[0] <= '9') || str[0] == '#')
+        {
+            if (Jim_GetCallFrameByLevel(interp, argv[1],
+                        &targetCallFrame,
+                        &newLevel) != JIM_OK)
+                return JIM_ERR;
+            argc--;
+            argv++;
+        } else {
+            if (Jim_GetCallFrameByLevel(interp, NULL,
+                        &targetCallFrame,
+                        &newLevel) != JIM_OK)
+                return JIM_ERR;
+        }
+        if (argc < 2) {
+            argc++;
+            argv--;
+            Jim_WrongNumArgs(interp, 1, argv,
+                    "?level? command ?arg ...?");
+            return JIM_ERR;
+        }
+        /* Eval the code in the target callframe. */
+        interp->framePtr = targetCallFrame;
+        oldLevel = interp->numLevels;
+        interp->numLevels = newLevel;
+        if (argc == 2) {
+            retcode = Jim_EvalObj(interp, argv[1]);
+        } else {
+            objPtr = Jim_ConcatObj(interp, argc-1, argv+1);
+            Jim_IncrRefCount(objPtr);
+            retcode = Jim_EvalObj(interp, objPtr);
+            Jim_DecrRefCount(interp, objPtr);
+        }
+        interp->numLevels = oldLevel;
+        interp->framePtr = savedCallFrame;
+        return retcode;
+    } else {
+        Jim_WrongNumArgs(interp, 1, argv, "?level? command ?arg ...?");
+        return JIM_ERR;
+    }
 }
 
 /* [expr] */
 int Jim_ExprCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	Jim_Obj *exprResultPtr;
-	int retcode;
-
-	if (argc == 2) {
-		retcode = Jim_EvalExpression(interp, argv[1], &exprResultPtr);
-	} else if (argc > 2) {
-		Jim_Obj *objPtr;
-
-		objPtr = Jim_ConcatObj(interp, argc-1, argv+1);
-		Jim_IncrRefCount(objPtr);
-		retcode = Jim_EvalExpression(interp, objPtr, &exprResultPtr);
-		Jim_DecrRefCount(interp, objPtr);
-	} else {
-		Jim_WrongNumArgs(interp, 1, argv, "expression ?...?");
-		return JIM_ERR;
-	}
-	if (retcode != JIM_OK) return retcode;
-	Jim_SetResult(interp, exprResultPtr);
-	Jim_DecrRefCount(interp, exprResultPtr);
-	return JIM_OK;
+    Jim_Obj *exprResultPtr;
+    int retcode;
+
+    if (argc == 2) {
+        retcode = Jim_EvalExpression(interp, argv[1], &exprResultPtr);
+    } else if (argc > 2) {
+        Jim_Obj *objPtr;
+
+        objPtr = Jim_ConcatObj(interp, argc-1, argv+1);
+        Jim_IncrRefCount(objPtr);
+        retcode = Jim_EvalExpression(interp, objPtr, &exprResultPtr);
+        Jim_DecrRefCount(interp, objPtr);
+    } else {
+        Jim_WrongNumArgs(interp, 1, argv, "expression ?...?");
+        return JIM_ERR;
+    }
+    if (retcode != JIM_OK) return retcode;
+    Jim_SetResult(interp, exprResultPtr);
+    Jim_DecrRefCount(interp, exprResultPtr);
+    return JIM_OK;
 }
 
 /* [break] */
 int Jim_BreakCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc != 1) {
-		Jim_WrongNumArgs(interp, 1, argv, "");
-		return JIM_ERR;
-	}
-	return JIM_BREAK;
+    if (argc != 1) {
+        Jim_WrongNumArgs(interp, 1, argv, "");
+        return JIM_ERR;
+    }
+    return JIM_BREAK;
 }
 
 /* [continue] */
 int Jim_ContinueCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc != 1) {
-		Jim_WrongNumArgs(interp, 1, argv, "");
-		return JIM_ERR;
-	}
-	return JIM_CONTINUE;
+    if (argc != 1) {
+        Jim_WrongNumArgs(interp, 1, argv, "");
+        return JIM_ERR;
+    }
+    return JIM_CONTINUE;
 }
 
 /* [return] */
 int Jim_ReturnCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc == 1) {
-		return JIM_RETURN;
-	} else if (argc == 2) {
-		Jim_SetResult(interp, argv[1]);
-		interp->returnCode = JIM_OK;
-		return JIM_RETURN;
-	} else if (argc == 3 || argc == 4) {
-		int returnCode;
-		if (Jim_GetReturnCode(interp, argv[2], &returnCode) == JIM_ERR)
-			return JIM_ERR;
-		interp->returnCode = returnCode;
-		if (argc == 4)
-			Jim_SetResult(interp, argv[3]);
-		return JIM_RETURN;
-	} else {
-		Jim_WrongNumArgs(interp, 1, argv, "?-code code? ?result?");
-		return JIM_ERR;
-	}
-	return JIM_CONTINUE;
+    if (argc == 1) {
+        return JIM_RETURN;
+    } else if (argc == 2) {
+        Jim_SetResult(interp, argv[1]);
+        interp->returnCode = JIM_OK;
+        return JIM_RETURN;
+    } else if (argc == 3 || argc == 4) {
+        int returnCode;
+        if (Jim_GetReturnCode(interp, argv[2], &returnCode) == JIM_ERR)
+            return JIM_ERR;
+        interp->returnCode = returnCode;
+        if (argc == 4)
+            Jim_SetResult(interp, argv[3]);
+        return JIM_RETURN;
+    } else {
+        Jim_WrongNumArgs(interp, 1, argv, "?-code code? ?result?");
+        return JIM_ERR;
+    }
+    return JIM_CONTINUE;
 }
 
 /* [proc] */
 int Jim_ProcCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	int argListLen;
-	int arityMin, arityMax;
-
-	if (argc != 4) {
-		Jim_WrongNumArgs(interp, 1, argv, "name arglist body");
-		return JIM_ERR;
-	}
-	Jim_ListLength(interp, argv[2], &argListLen);
-	arityMin = arityMax = argListLen+1;
-	if (argListLen) {
-		char *str;
-		int len;
-		Jim_Obj *lastArgPtr;
-		
-		Jim_ListIndex(interp, argv[2], argListLen-1, &lastArgPtr, JIM_NONE);
-		str = Jim_GetString(lastArgPtr, &len);
-		if (len == 4 && memcmp(str, "args", 4) == 0) {
-			arityMin--;
-			arityMax = -1;
-		}
-	}
-	Jim_CreateProcedure(interp, Jim_GetString(argv[1], NULL),
-			argv[2], argv[3], arityMin, arityMax);
-	return JIM_OK;
+    int argListLen;
+    int arityMin, arityMax;
+
+    if (argc != 4) {
+        Jim_WrongNumArgs(interp, 1, argv, "name arglist body");
+        return JIM_ERR;
+    }
+    Jim_ListLength(interp, argv[2], &argListLen);
+    arityMin = arityMax = argListLen+1;
+    if (argListLen) {
+        char *str;
+        int len;
+        Jim_Obj *lastArgPtr;
+        
+        Jim_ListIndex(interp, argv[2], argListLen-1, &lastArgPtr, JIM_NONE);
+        str = Jim_GetString(lastArgPtr, &len);
+        if (len == 4 && memcmp(str, "args", 4) == 0) {
+            arityMin--;
+            arityMax = -1;
+        }
+    }
+    Jim_CreateProcedure(interp, Jim_GetString(argv[1], NULL),
+            argv[2], argv[3], arityMin, arityMax);
+    return JIM_OK;
 }
 
 /* [concat] */
 int Jim_ConcatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	Jim_SetResult(interp, Jim_ConcatObj(interp, argc-1, argv+1));
-	return JIM_OK;
+    Jim_SetResult(interp, Jim_ConcatObj(interp, argc-1, argv+1));
+    return JIM_OK;
 }
 
 /* [upvar] */
 int Jim_UpvarCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	char *str;
-	int i;
-	Jim_CallFrame *targetCallFrame;
-
-	/* Lookup the target frame pointer */
-	str = Jim_GetString(argv[1], NULL);
-	if (argc > 3 && 
-	    ((str[0] >= '0' && str[0] <= '9') || str[0] == '#'))
-	{
-		if (Jim_GetCallFrameByLevel(interp, argv[1],
-					&targetCallFrame, NULL) != JIM_OK)
-			return JIM_ERR;
-		argc--;
-		argv++;
-	} else {
-		if (Jim_GetCallFrameByLevel(interp, NULL,
-					&targetCallFrame, NULL) != JIM_OK)
-			return JIM_ERR;
-	}
-	/* Check for arity */
-	if (argc < 3 || ((argc-1)%2) != 0) {
-		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;
-	}
-	return JIM_OK;
+    char *str;
+    int i;
+    Jim_CallFrame *targetCallFrame;
+
+    /* Lookup the target frame pointer */
+    str = Jim_GetString(argv[1], NULL);
+    if (argc > 3 && 
+        ((str[0] >= '0' && str[0] <= '9') || str[0] == '#'))
+    {
+        if (Jim_GetCallFrameByLevel(interp, argv[1],
+                    &targetCallFrame, NULL) != JIM_OK)
+            return JIM_ERR;
+        argc--;
+        argv++;
+    } else {
+        if (Jim_GetCallFrameByLevel(interp, NULL,
+                    &targetCallFrame, NULL) != JIM_OK)
+            return JIM_ERR;
+    }
+    /* Check for arity */
+    if (argc < 3 || ((argc-1)%2) != 0) {
+        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;
+    }
+    return JIM_OK;
 }
 
 /* [global] */
 int Jim_GlobalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	int i;
+    int i;
 
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "varName ?varName ...?");
-		return JIM_ERR;
-	}
-	/* Link every var to the toplevel having the same name */
-	if (interp->numLevels == 0) return JIM_OK; /* global at toplevel... */
-	for (i = 1; i < argc; i++) {
-		if (Jim_SetVariableLink(interp, argv[i], argv[i],
-				interp->topFramePtr) != JIM_OK) return JIM_ERR;
-	}
-	return JIM_OK;
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "varName ?varName ...?");
+        return JIM_ERR;
+    }
+    /* Link every var to the toplevel having the same name */
+    if (interp->numLevels == 0) return JIM_OK; /* global at toplevel... */
+    for (i = 1; i < argc; i++) {
+        if (Jim_SetVariableLink(interp, argv[i], argv[i],
+                interp->topFramePtr) != JIM_OK) return JIM_ERR;
+    }
+    return JIM_OK;
 }
 
 /* [string] */
 int Jim_StringCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "option ?arguments ...?");
-		return JIM_ERR;
-	}
-	if (Jim_CompareStringImmediate(interp, argv[1], "length")) {
-		int len;
-
-		if (argc != 3) {
-			Jim_WrongNumArgs(interp, 2, argv, "string");
-			return JIM_ERR;
-		}
-		Jim_GetString(argv[2], &len);
-		Jim_SetResult(interp, Jim_NewIntObj(interp, len));
-		return JIM_OK;
-	} else if (Jim_CompareStringImmediate(interp, argv[1], "compare")) {
-		char *a, *b;
-
-		if (argc != 4) {
-			Jim_WrongNumArgs(interp, 2, argv, "string1 string2");
-			return JIM_ERR;
-		}
-		a = Jim_GetString(argv[2], NULL);
-		b = Jim_GetString(argv[3], NULL);
-		Jim_SetResult(interp, Jim_NewIntObj(interp, strcmp(a,b)));
-		return JIM_OK;
-	} else if (Jim_CompareStringImmediate(interp, argv[1], "match")) {
-		int nocase = 0;
-		if ((argc != 4 && argc != 5) ||
-		    (argc == 5 && Jim_CompareStringImmediate(interp,
-				argv[2], "-nocase") == 0)) {
-			Jim_WrongNumArgs(interp, 2, argv, "?-nocase? pattern "
-					"string");
-			return JIM_ERR;
-		}
-		if (argc == 5) {
-			nocase = 1;
-			argv++;
-		}
-		Jim_SetResult(interp,
-			Jim_NewIntObj(interp, Jim_StringMatchObj(argv[2],
-					argv[3], nocase)));
-		return JIM_OK;
-	} else if (Jim_CompareStringImmediate(interp, argv[1], "equal")) {
-		if (argc != 4) {
-			Jim_WrongNumArgs(interp, 2, argv, "string1 string2");
-			return JIM_ERR;
-		}
-		Jim_SetResult(interp,
-			Jim_NewIntObj(interp, Jim_StringEqObj(argv[2],
-					argv[3], 0)));
-		return JIM_OK;
-	} else if (Jim_CompareStringImmediate(interp, argv[1], "range")) {
-		Jim_Obj *objPtr;
-
-		if (argc != 5) {
-			Jim_WrongNumArgs(interp, 2, argv, "string first last");
-			return JIM_ERR;
-		}
-		objPtr = Jim_StringRangeObj(interp, argv[2], argv[3], argv[4]);
-		if (objPtr == NULL)
-			return JIM_ERR;
-		Jim_SetResult(interp, objPtr);
-		return JIM_OK;
-	} else {
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-			"bad option \"", Jim_GetString(argv[1], NULL), "\":",
-			" must be length, compare, match, equal, range",
-			NULL);
-		return JIM_ERR;
-	}
-	return JIM_OK;
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "option ?arguments ...?");
+        return JIM_ERR;
+    }
+    if (Jim_CompareStringImmediate(interp, argv[1], "length")) {
+        int len;
+
+        if (argc != 3) {
+            Jim_WrongNumArgs(interp, 2, argv, "string");
+            return JIM_ERR;
+        }
+        Jim_GetString(argv[2], &len);
+        Jim_SetResult(interp, Jim_NewIntObj(interp, len));
+        return JIM_OK;
+    } else if (Jim_CompareStringImmediate(interp, argv[1], "compare")) {
+        char *a, *b;
+
+        if (argc != 4) {
+            Jim_WrongNumArgs(interp, 2, argv, "string1 string2");
+            return JIM_ERR;
+        }
+        a = Jim_GetString(argv[2], NULL);
+        b = Jim_GetString(argv[3], NULL);
+        Jim_SetResult(interp, Jim_NewIntObj(interp, strcmp(a,b)));
+        return JIM_OK;
+    } else if (Jim_CompareStringImmediate(interp, argv[1], "match")) {
+        int nocase = 0;
+        if ((argc != 4 && argc != 5) ||
+            (argc == 5 && Jim_CompareStringImmediate(interp,
+                argv[2], "-nocase") == 0)) {
+            Jim_WrongNumArgs(interp, 2, argv, "?-nocase? pattern "
+                    "string");
+            return JIM_ERR;
+        }
+        if (argc == 5) {
+            nocase = 1;
+            argv++;
+        }
+        Jim_SetResult(interp,
+            Jim_NewIntObj(interp, Jim_StringMatchObj(argv[2],
+                    argv[3], nocase)));
+        return JIM_OK;
+    } else if (Jim_CompareStringImmediate(interp, argv[1], "equal")) {
+        if (argc != 4) {
+            Jim_WrongNumArgs(interp, 2, argv, "string1 string2");
+            return JIM_ERR;
+        }
+        Jim_SetResult(interp,
+            Jim_NewIntObj(interp, Jim_StringEqObj(argv[2],
+                    argv[3], 0)));
+        return JIM_OK;
+    } else if (Jim_CompareStringImmediate(interp, argv[1], "range")) {
+        Jim_Obj *objPtr;
+
+        if (argc != 5) {
+            Jim_WrongNumArgs(interp, 2, argv, "string first last");
+            return JIM_ERR;
+        }
+        objPtr = Jim_StringRangeObj(interp, argv[2], argv[3], argv[4]);
+        if (objPtr == NULL)
+            return JIM_ERR;
+        Jim_SetResult(interp, objPtr);
+        return JIM_OK;
+    } else {
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+            "bad option \"", Jim_GetString(argv[1], NULL), "\":",
+            " must be length, compare, match, equal, range",
+            NULL);
+        return JIM_ERR;
+    }
+    return JIM_OK;
 }
 
 /* [time] */
 int Jim_TimeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	long i, count = 1, start, elapsed;
-	char buf [256];
-
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "script ?count?");
-		return JIM_ERR;
-	}
-	if (argc == 3) {
-		if (Jim_GetLong(interp, argv[2], &count) != JIM_OK)
-			return JIM_ERR;
-	}
-	if (count < 0)
-		return JIM_OK;
-	i = count;
-	start = Jim_Clock();
-	while (i-- > 0) {
-		int retval;
-
-		if ((retval = Jim_EvalObj(interp, argv[1])) != JIM_OK)
-			return retval;
-	}
-	elapsed = Jim_Clock() - start;
-	sprintf(buf, "%ld microseconds per iteration", elapsed/count);
-	Jim_SetResultString(interp, buf, -1);
-	return JIM_OK;
+    long i, count = 1, start, elapsed;
+    char buf [256];
+
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "script ?count?");
+        return JIM_ERR;
+    }
+    if (argc == 3) {
+        if (Jim_GetLong(interp, argv[2], &count) != JIM_OK)
+            return JIM_ERR;
+    }
+    if (count < 0)
+        return JIM_OK;
+    i = count;
+    start = Jim_Clock();
+    while (i-- > 0) {
+        int retval;
+
+        if ((retval = Jim_EvalObj(interp, argv[1])) != JIM_OK)
+            return retval;
+    }
+    elapsed = Jim_Clock() - start;
+    sprintf(buf, "%ld microseconds per iteration", elapsed/count);
+    Jim_SetResultString(interp, buf, -1);
+    return JIM_OK;
 }
 
 /* [exit] */
 int Jim_ExitCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	long exitCode = 0;
+    long exitCode = 0;
 
-	if (argc > 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "?exitCode?");
-		return JIM_ERR;
-	}
-	if (argc == 2) {
-		if (Jim_GetLong(interp, argv[1], &exitCode) != JIM_OK)
-			return JIM_ERR;
-	}
-	exit(exitCode);
-	return JIM_OK; /* unreached */
+    if (argc > 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "?exitCode?");
+        return JIM_ERR;
+    }
+    if (argc == 2) {
+        if (Jim_GetLong(interp, argv[1], &exitCode) != JIM_OK)
+            return JIM_ERR;
+    }
+    exit(exitCode);
+    return JIM_OK; /* unreached */
 }
 
 /* [catch] */
 int Jim_CatchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	int exitCode = 0;
+    int exitCode = 0;
 
-	if (argc != 2 && argc != 3) {
-		Jim_WrongNumArgs(interp, 1, argv, "script ?varName?");
-		return JIM_ERR;
-	}
-	exitCode = Jim_EvalObj(interp, argv[1]);
-	if (argc == 3) {
-		if (Jim_SetVariable(interp, argv[2], Jim_GetResult(interp))
-				!= JIM_OK)
-			return JIM_ERR;
-	}
-	Jim_SetResult(interp, Jim_NewIntObj(interp, exitCode));
-	return JIM_OK;
+    if (argc != 2 && argc != 3) {
+        Jim_WrongNumArgs(interp, 1, argv, "script ?varName?");
+        return JIM_ERR;
+    }
+    exitCode = Jim_EvalObj(interp, argv[1]);
+    if (argc == 3) {
+        if (Jim_SetVariable(interp, argv[2], Jim_GetResult(interp))
+                != JIM_OK)
+            return JIM_ERR;
+    }
+    Jim_SetResult(interp, Jim_NewIntObj(interp, exitCode));
+    return JIM_OK;
 }
 
 /* [ref] */
 int Jim_RefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc != 2 && argc != 3) {
-		Jim_WrongNumArgs(interp, 1, argv, "string ?finalizer?");
-		return JIM_ERR;
-	}
-	if (argc == 2) {
-		Jim_SetResult(interp, Jim_NewReference(interp, argv[1], NULL));
-	} else {
-		Jim_SetResult(interp, Jim_NewReference(interp, argv[1], argv[2]));
-	}
-	return JIM_OK;
+    if (argc != 2 && argc != 3) {
+        Jim_WrongNumArgs(interp, 1, argv, "string ?finalizer?");
+        return JIM_ERR;
+    }
+    if (argc == 2) {
+        Jim_SetResult(interp, Jim_NewReference(interp, argv[1], NULL));
+    } else {
+        Jim_SetResult(interp, Jim_NewReference(interp, argv[1], argv[2]));
+    }
+    return JIM_OK;
 }
 
 /* [getref] */
 int Jim_GetrefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	Jim_Reference *refPtr;
+    Jim_Reference *refPtr;
 
-	if (argc != 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "reference");
-		return JIM_ERR;
-	}
-	if ((refPtr = Jim_GetReference(interp, argv[1])) == NULL)
-		return JIM_ERR;
-	Jim_SetResult(interp, refPtr->objPtr);
-	return JIM_OK;
+    if (argc != 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "reference");
+        return JIM_ERR;
+    }
+    if ((refPtr = Jim_GetReference(interp, argv[1])) == NULL)
+        return JIM_ERR;
+    Jim_SetResult(interp, refPtr->objPtr);
+    return JIM_OK;
 }
 
 /* [setref] */
 int Jim_SetrefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	Jim_Reference *refPtr;
+    Jim_Reference *refPtr;
 
-	if (argc != 3) {
-		Jim_WrongNumArgs(interp, 1, argv, "reference newValue");
-		return JIM_ERR;
-	}
-	if ((refPtr = Jim_GetReference(interp, argv[1])) == NULL)
-		return JIM_ERR;
-	Jim_IncrRefCount(argv[2]);
-	Jim_DecrRefCount(interp, refPtr->objPtr);
-	refPtr->objPtr = argv[2];
-	Jim_SetResult(interp, argv[1]);
-	return JIM_OK;
+    if (argc != 3) {
+        Jim_WrongNumArgs(interp, 1, argv, "reference newValue");
+        return JIM_ERR;
+    }
+    if ((refPtr = Jim_GetReference(interp, argv[1])) == NULL)
+        return JIM_ERR;
+    Jim_IncrRefCount(argv[2]);
+    Jim_DecrRefCount(interp, refPtr->objPtr);
+    refPtr->objPtr = argv[2];
+    Jim_SetResult(interp, argv[1]);
+    return JIM_OK;
 }
 
 /* [collect] */
 int Jim_CollectCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc != 1) {
-		Jim_WrongNumArgs(interp, 1, argv, "");
-		return JIM_ERR;
-	}
-	Jim_SetResult(interp, Jim_NewIntObj(interp, Jim_Collect(interp)));
-	return JIM_OK;
+    if (argc != 1) {
+        Jim_WrongNumArgs(interp, 1, argv, "");
+        return JIM_ERR;
+    }
+    Jim_SetResult(interp, Jim_NewIntObj(interp, Jim_Collect(interp)));
+    return JIM_OK;
 }
 
 /* TODO */
@@ -8066,227 +8065,227 @@ int Jim_CollectCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 /* [rename] */
 int Jim_RenameCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	char *oldName, *newName;
+    char *oldName, *newName;
 
-	if (argc != 3) {
-		Jim_WrongNumArgs(interp, 1, argv, "oldName newName");
-		return JIM_ERR;
-	}
-	oldName = Jim_GetString(argv[1], NULL);
-	newName = Jim_GetString(argv[2], NULL);
-	if (Jim_RenameCommand(interp, oldName, newName) != JIM_OK) {
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-			"can't rename \"", oldName, "\": ",
-			"command doesn't exist", NULL);
-		return JIM_ERR;
-	}
-	return JIM_OK;
+    if (argc != 3) {
+        Jim_WrongNumArgs(interp, 1, argv, "oldName newName");
+        return JIM_ERR;
+    }
+    oldName = Jim_GetString(argv[1], NULL);
+    newName = Jim_GetString(argv[2], NULL);
+    if (Jim_RenameCommand(interp, oldName, newName) != JIM_OK) {
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+            "can't rename \"", oldName, "\": ",
+            "command doesn't exist", NULL);
+        return JIM_ERR;
+    }
+    return JIM_OK;
 }
 
 /* [dict] */
 int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "option ?arguments ...?");
-		return JIM_ERR;
-	}
-	if (Jim_CompareStringImmediate(interp, argv[1], "create")) {
-		Jim_Obj *objPtr;
-
-		if (argc % 2) {
-			Jim_WrongNumArgs(interp, 2, argv, "?key value ...?");
-			return JIM_ERR;
-		}
-		objPtr = Jim_NewDictObj(interp, argv+2, argc-2);
-		Jim_SetResult(interp, objPtr);
-		return JIM_OK;
-	} else if (Jim_CompareStringImmediate(interp, argv[1], "get")) {
-		Jim_Obj *objPtr;
-
-		if (Jim_DictKeysVector(interp, argv[2], argv+3, argc-3, &objPtr,
-				JIM_ERRMSG) != JIM_OK)
-			return JIM_ERR;
-		Jim_SetResult(interp, objPtr);
-		return JIM_OK;
-	} else if (Jim_CompareStringImmediate(interp, argv[1], "set")) {
-		if (argc < 5) {
-			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]);
-	} else if (Jim_CompareStringImmediate(interp, argv[1], "unset")) {
-		if (argc < 4) {
-			Jim_WrongNumArgs(interp, 2, argv, "varName key ?key ...?");
-			return JIM_ERR;
-		}
-		return Jim_SetDictKeysVector(interp, argv[2], argv+3, argc-3,
-					NULL);
-	} else if (Jim_CompareStringImmediate(interp, argv[1], "exists")) {
-		Jim_Obj *objPtr;
-		int exists;
-
-		if (Jim_DictKeysVector(interp, argv[2], argv+3, argc-3, &objPtr,
-				JIM_ERRMSG) == JIM_OK)
-			exists = 1;
-		else
-			exists = 0;
-		Jim_SetResult(interp, Jim_NewIntObj(interp, exists));
-		return JIM_OK;
-	} else {
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-			"bad option \"", Jim_GetString(argv[1], NULL), "\":",
-			" must be create, get, set", NULL);
-		return JIM_ERR;
-	}
-	return JIM_OK;
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "option ?arguments ...?");
+        return JIM_ERR;
+    }
+    if (Jim_CompareStringImmediate(interp, argv[1], "create")) {
+        Jim_Obj *objPtr;
+
+        if (argc % 2) {
+            Jim_WrongNumArgs(interp, 2, argv, "?key value ...?");
+            return JIM_ERR;
+        }
+        objPtr = Jim_NewDictObj(interp, argv+2, argc-2);
+        Jim_SetResult(interp, objPtr);
+        return JIM_OK;
+    } else if (Jim_CompareStringImmediate(interp, argv[1], "get")) {
+        Jim_Obj *objPtr;
+
+        if (Jim_DictKeysVector(interp, argv[2], argv+3, argc-3, &objPtr,
+                JIM_ERRMSG) != JIM_OK)
+            return JIM_ERR;
+        Jim_SetResult(interp, objPtr);
+        return JIM_OK;
+    } else if (Jim_CompareStringImmediate(interp, argv[1], "set")) {
+        if (argc < 5) {
+            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]);
+    } else if (Jim_CompareStringImmediate(interp, argv[1], "unset")) {
+        if (argc < 4) {
+            Jim_WrongNumArgs(interp, 2, argv, "varName key ?key ...?");
+            return JIM_ERR;
+        }
+        return Jim_SetDictKeysVector(interp, argv[2], argv+3, argc-3,
+                    NULL);
+    } else if (Jim_CompareStringImmediate(interp, argv[1], "exists")) {
+        Jim_Obj *objPtr;
+        int exists;
+
+        if (Jim_DictKeysVector(interp, argv[2], argv+3, argc-3, &objPtr,
+                JIM_ERRMSG) == JIM_OK)
+            exists = 1;
+        else
+            exists = 0;
+        Jim_SetResult(interp, Jim_NewIntObj(interp, exists));
+        return JIM_OK;
+    } else {
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+            "bad option \"", Jim_GetString(argv[1], NULL), "\":",
+            " must be create, get, set", NULL);
+        return JIM_ERR;
+    }
+    return JIM_OK;
 }
 
 /* [load] */
 int Jim_LoadCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "libaryFile");
-		return JIM_ERR;
-	}
-	return Jim_LoadLibrary(interp, Jim_GetString(argv[1], NULL));
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "libaryFile");
+        return JIM_ERR;
+    }
+    return Jim_LoadLibrary(interp, Jim_GetString(argv[1], NULL));
 }
 
 /* [subst] */
 int Jim_SubstCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	int i, flags = 0;
-	Jim_Obj *objPtr;
-
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv,
-			"?-nobackslashes? ?-nocommands? ?-novariables? string");
-		return JIM_ERR;
-	}
-	i = argc-2;
-	while(i--) {
-		if (Jim_CompareStringImmediate(interp, argv[i+1],
-					"-nobackslashes"))
-			flags |= JIM_SUBST_NOESC;
-		else if (Jim_CompareStringImmediate(interp, argv[i+1],
-					"-novariables"))
-			flags |= JIM_SUBST_NOVAR;
-		else if (Jim_CompareStringImmediate(interp, argv[i+1],
-					"-nocommands"))
-			flags |= JIM_SUBST_NOCMD;
-		else {
-			Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-			Jim_AppendStrings(interp, Jim_GetResult(interp),
-				"bad option \"", Jim_GetString(argv[i+1], NULL),
-				"\": must be -nobackslashes, -nocommands, or "
-				"-novariables", NULL);
-			return JIM_ERR;
-		}
-	}
-	if (Jim_SubstObj(interp, argv[argc-1], &objPtr, flags) != JIM_OK)
-		return JIM_ERR;
-	Jim_SetResult(interp, objPtr);
-	return JIM_OK;
+    int i, flags = 0;
+    Jim_Obj *objPtr;
+
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv,
+            "?-nobackslashes? ?-nocommands? ?-novariables? string");
+        return JIM_ERR;
+    }
+    i = argc-2;
+    while(i--) {
+        if (Jim_CompareStringImmediate(interp, argv[i+1],
+                    "-nobackslashes"))
+            flags |= JIM_SUBST_NOESC;
+        else if (Jim_CompareStringImmediate(interp, argv[i+1],
+                    "-novariables"))
+            flags |= JIM_SUBST_NOVAR;
+        else if (Jim_CompareStringImmediate(interp, argv[i+1],
+                    "-nocommands"))
+            flags |= JIM_SUBST_NOCMD;
+        else {
+            Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+            Jim_AppendStrings(interp, Jim_GetResult(interp),
+                "bad option \"", Jim_GetString(argv[i+1], NULL),
+                "\": must be -nobackslashes, -nocommands, or "
+                "-novariables", NULL);
+            return JIM_ERR;
+        }
+    }
+    if (Jim_SubstObj(interp, argv[argc-1], &objPtr, flags) != JIM_OK)
+        return JIM_ERR;
+    Jim_SetResult(interp, objPtr);
+    return JIM_OK;
 }
 
 /* [info] */
 int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, Jim_Obj **argv)
 {
-	if (argc < 2) {
-		Jim_WrongNumArgs(interp, 1, argv, "option ?args ...?");
-		return JIM_ERR;
-	}
-	if (Jim_CompareStringImmediate(interp, argv[1], "commands")) {
-		if (argc != 2 && argc != 3) {
-			Jim_WrongNumArgs(interp, 2, argv, "?pattern?");
-			return JIM_ERR;
-		}
-		if (argc == 3)
-			Jim_SetResult(interp,Jim_CommandsList(interp, argv[2]));
-		else
-			Jim_SetResult(interp, Jim_CommandsList(interp, NULL));
-		return JIM_OK;
-	} else if (Jim_CompareStringImmediate(interp, argv[1], "level")) {
-		Jim_Obj *objPtr;
-
-		if (argc != 2 && argc != 3) {
-			Jim_WrongNumArgs(interp, 2, argv, "?levelNum?");
-			return JIM_ERR;
-		}
-		if (argc == 2) {
-			Jim_SetResult(interp,
-				Jim_NewIntObj(interp, interp->numLevels));
-			return JIM_OK;
-		}
-		/* argc == 3 case: */
-		if (Jim_InfoLevel(interp, argv[2], &objPtr) != JIM_OK)
-			return JIM_ERR;
-		Jim_SetResult(interp, objPtr);
-		return JIM_OK;
-	} else {
-		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp),
-			"bad option \"", Jim_GetString(argv[1], NULL), "\":",
-			" must be commands, level", NULL);
-		return JIM_ERR;
-	}
+    if (argc < 2) {
+        Jim_WrongNumArgs(interp, 1, argv, "option ?args ...?");
+        return JIM_ERR;
+    }
+    if (Jim_CompareStringImmediate(interp, argv[1], "commands")) {
+        if (argc != 2 && argc != 3) {
+            Jim_WrongNumArgs(interp, 2, argv, "?pattern?");
+            return JIM_ERR;
+        }
+        if (argc == 3)
+            Jim_SetResult(interp,Jim_CommandsList(interp, argv[2]));
+        else
+            Jim_SetResult(interp, Jim_CommandsList(interp, NULL));
+        return JIM_OK;
+    } else if (Jim_CompareStringImmediate(interp, argv[1], "level")) {
+        Jim_Obj *objPtr;
+
+        if (argc != 2 && argc != 3) {
+            Jim_WrongNumArgs(interp, 2, argv, "?levelNum?");
+            return JIM_ERR;
+        }
+        if (argc == 2) {
+            Jim_SetResult(interp,
+                Jim_NewIntObj(interp, interp->numLevels));
+            return JIM_OK;
+        }
+        /* argc == 3 case: */
+        if (Jim_InfoLevel(interp, argv[2], &objPtr) != JIM_OK)
+            return JIM_ERR;
+        Jim_SetResult(interp, objPtr);
+        return JIM_OK;
+    } else {
+        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+        Jim_AppendStrings(interp, Jim_GetResult(interp),
+            "bad option \"", Jim_GetString(argv[1], NULL), "\":",
+            " must be commands, level", NULL);
+        return JIM_ERR;
+    }
 }
 
 static struct {
-	char *name;
-	Jim_CmdProc cmdProc;
+    char *name;
+    Jim_CmdProc cmdProc;
 } Jim_CoreCommandsTable[] = {
-	{"set", Jim_SetCoreCommand},
-	{"unset", Jim_UnsetCoreCommand},
-	{"puts", Jim_PutsCoreCommand},
-	{"+", Jim_AddCoreCommand},
-	{"*", Jim_MulCoreCommand},
-	{"-", Jim_SubCoreCommand},
-	{"/", Jim_DivCoreCommand},
-	{"incr", Jim_IncrCoreCommand},
-	{"while", Jim_WhileCoreCommand},
-	{"for", Jim_ForCoreCommand},
- 	{"foreach", Jim_ForeachCoreCommand},
-	{"if", Jim_IfCoreCommand},
-	{"list", Jim_ListCoreCommand},
-	{"lindex", Jim_LindexCoreCommand},
-	{"lset", Jim_LsetCoreCommand},
-	{"llength", Jim_LlengthCoreCommand},
-	{"lappend", Jim_LappendCoreCommand},
-	{"append", Jim_AppendCoreCommand},
-	{"debug", Jim_DebugCoreCommand},
-	{"eval", Jim_EvalCoreCommand},
-	{"uplevel", Jim_UplevelCoreCommand},
-	{"expr", Jim_ExprCoreCommand},
-	{"break", Jim_BreakCoreCommand},
-	{"continue", Jim_ContinueCoreCommand},
-	{"proc", Jim_ProcCoreCommand},
-	{"concat", Jim_ConcatCoreCommand},
-	{"return", Jim_ReturnCoreCommand},
-	{"upvar", Jim_UpvarCoreCommand},
-	{"global", Jim_GlobalCoreCommand},
-	{"string", Jim_StringCoreCommand},
-	{"time", Jim_TimeCoreCommand},
-	{"exit", Jim_ExitCoreCommand},
-	{"catch", Jim_CatchCoreCommand},
-	{"ref", Jim_RefCoreCommand},
-	{"getref", Jim_GetrefCoreCommand},
-	{"setref", Jim_SetrefCoreCommand},
-	{"collect", Jim_CollectCoreCommand},
-	{"rename", Jim_RenameCoreCommand},
-	{"dict", Jim_DictCoreCommand},
-	{"load", Jim_LoadCoreCommand},
-	{"subst", Jim_SubstCoreCommand},
-	{"info", Jim_InfoCoreCommand},
-	{NULL, NULL},
+    {"set", Jim_SetCoreCommand},
+    {"unset", Jim_UnsetCoreCommand},
+    {"puts", Jim_PutsCoreCommand},
+    {"+", Jim_AddCoreCommand},
+    {"*", Jim_MulCoreCommand},
+    {"-", Jim_SubCoreCommand},
+    {"/", Jim_DivCoreCommand},
+    {"incr", Jim_IncrCoreCommand},
+    {"while", Jim_WhileCoreCommand},
+    {"for", Jim_ForCoreCommand},
+     {"foreach", Jim_ForeachCoreCommand},
+    {"if", Jim_IfCoreCommand},
+    {"list", Jim_ListCoreCommand},
+    {"lindex", Jim_LindexCoreCommand},
+    {"lset", Jim_LsetCoreCommand},
+    {"llength", Jim_LlengthCoreCommand},
+    {"lappend", Jim_LappendCoreCommand},
+    {"append", Jim_AppendCoreCommand},
+    {"debug", Jim_DebugCoreCommand},
+    {"eval", Jim_EvalCoreCommand},
+    {"uplevel", Jim_UplevelCoreCommand},
+    {"expr", Jim_ExprCoreCommand},
+    {"break", Jim_BreakCoreCommand},
+    {"continue", Jim_ContinueCoreCommand},
+    {"proc", Jim_ProcCoreCommand},
+    {"concat", Jim_ConcatCoreCommand},
+    {"return", Jim_ReturnCoreCommand},
+    {"upvar", Jim_UpvarCoreCommand},
+    {"global", Jim_GlobalCoreCommand},
+    {"string", Jim_StringCoreCommand},
+    {"time", Jim_TimeCoreCommand},
+    {"exit", Jim_ExitCoreCommand},
+    {"catch", Jim_CatchCoreCommand},
+    {"ref", Jim_RefCoreCommand},
+    {"getref", Jim_GetrefCoreCommand},
+    {"setref", Jim_SetrefCoreCommand},
+    {"collect", Jim_CollectCoreCommand},
+    {"rename", Jim_RenameCoreCommand},
+    {"dict", Jim_DictCoreCommand},
+    {"load", Jim_LoadCoreCommand},
+    {"subst", Jim_SubstCoreCommand},
+    {"info", Jim_InfoCoreCommand},
+    {NULL, NULL},
 };
 
 /* Some Jim core command is actually a procedure written in Jim itself. */
 static void Jim_RegisterCoreProcedures(Jim_Interp *interp)
 {
-	Jim_Eval(interp,
+    Jim_Eval(interp,
 "proc lambda {arglist body} {\n"
 "    set name [ref {} lambdaFinalizer]\n"
 "    proc $name $arglist $body\n"
@@ -8295,21 +8294,21 @@ static void Jim_RegisterCoreProcedures(Jim_Interp *interp)
 "proc lambdaFinalizer {name val} {\n"
 "    rename $name {}\n"
 "}\n"
-	);
+    );
 }
 
 void Jim_RegisterCoreCommands(Jim_Interp *interp)
 {
-	int i = 0;
+    int i = 0;
 
-	while(Jim_CoreCommandsTable[i].name != NULL) {
-		Jim_CreateCommand(interp, 
-				Jim_CoreCommandsTable[i].name,
-				Jim_CoreCommandsTable[i].cmdProc,
-				NULL);
-		i++;
-	}
-	Jim_RegisterCoreProcedures(interp);
+    while(Jim_CoreCommandsTable[i].name != NULL) {
+        Jim_CreateCommand(interp, 
+                Jim_CoreCommandsTable[i].name,
+                Jim_CoreCommandsTable[i].cmdProc,
+                NULL);
+        i++;
+    }
+    Jim_RegisterCoreProcedures(interp);
 }
 
 /* -----------------------------------------------------------------------------
@@ -8317,143 +8316,143 @@ void Jim_RegisterCoreCommands(Jim_Interp *interp)
  * ---------------------------------------------------------------------------*/
 int test_parser(char *filename, int parsetype)
 {
-	struct JimParserCtx parser;
-	char prg[1024];
-	FILE *fp;
-	int nread;
-
-	if ((fp = fopen(filename, "r")) == NULL) {
-		perror("fopen");
-		exit(1);
-	}
-	nread = fread(prg, 1, 1024, fp);
-	prg[nread] = '\0';
-	fclose(fp);
-
-	JimParserInit(&parser, prg, 1);
-	while(!JimParserEof(&parser)) {
-		char *type = "", *tok;
-		int len, retval = 0;
-		if (parsetype == 0)
-			retval = JimParseScript(&parser);
-		else if (parsetype == 1)
-			retval = JimParseExpression(&parser);
-		else if (parsetype == 2)
-			retval = JimParseSubst(&parser, 0);
-		if (retval != JIM_OK) {
-			printf("PARSE ERROR\n");
-			exit(1);
-		}
-		switch(JimParserTtype(&parser)) {
-		case JIM_TT_STR: type = "STR"; break;
-		case JIM_TT_ESC: type = "ESC"; break;
-		case JIM_TT_VAR: type = "VAR"; break;
-		case JIM_TT_DICTSUGAR: type = "DICTSUGAR"; break;
-		case JIM_TT_CMD: type = "CMD"; break;
-		case JIM_TT_SEP: type = "SEP"; break;
-		case JIM_TT_EOL: type = "EOL"; break;
-		case JIM_TT_NONE: type = "NONE"; break;
-		case JIM_TT_SUBEXPR_START: type = "SUBEXPR_START"; break;
-		case JIM_TT_SUBEXPR_END : type = "SUBEXPR_END"; break;
-		case JIM_TT_EXPR_NUMBER : type = "EXPR_NUMBER"; break;
-		case JIM_TT_EXPR_OPERATOR: type = "EXPR_OPERATOR"; break;
-		}
-		printf("%d %s: ", JimParserTline(&parser), type);
-		tok = JimParserGetToken(&parser, &len, NULL, NULL);
-		printf("'%s' (%d)\n", tok, len);
-	}
-	return 0;
+    struct JimParserCtx parser;
+    char prg[1024];
+    FILE *fp;
+    int nread;
+
+    if ((fp = fopen(filename, "r")) == NULL) {
+        perror("fopen");
+        exit(1);
+    }
+    nread = fread(prg, 1, 1024, fp);
+    prg[nread] = '\0';
+    fclose(fp);
+
+    JimParserInit(&parser, prg, 1);
+    while(!JimParserEof(&parser)) {
+        char *type = "", *tok;
+        int len, retval = 0;
+        if (parsetype == 0)
+            retval = JimParseScript(&parser);
+        else if (parsetype == 1)
+            retval = JimParseExpression(&parser);
+        else if (parsetype == 2)
+            retval = JimParseSubst(&parser, 0);
+        if (retval != JIM_OK) {
+            printf("PARSE ERROR\n");
+            exit(1);
+        }
+        switch(JimParserTtype(&parser)) {
+        case JIM_TT_STR: type = "STR"; break;
+        case JIM_TT_ESC: type = "ESC"; break;
+        case JIM_TT_VAR: type = "VAR"; break;
+        case JIM_TT_DICTSUGAR: type = "DICTSUGAR"; break;
+        case JIM_TT_CMD: type = "CMD"; break;
+        case JIM_TT_SEP: type = "SEP"; break;
+        case JIM_TT_EOL: type = "EOL"; break;
+        case JIM_TT_NONE: type = "NONE"; break;
+        case JIM_TT_SUBEXPR_START: type = "SUBEXPR_START"; break;
+        case JIM_TT_SUBEXPR_END : type = "SUBEXPR_END"; break;
+        case JIM_TT_EXPR_NUMBER : type = "EXPR_NUMBER"; break;
+        case JIM_TT_EXPR_OPERATOR: type = "EXPR_OPERATOR"; break;
+        }
+        printf("%d %s: ", JimParserTline(&parser), type);
+        tok = JimParserGetToken(&parser, &len, NULL, NULL);
+        printf("'%s' (%d)\n", tok, len);
+    }
+    return 0;
 }
 
 void Jim_PrintErrorMessage(Jim_Interp *interp)
 {
-	int len, i;
-
-	printf("Runtime error, file \"%s\", line %d:\n",
-			interp->errorFileName, interp->errorLine);
-	printf("    %s\n", Jim_GetString(interp->result, NULL));
-	Jim_ListLength(interp, interp->stackTrace, &len);
-	for (i = 0; i < len; i+= 3) {
-		Jim_Obj *objPtr;
-		char *proc, *file, *line;
-
-		Jim_ListIndex(interp, interp->stackTrace, i, &objPtr, JIM_NONE);
-		proc = Jim_GetString(objPtr, NULL);
-		Jim_ListIndex(interp, interp->stackTrace, i+1, &objPtr,
-				JIM_NONE);
-		file = Jim_GetString(objPtr, NULL);
-		Jim_ListIndex(interp, interp->stackTrace, i+2, &objPtr,
-				JIM_NONE);
-		line = Jim_GetString(objPtr, NULL);
-		printf("In procedure '%s' called at file \"%s\", line %s\n",
-				proc, file, line);
-	}
+    int len, i;
+
+    printf("Runtime error, file \"%s\", line %d:\n",
+            interp->errorFileName, interp->errorLine);
+    printf("    %s\n", Jim_GetString(interp->result, NULL));
+    Jim_ListLength(interp, interp->stackTrace, &len);
+    for (i = 0; i < len; i+= 3) {
+        Jim_Obj *objPtr;
+        char *proc, *file, *line;
+
+        Jim_ListIndex(interp, interp->stackTrace, i, &objPtr, JIM_NONE);
+        proc = Jim_GetString(objPtr, NULL);
+        Jim_ListIndex(interp, interp->stackTrace, i+1, &objPtr,
+                JIM_NONE);
+        file = Jim_GetString(objPtr, NULL);
+        Jim_ListIndex(interp, interp->stackTrace, i+2, &objPtr,
+                JIM_NONE);
+        line = Jim_GetString(objPtr, NULL);
+        printf("In procedure '%s' called at file \"%s\", line %s\n",
+                proc, file, line);
+    }
 }
 
 int Jim_InteractivePrompt(void)
 {
-	Jim_Interp *interp = Jim_CreateInterp();
-	int retcode = JIM_OK;
-
-	Jim_RegisterCoreCommands(interp);
-	printf("Welcome to Jim version %d, "
-	       "Copyright (c) 2005 Salvatore Sanfilippo\n", JIM_VERSION);
-	while (1) {
-		char prg[1024], *result;
-		int reslen;
-
-		printf("%d jim> ", retcode);
-		fflush(stdout);
-		if (fgets(prg, 1024, stdin) == NULL) break;
-		retcode = Jim_Eval(interp, prg);
-		result = Jim_GetString(Jim_GetResult(interp), &reslen);
-		if (retcode == JIM_ERR) {
-			Jim_PrintErrorMessage(interp);
-		} else {
-			if (reslen) {
-				printf("%s\n", result);
-			}
-		}
-	}
-	Jim_FreeInterp(interp);
-	return 0;
+    Jim_Interp *interp = Jim_CreateInterp();
+    int retcode = JIM_OK;
+
+    Jim_RegisterCoreCommands(interp);
+    printf("Welcome to Jim version %d, "
+           "Copyright (c) 2005 Salvatore Sanfilippo\n", JIM_VERSION);
+    while (1) {
+        char prg[1024], *result;
+        int reslen;
+
+        printf("%d jim> ", retcode);
+        fflush(stdout);
+        if (fgets(prg, 1024, stdin) == NULL) break;
+        retcode = Jim_Eval(interp, prg);
+        result = Jim_GetString(Jim_GetResult(interp), &reslen);
+        if (retcode == JIM_ERR) {
+            Jim_PrintErrorMessage(interp);
+        } else {
+            if (reslen) {
+                printf("%s\n", result);
+            }
+        }
+    }
+    Jim_FreeInterp(interp);
+    return 0;
 }
 
 int main(int argc, char **argv)
 {
-	int retcode;
-	Jim_Interp *interp;
-	
-	if (argc == 1)
-		return Jim_InteractivePrompt();
-
-	/* Parser? */
-	if (argc == 3 && !strcmp(argv[1], "--parse")) {
-		test_parser(argv[2], 0);
-		return 0;
-	} else if (argc == 3 && !strcmp(argv[1], "--parse-expr")) {
-		test_parser(argv[2], 1);
-		return 0;
-	} else if (argc == 3 && !strcmp(argv[1], "--parse-subst")) {
-		test_parser(argv[2], 2);
-		return 0;
-	} else if (argc == 2 && !strcmp(argv[1], "--test-ht")) {
-		testHashTable();
-		return 0;
-	}
-
-	/* Load the program */
-	if (argc != 2) {
-		fprintf(stderr, "missing filename\n");
-		exit(1);
-	}
-
-	/* Run it */
-	interp = Jim_CreateInterp();
-	Jim_RegisterCoreCommands(interp);
-	if ((retcode = Jim_EvalFile(interp, argv[1])) == JIM_ERR) {
-		Jim_PrintErrorMessage(interp);
-	}
-	Jim_FreeInterp(interp);
-	return retcode;
+    int retcode;
+    Jim_Interp *interp;
+    
+    if (argc == 1)
+        return Jim_InteractivePrompt();
+
+    /* Parser? */
+    if (argc == 3 && !strcmp(argv[1], "--parse")) {
+        test_parser(argv[2], 0);
+        return 0;
+    } else if (argc == 3 && !strcmp(argv[1], "--parse-expr")) {
+        test_parser(argv[2], 1);
+        return 0;
+    } else if (argc == 3 && !strcmp(argv[1], "--parse-subst")) {
+        test_parser(argv[2], 2);
+        return 0;
+    } else if (argc == 2 && !strcmp(argv[1], "--test-ht")) {
+        testHashTable();
+        return 0;
+    }
+
+    /* Load the program */
+    if (argc != 2) {
+        fprintf(stderr, "missing filename\n");
+        exit(1);
+    }
+
+    /* Run it */
+    interp = Jim_CreateInterp();
+    Jim_RegisterCoreCommands(interp);
+    if ((retcode = Jim_EvalFile(interp, argv[1])) == JIM_ERR) {
+        Jim_PrintErrorMessage(interp);
+    }
+    Jim_FreeInterp(interp);
+    return retcode;
 }
diff --git a/jim.h b/jim.h
index c57b57d..f95009d 100644
--- a/jim.h
+++ b/jim.h
@@ -45,20 +45,20 @@
 #  ifdef _MSC_VER /* MSC compiler */
 #    define jim_wide _int64
 #    ifndef LLONG_MAX
-#      define LLONG_MAX	9223372036854775807I64
+#      define LLONG_MAX    9223372036854775807I64
 #    endif
 #    ifndef LLONG_MIN
-#      define LLONG_MIN	(-LLONG_MAX - 1I64)
+#      define LLONG_MIN    (-LLONG_MAX - 1I64)
 #    endif
 #    define JIM_WIDE_MIN LLONG_MIN
 #    define JIM_WIDE_MAX LLONG_MAX
 #  else /* Other compilers (mainly GCC) */
 #    define jim_wide long long
 #    ifndef LLONG_MAX
-#      define LLONG_MAX	9223372036854775807LL
+#      define LLONG_MAX    9223372036854775807LL
 #    endif
 #    ifndef LLONG_MIN
-#      define LLONG_MIN	(-LLONG_MAX - 1LL)
+#      define LLONG_MIN    (-LLONG_MAX - 1LL)
 #    endif
 #    define JIM_WIDE_MIN LLONG_MIN
 #    define JIM_WIDE_MAX LLONG_MAX
@@ -97,8 +97,8 @@
 
 /* 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    /* no flags set */
+#define JIM_ERRMSG 1    /* set an error message in the interpreter. */
 
 /* Flags for Jim_SubstObj() */
 #define JIM_SUBST_NOVAR 1 /* don't perform variables substitutions */
@@ -110,34 +110,34 @@
  * ---------------------------------------------------------------------------*/
 
 typedef struct Jim_HashEntry {
-	void *key;
-	void *val;
-	struct Jim_HashEntry *next;
+    void *key;
+    void *val;
+    struct Jim_HashEntry *next;
 } Jim_HashEntry;
 
 typedef struct Jim_HashTableType {
-	unsigned int (*hashFunction)(void *key);
-	void *(*keyDup)(void *privdata, void *key);
-	void *(*valDup)(void *privdata, void *obj);
-	int (*keyCompare)(void *privdata, void *key1, void *key2);
-	void (*keyDestructor)(void *privdata, void *key);
-	void (*valDestructor)(void *privdata, void *obj);
+    unsigned int (*hashFunction)(void *key);
+    void *(*keyDup)(void *privdata, void *key);
+    void *(*valDup)(void *privdata, void *obj);
+    int (*keyCompare)(void *privdata, void *key1, void *key2);
+    void (*keyDestructor)(void *privdata, void *key);
+    void (*valDestructor)(void *privdata, void *obj);
 } Jim_HashTableType;
 
 typedef struct Jim_HashTable {
-	Jim_HashEntry **table;
-	Jim_HashTableType *type;
-	unsigned int size;
-	unsigned int sizemask;
-	unsigned int used;
-	unsigned int collisions;
-	void *privdata;
+    Jim_HashEntry **table;
+    Jim_HashTableType *type;
+    unsigned int size;
+    unsigned int sizemask;
+    unsigned int used;
+    unsigned int collisions;
+    void *privdata;
 } Jim_HashTable;
 
 typedef struct Jim_HashTableIterator {
-	Jim_HashTable *ht;
-	int index;
-	Jim_HashEntry *entry;
+    Jim_HashTable *ht;
+    int index;
+    Jim_HashEntry *entry;
 } Jim_HashTableIterator;
 
 /* This is the initial size of every hash table */
@@ -145,31 +145,31 @@ typedef struct Jim_HashTableIterator {
 
 /* ------------------------------- Macros ------------------------------------*/
 #define Jim_FreeEntryVal(ht, entry) \
-	if ((ht)->type->valDestructor) \
-		(ht)->type->valDestructor((ht)->privdata, (entry)->val)
+    if ((ht)->type->valDestructor) \
+        (ht)->type->valDestructor((ht)->privdata, (entry)->val)
 
 #define Jim_SetHashVal(ht, entry, _val_) do { \
-	if ((ht)->type->valDup) \
-		entry->val = (ht)->type->valDup((ht)->privdata, _val_); \
-	else \
-		entry->val = (_val_); \
+    if ((ht)->type->valDup) \
+        entry->val = (ht)->type->valDup((ht)->privdata, _val_); \
+    else \
+        entry->val = (_val_); \
 } while(0)
 
 #define Jim_FreeEntryKey(ht, entry) \
-	if ((ht)->type->keyDestructor) \
-		(ht)->type->keyDestructor((ht)->privdata, (entry)->key)
+    if ((ht)->type->keyDestructor) \
+        (ht)->type->keyDestructor((ht)->privdata, (entry)->key)
 
 #define Jim_SetHashKey(ht, entry, _key_) do { \
-	if ((ht)->type->keyDup) \
-		entry->key = (ht)->type->keyDup((ht)->privdata, _key_); \
-	else \
-		entry->key = (_key_); \
+    if ((ht)->type->keyDup) \
+        entry->key = (ht)->type->keyDup((ht)->privdata, _key_); \
+    else \
+        entry->key = (_key_); \
 } while(0)
 
 #define Jim_CompareHashKeys(ht, key1, key2) \
-	(((ht)->type->keyCompare) ? \
-		(ht)->type->keyCompare((ht)->privdata, key1, key2) : \
-		(key1) == (key2))
+    (((ht)->type->keyCompare) ? \
+        (ht)->type->keyCompare((ht)->privdata, key1, key2) : \
+        (key1) == (key2))
 
 #define Jim_HashKey(ht, key) (ht)->type->hashFunction(key)
 
@@ -194,82 +194,82 @@ typedef struct Jim_HashTableIterator {
  * 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. */
-	struct Jim_ObjType *typePtr; /* object type. */
-	/* Internal representation union */
-	union {
-		/* integer number type */
-		jim_wide wideValue;
-		/* 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 */
-		} listValue;
-		/* String type */
-		struct {
-			int maxLength;
-		} strValue;
-		/* Reference type */
-		struct {
-			jim_wide id;
-			struct Jim_Reference *refPtr;
-		} refValue;
-		/* Source type */
-		struct {
-			char *fileName;
-			int lineNumber;
-		} sourceValue;
-		/* Dict substitution type */
-		struct {
-			struct Jim_Obj *varNameObjPtr;
-			struct Jim_Obj *indexObjPtr;
-		} dictSubstValue;
+    int refCount; /* reference count */
+    char *bytes; /* string representation buffer. NULL = no string repr. */
+    int length; /* number of bytes in 'bytes', not including the numterm. */
+    struct Jim_ObjType *typePtr; /* object type. */
+    /* Internal representation union */
+    union {
+        /* integer number type */
+        jim_wide wideValue;
+        /* 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 */
+        } listValue;
+        /* String type */
+        struct {
+            int maxLength;
+        } strValue;
+        /* Reference type */
+        struct {
+            jim_wide id;
+            struct Jim_Reference *refPtr;
+        } refValue;
+        /* Source type */
+        struct {
+            char *fileName;
+            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;
-	} 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. */
+    } 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. */
 } Jim_Obj;
 
 /* Jim_Obj related macros */
 #define Jim_IncrRefCount(objPtr) \
-	++(objPtr)->refCount
+    ++(objPtr)->refCount
 #define Jim_DecrRefCount(interp, objPtr) \
-	if (--(objPtr)->refCount <= 0) Jim_FreeObj(interp, objPtr)
+    if (--(objPtr)->refCount <= 0) Jim_FreeObj(interp, objPtr)
 #define Jim_IsShared(objPtr) \
-	((objPtr)->refCount > 1)
+    ((objPtr)->refCount > 1)
 
 /* The object type structure.
  * There are four methods.
@@ -288,22 +288,22 @@ typedef struct Jim_Obj {
 struct Jim_Interp;
 
 typedef void (Jim_FreeInternalRepProc)(struct Jim_Interp *interp,
-		struct Jim_Obj *objPtr);
+        struct Jim_Obj *objPtr);
 typedef void (Jim_DupInternalRepProc)(struct Jim_Interp *interp,
-		struct Jim_Obj *srcPtr, Jim_Obj *dupPtr);
+        struct Jim_Obj *srcPtr, Jim_Obj *dupPtr);
 typedef void (Jim_UpdateStringProc)(struct Jim_Obj *objPtr);
-	
+    
 typedef struct Jim_ObjType {
-	char *name; /* The name of the type. */
-	Jim_FreeInternalRepProc *freeIntRepProc;
-	Jim_DupInternalRepProc *dupIntRepProc;
-	Jim_UpdateStringProc *updateStringProc;
-	int flags;
+    char *name; /* The name of the type. */
+    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. */
+#define JIM_TYPE_NONE 0        /* No flags */
+#define JIM_TYPE_REFERENCES 1    /* The object may contain referneces. */
 
 /* -----------------------------------------------------------------------------
  * Call frame, vars, commands structures
@@ -311,14 +311,14 @@ typedef struct Jim_ObjType {
 
 /* Call frame */
 typedef struct Jim_CallFrame {
-	unsigned jim_wide id; /* Call Frame ID. Used for caching. */
-	struct Jim_HashTable vars;
-	struct Jim_CallFrame *parentCallFrame;
-	Jim_Obj **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 */
-	struct Jim_CallFrame *nextFramePtr;
+    unsigned jim_wide id; /* Call Frame ID. Used for caching. */
+    struct Jim_HashTable vars;
+    struct Jim_CallFrame *parentCallFrame;
+    Jim_Obj **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 */
+    struct Jim_CallFrame *nextFramePtr;
 } Jim_CallFrame;
 
 /* The var structure. It just holds the pointer of the referenced
@@ -329,8 +329,8 @@ typedef struct Jim_CallFrame {
  * 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_Obj *objPtr;
+    struct Jim_CallFrame *linkFramePtr;
 } Jim_Var;
 
 /* The cmd structure. */
@@ -340,12 +340,12 @@ typedef int (*Jim_CmdProc)(struct Jim_Interp *interp, int argc, Jim_Obj **argv);
  * it's a Tcl procedure with the arglist and body represented by the
  * two objects referenced by arglistObjPtr and bodyoObjPtr. */
 typedef struct Jim_Cmd {
-	Jim_CmdProc cmdProc; /* Not-NULL for a C command. */
-	void *privData; /* Only used for C commands. */
-	Jim_Obj *argListObjPtr;
-	Jim_Obj *bodyObjPtr;
-	int arityMin; /* Min number of arguments. */
-	int arityMax; /* Max number of arguments. */
+    Jim_CmdProc cmdProc; /* Not-NULL for a C command. */
+    void *privData; /* Only used for C commands. */
+    Jim_Obj *argListObjPtr;
+    Jim_Obj *bodyObjPtr;
+    int arityMin; /* Min number of arguments. */
+    int arityMax; /* Max number of arguments. */
 } Jim_Cmd;
 
 /* -----------------------------------------------------------------------------
@@ -353,45 +353,45 @@ typedef struct Jim_Cmd {
  * 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 numLevels; /* Number of current nested calls. */
-	int maxNestingDepth; /* Used for infinite loop detection. */
-	int returnCode; /* Completion code to return on JIM_RETURN. */
-	Jim_CallFrame *framePtr; /* Pointer to the current call frame */
-	Jim_CallFrame *topFramePtr; /* toplevel/global frame pointer. */
-	struct Jim_HashTable commands; /* Commands hash table */
-	unsigned jim_wide procEpoch; /* Incremented every time the result
-				of procedures names lookup caching
-				may no longer be valid. */
-	unsigned jim_wide callFrameEpoch; /* Incremented every time a new
-				callframe is created. This id is used for the
-				'ID' field contained in the Jim_CallFrame
-				structure. */
-	Jim_Obj *liveList; /* Linked list of all the live objects. */
-	Jim_Obj *freeList; /* Linked list of all the unused objects. */
-	char *scriptFileName; /* File name of the script currently in execution. */
-	Jim_Obj *emptyObj; /* Shared empty string object. */
-	unsigned jim_wide referenceNextId; /* Next id for reference. */
-	struct Jim_HashTable references; /* References hash table. */
-	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 *unknown; /* Unknown command cache */
-	int errorFlag; /* Set if an error occurred during execution. */
-	void *cmdPrivData; /* Used to pass the private data pointer to
-			      command. It is set to what the user specified
-			      via Jim_CreateCommand(). */
-
-	struct Jim_HashTable stub; /* Stub hash table to export API */
-	void *getApiFuncPtr; /* Jim_GetApi() function pointer. */
-	struct Jim_CallFrame *freeFramesList; /* list of CallFrame structures. */
+    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 numLevels; /* Number of current nested calls. */
+    int maxNestingDepth; /* Used for infinite loop detection. */
+    int returnCode; /* Completion code to return on JIM_RETURN. */
+    Jim_CallFrame *framePtr; /* Pointer to the current call frame */
+    Jim_CallFrame *topFramePtr; /* toplevel/global frame pointer. */
+    struct Jim_HashTable commands; /* Commands hash table */
+    unsigned jim_wide procEpoch; /* Incremented every time the result
+                of procedures names lookup caching
+                may no longer be valid. */
+    unsigned jim_wide callFrameEpoch; /* Incremented every time a new
+                callframe is created. This id is used for the
+                'ID' field contained in the Jim_CallFrame
+                structure. */
+    Jim_Obj *liveList; /* Linked list of all the live objects. */
+    Jim_Obj *freeList; /* Linked list of all the unused objects. */
+    char *scriptFileName; /* File name of the script currently in execution. */
+    Jim_Obj *emptyObj; /* Shared empty string object. */
+    unsigned jim_wide referenceNextId; /* Next id for reference. */
+    struct Jim_HashTable references; /* References hash table. */
+    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 *unknown; /* Unknown command cache */
+    int errorFlag; /* Set if an error occurred during execution. */
+    void *cmdPrivData; /* Used to pass the private data pointer to
+                  command. It is set to what the user specified
+                  via Jim_CreateCommand(). */
+
+    struct Jim_HashTable stub; /* Stub hash table to export API */
+    void *getApiFuncPtr; /* Jim_GetApi() function pointer. */
+    struct Jim_CallFrame *freeFramesList; /* list of CallFrame structures. */
 } Jim_Interp;
 
 /* Currently provided as macro that performs the increment.
@@ -407,16 +407,16 @@ typedef struct Jim_Interp {
 /* 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_); \
-	Jim_DecrRefCount(i,(i)->result);  \
-	(i)->result = _resultObjPtr_;     \
+    Jim_Obj *_resultObjPtr_ = (o);    \
+    Jim_IncrRefCount(_resultObjPtr_); \
+    Jim_DecrRefCount(i,(i)->result);  \
+    (i)->result = _resultObjPtr_;     \
 } while(0)
 
 /* Reference structure. The interpreter pointer is held within privdata member in HashTable */
 typedef struct Jim_Reference {
-	Jim_Obj *objPtr;
-	Jim_Obj *finalizerCmdNamePtr;
+    Jim_Obj *objPtr;
+    Jim_Obj *finalizerCmdNamePtr;
 } Jim_Reference;
 
 /* -----------------------------------------------------------------------------
@@ -455,66 +455,66 @@ JIM_STATIC char * JIM_API(Jim_StrDup) (char *s);
 /* evaluation */
 JIM_STATIC int JIM_API(Jim_EvalObj) (Jim_Interp *interp, Jim_Obj *scriptObjPtr);
 JIM_STATIC int JIM_API(Jim_EvalObjVector) (Jim_Interp *interp, int objc,
-		Jim_Obj **objv);
+        Jim_Obj **objv);
 JIM_STATIC int JIM_API(Jim_SubstObj) (Jim_Interp *interp, Jim_Obj *substObjPtr,
-		Jim_Obj **resObjPtrPtr, int flags);
+        Jim_Obj **resObjPtrPtr, int flags);
 
 /* hash table */
 JIM_STATIC int JIM_API(Jim_InitHashTable) (Jim_HashTable *ht,
-		Jim_HashTableType *type, void *privdata);
+        Jim_HashTableType *type, void *privdata);
 JIM_STATIC int JIM_API(Jim_ExpandHashTable) (Jim_HashTable *ht,
-		unsigned int size);
+        unsigned int size);
 JIM_STATIC int JIM_API(Jim_AddHashEntry) (Jim_HashTable *ht, void *key,
-		void *val);
+        void *val);
 JIM_STATIC int JIM_API(Jim_ReplaceHashEntry) (Jim_HashTable *ht, void *key,
-		void *val);
+        void *val);
 JIM_STATIC int JIM_API(Jim_DeleteHashEntry) (Jim_HashTable *ht, void *key);
 JIM_STATIC int JIM_API(Jim_FreeHashTable) (Jim_HashTable *ht);
 JIM_STATIC Jim_HashEntry * JIM_API(Jim_FindHashEntry) (Jim_HashTable *ht,
-		void *key);
+        void *key);
 JIM_STATIC int JIM_API(Jim_ResizeHashTable) (Jim_HashTable *ht);
 JIM_STATIC Jim_HashTableIterator *JIM_API(Jim_GetHashTableIterator)
-		(Jim_HashTable *ht);
+        (Jim_HashTable *ht);
 JIM_STATIC Jim_HashEntry * JIM_API(Jim_NextHashEntry)
-		(Jim_HashTableIterator *iterator);
+        (Jim_HashTableIterator *iterator);
 
 /* objects */
 JIM_STATIC Jim_Obj * JIM_API(Jim_NewObj) (Jim_Interp *interp);
 JIM_STATIC void JIM_API(Jim_FreeObj) (Jim_Interp *interp, Jim_Obj *objPtr);
 JIM_STATIC void JIM_API(Jim_InvalidateStringRep) (Jim_Obj *objPtr);
 JIM_STATIC void JIM_API(Jim_InitStringRep) (Jim_Obj *objPtr, char *bytes,
-		int length);
+        int length);
 JIM_STATIC Jim_Obj * JIM_API(Jim_DuplicateObj) (Jim_Interp *interp,
-		Jim_Obj *objPtr);
+        Jim_Obj *objPtr);
 JIM_STATIC char * JIM_API(Jim_GetString)(Jim_Obj *objPtr, int *lenPtr);
 JIM_STATIC void JIM_API(Jim_InvalidateStringRep)(Jim_Obj *objPtr);
 
 /* string object */
 JIM_STATIC Jim_Obj * JIM_API(Jim_NewStringObj) (Jim_Interp *interp,
-		const char *s, int len);
+        const char *s, int len);
 JIM_STATIC Jim_Obj * JIM_API(Jim_NewStringObjNoAlloc) (Jim_Interp *interp,
-		char *s, int len);
+        char *s, int len);
 JIM_STATIC void JIM_API(Jim_AppendString) (Jim_Interp *interp, Jim_Obj *objPtr,
-		char *str, int len);
+        char *str, int len);
 JIM_STATIC void JIM_API(Jim_AppendObj) (Jim_Interp *interp, Jim_Obj *objPtr,
-		Jim_Obj *appendObjPtr);
+        Jim_Obj *appendObjPtr);
 JIM_STATIC void JIM_API(Jim_AppendStrings) (Jim_Interp *interp,
-		Jim_Obj *objPtr, ...);
+        Jim_Obj *objPtr, ...);
 JIM_STATIC int JIM_API(Jim_StringEqObj) (Jim_Obj *aObjPtr, Jim_Obj *bObjPtr,
-		int nocase);
+        int nocase);
 JIM_STATIC int JIM_API(Jim_StringMatchObj) (Jim_Obj *patternObjPtr,
-		Jim_Obj *objPtr, int nocase);
+        Jim_Obj *objPtr, int nocase);
 JIM_STATIC Jim_Obj * JIM_API(Jim_StringRangeObj) (Jim_Interp *interp,
-		Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr,
-		Jim_Obj *lastObjPtr);
+        Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr,
+        Jim_Obj *lastObjPtr);
 JIM_STATIC int JIM_API(Jim_CompareStringImmediate) (Jim_Interp *interp,
-		Jim_Obj *objPtr, char *str);
+        Jim_Obj *objPtr, char *str);
 
 /* reference object */
 JIM_STATIC Jim_Obj * JIM_API(Jim_NewReference) (Jim_Interp *interp,
-		Jim_Obj *objPtr, Jim_Obj *cmdNamePtr);
+        Jim_Obj *objPtr, Jim_Obj *cmdNamePtr);
 JIM_STATIC Jim_Reference * JIM_API(Jim_GetReference) (Jim_Interp *interp,
-		Jim_Obj *objPtr);
+        Jim_Obj *objPtr);
 
 /* interpreter */
 JIM_STATIC Jim_Interp * JIM_API(Jim_CreateInterp) (void);
@@ -523,29 +523,29 @@ JIM_STATIC void JIM_API(Jim_FreeInterp) (Jim_Interp *i);
 /* commands */
 JIM_STATIC void JIM_API(Jim_RegisterCoreCommands) (Jim_Interp *interp);
 JIM_STATIC int JIM_API(Jim_CreateCommand) (Jim_Interp *interp, char *cmdName,
-		Jim_CmdProc cmdProc, void *privData);
+        Jim_CmdProc cmdProc, void *privData);
 JIM_STATIC int JIM_API(Jim_CreateProcedure) (Jim_Interp *interp, char *cmdName,
                 Jim_Obj *argListObjPtr, Jim_Obj *bodyObjPtr,
                 int arityMin, int arityMax);
 JIM_STATIC int JIM_API(Jim_DeleteCommand) (Jim_Interp *interp, char *cmdName);
 JIM_STATIC int JIM_API(Jim_RenameCommand) (Jim_Interp *interp, char *oldName,
-		char *newName);
+        char *newName);
 JIM_STATIC Jim_Cmd * JIM_API(Jim_GetCommand) (Jim_Interp *interp,
-		Jim_Obj *objPtr, int flags);
+        Jim_Obj *objPtr, int flags);
 JIM_STATIC int JIM_API(Jim_SetVariable) (Jim_Interp *interp,
-		Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr);
+        Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr);
 JIM_STATIC int JIM_API(Jim_SetVariableLink) (Jim_Interp *interp,
-		Jim_Obj *nameObjPtr, Jim_Obj *targetNameObjPtr,
-		Jim_CallFrame *targetCallFrame);
+        Jim_Obj *nameObjPtr, Jim_Obj *targetNameObjPtr,
+        Jim_CallFrame *targetCallFrame);
 JIM_STATIC Jim_Obj * JIM_API(Jim_GetVariable) (Jim_Interp *interp,
-		Jim_Obj *nameObjPtr, int flags);
+        Jim_Obj *nameObjPtr, int flags);
 JIM_STATIC int JIM_API(Jim_UnsetVariable) (Jim_Interp *interp,
-		Jim_Obj *nameObjPtr, int flags);
+        Jim_Obj *nameObjPtr, int flags);
 
 /* call frame */
 JIM_STATIC int JIM_API(Jim_GetCallFrameByLevel) (Jim_Interp *interp,
-		Jim_Obj *levelObjPtr, Jim_CallFrame **framePtrPtr,
-		int *newLevelPtr);
+        Jim_Obj *levelObjPtr, Jim_CallFrame **framePtrPtr,
+        int *newLevelPtr);
 
 /* garbage collection */
 JIM_STATIC int JIM_API(Jim_Collect) (Jim_Interp *interp);
@@ -553,58 +553,58 @@ JIM_STATIC void JIM_API(Jim_CollectIfNeeded) (Jim_Interp *interp);
 
 /* index object */
 JIM_STATIC int JIM_API(Jim_GetIndex) (Jim_Interp *interp, Jim_Obj *objPtr,
-		int *indexPtr);
+        int *indexPtr);
 
 /* list object */
 JIM_STATIC Jim_Obj * JIM_API(Jim_NewListObj) (Jim_Interp *interp,
-		Jim_Obj **elements, int len);
+        Jim_Obj **elements, int len);
 JIM_STATIC void JIM_API(Jim_ListAppendElement) (Jim_Interp *interp,
-		Jim_Obj *listPtr, Jim_Obj *objPtr);
+        Jim_Obj *listPtr, Jim_Obj *objPtr);
 JIM_STATIC void JIM_API(Jim_ListAppendList) (Jim_Interp *interp,
-		Jim_Obj *listPtr, Jim_Obj *appendListPtr);
+        Jim_Obj *listPtr, Jim_Obj *appendListPtr);
 JIM_STATIC void JIM_API(Jim_ListLength) (Jim_Interp *interp, Jim_Obj *listPtr,
-		int *intPtr);
+        int *intPtr);
 JIM_STATIC int JIM_API(Jim_ListIndex) (Jim_Interp *interp, Jim_Obj *listPrt,
-		int index, Jim_Obj **objPtrPtr, int seterr);
+        int index, Jim_Obj **objPtrPtr, int seterr);
 JIM_STATIC int JIM_API(Jim_SetListIndex) (Jim_Interp *interp,
-		Jim_Obj *varNamePtr, Jim_Obj **indexv, int indexc,
-		Jim_Obj *newObjPtr);
+        Jim_Obj *varNamePtr, Jim_Obj **indexv, int indexc,
+        Jim_Obj *newObjPtr);
 JIM_STATIC Jim_Obj * JIM_API(Jim_ConcatObj) (Jim_Interp *interp, int objc,
-		Jim_Obj **objv);
+        Jim_Obj **objv);
 
 /* dict object */
 JIM_STATIC Jim_Obj * JIM_API(Jim_NewDictObj) (Jim_Interp *interp,
-		Jim_Obj **elements, int len);
+        Jim_Obj **elements, int len);
 JIM_STATIC int JIM_API(Jim_DictKey) (Jim_Interp *interp, Jim_Obj *dictPtr,
-		Jim_Obj *keyPtr, Jim_Obj **objPtrPtr, int flags);
+        Jim_Obj *keyPtr, Jim_Obj **objPtrPtr, int flags);
 JIM_STATIC int JIM_API(Jim_DictKeysVector) (Jim_Interp *interp,
-		Jim_Obj *dictPtr, Jim_Obj **keyv, int keyc,
-		Jim_Obj **objPtrPtr, int flags);
+        Jim_Obj *dictPtr, Jim_Obj **keyv, int keyc,
+        Jim_Obj **objPtrPtr, int flags);
 JIM_STATIC int JIM_API(Jim_GetIndex) (Jim_Interp *interp, Jim_Obj *objPtr,
-		int *indexPtr);
+        int *indexPtr);
 JIM_STATIC int JIM_API(Jim_SetDictKeysVector) (Jim_Interp *interp,
-		Jim_Obj *varNamePtr, Jim_Obj **keyv, int keyc,
-		Jim_Obj *newObjPtr);
+        Jim_Obj *varNamePtr, Jim_Obj **keyv, int keyc,
+        Jim_Obj *newObjPtr);
 
 /* return code object */
 JIM_STATIC int JIM_API(Jim_GetReturnCode) (Jim_Interp *interp, Jim_Obj *objPtr,
-		int *intPtr);
+        int *intPtr);
 
 /* expression object */
 JIM_STATIC int JIM_API(Jim_EvalExpression) (Jim_Interp *interp,
-		Jim_Obj *exprObjPtr, Jim_Obj **exprResultPtrPtr);
+        Jim_Obj *exprObjPtr, Jim_Obj **exprResultPtrPtr);
 JIM_STATIC int JIM_API(Jim_GetBoolFromExpr) (Jim_Interp *interp,
-		Jim_Obj *exprObjPtr, int *boolPtr);
+        Jim_Obj *exprObjPtr, int *boolPtr);
 
 /* integer object */
 JIM_STATIC int JIM_API(Jim_GetWide) (Jim_Interp *interp, Jim_Obj *objPtr,
-		jim_wide *widePtr);
+        jim_wide *widePtr);
 JIM_STATIC int JIM_API(Jim_GetLong) (Jim_Interp *interp, Jim_Obj *objPtr,
-		long *longPtr);
+        long *longPtr);
 JIM_STATIC void JIM_API(Jim_SetWide) (Jim_Interp *interp, Jim_Obj *objPtr,
-		jim_wide wideValue);
+        jim_wide wideValue);
 JIM_STATIC Jim_Obj * JIM_API(Jim_NewIntObj) (Jim_Interp *interp,
-		jim_wide wideValue);
+        jim_wide wideValue);
 
 /* shared strings */
 JIM_STATIC char JIM_API(*Jim_GetSharedString) (Jim_Interp *interp, char *str);
@@ -612,12 +612,12 @@ JIM_STATIC void JIM_API(Jim_ReleaseSharedString) (Jim_Interp *interp, char *str)
 
 /* commands utilities */
 JIM_STATIC void JIM_API(Jim_WrongNumArgs) (Jim_Interp *interp, int argc,
-		Jim_Obj **argv, char *msg);
+        Jim_Obj **argv, char *msg);
 
 /* API import/export functions */
 JIM_STATIC void* JIM_API(Jim_GetApi)(Jim_Interp *interp, char *funcname);
 JIM_STATIC int JIM_API(Jim_RegisterApi)(Jim_Interp *interp, char *funcname,
-		void *funcptr);
+        void *funcptr);
 
 #ifndef __JIM_CORE__
 /* This must be included "inline" inside the extension */