X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fhelper%2Fjim.c;h=2bdf15a669e6386dd45f2a42ca041a5261b67bcf;hp=791dfc6f4535f03575c69c82bff70f56f62a7e5e;hb=6d1d58a1fc3dfd60e9cac89460b5a6e438d11efa;hpb=ef1cfb23947bd32798077c6abb5c25a049460ae9 diff --git a/src/helper/jim.c b/src/helper/jim.c index 791dfc6f45..2bdf15a669 100644 --- a/src/helper/jim.c +++ b/src/helper/jim.c @@ -7,6 +7,7 @@ * Copyright 2008 Andrew Lunn * Copyright 2008 Duane Ellis * Copyright 2008 Uwe Klein + * Copyright 2008 Steve Bennett * * The FreeBSD license * @@ -38,16 +39,15 @@ * are those of the authors and should not be interpreted as representing * official policies, either expressed or implied, of the Jim Tcl Project. **/ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #define __JIM_CORE__ #define JIM_OPTIMIZATION /* comment to avoid optimizations and reduce size */ #ifdef __ECOS #include -#endif -#ifndef JIM_ANSIC -#define JIM_DYNLIB /* Dynamic library support for UNIX and WIN32 */ -#endif /* JIM_ANSIC */ - #include #include #include @@ -57,8 +57,13 @@ #include #include #include +#endif +#ifndef JIM_ANSIC +#define JIM_DYNLIB /* Dynamic library support for UNIX and WIN32 */ +#endif /* JIM_ANSIC */ -#include "replacements.h" +#include +#include /* Include the platform dependent libraries for * dynamic loading of libraries. */ @@ -105,7 +110,7 @@ static void JimChangeCallFrameId(Jim_Interp *interp, Jim_CallFrame *cf); static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int flags); static void JimRegisterCoreApi(Jim_Interp *interp); -static Jim_HashTableType JimVariablesHashTableType; +static Jim_HashTableType *getJimVariablesHashTableType(void); /* ----------------------------------------------------------------------------- * Utility functions @@ -122,7 +127,9 @@ static char buf[2048]; buf[sizeof(buf)-1] = 0; #else char *buf; - vasprintf( &buf, fmt, ap ); + int result; + result = vasprintf( &buf, fmt, ap ); + if (result < 0) exit(-1); #endif return buf; } @@ -145,7 +152,7 @@ jim_vasprintf_done( void *buf ) * Ignores `locale' stuff. Assumes that the upper and lower case * alphabets and digits are each contiguous. */ -#ifdef HAVE_LONG_LONG +#ifdef HAVE_LONG_LONG_INT #define JimIsAscii(c) (((c) & ~0x7f) == 0) static jim_wide JimStrtoll(const char *nptr, char **endptr, register int base) { @@ -191,7 +198,7 @@ static jim_wide JimStrtoll(const char *nptr, char **endptr, register int base) * 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 + * 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. @@ -238,8 +245,8 @@ static jim_wide JimStrtoll(const char *nptr, char **endptr, register int base) static int JimStringMatch(const char *pattern, int patternLen, const char *string, int stringLen, int nocase) { - while(patternLen) { - switch(pattern[0]) { + while (patternLen) { + switch (pattern[0]) { case '*': while (pattern[1] == '*') { pattern++; @@ -247,8 +254,8 @@ static int JimStringMatch(const char *pattern, int patternLen, } if (patternLen == 1) return 1; /* match */ - while(stringLen) { - if (JimStringMatch(pattern+1, patternLen-1, + while (stringLen) { + if (JimStringMatch(pattern + 1, patternLen-1, string, stringLen, nocase)) return 1; /* match */ string++; @@ -274,7 +281,7 @@ static int JimStringMatch(const char *pattern, int patternLen, patternLen--; } match = 0; - while(1) { + while (1) { if (pattern[0] == '\\') { pattern++; patternLen--; @@ -345,7 +352,7 @@ static int JimStringMatch(const char *pattern, int patternLen, pattern++; patternLen--; if (stringLen == 0) { - while(*pattern == '*') { + while (*pattern == '*') { pattern++; patternLen--; } @@ -363,7 +370,7 @@ int JimStringCompare(const char *s1, int l1, const char *s2, int l2, unsigned char *u1 = (unsigned char*) s1, *u2 = (unsigned char*) s2; if (nocase == 0) { - while(l1 && l2) { + while (l1 && l2) { if (*u1 != *u2) return (int)*u1-*u2; u1++; u2++; l1--; l2--; @@ -371,7 +378,7 @@ int JimStringCompare(const char *s1, int l1, const char *s2, int l2, if (!l1 && !l2) return 0; return l1-l2; } else { - while(l1 && l2) { + while (l1 && l2) { if (tolower((int)*u1) != tolower((int)*u2)) return tolower((int)*u1)-tolower((int)*u2); u1++; u2++; l1--; l2--; @@ -409,7 +416,7 @@ int Jim_StringToWide(const char *str, jim_wide *widePtr, int base) { char *endptr; -#ifdef HAVE_LONG_LONG +#ifdef HAVE_LONG_LONG_INT *widePtr = JimStrtoll(str, &endptr, base); #else *widePtr = strtol(str, &endptr, base); @@ -417,7 +424,7 @@ int Jim_StringToWide(const char *str, jim_wide *widePtr, int base) if ((str[0] == '\0') || (str == endptr) ) return JIM_ERR; if (endptr[0] != '\0') { - while(*endptr) { + while (*endptr) { if (!isspace((int)*endptr)) return JIM_ERR; endptr++; @@ -434,7 +441,7 @@ int Jim_StringToIndex(const char *str, int *intPtr) if ( (str[0] == '\0') || (str == endptr) ) return JIM_ERR; if (endptr[0] != '\0') { - while(*endptr) { + while (*endptr) { if (!isspace((int)*endptr)) return JIM_ERR; endptr++; @@ -450,7 +457,7 @@ int Jim_StringToIndex(const char *str, int *intPtr) * in length, this allows to avoid to check every object with a string * repr < 32, and usually there are many of this objects. */ -#define JIM_REFERENCE_SPACE (35+JIM_REFERENCE_TAGLEN) +#define JIM_REFERENCE_SPACE (35 + JIM_REFERENCE_TAGLEN) static int JimFormatReference(char *buf, Jim_Reference *refPtr, jim_wide id) { @@ -466,7 +473,7 @@ int Jim_DoubleToString(char *buf, double doubleValue) len = sprintf(buf, "%.17g", doubleValue); s = buf; - while(*s) { + while (*s) { if (*s == '.') return len; s++; } @@ -478,7 +485,7 @@ int Jim_DoubleToString(char *buf, double doubleValue) s[0] = '.'; s[1] = '0'; s[2] = '\0'; - return len+2; + return len + 2; } return len; } @@ -496,8 +503,8 @@ int Jim_StringToDouble(const char *str, double *doublePtr) static jim_wide JimPowWide(jim_wide b, jim_wide e) { jim_wide i, res = 1; - if ((b==0 && e!=0) || (e<0)) return 0; - for(i=0; icookie_stderr ){ + if ( interp && interp->cookie_stderr ){ Jim_fprintf( interp, interp->cookie_stderr, JIM_NL "JIM INTERPRETER PANIC: "); Jim_vfprintf( interp, interp->cookie_stderr, fmt, ap ); Jim_fprintf( interp, interp->cookie_stderr, JIM_NL JIM_NL ); @@ -561,8 +568,8 @@ void Jim_Panic(Jim_Interp *interp, const char *fmt, ...) void *Jim_Alloc(int size) { /* We allocate zero length arrayes, etc. to use a single orthogonal codepath */ - if (size==0) - size=1; + if (size == 0) + size = 1; void *p = malloc(size); if (p == NULL) Jim_Panic(NULL,"malloc: Out of memory"); @@ -576,8 +583,8 @@ void Jim_Free(void *ptr) { void *Jim_Realloc(void *ptr, int size) { /* We allocate zero length arrayes, etc. to use a single orthogonal codepath */ - if (size==0) - size=1; + if (size == 0) + size = 1; void *p = realloc(ptr, size); if (p == NULL) Jim_Panic(NULL,"realloc: Out of memory"); @@ -587,17 +594,17 @@ void *Jim_Realloc(void *ptr, int size) char *Jim_StrDup(const char *s) { int l = strlen(s); - char *copy = Jim_Alloc(l+1); + char *copy = Jim_Alloc(l + 1); - memcpy(copy, s, l+1); + memcpy(copy, s, l + 1); return copy; } char *Jim_StrDupLen(const char *s, int l) { - char *copy = Jim_Alloc(l+1); + char *copy = Jim_Alloc(l + 1); - memcpy(copy, s, l+1); + memcpy(copy, s, l + 1); copy[l] = 0; /* Just to be sure, original could be substring */ return copy; } @@ -654,8 +661,8 @@ unsigned int Jim_IdentityHashFunction(unsigned int key) unsigned int Jim_GenHashFunction(const unsigned char *buf, int len) { unsigned int h = 0; - while(len--) - h += (h<<3)+*buf++; + while (len--) + h += (h << 3)+*buf++; return h; } @@ -722,7 +729,7 @@ int Jim_ExpandHashTable(Jim_HashTable *ht, unsigned int size) /* For each hash entry on this slot... */ he = ht->table[i]; - while(he) { + while (he) { unsigned int h; nextHe = he->next; @@ -795,7 +802,7 @@ int Jim_DeleteHashEntry(Jim_HashTable *ht, const void *key) he = ht->table[h]; prevHe = NULL; - while(he) { + while (he) { if (Jim_CompareHashKeys(ht, key, he->key)) { /* Unlink the element from the list */ if (prevHe) @@ -824,7 +831,7 @@ int Jim_FreeHashTable(Jim_HashTable *ht) Jim_HashEntry *he, *nextHe; if ((he = ht->table[i]) == NULL) continue; - while(he) { + while (he) { nextHe = he->next; Jim_FreeEntryKey(ht, he); Jim_FreeEntryVal(ht, he); @@ -848,7 +855,7 @@ Jim_HashEntry *Jim_FindHashEntry(Jim_HashTable *ht, const void *key) if (ht->size == 0) return NULL; h = Jim_HashKey(ht, key) & ht->sizemask; he = ht->table[h]; - while(he) { + while (he) { if (Jim_CompareHashKeys(ht, key, he->key)) return he; he = he->next; @@ -909,7 +916,7 @@ static unsigned int JimHashTableNextPower(unsigned int size) if (size >= 2147483648U) return 2147483648U; - while(1) { + while (1) { if (i >= size) return i; i *= 2; @@ -931,7 +938,7 @@ static int JimInsertHashEntry(Jim_HashTable *ht, const void *key) h = Jim_HashKey(ht, key) & ht->sizemask; /* Search if this slot does not already contain the given key */ he = ht->table[h]; - while(he) { + while (he) { if (Jim_CompareHashKeys(ht, key, he->key)) return -1; he = he->next; @@ -949,7 +956,7 @@ static unsigned int JimStringCopyHTHashFunction(const void *key) static const void *JimStringCopyHTKeyDup(void *privdata, const void *key) { int len = strlen(key); - char *copy = Jim_Alloc(len+1); + char *copy = Jim_Alloc(len + 1); JIM_NOTUSED(privdata); memcpy(copy, key, len); @@ -960,7 +967,7 @@ static const void *JimStringCopyHTKeyDup(void *privdata, const void *key) static void *JimStringKeyValCopyHTValDup(void *privdata, const void *val) { int len = strlen(val); - char *copy = Jim_Alloc(len+1); + char *copy = Jim_Alloc(len + 1); JIM_NOTUSED(privdata); memcpy(copy, val, len); @@ -1065,7 +1072,7 @@ int Jim_StackLen(Jim_Stack *stack) } void Jim_StackPush(Jim_Stack *stack, void *element) { - int neededLen = stack->len+1; + int neededLen = stack->len + 1; if (neededLen > stack->maxlen) { stack->maxlen = neededLen*2; stack->vector = Jim_Realloc(stack->vector, sizeof(void*)*stack->maxlen); @@ -1173,7 +1180,7 @@ void JimParserInit(struct JimParserCtx *pc, const char *prg, int JimParseScript(struct JimParserCtx *pc) { - while(1) { /* the while is used to reiterate with continue if needed */ + while (1) { /* the while is used to reiterate with continue if needed */ if (!pc->len) { pc->tstart = pc->p; pc->tend = pc->p-1; @@ -1182,9 +1189,9 @@ int JimParseScript(struct JimParserCtx *pc) pc->eof = 1; return JIM_OK; } - switch(*(pc->p)) { + switch (*(pc->p)) { case '\\': - if (*(pc->p+1) == '\n') + if (*(pc->p + 1) == '\n') return JimParseSep(pc); else { pc->comment = 0; @@ -1244,7 +1251,7 @@ 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')) { + (*pc->p == '\\' && *(pc->p + 1) == '\n')) { if (*pc->p == '\\') { pc->p++; pc->len--; pc->linenr++; @@ -1320,19 +1327,21 @@ int JimParseVar(struct JimParserCtx *pc) if (brace) { while (!stop) { if (*pc->p == '}' || pc->len == 0) { + pc->tend = pc->p-1; stop = 1; if (pc->len == 0) - continue; + break; } else if (*pc->p == '\n') pc->linenr++; pc->p++; pc->len--; } - if (pc->len == 0) - pc->tend = pc->p-1; - else - pc->tend = pc->p-2; } else { + /* Include leading colons */ + while (*pc->p == ':') { + pc->p++; + pc->len--; + } while (!stop) { if (!((*pc->p >= 'a' && *pc->p <= 'z') || (*pc->p >= 'A' && *pc->p <= 'Z') || @@ -1418,10 +1427,10 @@ int JimParseStr(struct JimParserCtx *pc) pc->tt = JIM_TT_ESC; return JIM_OK; } - switch(*pc->p) { + switch (*pc->p) { case '\\': if (pc->state == JIM_PS_DEF && - *(pc->p+1) == '\n') { + *(pc->p + 1) == '\n') { pc->tend = pc->p-1; pc->tt = JIM_TT_ESC; return JIM_OK; @@ -1509,9 +1518,9 @@ static int JimEscape(char *dest, const char *s, int slen) slen = strlen(s); for (i = 0; i < slen; i++) { - switch(s[i]) { + switch (s[i]) { case '\\': - switch(s[i+1]) { + switch (s[i + 1]) { case 'a': *p++ = 0x7; i++; break; case 'b': *p++ = 0x8; i++; break; case 'f': *p++ = 0xc; i++; break; @@ -1522,48 +1531,48 @@ static int JimEscape(char *dest, const char *s, int slen) case '\0': *p++ = '\\'; i++; break; case '\n': *p++ = ' '; i++; break; default: - if (s[i+1] == 'x') { + if (s[i + 1] == 'x') { int val = 0; - int c = xdigitval(s[i+2]); + int c = xdigitval(s[i + 2]); if (c == -1) { *p++ = 'x'; i++; break; } val = c; - c = xdigitval(s[i+3]); + c = xdigitval(s[i + 3]); if (c == -1) { *p++ = val; i += 2; break; } - val = (val*16)+c; + val = (val*16) + c; *p++ = val; i += 3; break; - } else if (s[i+1] >= '0' && s[i+1] <= '7') + } else if (s[i + 1] >= '0' && s[i + 1] <= '7') { int val = 0; - int c = odigitval(s[i+1]); + int c = odigitval(s[i + 1]); val = c; - c = odigitval(s[i+2]); + c = odigitval(s[i + 2]); if (c == -1) { *p++ = val; i ++; break; } - val = (val*8)+c; - c = odigitval(s[i+3]); + val = (val*8) + c; + c = odigitval(s[i + 3]); if (c == -1) { *p++ = val; i += 2; break; } - val = (val*8)+c; + val = (val*8) + c; *p++ = val; i += 3; } else { - *p++ = s[i+1]; + *p++ = s[i + 1]; i++; } break; @@ -1616,8 +1625,8 @@ char *JimParserGetToken(struct JimParserCtx *pc, token[0] = '\0'; return token; } - len = (end-start)+1; - token = Jim_Alloc(len+1); + 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); @@ -1648,7 +1657,7 @@ int Jim_ScriptIsComplete(const char *s, int len, char *stateCharPtr) int level = 0; int state = ' '; - while(len) { + while (len) { switch (*s) { case '\\': if (len > 1) @@ -1700,7 +1709,7 @@ int JimParseList(struct JimParserCtx *pc) pc->eof = 1; return JIM_OK; } - switch(*pc->p) { + switch (*pc->p) { case ' ': case '\n': case '\t': @@ -1748,7 +1757,7 @@ int JimParseListStr(struct JimParserCtx *pc) pc->tt = JIM_TT_ESC; return JIM_OK; } - switch(*pc->p) { + switch (*pc->p) { case '\\': pc->p++; pc->len--; break; @@ -1870,7 +1879,7 @@ void Jim_InitStringRep(Jim_Obj *objPtr, const char *bytes, int length) objPtr->bytes = JimEmptyStringRep; objPtr->length = 0; } else { - objPtr->bytes = Jim_Alloc(length+1); + objPtr->bytes = Jim_Alloc(length + 1); objPtr->length = length; memcpy(objPtr->bytes, bytes, length); objPtr->bytes[length] = '\0'; @@ -1978,7 +1987,7 @@ Jim_Obj *Jim_NewStringObj(Jim_Interp *interp, const char *s, int len) objPtr->bytes = JimEmptyStringRep; objPtr->length = 0; } else { - objPtr->bytes = Jim_Alloc(len+1); + objPtr->bytes = Jim_Alloc(len + 1); objPtr->length = len; memcpy(objPtr->bytes, s, len); objPtr->bytes[len] = '\0'; @@ -2014,14 +2023,14 @@ void StringAppendString(Jim_Obj *objPtr, const char *str, int len) if (objPtr->internalRep.strValue.maxLength < needlen || objPtr->internalRep.strValue.maxLength == 0) { if (objPtr->bytes == JimEmptyStringRep) { - objPtr->bytes = Jim_Alloc((needlen*2)+1); + objPtr->bytes = Jim_Alloc((needlen*2) + 1); } else { - objPtr->bytes = Jim_Realloc(objPtr->bytes, (needlen*2)+1); + 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->bytes[objPtr->length + len] = '\0'; objPtr->length += len; } @@ -2055,7 +2064,7 @@ void Jim_AppendString_sprintf( Jim_Interp *interp, Jim_Obj *objPtr, const char * buf = jim_vasprintf( fmt, ap ); va_end(ap); - if( buf ){ + if ( buf ){ Jim_AppendString( interp, objPtr, buf, -1 ); jim_vasprintf_done(buf); } @@ -2154,7 +2163,7 @@ static void JimRelToAbsRange(int len, int first, int last, if (first > last) { rangeLen = 0; } else { - rangeLen = last-first+1; + rangeLen = last-first + 1; if (rangeLen) { if (first < 0) { rangeLen += first; @@ -2187,15 +2196,20 @@ Jim_Obj *Jim_StringRangeObj(Jim_Interp *interp, first = JimRelToAbsIndex(len, first); last = JimRelToAbsIndex(len, last); JimRelToAbsRange(len, first, last, &first, &last, &rangeLen); - return Jim_NewStringObj(interp, str+first, rangeLen); + return Jim_NewStringObj(interp, str + first, rangeLen); } static Jim_Obj *JimStringToLower(Jim_Interp *interp, Jim_Obj *strObjPtr) { - char *buf = Jim_Alloc(strObjPtr->length+1); + char *buf; int i; + if (strObjPtr->typePtr != &stringObjType) { + SetStringFromAny(interp, strObjPtr); + } + + buf = Jim_Alloc(strObjPtr->length + 1); - memcpy(buf, strObjPtr->bytes, strObjPtr->length+1); + memcpy(buf, strObjPtr->bytes, strObjPtr->length + 1); for (i = 0; i < strObjPtr->length; i++) buf[i] = tolower(buf[i]); return Jim_NewStringObjNoAlloc(interp, buf, strObjPtr->length); @@ -2203,10 +2217,15 @@ static Jim_Obj *JimStringToLower(Jim_Interp *interp, Jim_Obj *strObjPtr) static Jim_Obj *JimStringToUpper(Jim_Interp *interp, Jim_Obj *strObjPtr) { - char *buf = Jim_Alloc(strObjPtr->length+1); + char *buf; int i; + if (strObjPtr->typePtr != &stringObjType) { + SetStringFromAny(interp, strObjPtr); + } + + buf = Jim_Alloc(strObjPtr->length + 1); - memcpy(buf, strObjPtr->bytes, strObjPtr->length+1); + memcpy(buf, strObjPtr->bytes, strObjPtr->length + 1); for (i = 0; i < strObjPtr->length; i++) buf[i] = toupper(buf[i]); return Jim_NewStringObjNoAlloc(interp, buf, strObjPtr->length); @@ -2264,10 +2283,10 @@ static Jim_Obj *Jim_FormatString_Inner(Jim_Interp *interp, Jim_Obj *fmtObjPtr, haveprec = 0; prec = -1; /* not found yet */ next_fmt: - if( fmtLen <= 0 ){ + if ( fmtLen <= 0 ){ break; } - switch( *fmt ){ + switch ( *fmt ){ /* terminals */ case 'b': /* binary - not all printfs() do this */ case 's': /* string */ @@ -2284,32 +2303,32 @@ static Jim_Obj *Jim_FormatString_Inner(Jim_Interp *interp, Jim_Obj *fmtObjPtr, /* non-terminals */ case '0': /* zero pad */ zpad = 1; - *fmt++; fmtLen--; + fmt++; fmtLen--; goto next_fmt; break; case '+': forceplus = 1; - *fmt++; fmtLen--; + fmt++; fmtLen--; goto next_fmt; break; case ' ': /* sign space */ spad = 1; - *fmt++; fmtLen--; + fmt++; fmtLen--; goto next_fmt; break; case '-': ljust = 1; - *fmt++; fmtLen--; + fmt++; fmtLen--; goto next_fmt; break; case '#': altfm = 1; - *fmt++; fmtLen--; + fmt++; fmtLen--; goto next_fmt; - + case '.': inprec = 1; - *fmt++; fmtLen--; + fmt++; fmtLen--; goto next_fmt; break; case '1': @@ -2322,11 +2341,11 @@ static Jim_Obj *Jim_FormatString_Inner(Jim_Interp *interp, Jim_Obj *fmtObjPtr, case '8': case '9': accum = 0; - while( isdigit(*fmt) && (fmtLen > 0) ){ + while ( isdigit(*fmt) && (fmtLen > 0) ){ accum = (accum * 10) + (*fmt - '0'); fmt++; fmtLen--; } - if( inprec ){ + if ( inprec ){ haveprec = 1; prec = accum; } else { @@ -2335,29 +2354,29 @@ static Jim_Obj *Jim_FormatString_Inner(Jim_Interp *interp, Jim_Obj *fmtObjPtr, goto next_fmt; case '*': /* suck up the next item as an integer */ - *fmt++; fmtLen--; + fmt++; fmtLen--; objc--; - if( objc <= 0 ){ + if ( objc <= 0 ){ goto not_enough_args; } - if( Jim_GetWide(interp,objv[0],&wideValue )== JIM_ERR ){ + if ( Jim_GetWide(interp,objv[0],&wideValue )== JIM_ERR ){ Jim_FreeNewObj(interp, resObjPtr ); return NULL; } - if( inprec ){ + if ( inprec ){ haveprec = 1; prec = wideValue; - if( prec < 0 ){ + if ( prec < 0 ){ /* man 3 printf says */ /* if prec is negative, it is zero */ prec = 0; } } else { - width = wideValue; - if( width < 0 ){ - ljust = 1; - width = -width; - } + width = wideValue; + if ( width < 0 ){ + ljust = 1; + width = -width; + } } objv++; goto next_fmt; @@ -2383,32 +2402,32 @@ static Jim_Obj *Jim_FormatString_Inner(Jim_Interp *interp, Jim_Obj *fmtObjPtr, */ cp = fmt_str; *cp++ = '%'; - if( altfm ){ + if ( altfm ){ *cp++ = '#'; } - if( forceplus ){ + if ( forceplus ){ *cp++ = '+'; - } else if( spad ){ + } else if ( spad ){ /* PLUS overrides */ *cp++ = ' '; } - if( ljust ){ + if ( ljust ){ *cp++ = '-'; } - if( zpad ){ + if ( zpad ){ *cp++ = '0'; } - if( width > 0 ){ + if ( width > 0 ){ sprintf( cp, "%d", width ); /* skip ahead */ cp = strchr(cp,0); } /* did we find a period? */ - if( inprec ){ + if ( inprec ){ /* then add it */ *cp++ = '.'; /* did something occur after the period? */ - if( haveprec ){ + if ( haveprec ){ sprintf( cp, "%d", prec ); } cp = strchr(cp,0); @@ -2417,7 +2436,7 @@ static Jim_Obj *Jim_FormatString_Inner(Jim_Interp *interp, Jim_Obj *fmtObjPtr, /* here we do the work */ /* actually - we make sprintf() do it for us */ - switch(*fmt) { + switch (*fmt) { case 's': *cp++ = 's'; *cp = 0; @@ -2442,7 +2461,7 @@ static Jim_Obj *Jim_FormatString_Inner(Jim_Interp *interp, Jim_Obj *fmtObjPtr, case 'E': *cp++ = *fmt; *cp = 0; - if( Jim_GetDouble( interp, objv[0], &doubleValue ) == JIM_ERR ){ + if ( Jim_GetDouble( interp, objv[0], &doubleValue ) == JIM_ERR ){ Jim_FreeNewObj( interp, resObjPtr ); return NULL; } @@ -2450,12 +2469,13 @@ static Jim_Obj *Jim_FormatString_Inner(Jim_Interp *interp, Jim_Obj *fmtObjPtr, break; case 'b': case 'd': + case 'o': case 'i': case 'u': case 'x': case 'X': /* jim widevaluse are 64bit */ - if( sizeof(jim_wide) == sizeof(long long) ){ + if ( sizeof(jim_wide) == sizeof(long long) ){ *cp++ = 'l'; *cp++ = 'l'; } else { @@ -2501,8 +2521,8 @@ static Jim_Obj *Jim_FormatString_Inner(Jim_Interp *interp, Jim_Obj *fmtObjPtr, Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_Obj *const *objv) { - char *sprintf_buf=malloc(JIM_MAX_FMT); - Jim_Obj *t=Jim_FormatString_Inner(interp, fmtObjPtr, objc, objv, sprintf_buf); + char *sprintf_buf = malloc(JIM_MAX_FMT); + Jim_Obj *t = Jim_FormatString_Inner(interp, fmtObjPtr, objc, objv, sprintf_buf); free(sprintf_buf); return t; } @@ -2586,11 +2606,11 @@ int Jim_GetEnum(Jim_Interp *interp, Jim_Obj *objPtr, memcpy(tablePtrSorted, tablePtr, sizeof(char*)*count); qsort(tablePtrSorted, count, sizeof(char*), qsortCompareStringPointers); for (i = 0; i < count; i++) { - if (i+1 == count && count > 1) + if (i + 1 == count && count > 1) Jim_AppendString(interp, Jim_GetResult(interp), "or ", -1); Jim_AppendString(interp, Jim_GetResult(interp), tablePtrSorted[i], -1); - if (i+1 != count) + if (i + 1 != count) Jim_AppendString(interp, Jim_GetResult(interp), ", ", -1); } Jim_Free(tablePtrSorted); @@ -2607,12 +2627,12 @@ int Jim_GetNvp(Jim_Interp *interp, int e; e = Jim_Nvp_name2value_obj( interp, nvp_table, objPtr, &n ); - if( e == JIM_ERR ){ + if ( e == JIM_ERR ){ return e; } /* Success? found? */ - if( n->name ){ + if ( n->name ){ /* remove const */ *result = (Jim_Nvp *)n; return JIM_OK; @@ -2868,7 +2888,7 @@ static void ScriptObjAddToken(Jim_Interp *interp, struct ScriptObj *script, script->token = Jim_Realloc(script->token, sizeof(ScriptToken)*script->len); /* Initialize the new token */ - token = script->token+(script->len-1); + 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 @@ -3004,12 +3024,12 @@ int SetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr) initialLineNumber = objPtr->internalRep.sourceValue.lineNumber; propagateSourceInfo = 1; } else { - script->fileName = Jim_StrDup("?"); + script->fileName = Jim_StrDup(""); initialLineNumber = 1; } JimParserInit(&parser, scriptText, scriptTextLen, initialLineNumber); - while(!JimParserEof(&parser)) { + while (!JimParserEof(&parser)) { char *token; int len, type, linenr; @@ -3040,8 +3060,8 @@ int SetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr) 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 && + token[end + 1].type != JIM_TT_SEP && + token[end + 1].type != JIM_TT_EOL && (!strcmp(token[end].objPtr->bytes, "expand") || !strcmp(token[end].objPtr->bytes, "*"))) expand++; @@ -3050,7 +3070,7 @@ int SetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr) args++; end++; } - interpolation = !((end-start+1) == args*2); + interpolation = !((end-start + 1) == args*2); /* Add the 'number of arguments' info into cmdstruct. * Negative value if there is list expansion involved. */ if (expand) @@ -3156,9 +3176,6 @@ int Jim_CreateCommand(Jim_Interp *interp, const char *cmdName, he = Jim_FindHashEntry(&interp->commands, cmdName); if (he == NULL) { /* New command to create */ cmdPtr = Jim_Alloc(sizeof(*cmdPtr)); - cmdPtr->cmdProc = cmdProc; - cmdPtr->privData = privData; - cmdPtr->delProc = delProc; Jim_AddHashEntry(&interp->commands, cmdName, cmdPtr); } else { Jim_InterpIncrProcEpoch(interp); @@ -3176,9 +3193,13 @@ int Jim_CreateCommand(Jim_Interp *interp, const char *cmdName, /* If it was a C coded command, call the delProc if any */ cmdPtr->delProc(interp, cmdPtr->privData); } - cmdPtr->cmdProc = cmdProc; - cmdPtr->privData = privData; } + + /* Store the new details for this proc */ + cmdPtr->delProc = delProc; + 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. */ @@ -3208,7 +3229,7 @@ int Jim_CreateProcedure(Jim_Interp *interp, const char *cmdName, Jim_ListLength(interp, staticsListObjPtr, &len); if (len != 0) { cmdPtr->staticVars = Jim_Alloc(sizeof(Jim_HashTable)); - Jim_InitHashTable(cmdPtr->staticVars, &JimVariablesHashTableType, + Jim_InitHashTable(cmdPtr->staticVars, getJimVariablesHashTableType(), interp); for (i = 0; i < len; i++) { Jim_Obj *objPtr, *initObjPtr, *nameObjPtr; @@ -3411,6 +3432,11 @@ static Jim_HashTableType JimVariablesHashTableType = { JimVariablesHTValDestructor /* val destructor */ }; +static Jim_HashTableType *getJimVariablesHashTableType(void) +{ + return &JimVariablesHashTableType; +} + /* ----------------------------------------------------------------------------- * Variable object * ---------------------------------------------------------------------------*/ @@ -3458,14 +3484,22 @@ int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr) /* 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) { - /* Try with static vars. */ - if (interp->framePtr->staticVars == NULL) - return JIM_ERR; - if (!(he = Jim_FindHashEntry(interp->framePtr->staticVars, varName))) + if (varName[0] == ':' && varName[1] == ':') { + he = Jim_FindHashEntry(&interp->topFramePtr->vars, varName + 2); + if (he == NULL) { return JIM_ERR; + } + } + else { + /* Lookup this name into the variables hash table */ + he = Jim_FindHashEntry(&interp->framePtr->vars, varName); + if (he == NULL) { + /* Try with static vars. */ + if (interp->framePtr->staticVars == NULL) + return JIM_ERR; + if (!(he = Jim_FindHashEntry(interp->framePtr->staticVars, varName))) + return JIM_ERR; + } } /* Free the old internal repr and set the new one. */ Jim_FreeIntRep(interp, objPtr); @@ -3504,7 +3538,13 @@ int Jim_SetVariable(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr) Jim_IncrRefCount(valObjPtr); var->linkFramePtr = NULL; /* Insert the new variable */ - Jim_AddHashEntry(&interp->framePtr->vars, name, var); + if (name[0] == ':' && name[1] == ':') { + /* Into to the top evel frame */ + Jim_AddHashEntry(&interp->topFramePtr->vars, name + 2, var); + } + else { + Jim_AddHashEntry(&interp->framePtr->vars, name, var); + } /* Make the object int rep a variable */ Jim_FreeIntRep(interp, nameObjPtr); nameObjPtr->typePtr = &variableObjType; @@ -3581,7 +3621,7 @@ int Jim_SetVariableLink(Jim_Interp *interp, Jim_Obj *nameObjPtr, Jim_Obj *objPtr = targetNameObjPtr; Jim_Var *varPtr; /* Cycles are only possible with 'uplevel 0' */ - while(1) { + while (1) { if (Jim_StringEqObj(objPtr, nameObjPtr, 0)) { Jim_SetResultString(interp, "can't upvar from variable to itself", -1); @@ -3756,15 +3796,15 @@ static void JimDictSugarParseVarKey(Jim_Interp *interp, Jim_Obj *objPtr, str = Jim_GetString(objPtr, &len); p = strchr(str, '('); p++; - keyLen = len-((p-str)+1); + keyLen = len-((p-str) + 1); nameLen = (p-str)-1; /* Create the objects with the variable name and key. */ - t = Jim_Alloc(nameLen+1); + t = Jim_Alloc(nameLen + 1); memcpy(t, str, nameLen); t[nameLen] = '\0'; varObjPtr = Jim_NewStringObjNoAlloc(interp, t, nameLen); - t = Jim_Alloc(keyLen+1); + t = Jim_Alloc(keyLen + 1); memcpy(t, p, keyLen); t[keyLen] = '\0'; keyObjPtr = Jim_NewStringObjNoAlloc(interp, t, keyLen); @@ -4038,13 +4078,13 @@ static Jim_ObjType referenceObjType = { void UpdateStringOfReference(struct Jim_Obj *objPtr) { int len; - char buf[JIM_REFERENCE_SPACE+1]; + char buf[JIM_REFERENCE_SPACE + 1]; Jim_Reference *refPtr; refPtr = objPtr->internalRep.refValue.refPtr; len = JimFormatReference(buf, refPtr, objPtr->internalRep.refValue.id); - objPtr->bytes = Jim_Alloc(len+1); - memcpy(objPtr->bytes, buf, len+1); + objPtr->bytes = Jim_Alloc(len + 1); + memcpy(objPtr->bytes, buf, len + 1); objPtr->length = len; } @@ -4072,19 +4112,19 @@ int SetReferenceFromAny(Jim_Interp *interp, Jim_Obj *objPtr) if (len < JIM_REFERENCE_SPACE) goto badformat; /* Trim spaces */ start = str; - end = str+len-1; + end = str + len-1; while (*start == ' ') start++; while (*end == ' ' && end > start) end--; - if (end-start+1 != JIM_REFERENCE_SPACE) goto badformat; + if (end-start + 1 != JIM_REFERENCE_SPACE) goto badformat; /* .%020> */ if (memcmp(start, "liveList; - while(objPtr) { + while (objPtr) { if (objPtr->typePtr == NULL || objPtr->typePtr->flags & JIM_TYPE_REFERENCES) { const char *str, *p; @@ -4251,7 +4291,7 @@ int Jim_Collect(Jim_Interp *interp) continue; } /* Extract references from the object string repr. */ - while(1) { + while (1) { int i; jim_wide id; char buf[21]; @@ -4265,7 +4305,7 @@ int Jim_Collect(Jim_Interp *interp) if (!isdigit((int)p[i])) break; /* Get the ID */ - memcpy(buf, p+21, 20); + memcpy(buf, p + 21, 20); buf[20] = '\0'; Jim_StringToWide(buf, &id, 10); @@ -4300,7 +4340,7 @@ int Jim_Collect(Jim_Interp *interp) * finalizer first if registered. */ refPtr = he->val; if (refPtr->finalizerCmdNamePtr) { - char *refstr = Jim_Alloc(JIM_REFERENCE_SPACE+1); + char *refstr = Jim_Alloc(JIM_REFERENCE_SPACE + 1); Jim_Obj *objv[3], *oldResult; JimFormatReference(refstr, refPtr, *refId); @@ -4405,6 +4445,7 @@ Jim_Interp *Jim_CreateInterp(void) i->result = i->emptyObj; i->stackTrace = Jim_NewListObj(i, NULL, 0); i->unknown = Jim_NewStringObj(i, "unknown", -1); + i->unknown_called = 0; Jim_IncrRefCount(i->emptyObj); Jim_IncrRefCount(i->result); Jim_IncrRefCount(i->stackTrace); @@ -4447,7 +4488,7 @@ void Jim_FreeInterp(Jim_Interp *i) Jim_FreeHashTable(&i->packages); Jim_Free(i->prngState); /* Free the call frames list */ - while(cf) { + while (cf) { prevcf = cf->parentCallFrame; JimFreeCallFrame(i, cf, JIM_FCF_NONE); cf = prevcf; @@ -4459,7 +4500,7 @@ void Jim_FreeInterp(Jim_Interp *i) Jim_fprintf( i, i->cookie_stdout,JIM_NL "-------------------------------------" JIM_NL); Jim_fprintf( i, i->cookie_stdout,"Objects still in the free list:" JIM_NL); - while(objPtr) { + while (objPtr) { const char *type = objPtr->typePtr ? objPtr->typePtr->name : ""; Jim_fprintf( i, i->cookie_stdout,"%p \"%-10s\": '%.20s' (refCount: %d)" JIM_NL, @@ -4485,7 +4526,7 @@ void Jim_FreeInterp(Jim_Interp *i) } /* Free cached CallFrame structures */ cf = i->freeFramesList; - while(cf) { + while (cf) { nextcf = cf->nextFramePtr; if (cf->vars.table != NULL) Jim_Free(cf->vars.table); @@ -4534,7 +4575,7 @@ int Jim_GetCallFrameByLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr, return JIM_OK; } - level = strtol(str+1, &endptr, 0); + level = strtol(str + 1, &endptr, 0); if (str[1] == '\0' || endptr[0] != '\0' || level < 0) goto badlevel; /* An 'absolute' level is converted into the @@ -4619,6 +4660,11 @@ static void JimResetStackTrace(Jim_Interp *interp) static void JimAppendStackTrace(Jim_Interp *interp, const char *procname, const char *filename, int linenr) { + /* No need to add this dummy entry to the stack trace */ + if (strcmp(procname, "unknown") == 0) { + return; + } + if (Jim_IsShared(interp->stackTrace)) { interp->stackTrace = Jim_DuplicateObj(interp, interp->stackTrace); @@ -4746,11 +4792,11 @@ static Jim_ObjType intObjType = { void UpdateStringOfInt(struct Jim_Obj *objPtr) { int len; - char buf[JIM_INTEGER_SPACE+1]; + 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->bytes = Jim_Alloc(len + 1); + memcpy(objPtr->bytes, buf, len + 1); objPtr->length = len; } @@ -4858,11 +4904,11 @@ static Jim_ObjType doubleObjType = { void UpdateStringOfDouble(struct Jim_Obj *objPtr) { int len; - char buf[JIM_DOUBLE_SPACE+1]; + 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->bytes = Jim_Alloc(len + 1); + memcpy(objPtr->bytes, buf, len + 1); objPtr->length = len; } @@ -4984,7 +5030,7 @@ static int ListElementQuotingType(const char *s, int len) goto testbrace; } for (i = 0; i < len; i++) { - switch(s[i]) { + switch (s[i]) { case ' ': case '$': case '"': @@ -5011,23 +5057,23 @@ testbrace: s[len-1] == ']') return JIM_ELESTR_QUOTE; level = 0; for (i = 0; i < len; i++) { - switch(s[i]) { + switch (s[i]) { case '{': level++; break; case '}': level--; if (level < 0) return JIM_ELESTR_QUOTE; break; case '\\': - if (s[i+1] == '\n') + if (s[i + 1] == '\n') return JIM_ELESTR_QUOTE; else - if (s[i+1] != '\0') i++; + 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]) { + switch (s[i]) { case ' ': case '$': case '"': @@ -5053,10 +5099,10 @@ testbrace: * using backslash to quote special chars. */ char *BackslashQuoteString(const char *s, int len, int *qlenPtr) { - char *q = Jim_Alloc(len*2+1), *p; + char *q = Jim_Alloc(len*2 + 1), *p; p = q; - while(*s) { + while (*s) { switch (*s) { case ' ': case '$': @@ -5094,7 +5140,7 @@ void UpdateStringOfList(struct Jim_Obj *objPtr) Jim_Obj **ele = objPtr->internalRep.listValue.ele; /* (Over) Estimate the space needed. */ - quotingType = Jim_Alloc(sizeof(int)*objPtr->internalRep.listValue.len+1); + quotingType = Jim_Alloc(sizeof(int)*objPtr->internalRep.listValue.len + 1); bufLen = 0; for (i = 0; i < objPtr->internalRep.listValue.len; i++) { int len; @@ -5103,7 +5149,7 @@ void UpdateStringOfList(struct Jim_Obj *objPtr) 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_BRACE: bufLen += len + 2; break; case JIM_ELESTR_QUOTE: bufLen += len*2; break; } bufLen++; /* elements separator. */ @@ -5111,14 +5157,14 @@ void UpdateStringOfList(struct Jim_Obj *objPtr) bufLen++; /* Generate the string rep. */ - p = objPtr->bytes = Jim_Alloc(bufLen+1); + p = objPtr->bytes = Jim_Alloc(bufLen + 1); realLength = 0; for (i = 0; i < objPtr->internalRep.listValue.len; i++) { int len, qlen; const char *strRep = Jim_GetString(ele[i], &len); char *q; - switch(quotingType[i]) { + switch (quotingType[i]) { case JIM_ELESTR_SIMPLE: memcpy(p, strRep, len); p += len; @@ -5129,7 +5175,7 @@ void UpdateStringOfList(struct Jim_Obj *objPtr) memcpy(p, strRep, len); p += len; *p++ = '}'; - realLength += len+2; + realLength += len + 2; break; case JIM_ELESTR_QUOTE: q = BackslashQuoteString(strRep, len, &qlen); @@ -5140,7 +5186,7 @@ void UpdateStringOfList(struct Jim_Obj *objPtr) break; } /* Add a separating space */ - if (i+1 != objPtr->internalRep.listValue.len) { + if (i + 1 != objPtr->internalRep.listValue.len) { *p++ = ' '; realLength ++; } @@ -5169,7 +5215,7 @@ int SetListFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr) /* Convert into a list */ JimParserInit(&parser, str, strLen, 1); - while(!JimParserEof(&parser)) { + while (!JimParserEof(&parser)) { char *token; int tokenLen, type; Jim_Obj *elementPtr; @@ -5319,8 +5365,8 @@ void ListInsertElements(Jim_Obj *listPtr, int index, int elemc, listPtr->internalRep.listValue.maxLen = maxLen; } point = listPtr->internalRep.listValue.ele + index; - memmove(point+elemc, point, (currentLen-index) * sizeof(Jim_Obj*)); - for (i=0; i < elemc; ++i) { + memmove(point + elemc, point, (currentLen-index) * sizeof(Jim_Obj*)); + for (i = 0; i < elemc; ++i) { point[i] = elemVec[i]; Jim_IncrRefCount(point[i]); } @@ -5345,7 +5391,7 @@ void ListAppendList(Jim_Obj *listPtr, Jim_Obj *appendListPtr) } for (i = 0; i < appendLen; i++) { Jim_Obj *objPtr = appendListPtr->internalRep.listValue.ele[i]; - listPtr->internalRep.listValue.ele[oldLen+i] = objPtr; + listPtr->internalRep.listValue.ele[oldLen + i] = objPtr; Jim_IncrRefCount(objPtr); } listPtr->internalRep.listValue.len += appendLen; @@ -5407,7 +5453,7 @@ int Jim_ListIndex(Jim_Interp *interp, Jim_Obj *listPtr, int index, return JIM_ERR; } if (index < 0) - index = listPtr->internalRep.listValue.len+index; + index = listPtr->internalRep.listValue.len + index; *objPtrPtr = listPtr->internalRep.listValue.ele[index]; return JIM_OK; } @@ -5426,7 +5472,7 @@ static int ListSetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int index, return JIM_ERR; } if (index < 0) - index = listPtr->internalRep.listValue.len+index; + index = listPtr->internalRep.listValue.len + index; Jim_DecrRefCount(interp, listPtr->internalRep.listValue.ele[index]); listPtr->internalRep.listValue.ele[index] = newObjPtr; Jim_IncrRefCount(newObjPtr); @@ -5506,7 +5552,7 @@ Jim_Obj *Jim_ConcatObj(Jim_Interp *interp, int objc, Jim_Obj *const *objv) } if (objc) len += objc-1; /* Create the string rep, and a stinrg object holding it. */ - p = bytes = Jim_Alloc(len+1); + p = bytes = Jim_Alloc(len + 1); for (i = 0; i < objc; i++) { const char *s = Jim_GetString(objv[i], &objLen); while (objLen && (*s == ' ' || *s == '\t' || *s == '\n')) @@ -5519,9 +5565,9 @@ Jim_Obj *Jim_ConcatObj(Jim_Interp *interp, int objc, Jim_Obj *const *objv) } memcpy(p, s, objLen); p += objLen; - if (objLen && i+1 != objc) { + if (objLen && i + 1 != objc) { *p++ = ' '; - } else if (i+1 != objc) { + } else if (i + 1 != objc) { /* Drop the space calcuated for this * element that is instead null. */ len--; @@ -5548,7 +5594,7 @@ Jim_Obj *Jim_ListRange(Jim_Interp *interp, Jim_Obj *listObjPtr, Jim_Obj *firstOb last = JimRelToAbsIndex(len, last); JimRelToAbsRange(len, first, last, &first, &last, &rangeLen); return Jim_NewListObj(interp, - listObjPtr->internalRep.listValue.ele+first, rangeLen); + listObjPtr->internalRep.listValue.ele + first, rangeLen); } /* ----------------------------------------------------------------------------- @@ -5678,7 +5724,7 @@ void UpdateStringOfDict(struct Jim_Obj *objPtr) 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_BRACE: bufLen += len + 2; break; case JIM_ELESTR_QUOTE: bufLen += len*2; break; } bufLen++; /* elements separator. */ @@ -5686,14 +5732,14 @@ void UpdateStringOfDict(struct Jim_Obj *objPtr) bufLen++; /* Generate the string rep. */ - p = objPtr->bytes = Jim_Alloc(bufLen+1); + p = objPtr->bytes = Jim_Alloc(bufLen + 1); realLength = 0; for (i = 0; i < objc; i++) { int len, qlen; const char *strRep = Jim_GetString(objv[i], &len); char *q; - switch(quotingType[i]) { + switch (quotingType[i]) { case JIM_ELESTR_SIMPLE: memcpy(p, strRep, len); p += len; @@ -5704,7 +5750,7 @@ void UpdateStringOfDict(struct Jim_Obj *objPtr) memcpy(p, strRep, len); p += len; *p++ = '}'; - realLength += len+2; + realLength += len + 2; break; case JIM_ELESTR_QUOTE: q = BackslashQuoteString(strRep, len, &qlen); @@ -5715,7 +5761,7 @@ void UpdateStringOfDict(struct Jim_Obj *objPtr) break; } /* Add a separating space */ - if (i+1 != objc) { + if (i + 1 != objc) { *p++ = ' '; realLength ++; } @@ -5748,7 +5794,7 @@ int SetDictFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr) /* Convert into a dict */ JimParserInit(&parser, str, strLen, 1); i = 0; - while(!JimParserEof(&parser)) { + while (!JimParserEof(&parser)) { char *token; int tokenLen, type; @@ -5840,7 +5886,7 @@ Jim_Obj *Jim_NewDictObj(Jim_Interp *interp, Jim_Obj *const *elements, int len) objPtr->internalRep.ptr = Jim_Alloc(sizeof(Jim_HashTable)); Jim_InitHashTable(objPtr->internalRep.ptr, &JimDictHashTableType, interp); for (i = 0; i < len; i += 2) - DictAddElement(interp, objPtr, elements[i], elements[i+1]); + DictAddElement(interp, objPtr, elements[i], elements[i + 1]); return objPtr; } @@ -5873,7 +5919,7 @@ int Jim_DictKey(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj *keyPtr, int Jim_DictKeysVector(Jim_Interp *interp, Jim_Obj *dictPtr, Jim_Obj *const *keyv, int keyc, Jim_Obj **objPtrPtr, int flags) { - Jim_Obj *objPtr; + Jim_Obj *objPtr = NULL; int i; if (keyc == 0) { @@ -5979,17 +6025,17 @@ static Jim_ObjType indexObjType = { void UpdateStringOfIndex(struct Jim_Obj *objPtr) { int len; - char buf[JIM_INTEGER_SPACE+1]; + 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); + len = sprintf(buf, "end%d", objPtr->internalRep.indexValue + 1); } - objPtr->bytes = Jim_Alloc(len+1); - memcpy(objPtr->bytes, buf, len+1); + objPtr->bytes = Jim_Alloc(len + 1); + memcpy(objPtr->bytes, buf, len + 1); objPtr->length = len; } @@ -6021,7 +6067,7 @@ int SetIndexFromAny(Jim_Interp *interp, Jim_Obj *objPtr) if (index < 0) index = INT_MAX; else - index = -(index+1); + index = -(index + 1); } else if (!end && index < 0) index = -INT_MAX; /* Free the old internal repr and set the new one. */ @@ -6230,11 +6276,11 @@ static struct Jim_ExprOperator Jim_ExprOperators[] = { int JimParseExpression(struct JimParserCtx *pc) { /* Discard spaces and quoted newline */ - while(*(pc->p) == ' ' || + while (*(pc->p) == ' ' || *(pc->p) == '\t' || *(pc->p) == '\r' || *(pc->p) == '\n' || - (*(pc->p) == '\\' && *(pc->p+1) == '\n')) { + (*(pc->p) == '\\' && *(pc->p + 1) == '\n')) { pc->p++; pc->len--; } @@ -6245,7 +6291,7 @@ int JimParseExpression(struct JimParserCtx *pc) pc->eof = 1; return JIM_OK; } - switch(*(pc->p)) { + switch (*(pc->p)) { case '(': pc->tstart = pc->tend = pc->p; pc->tline = pc->linenr; @@ -6269,7 +6315,7 @@ int JimParseExpression(struct JimParserCtx *pc) break; case '-': if ((pc->tt == JIM_TT_NONE || pc->tt == JIM_TT_EXPR_OPERATOR) && - isdigit((int)*(pc->p+1))) + isdigit((int)*(pc->p + 1))) return JimParseExprNumber(pc); else return JimParseExprOperator(pc); @@ -6320,7 +6366,7 @@ int JimParseExprNumber(struct JimParserCtx *pc) if (*pc->p == '.') allowdot = 0; pc->p++; pc->len--; - if (!allowdot && *pc->p == 'e' && *(pc->p+1) == '-') { + if (!allowdot && *pc->p == 'e' && *(pc->p + 1) == '-') { pc->p += 2; pc->len -= 2; } } @@ -6444,8 +6490,8 @@ void DupExprInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr) static void ExprObjAddInstr(Jim_Interp *interp, ExprByteCode *expr, 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 = 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]); @@ -6462,7 +6508,7 @@ static int ExprCheckCorrectness(ExprByteCode *expr) * 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]) { + switch (expr->opcode[i]) { case JIM_EXPROP_NUMBER: case JIM_EXPROP_STRING: case JIM_EXPROP_SUBST: @@ -6577,8 +6623,8 @@ static void ExprMakeLazy(Jim_Interp *interp, ExprByteCode *expr) /* Search for the end of the first operator */ leftindex = index-1; arity = 1; - while(arity) { - switch(expr->opcode[leftindex]) { + while (arity) { + switch (expr->opcode[leftindex]) { case JIM_EXPROP_NUMBER: case JIM_EXPROP_COMMAND: case JIM_EXPROP_VARIABLE: @@ -6587,7 +6633,7 @@ static void ExprMakeLazy(Jim_Interp *interp, ExprByteCode *expr) case JIM_EXPROP_STRING: break; default: - op = JimExprOperatorInfoByOpcode(expr->opcode[i]); + op = JimExprOperatorInfoByOpcode(expr->opcode[leftindex]); if (op == NULL) { Jim_Panic(interp,"Default reached in ExprMakeLazy()"); } @@ -6598,32 +6644,32 @@ static void ExprMakeLazy(Jim_Interp *interp, ExprByteCode *expr) leftindex--; } leftindex++; - expr->opcode = Jim_Realloc(expr->opcode, sizeof(int)*(expr->len+2)); - expr->obj = Jim_Realloc(expr->obj, sizeof(Jim_Obj*)*(expr->len+2)); - memmove(&expr->opcode[leftindex+2], &expr->opcode[leftindex], + expr->opcode = Jim_Realloc(expr->opcode, sizeof(int)*(expr->len + 2)); + expr->obj = Jim_Realloc(expr->obj, sizeof(Jim_Obj*)*(expr->len + 2)); + memmove(&expr->opcode[leftindex + 2], &expr->opcode[leftindex], sizeof(int)*(expr->len-leftindex)); - memmove(&expr->obj[leftindex+2], &expr->obj[leftindex], + memmove(&expr->obj[leftindex + 2], &expr->obj[leftindex], sizeof(Jim_Obj*)*(expr->len-leftindex)); expr->len += 2; index += 2; offset = (index-leftindex)-1; Jim_DecrRefCount(interp, expr->obj[index]); if (expr->opcode[index] == JIM_EXPROP_LOGICAND) { - expr->opcode[leftindex+1] = JIM_EXPROP_LOGICAND_LEFT; + expr->opcode[leftindex + 1] = JIM_EXPROP_LOGICAND_LEFT; expr->opcode[index] = JIM_EXPROP_LOGICAND_RIGHT; - expr->obj[leftindex+1] = Jim_NewStringObj(interp, "&L", -1); + expr->obj[leftindex + 1] = Jim_NewStringObj(interp, "&L", -1); expr->obj[index] = Jim_NewStringObj(interp, "&R", -1); } else { - expr->opcode[leftindex+1] = JIM_EXPROP_LOGICOR_LEFT; + expr->opcode[leftindex + 1] = JIM_EXPROP_LOGICOR_LEFT; expr->opcode[index] = JIM_EXPROP_LOGICOR_RIGHT; - expr->obj[leftindex+1] = Jim_NewStringObj(interp, "|L", -1); + expr->obj[leftindex + 1] = Jim_NewStringObj(interp, "|L", -1); expr->obj[index] = Jim_NewStringObj(interp, "|R", -1); } expr->opcode[leftindex] = JIM_EXPROP_NUMBER; expr->obj[leftindex] = Jim_NewIntObj(interp, offset); Jim_IncrRefCount(expr->obj[index]); Jim_IncrRefCount(expr->obj[leftindex]); - Jim_IncrRefCount(expr->obj[leftindex+1]); + Jim_IncrRefCount(expr->obj[leftindex + 1]); } } @@ -6651,7 +6697,7 @@ int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr) Jim_InitStack(&stack); JimParserInit(&parser, exprText, exprTextLen, 1); - while(!JimParserEof(&parser)) { + while (!JimParserEof(&parser)) { char *token; int len, type; @@ -6664,7 +6710,7 @@ int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr) Jim_Free(token); break; } - switch(type) { + switch (type) { case JIM_TT_STR: ExprObjAddInstr(interp, expr, JIM_EXPROP_STRING, token, len); break; @@ -6685,7 +6731,7 @@ int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr) break; case JIM_TT_EXPR_OPERATOR: op = JimExprOperatorInfo(token); - while(1) { + while (1) { Jim_ExprOperator *stackTopOp; if (Jim_StackPeek(&stack) != NULL) { @@ -6712,7 +6758,7 @@ int SetExprFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr) case JIM_TT_SUBEXPR_END: { int found = 0; - while(Jim_StackLen(&stack)) { + while (Jim_StackLen(&stack)) { char *opstr = Jim_StackPop(&stack); if (!strcmp(opstr, "(")) { Jim_Free(opstr); @@ -6903,21 +6949,21 @@ int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr, } Jim_DecrRefCount(interp, A); Jim_DecrRefCount(interp, B); - switch(expr->opcode[i]) { - case JIM_EXPROP_ADD: wC = wA+wB; break; + 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 = wAwB; 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_NUMEQ: wC = wA==wB; break; - case JIM_EXPROP_NUMNE: 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_BITOR: wC = wA | wB; break; case JIM_EXPROP_POW: wC = JimPowWide(wA,wB); break; case JIM_EXPROP_LOGICAND_LEFT: if (wA == 0) { @@ -6950,7 +6996,7 @@ int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr, wC = _rotl(uA,(unsigned long)wB); #else const unsigned int S = sizeof(unsigned long) * 8; - wC = (unsigned long)((uA<>(S-wB))); + wC = (unsigned long)((uA << wB) | (uA >> (S-wB))); #endif break; } @@ -6960,7 +7006,7 @@ int Jim_EvalExpression(Jim_Interp *interp, Jim_Obj *exprObjPtr, wC = _rotr(uA,(unsigned long)wB); #else const unsigned int S = sizeof(unsigned long) * 8; - wC = (unsigned long)((uA>>wB)|(uA<<(S-wB))); + wC = (unsigned long)((uA >> wB) | (uA << (S-wB))); #endif break; } @@ -6977,6 +7023,16 @@ trydouble: /* --- Double --- */ if (Jim_GetDouble(interp, A, &dA) != JIM_OK || Jim_GetDouble(interp, B, &dB) != JIM_OK) { + + /* Hmmm! For compatibility, maybe convert != and == into ne and eq */ + if (expr->opcode[i] == JIM_EXPROP_NUMNE) { + opcode = JIM_EXPROP_STRNE; + goto retry_as_string; + } + else if (expr->opcode[i] == JIM_EXPROP_NUMEQ) { + opcode = JIM_EXPROP_STREQ; + goto retry_as_string; + } Jim_DecrRefCount(interp, A); Jim_DecrRefCount(interp, B); error = 1; @@ -6984,7 +7040,7 @@ trydouble: } Jim_DecrRefCount(interp, A); Jim_DecrRefCount(interp, B); - switch(expr->opcode[i]) { + switch (expr->opcode[i]) { case JIM_EXPROP_ROTL: case JIM_EXPROP_ROTR: case JIM_EXPROP_LSHIFT: @@ -6999,15 +7055,15 @@ trydouble: error = 1; goto err; break; - case JIM_EXPROP_ADD: dC = dA+dB; 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 = dAdB; 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_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_LEFT: if (dA == 0) { i += (int)dB; @@ -7038,9 +7094,10 @@ trydouble: } else if (opcode == JIM_EXPROP_STREQ || opcode == JIM_EXPROP_STRNE) { B = stack[--stacklen]; A = stack[--stacklen]; +retry_as_string: sA = Jim_GetString(A, &Alen); sB = Jim_GetString(B, &Blen); - switch(expr->opcode[i]) { + switch (opcode) { case JIM_EXPROP_STREQ: if (Alen == Blen && memcmp(sA, sB, Alen) ==0) wC = 1; @@ -7077,7 +7134,7 @@ trydouble: goto trydouble_unary; } Jim_DecrRefCount(interp, A); - switch(expr->opcode[i]) { + switch (expr->opcode[i]) { case JIM_EXPROP_NOT: wC = !wA; break; case JIM_EXPROP_BITNOT: wC = ~wA; break; case JIM_EXPROP_LOGICAND_RIGHT: @@ -7098,7 +7155,7 @@ trydouble_unary: goto err; } Jim_DecrRefCount(interp, A); - switch(expr->opcode[i]) { + switch (expr->opcode[i]) { case JIM_EXPROP_NOT: dC = !dA; break; case JIM_EXPROP_LOGICAND_RIGHT: case JIM_EXPROP_LOGICOR_RIGHT: dC = (dA != 0); break; @@ -7278,7 +7335,7 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr) Jim_FreeIntRep(interp, objPtr); /* Count how many conversions could take place maximally */ - for (i=0, maxCount=0; i < maxFmtLen; ++i) + for (i = 0, maxCount = 0; i < maxFmtLen; ++i) if (fmt[i] == '%') ++maxCount; /* Calculate an approximation of the memory necessary */ @@ -7293,14 +7350,14 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr) memset(fmtObj, 0, approxSize); fmtObj->size = approxSize; fmtObj->maxPos = 0; - fmtObj->scratch = (char*)&fmtObj->descr[maxCount+1]; + fmtObj->scratch = (char*)&fmtObj->descr[maxCount + 1]; fmtObj->stringRep = fmtObj->scratch + maxFmtLen + 3 + 1; memcpy(fmtObj->stringRep, fmt, maxFmtLen); buffer = fmtObj->stringRep + maxFmtLen + 1; objPtr->internalRep.ptr = fmtObj; objPtr->typePtr = &scanFmtStringObjType; - for (i=0, curr=0; fmt < fmtEnd; ++fmt) { - int width=0, skip; + for (i = 0, curr = 0; fmt < fmtEnd; ++fmt) { + int width = 0, skip; ScanFmtPartDescr *descr = &fmtObj->descr[curr]; fmtObj->count++; descr->width = 0; /* Assume width unspecified */ @@ -7344,7 +7401,7 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr) return JIM_ERR; } /* Look if this position was already used */ - for (prev=0; prev < curr; ++prev) { + for (prev = 0; prev < curr; ++prev) { if (fmtObj->descr[prev].pos == -1) continue; if (fmtObj->descr[prev].pos == descr->pos) { fmtObj->error = "same \"%n$\" conversion specifier " @@ -7385,11 +7442,11 @@ static int SetScanFmtFromAny(Jim_Interp *interp, Jim_Obj *objPtr) /* In case a range fence was given "backwards", swap it */ while (swapped) { swapped = 0; - for (j=beg+1; j < end-1; ++j) { - if (buffer[j] == '-' && buffer[j-1] > buffer[j+1]) { + for (j = beg + 1; j < end-1; ++j) { + if (buffer[j] == '-' && buffer[j-1] > buffer[j + 1]) { char tmp = buffer[j-1]; - buffer[j-1] = buffer[j+1]; - buffer[j+1] = tmp; + buffer[j-1] = buffer[j + 1]; + buffer[j + 1] = tmp; swapped = 1; } } @@ -7468,8 +7525,8 @@ JimScanAString(Jim_Interp *interp, const char *sdescr, const char *str) { size_t i; Jim_Obj *result; - char charset[256/8+1]; /* A Charset may contain max 256 chars */ - char *buffer = Jim_Alloc(strlen(str)+1), *anchor = buffer; + char charset[256/8 + 1]; /* A Charset may contain max 256 chars */ + char *buffer = Jim_Alloc(strlen(str) + 1), *anchor = buffer; /* First init charset to nothing or all, depending if a specified * or an unspecified string has to be parsed */ @@ -7493,7 +7550,7 @@ JimScanAString(Jim_Interp *interp, const char *sdescr, const char *str) if (sdescr[1] == '-' && sdescr[2] != 0) { /* Handle range definitions */ int i; - for (i=sdescr[0]; i <= sdescr[2]; ++i) + for (i = sdescr[0]; i <= sdescr[2]; ++i) JimSetBit(charset, (char)i); sdescr += 3; } else { @@ -7502,7 +7559,7 @@ JimScanAString(Jim_Interp *interp, const char *sdescr, const char *str) } } /* Negate the charset if there was a NOT given */ - for (i=0; notFlag && i < sizeof(charset); ++i) + for (i = 0; notFlag && i < sizeof(charset); ++i) charset[i] = ~charset[i]; } /* And after all the mess above, the real work begin ... */ @@ -7543,7 +7600,7 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, long pos, if (descr->prefix) { /* There was a prefix given before the conversion, skip it and adjust * the string-to-be-parsed accordingly */ - for (i=0; str[pos] && descr->prefix[i]; ++i) { + for (i = 0; str[pos] && descr->prefix[i]; ++i) { /* If prefix require, skip WS */ if (isspace((int)descr->prefix[i])) while (str[pos] && isspace((int)str[pos])) ++pos; @@ -7585,6 +7642,8 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, long pos, scanned += 1; break; case 'd': case 'o': case 'x': case 'u': case 'i': { + jim_wide jwvalue = 0; + long lvalue = 0; char *endp; /* Position where the number finished */ int base = descr->type == 'o' ? 8 : descr->type == 'x' ? 16 @@ -7594,16 +7653,22 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, long pos, do { /* Try to scan a number with the given base */ if (descr->modifier == 'l') -#ifdef HAVE_LONG_LONG - *(jim_wide*)value = JimStrtoll(tok, &endp, base); + { +#ifdef HAVE_LONG_LONG_INT + jwvalue = JimStrtoll(tok, &endp, base), #else - *(jim_wide*)value = strtol(tok, &endp, base); + jwvalue = strtol(tok, &endp, base), #endif + memcpy(value, &jwvalue, sizeof(jim_wide)); + } else + { if (descr->type == 'u') - *(long*)value = strtoul(tok, &endp, base); + lvalue = strtoul(tok, &endp, base); else - *(long*)value = strtol(tok, &endp, base); + lvalue = strtol(tok, &endp, base); + memcpy(value, &lvalue, sizeof(lvalue)); + } /* If scanning failed, and base was undetermined, simply * put it to 10 and try once more. This should catch the * case where %i begin to parse a number prefix (e.g. @@ -7615,9 +7680,9 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, long pos, if (endp != tok) { /* There was some number sucessfully scanned! */ if (descr->modifier == 'l') - *valObjPtr = Jim_NewIntObj(interp, *(jim_wide*)value); + *valObjPtr = Jim_NewIntObj(interp, jwvalue); else - *valObjPtr = Jim_NewIntObj(interp, *(long*)value); + *valObjPtr = Jim_NewIntObj(interp, lvalue); /* Adjust the number-of-chars scanned so far */ scanned += endp - tok; } else { @@ -7636,10 +7701,11 @@ static int ScanOneEntry(Jim_Interp *interp, const char *str, long pos, case 'e': case 'f': case 'g': { char *endp; - *(double*)value = strtod(tok, &endp); + double dvalue = strtod(tok, &endp); + memcpy(value, &dvalue, sizeof(double)); if (endp != tok) { /* There was some number sucessfully scanned! */ - *valObjPtr = Jim_NewDoubleObj(interp, *(double*)value); + *valObjPtr = Jim_NewDoubleObj(interp, dvalue); /* Adjust the number-of-chars scanned so far */ scanned += endp - tok; } else { @@ -7691,12 +7757,12 @@ Jim_Obj *Jim_ScanString(Jim_Interp *interp, Jim_Obj *strObjPtr, /* Create a list and fill it with empty strings up to max specified XPG3 */ resultList = Jim_NewListObj(interp, 0, 0); if (fmtObj->maxPos > 0) { - for (i=0; i < fmtObj->maxPos; ++i) + for (i = 0; i < fmtObj->maxPos; ++i) Jim_ListAppendElement(interp, resultList, emptyStr); JimListGetElements(interp, resultList, &resultc, &resultVec); } /* Now handle every partial format description */ - for (i=0, pos=0; i < fmtObj->count; ++i) { + for (i = 0, pos = 0; i < fmtObj->count; ++i) { ScanFmtPartDescr *descr = &(fmtObj->descr[i]); Jim_Obj *value = 0; /* Only last type may be "literal" w/o conversion - skip it! */ @@ -7772,13 +7838,13 @@ static void JimRandomBytes(Jim_Interp *interp, void *dest, unsigned int len) prng = interp->prngState; /* generates 'len' bytes of pseudo-random numbers */ for (x = 0; x < len; x++) { - prng->i = (prng->i+1) & 0xff; + prng->i = (prng->i + 1) & 0xff; si = prng->sbox[prng->i]; prng->j = (prng->j + si) & 0xff; sj = prng->sbox[prng->j]; prng->sbox[prng->i] = sj; prng->sbox[prng->j] = si; - *destByte++ = prng->sbox[(si+sj)&0xff]; + *destByte++ = prng->sbox[(si + sj)&0xff]; } } @@ -7872,21 +7938,21 @@ int Jim_LoadLibrary(Jim_Interp *interp, const char *pathName) 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_PATH_LEN) + prefix = Jim_GetString(prefixObjPtr, &prefixlen); + if (prefixlen + strlen(pathName) + 1 >= JIM_PATH_LEN) continue; - if (prefixlen && prefix[prefixlen-1] == '/') + if (*pathName == '/') { + strcpy(buf, pathName); + } + else if (prefixlen && prefix[prefixlen-1] == '/') sprintf(buf, "%s%s", prefix, pathName); else sprintf(buf, "%s/%s", prefix, pathName); - printf("opening '%s'\n", buf); fp = fopen(buf, "r"); if (fp == NULL) continue; fclose(fp); handle = dlopen(buf, RTLD_LAZY); - printf("got handle %p\n", handle); } if (handle == NULL) { Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); @@ -7934,7 +8000,7 @@ int Jim_LoadLibrary(Jim_Interp *interp, const char *pathName) #define JIM_PKG_ANY_VERSION -1 /* Convert a string of the type "1.2" into an integer. - * MAJOR.MINOR is converted as MAJOR*100+MINOR, so "1.2" is converted + * MAJOR.MINOR is converted as MAJOR*100 + MINOR, so "1.2" is converted * to the integer with value 102 */ static int JimPackageVersionToInt(Jim_Interp *interp, const char *v, int *intPtr, int flags) @@ -7953,12 +8019,12 @@ static int JimPackageVersionToInt(Jim_Interp *interp, const char *v, if (p == NULL) goto badfmt; *p = '\0'; majorStr = copy; - minorStr = p+1; + minorStr = p + 1; if (Jim_StringToWide(majorStr, &major, 10) != JIM_OK || Jim_StringToWide(minorStr, &minor, 10) != JIM_OK) goto badfmt; - *intPtr = (int)(major*100+minor); + *intPtr = (int)(major*100 + minor); Jim_Free(copy); return JIM_OK; @@ -7972,7 +8038,7 @@ badfmt: return JIM_ERR; } -#define JIM_MATCHVER_EXACT (1<name = (char *) Jim_Alloc(base_length + strlen(all) + 1)) != 0) { strcat(strcpy(dir->name, name), all); - if((dir->handle = (long) _findfirst(dir->name, &dir->info)) != -1) + if ((dir->handle = (long) _findfirst(dir->name, &dir->info)) != -1) dir->result.d_name = 0; else { /* rollback */ Jim_Free(dir->name); @@ -8070,13 +8136,13 @@ int closedir(DIR *dir) { int result = -1; - if(dir) { - if(dir->handle != -1) + if (dir) { + if (dir->handle != -1) result = _findclose(dir->handle); Jim_Free(dir->name); Jim_Free(dir); } - if(result == -1) /* map all errors to EBADF */ + if (result == -1) /* map all errors to EBADF */ errno = EBADF; return result; } @@ -8085,8 +8151,8 @@ struct dirent *readdir(DIR *dir) { struct dirent *result = 0; - if(dir && dir->handle != -1) { - if(!dir->result.d_name || _findnext(dir->handle, &dir->info) != -1) { + if (dir && dir->handle != -1) { + if (!dir->result.d_name || _findnext(dir->handle, &dir->info) != -1) { result = &dir->result; result->d_name = dir->info.name; } @@ -8124,20 +8190,20 @@ static char *JimFindBestPackage(Jim_Interp *interp, char **prefixes, int fileNameLen = strlen(fileName); if (strncmp(fileName, "jim-", 4) == 0 && - strncmp(fileName+4, pkgName, pkgNameLen) == 0 && - *(fileName+4+pkgNameLen) == '-' && + strncmp(fileName + 4, pkgName, pkgNameLen) == 0 && + *(fileName + 4+pkgNameLen) == '-' && fileNameLen > 4 && /* note that this is not really useful */ - (strncmp(fileName+fileNameLen-4, ".tcl", 4) == 0 || - strncmp(fileName+fileNameLen-4, ".dll", 4) == 0 || - strncmp(fileName+fileNameLen-3, ".so", 3) == 0)) + (strncmp(fileName + fileNameLen-4, ".tcl", 4) == 0 || + strncmp(fileName + fileNameLen-4, ".dll", 4) == 0 || + strncmp(fileName + fileNameLen-3, ".so", 3) == 0)) { - char ver[6]; /* xx.yy */ + char ver[6]; /* xx.yy < nulterm> */ char *p = strrchr(fileName, '.'); int verLen, fileVer; - verLen = p - (fileName+4+pkgNameLen+1); + verLen = p - (fileName + 4+pkgNameLen + 1); if (verLen < 3 || verLen > 5) continue; - memcpy(ver, fileName+4+pkgNameLen+1, verLen); + memcpy(ver, fileName + 4+pkgNameLen + 1, verLen); ver[verLen] = '\0'; if (JimPackageVersionToInt(interp, ver, &fileVer, JIM_NONE) != JIM_OK) continue; @@ -8146,7 +8212,7 @@ static char *JimFindBestPackage(Jim_Interp *interp, char **prefixes, { bestVer = fileVer; Jim_Free(bestPackage); - bestPackage = Jim_Alloc(strlen(buf)+strlen(fileName)+2); + bestPackage = Jim_Alloc(strlen(buf) + strlen(fileName) + 2); sprintf(bestPackage, "%s/%s", buf, fileName); } } @@ -8230,6 +8296,9 @@ const char *Jim_PackageRequire(Jim_Interp *interp, const char *name, Jim_HashEntry *he; int requiredVer; + /* Start with an empty error string */ + Jim_SetResultString(interp, "", 0); + if (JimPackageVersionToInt(interp, ver, &requiredVer, JIM_ERRMSG) != JIM_OK) return NULL; he = Jim_FindHashEntry(&interp->packages, name); @@ -8244,8 +8313,9 @@ const char *Jim_PackageRequire(Jim_Interp *interp, const char *name, } /* No way... return an error. */ if (flags & JIM_ERRMSG) { - Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); - Jim_AppendStrings(interp, Jim_GetResult(interp), + int len; + Jim_GetString(Jim_GetResult(interp), &len); + Jim_AppendStrings(interp, Jim_GetResult(interp), len ? "\n" : "", "Can't find package '", name, "'", NULL); } return NULL; @@ -8258,7 +8328,6 @@ const char *Jim_PackageRequire(Jim_Interp *interp, const char *name, } /* Check if version matches. */ if (JimPackageMatchVersion(requiredVer, actualVer, flags) == 0) { - Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); Jim_AppendStrings(interp, Jim_GetResult(interp), "Package '", name, "' already loaded, but with version ", he->val, NULL); @@ -8283,6 +8352,13 @@ static int JimUnknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv) Jim_Obj **v, *sv[JIM_EVAL_SARGV_LEN]; int retCode; + /* If JimUnknown() is recursively called (e.g. error in the unknown proc, + * done here + */ + if (interp->unknown_called) { + return JIM_ERR; + } + /* If the [unknown] command does not exists returns * just now */ if (Jim_GetCommand(interp, interp->unknown, JIM_NONE) == NULL) @@ -8292,18 +8368,21 @@ static int JimUnknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv) * 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) + if (argc + 1 <= JIM_EVAL_SARGV_LEN) v = sv; else - v = Jim_Alloc(sizeof(Jim_Obj*)*(argc+1)); + 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); + memcpy(v + 1, argv, sizeof(Jim_Obj*)*argc); v[0] = interp->unknown; /* Call it */ - retCode = Jim_EvalObjVector(interp, argc+1, v); + interp->unknown_called++; + retCode = Jim_EvalObjVector(interp, argc + 1, v); + interp->unknown_called--; + /* Clean up */ if (v != sv) Jim_Free(v); @@ -8337,12 +8416,16 @@ int Jim_EvalObjVector(Jim_Interp *interp, int objc, Jim_Obj *const *objv) if (cmdPtr->cmdProc) { interp->cmdPrivData = cmdPtr->privData; retcode = cmdPtr->cmdProc(interp, objc, objv); + if (retcode == JIM_ERR_ADDSTACK) { + //JimAppendStackTrace(interp, "", script->fileName, token[i-argc*2].linenr); + retcode = JIM_ERR; + } } else { retcode = JimCallProcedure(interp, cmdPtr, objc, objv); - if (retcode == JIM_ERR) { - JimAppendStackTrace(interp, - Jim_GetString(objv[0], NULL), "?", 1); - } + if (retcode == JIM_ERR) { + JimAppendStackTrace(interp, + Jim_GetString(objv[0], NULL), "", 1); + } } } /* Decr refcount of arguments and return the retcode */ @@ -8371,7 +8454,7 @@ int Jim_InterpolateTokens(Jim_Interp *interp, ScriptToken *token, /* Compute every token forming the argument * in the intv objects vector. */ for (i = 0; i < tokens; i++) { - switch(token[i].type) { + switch (token[i].type) { case JIM_TT_ESC: case JIM_TT_STR: intv[i] = token[i].objPtr; @@ -8413,7 +8496,7 @@ int Jim_InterpolateTokens(Jim_Interp *interp, ScriptToken *token, * object. */ objPtr = Jim_NewStringObjNoAlloc(interp, NULL, 0); - s = objPtr->bytes = Jim_Alloc(totlen+1); + s = objPtr->bytes = Jim_Alloc(totlen + 1); objPtr->length = totlen; for (i = 0; i < tokens; i++) { memcpy(s, intv[i]->bytes, intv[i]->length); @@ -8444,7 +8527,7 @@ 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)); + (*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. */ @@ -8454,7 +8537,7 @@ void Jim_ExpandArgument(Jim_Interp *interp, Jim_Obj ***argv, int len, i; Jim_ListLength(interp, objPtr, &len); - (*argv) = Jim_Realloc(*argv, sizeof(Jim_Obj*)*((*argcPtr)+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]); @@ -8545,7 +8628,7 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr) if (tokens == 1) { /* Fast path if the token does not * need interpolation */ - switch(token[i].type) { + switch (token[i].type) { case JIM_TT_ESC: case JIM_TT_STR: argv[j] = token[i].objPtr; @@ -8585,13 +8668,13 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr) /* For interpolation we call an helper * function doing the work for us. */ if ((retcode = Jim_InterpolateTokens(interp, - token+i, tokens, &tmpObjPtr)) != JIM_OK) + token + i, tokens, &tmpObjPtr)) != JIM_OK) { goto err; } argv[j] = tmpObjPtr; Jim_IncrRefCount(argv[j]); - i += tokens+1; + i += tokens + 1; } } /* Handle {expand} expansion */ @@ -8623,6 +8706,10 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr) if (cmd->cmdProc) { interp->cmdPrivData = cmd->privData; retcode = cmd->cmdProc(interp, argc, argv); + if ((retcode == JIM_ERR)||(retcode == JIM_ERR_ADDSTACK)) { + JimAppendStackTrace(interp, "", script->fileName, token[i-argc*2].linenr); + retcode = JIM_ERR; + } } else { retcode = JimCallProcedure(interp, cmd, argc, argv); if (retcode == JIM_ERR) { @@ -8636,7 +8723,7 @@ int Jim_EvalObj(Jim_Interp *interp, Jim_Obj *scriptObjPtr) retcode = JimUnknown(interp, argc, argv); if (retcode == JIM_ERR) { JimAppendStackTrace(interp, - Jim_GetString(argv[0], NULL), script->fileName, + "", script->fileName, token[i-argc*2].linenr); } } @@ -8692,6 +8779,7 @@ int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, int argc, { int i, retcode; Jim_CallFrame *callFramePtr; + int num_args; /* Check arity */ if (argc < cmd->arityMin || (cmd->arityMax != -1 && @@ -8722,19 +8810,47 @@ int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, int argc, Jim_IncrRefCount(cmd->bodyObjPtr); interp->framePtr = callFramePtr; interp->numLevels ++; + /* Set arguments */ - for (i = 0; i < cmd->arityMin-1; i++) { - Jim_Obj *objPtr; + Jim_ListLength(interp, cmd->argListObjPtr, &num_args); - Jim_ListIndex(interp, cmd->argListObjPtr, i, &objPtr, JIM_NONE); - Jim_SetVariable(interp, objPtr, argv[i+1]); + /* If last argument is 'args', don't set it here */ + if (cmd->arityMax == -1) { + num_args--; + } + + for (i = 0; i < num_args; i++) { + Jim_Obj *argObjPtr; + Jim_Obj *nameObjPtr; + Jim_Obj *valueObjPtr; + + Jim_ListIndex(interp, cmd->argListObjPtr, i, &argObjPtr, JIM_NONE); + if (i + 1 >= cmd->arityMin) { + /* The name is the first element of the list */ + Jim_ListIndex(interp, argObjPtr, 0, &nameObjPtr, JIM_NONE); + } + else { + /* The element arg is the name */ + nameObjPtr = argObjPtr; + } + + if (i + 1 >= argc) { + /* No more values, so use default */ + /* The value is the second element of the list */ + Jim_ListIndex(interp, argObjPtr, 1, &valueObjPtr, JIM_NONE); + } + else { + valueObjPtr = argv[i + 1]; + } + Jim_SetVariable(interp, nameObjPtr, valueObjPtr); } + /* Set optional arguments */ 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); + i++; + listObjPtr = Jim_NewListObj(interp, argv + i, argc-i); + Jim_ListIndex(interp, cmd->argListObjPtr, num_args, &objPtr, JIM_NONE); Jim_SetVariable(interp, objPtr, listObjPtr); } /* Eval the body */ @@ -8778,7 +8894,7 @@ int Jim_Eval_Named(Jim_Interp *interp, const char *script, const char *filename, Jim_IncrRefCount(scriptObjPtr); - if( filename ){ + if ( filename ){ JimSetSourceInfo( interp, scriptObjPtr, filename, lineno ); } @@ -8844,10 +8960,10 @@ int Jim_EvalFile(Jim_Interp *interp, const char *filename) Jim_Obj *scriptObjPtr; if ((fp = fopen(filename, "r")) == NULL) { - const int cwd_len=2048; - char *cwd=malloc(cwd_len); + const int cwd_len = 2048; + char *cwd = malloc(cwd_len); Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); - getcwd( cwd, cwd_len ); + if (!getcwd( cwd, cwd_len )) strcpy(cwd, "unknown"); Jim_AppendStrings(interp, Jim_GetResult(interp), "Error loading script \"", filename, "\"", " cwd: ", cwd, @@ -8858,12 +8974,12 @@ int Jim_EvalFile(Jim_Interp *interp, const char *filename) buflen = 1024; maxlen = totread = 0; while (1) { - if (maxlen < totread+buflen+1) { - maxlen = totread+buflen+1; + if (maxlen < totread + buflen + 1) { + maxlen = totread + buflen + 1; prg = Jim_Realloc(prg, maxlen); } /* do not use Jim_fread() - this is really a file */ - if ((nread = fread(prg+totread, 1, buflen, fp)) == 0) break; + if ((nread = fread(prg + totread, 1, buflen, fp)) == 0) break; totread += nread; } prg[totread] = '\0'; @@ -8904,7 +9020,7 @@ static int JimParseSubst(struct JimParserCtx *pc, int flags) pc->eof = 1; return JIM_OK; } - switch(*pc->p) { + switch (*pc->p) { case '[': retval = JimParseCmd(pc); if (flags & JIM_SUBST_NOCMD) { @@ -8929,7 +9045,7 @@ static int JimParseSubst(struct JimParserCtx *pc, int flags) pc->tt = JIM_TT_ESC; if (*pc->tstart == '{') { pc->tstart--; - if (*(pc->tend+1)) + if (*(pc->tend + 1)) pc->tend++; } } @@ -8978,7 +9094,7 @@ int SetSubstFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr, int flags) script->fileName = NULL; JimParserInit(&parser, scriptText, scriptTextLen, 1); - while(1) { + while (1) { char *token; int len, type, linenr; @@ -9054,7 +9170,7 @@ int Jim_SubstObj(Jim_Interp *interp, Jim_Obj *substObjPtr, for (i = 0; i < len; i++) { Jim_Obj *objPtr; - switch(token[i].type) { + switch (token[i].type) { case JIM_TT_STR: case JIM_TT_ESC: Jim_AppendObj(interp, resObjPtr, token[i].objPtr); @@ -9288,7 +9404,7 @@ void Jim_WrongNumArgs(Jim_Interp *interp, int argc, Jim_Obj *const *argv, 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')) + if (!(i + 1 == argc && msg[0] == '\0')) Jim_AppendString(interp, objPtr, " ", 1); } Jim_AppendString(interp, objPtr, msg, -1); @@ -9607,13 +9723,13 @@ static int Jim_IncrCoreCommand(Jim_Interp *interp, int argc, if (Jim_GetWide(interp, intObjPtr, &wideValue) != JIM_OK) return JIM_ERR; if (Jim_IsShared(intObjPtr)) { - intObjPtr = Jim_NewIntObj(interp, wideValue+increment); + intObjPtr = Jim_NewIntObj(interp, wideValue + increment); if (Jim_SetVariable(interp, argv[1], intObjPtr) != JIM_OK) { Jim_FreeNewObj(interp, intObjPtr); return JIM_ERR; } } else { - Jim_SetWide(interp, intObjPtr, wideValue+increment); + Jim_SetWide(interp, intObjPtr, wideValue + increment); /* The following step is required in order to invalidate the * string repr of "FOO" if the var name is on the form of "FOO(IDX)" */ if (Jim_SetVariable(interp, argv[1], intObjPtr) != JIM_OK) { @@ -9657,7 +9773,7 @@ static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, if ((expr = Jim_GetExpression(interp, argv[1])) == NULL) goto noopt; if (expr->len <= 0 || expr->len > 3) goto noopt; - switch(expr->len) { + switch (expr->len) { case 1: if (expr->opcode[0] != JIM_EXPROP_VARIABLE && expr->opcode[0] != JIM_EXPROP_NUMBER) @@ -9673,7 +9789,7 @@ static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, (expr->opcode[1] != JIM_EXPROP_NUMBER && expr->opcode[1] != JIM_EXPROP_VARIABLE)) goto noopt; - switch(expr->opcode[2]) { + switch (expr->opcode[2]) { case JIM_EXPROP_LT: case JIM_EXPROP_LTE: case JIM_EXPROP_GT: @@ -9718,7 +9834,7 @@ static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, } if (!wideValue) break; if ((retval = Jim_EvalObj(interp, argv[2])) != JIM_OK) { - switch(retval) { + switch (retval) { case JIM_BREAK: if (varAObjPtr) Jim_DecrRefCount(interp, varAObjPtr); @@ -9769,7 +9885,7 @@ static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, goto noopt; } } - switch(cmpType) { + switch (cmpType) { case JIM_EXPROP_LT: cmpRes = wideValueA < wideValueB; break; case JIM_EXPROP_LTE: @@ -9785,7 +9901,7 @@ static int Jim_WhileCoreCommand(Jim_Interp *interp, int argc, } if (!cmpRes) break; if ((retval = Jim_EvalObj(interp, argv[2])) != JIM_OK) { - switch(retval) { + switch (retval) { case JIM_BREAK: Jim_DecrRefCount(interp, varAObjPtr); if (varBObjPtr) @@ -9825,7 +9941,7 @@ noopt: return retval; if (!boolean) break; if ((retval = Jim_EvalObj(interp, argv[2])) != JIM_OK) { - switch(retval) { + switch (retval) { case JIM_BREAK: goto out; break; @@ -9962,7 +10078,7 @@ static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, } /* Eval body */ if ((retval = Jim_EvalObj(interp, argv[4])) != JIM_OK) { - switch(retval) { + switch (retval) { case JIM_BREAK: if (stopVarNamePtr) Jim_DecrRefCount(interp, stopVarNamePtr); @@ -10000,7 +10116,7 @@ static int Jim_ForCoreCommand(Jim_Interp *interp, int argc, Jim_DecrRefCount(interp, varNamePtr); goto evalnext; } - auxObjPtr = Jim_NewIntObj(interp, currentVal+1); + auxObjPtr = Jim_NewIntObj(interp, currentVal + 1); if (Jim_SetVariable(interp, varNamePtr, auxObjPtr) == JIM_ERR) { if (stopVarNamePtr) Jim_DecrRefCount(interp, stopVarNamePtr); @@ -10031,7 +10147,7 @@ testcond: if (!boolean) break; /* Eval body */ if ((retval = Jim_EvalObj(interp, argv[4])) != JIM_OK) { - switch(retval) { + switch (retval) { case JIM_BREAK: goto out; break; @@ -10045,7 +10161,7 @@ testcond: evalnext: /* Eval next */ if ((retval = Jim_EvalObj(interp, argv[3])) != JIM_OK) { - switch(retval) { + switch (retval) { case JIM_BREAK: goto out; break; @@ -10087,31 +10203,31 @@ static int JimForeachMapHelper(Jim_Interp *interp, int argc, /* 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) { + 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]); + 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]); + 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) { + 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) + 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) + if (Jim_ListIndex(interp, argv[lst + 1], listsIdx[i], &ele, JIM_ERRMSG) != JIM_OK) goto err; if (Jim_SetVariable(interp, varName, ele) != JIM_OK) { @@ -10224,11 +10340,11 @@ enum {SWITCH_EXACT, SWITCH_GLOB, SWITCH_RE, SWITCH_CMD, SWITCH_UNKNOWN}; static int Jim_SwitchCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { - int retcode = JIM_ERR, matchOpt = SWITCH_EXACT, opt=1, patCount, i; + int retcode = JIM_ERR, matchOpt = SWITCH_EXACT, opt = 1, patCount, i; Jim_Obj *command = 0, *const *caseList = 0, *strObj; Jim_Obj *script = 0; if (argc < 3) goto wrongnumargs; - for (opt=1; opt < argc; ++opt) { + for (opt = 1; opt < argc; ++opt) { const char *option = Jim_GetString(argv[opt], 0); if (*option != '-') break; else if (strncmp(option, "--", 2) == 0) { ++opt; break; } @@ -10256,18 +10372,18 @@ static int Jim_SwitchCoreCommand(Jim_Interp *interp, int argc, } else caseList = &argv[opt]; if (patCount == 0 || patCount % 2 != 0) goto wrongnumargs; - for (i=0; script == 0 && i < patCount; i += 2) { + for (i = 0; script == 0 && i < patCount; i += 2) { Jim_Obj *patObj = caseList[i]; if (!Jim_CompareStringImmediate(interp, patObj, "default") || i < (patCount-2)) { switch (matchOpt) { case SWITCH_EXACT: if (Jim_StringEqObj(strObj, patObj, 0)) - script = caseList[i+1]; + script = caseList[i + 1]; break; case SWITCH_GLOB: if (Jim_StringMatchObj(patObj, strObj, 0)) - script = caseList[i+1]; + script = caseList[i + 1]; break; case SWITCH_RE: command = Jim_NewStringObj(interp, "regexp", -1); @@ -10296,7 +10412,7 @@ static int Jim_SwitchCoreCommand(Jim_Interp *interp, int argc, goto err; } if (matching) - script = caseList[i+1]; + script = caseList[i + 1]; break; } default: @@ -10306,12 +10422,12 @@ static int Jim_SwitchCoreCommand(Jim_Interp *interp, int argc, goto err; } } else { - script = caseList[i+1]; + script = caseList[i + 1]; } } - for(; i < patCount && Jim_CompareStringImmediate(interp, script, "-"); + for (; i < patCount && Jim_CompareStringImmediate(interp, script, "-"); i += 2) - script = caseList[i+1]; + script = caseList[i + 1]; if (script && Jim_CompareStringImmediate(interp, script, "-")) { Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); Jim_AppendStrings(interp, Jim_GetResult(interp), @@ -10338,7 +10454,7 @@ static int Jim_ListCoreCommand(Jim_Interp *interp, int argc, { Jim_Obj *listObjPtr; - listObjPtr = Jim_NewListObj(interp, argv+1, argc-1); + listObjPtr = Jim_NewListObj(interp, argv + 1, argc-1); Jim_SetResult(interp, listObjPtr); return JIM_OK; } @@ -10473,7 +10589,7 @@ static int Jim_LsetCoreCommand(Jim_Interp *interp, int argc, Jim_SetResult(interp, argv[2]); return JIM_OK; } - if (Jim_SetListIndex(interp, argv[1], argv+2, argc-3, argv[argc-1]) + if (Jim_SetListIndex(interp, argv[1], argv + 2, argc-3, argv[argc-1]) == JIM_ERR) return JIM_ERR; return JIM_OK; } @@ -10499,7 +10615,7 @@ static int Jim_LsortCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const arg if (Jim_GetEnum(interp, argv[i], options, &option, "option", JIM_ERRMSG) != JIM_OK) return JIM_ERR; - switch(option) { + switch (option) { case OPT_ASCII: lsortType = JIM_LSORT_ASCII; break; case OPT_NOCASE: lsortType = JIM_LSORT_NOCASE; break; case OPT_INCREASING: decreasing = 0; break; @@ -10507,7 +10623,7 @@ static int Jim_LsortCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const arg } } if (decreasing) { - switch(lsortType) { + switch (lsortType) { case JIM_LSORT_ASCII: lsortType = JIM_LSORT_ASCII_DECR; break; case JIM_LSORT_NOCASE: lsortType = JIM_LSORT_NOCASE_DECR; break; } @@ -10684,7 +10800,7 @@ static int Jim_DebugCoreCommand(Jim_Interp *interp, int argc, const char *type; Jim_ExprOperator *op; - switch(expr->opcode[i]) { + switch (expr->opcode[i]) { case JIM_EXPROP_NUMBER: type = "number"; break; case JIM_EXPROP_COMMAND: type = "command"; break; case JIM_EXPROP_VARIABLE: type = "variable"; break; @@ -10725,7 +10841,7 @@ static int Jim_EvalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *objPtr; int retcode; - objPtr = Jim_ConcatObj(interp, argc-1, argv+1); + objPtr = Jim_ConcatObj(interp, argc-1, argv + 1); Jim_IncrRefCount(objPtr); retcode = Jim_EvalObj(interp, objPtr); Jim_DecrRefCount(interp, objPtr); @@ -10779,7 +10895,7 @@ static int Jim_UplevelCoreCommand(Jim_Interp *interp, int argc, if (argc == 2) { retcode = Jim_EvalObj(interp, argv[1]); } else { - objPtr = Jim_ConcatObj(interp, argc-1, argv+1); + objPtr = Jim_ConcatObj(interp, argc-1, argv + 1); Jim_IncrRefCount(objPtr); retcode = Jim_EvalObj(interp, objPtr); Jim_DecrRefCount(interp, objPtr); @@ -10805,7 +10921,7 @@ static int Jim_ExprCoreCommand(Jim_Interp *interp, int argc, } else if (argc > 2) { Jim_Obj *objPtr; - objPtr = Jim_ConcatObj(interp, argc-1, argv+1); + objPtr = Jim_ConcatObj(interp, argc-1, argv + 1); Jim_IncrRefCount(objPtr); retcode = Jim_EvalExpression(interp, objPtr, &exprResultPtr); Jim_DecrRefCount(interp, objPtr); @@ -10872,7 +10988,7 @@ static int Jim_TailcallCoreCommand(Jim_Interp *interp, int argc, { Jim_Obj *objPtr; - objPtr = Jim_NewListObj(interp, argv+1, argc-1); + objPtr = Jim_NewListObj(interp, argv + 1, argc-1); Jim_SetResult(interp, objPtr); return JIM_EVAL; } @@ -10889,18 +11005,32 @@ static int Jim_ProcCoreCommand(Jim_Interp *interp, int argc, return JIM_ERR; } Jim_ListLength(interp, argv[2], &argListLen); - arityMin = arityMax = argListLen+1; + arityMin = arityMax = argListLen + 1; + if (argListLen) { const char *str; int len; - Jim_Obj *lastArgPtr; + Jim_Obj *argPtr; - Jim_ListIndex(interp, argv[2], argListLen-1, &lastArgPtr, JIM_NONE); - str = Jim_GetString(lastArgPtr, &len); + /* Check for 'args' and adjust arityMin and arityMax if necessary */ + Jim_ListIndex(interp, argv[2], argListLen-1, &argPtr, JIM_NONE); + str = Jim_GetString(argPtr, &len); if (len == 4 && memcmp(str, "args", 4) == 0) { arityMin--; arityMax = -1; } + + /* Check for default arguments and reduce arityMin if necessary */ + while (arityMin > 1) { + int len; + Jim_ListIndex(interp, argv[2], arityMin - 2, &argPtr, JIM_NONE); + Jim_ListLength(interp, argPtr, &len); + if (len != 2) { + /* No default argument */ + break; + } + arityMin--; + } } if (argc == 4) { return Jim_CreateProcedure(interp, Jim_GetString(argv[1], NULL), @@ -10915,7 +11045,7 @@ static int Jim_ProcCoreCommand(Jim_Interp *interp, int argc, static int Jim_ConcatCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { - Jim_SetResult(interp, Jim_ConcatObj(interp, argc-1, argv+1)); + Jim_SetResult(interp, Jim_ConcatObj(interp, argc-1, argv + 1)); return JIM_OK; } @@ -10949,7 +11079,7 @@ static int Jim_UpvarCoreCommand(Jim_Interp *interp, int argc, } /* Now... for every other/local couple: */ for (i = 1; i < argc; i += 2) { - if (Jim_SetVariableLink(interp, argv[i+1], argv[i], + if (Jim_SetVariableLink(interp, argv[i + 1], argv[i], targetCallFrame) != JIM_OK) return JIM_ERR; } return JIM_OK; @@ -11003,12 +11133,12 @@ static Jim_Obj *JimStringMap(Jim_Interp *interp, Jim_Obj *mapListObjPtr, Jim_ListIndex(interp, mapListObjPtr, i*2, &eleObjPtr, JIM_NONE); key[i] = Jim_GetString(eleObjPtr, &keyLen[i]); - Jim_ListIndex(interp, mapListObjPtr, i*2+1, &eleObjPtr, JIM_NONE); + Jim_ListIndex(interp, mapListObjPtr, i*2 + 1, &eleObjPtr, JIM_NONE); value[i] = eleObjPtr; } str = Jim_GetString(objPtr, &strLen); /* Map it */ - while(strLen) { + while (strLen) { for (i = 0; i < numMaps; i++) { if (strLen >= keyLen[i] && keyLen[i]) { if (!JimStringCompare(str, keyLen[i], key[i], keyLen[i], @@ -11182,7 +11312,7 @@ static int Jim_StringCoreCommand(Jim_Interp *interp, int argc, Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); return JIM_OK; } else { - Jim_SetResult(interp, Jim_NewStringObj(interp, str+index, 1)); + Jim_SetResult(interp, Jim_NewStringObj(interp, str + index, 1)); return JIM_OK; } } else if (option == OPT_FIRST) { @@ -11430,13 +11560,13 @@ static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_WrongNumArgs(interp, 2, argv, "?key value ...?"); return JIM_ERR; } - objPtr = Jim_NewDictObj(interp, argv+2, argc-2); + objPtr = Jim_NewDictObj(interp, argv + 2, argc-2); Jim_SetResult(interp, objPtr); return JIM_OK; } else if (option == OPT_GET) { Jim_Obj *objPtr; - if (Jim_DictKeysVector(interp, argv[2], argv+3, argc-3, &objPtr, + if (Jim_DictKeysVector(interp, argv[2], argv + 3, argc-3, &objPtr, JIM_ERRMSG) != JIM_OK) return JIM_ERR; Jim_SetResult(interp, objPtr); @@ -11446,20 +11576,20 @@ static int Jim_DictCoreCommand(Jim_Interp *interp, int argc, Jim_WrongNumArgs(interp, 2, argv, "varName key ?key ...? value"); return JIM_ERR; } - return Jim_SetDictKeysVector(interp, argv[2], argv+3, argc-4, + return Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc-4, argv[argc-1]); } else if (option == OPT_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, + return Jim_SetDictKeysVector(interp, argv[2], argv + 3, argc-3, NULL); } else if (option == OPT_EXIST) { Jim_Obj *objPtr; int exists; - if (Jim_DictKeysVector(interp, argv[2], argv+3, argc-3, &objPtr, + if (Jim_DictKeysVector(interp, argv[2], argv + 3, argc-3, &objPtr, JIM_ERRMSG) == JIM_OK) exists = 1; else @@ -11500,20 +11630,20 @@ static int Jim_SubstCoreCommand(Jim_Interp *interp, int argc, return JIM_ERR; } i = argc-2; - while(i--) { - if (Jim_CompareStringImmediate(interp, argv[i+1], + while (i--) { + if (Jim_CompareStringImmediate(interp, argv[i + 1], "-nobackslashes")) flags |= JIM_SUBST_NOESC; - else if (Jim_CompareStringImmediate(interp, argv[i+1], + else if (Jim_CompareStringImmediate(interp, argv[i + 1], "-novariables")) flags |= JIM_SUBST_NOVAR; - else if (Jim_CompareStringImmediate(interp, argv[i+1], + 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), + "bad option \"", Jim_GetString(argv[i + 1], NULL), "\": must be -nobackslashes, -nocommands, or " "-novariables", NULL); return JIM_ERR; @@ -11532,10 +11662,10 @@ static int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, int cmd, result = JIM_OK; static const char *commands[] = { "body", "commands", "exists", "globals", "level", "locals", - "vars", "version", "complete", "args", NULL + "vars", "version", "complete", "args", "hostname", NULL }; enum {INFO_BODY, INFO_COMMANDS, INFO_EXISTS, INFO_GLOBALS, INFO_LEVEL, - INFO_LOCALS, INFO_VARS, INFO_VERSION, INFO_COMPLETE, INFO_ARGS}; + INFO_LOCALS, INFO_VARS, INFO_VERSION, INFO_COMPLETE, INFO_ARGS, INFO_HOSTNAME}; if (argc < 2) { Jim_WrongNumArgs(interp, 1, argv, "command ?args ...?"); @@ -11631,6 +11761,10 @@ static int Jim_InfoCoreCommand(Jim_Interp *interp, int argc, s = Jim_GetString(argv[2], &len); Jim_SetResult(interp, Jim_NewIntObj(interp, Jim_ScriptIsComplete(s, len, NULL))); + } else if (cmd == INFO_HOSTNAME) { + /* Redirect to os.hostname if it exists */ + Jim_Obj *command = Jim_NewStringObj(interp, "os.gethostname", -1); + result = Jim_EvalObjVector(interp, 1, &command); } return result; } @@ -11668,7 +11802,7 @@ static int Jim_SplitCoreCommand(Jim_Interp *interp, int argc, objPtr = Jim_NewStringObj(interp, noMatchStart, (str-noMatchStart)); Jim_ListAppendElement(interp, resObjPtr, objPtr); - noMatchStart = str+1; + noMatchStart = str + 1; break; } } @@ -11687,7 +11821,7 @@ static int Jim_SplitCoreCommand(Jim_Interp *interp, int argc, int c = u[i]; if (objCache[c] == NULL) - objCache[c] = Jim_NewStringObj(interp, (char*)u+i, 1); + objCache[c] = Jim_NewStringObj(interp, (char*)u + i, 1); Jim_ListAppendElement(interp, resObjPtr, objCache[c]); } } @@ -11722,7 +11856,7 @@ static int Jim_JoinCoreCommand(Jim_Interp *interp, int argc, Jim_ListIndex(interp, argv[1], i, &objPtr, JIM_NONE); Jim_AppendObj(interp, resObjPtr, objPtr); - if (i+1 != listLen) { + if (i + 1 != listLen) { Jim_AppendString(interp, resObjPtr, joinStr, joinStrLen); } } @@ -11740,7 +11874,7 @@ static int Jim_FormatCoreCommand(Jim_Interp *interp, int argc, Jim_WrongNumArgs(interp, 1, argv, "formatString ?arg arg ...?"); return JIM_ERR; } - objPtr = Jim_FormatString(interp, argv[1], argc-2, argv+2); + objPtr = Jim_FormatString(interp, argv[1], argc-2, argv + 2); if (objPtr == NULL) return JIM_ERR; Jim_SetResult(interp, objPtr); @@ -11795,7 +11929,7 @@ static int Jim_ScanCoreCommand(Jim_Interp *interp, int argc, for (i = 0; i < outc; ++i) { if (Jim_Length(outVec[i]) > 0) { ++count; - if (Jim_SetVariable(interp, argv[3+i], outVec[i]) != JIM_OK) + if (Jim_SetVariable(interp, argv[3 + i], outVec[i]) != JIM_OK) goto err; } } @@ -11849,6 +11983,27 @@ static int Jim_EnvCoreCommand(Jim_Interp *interp, int argc, const char *key; char *val; + if (argc == 1) { + +#ifdef NEED_ENVIRON_EXTERN + extern char **environ; +#endif + + int i; + Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0); + + for (i = 0; environ[i]; i++) { + const char *equals = strchr(environ[i], '='); + if (equals) { + Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, environ[i], equals - environ[i])); + Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, equals + 1, -1)); + } + } + + Jim_SetResult(interp, listObjPtr); + return JIM_OK; + } + if (argc != 2) { Jim_WrongNumArgs(interp, 1, argv, "varName"); return JIM_ERR; @@ -11877,6 +12032,9 @@ static int Jim_SourceCoreCommand(Jim_Interp *interp, int argc, return JIM_ERR; } retval = Jim_EvalFile(interp, Jim_GetString(argv[1], NULL)); + if (retval == JIM_ERR) { + return JIM_ERR_ADDSTACK; + } if (retval == JIM_RETURN) return JIM_OK; return retval; @@ -11949,7 +12107,7 @@ static int Jim_RangeCoreCommand(Jim_Interp *interp, int argc, } objPtr = Jim_NewListObj(interp, NULL, 0); for (i = 0; i < len; i++) - ListAppendElement(objPtr, Jim_NewIntObj(interp, start+i*step)); + ListAppendElement(objPtr, Jim_NewIntObj(interp, start + i*step)); Jim_SetResult(interp, objPtr); return JIM_OK; } @@ -11986,7 +12144,7 @@ static int Jim_RandCoreCommand(Jim_Interp *interp, int argc, JimRandomBytes(interp, &r, sizeof(jim_wide)); if (r < 0 || r >= maxMul) continue; r = (len == 0) ? 0 : r%len; - Jim_SetResult(interp, Jim_NewIntObj(interp, min+r)); + Jim_SetResult(interp, Jim_NewIntObj(interp, min + r)); return JIM_OK; } } @@ -12026,7 +12184,7 @@ static int Jim_PackageCoreCommand(Jim_Interp *interp, int argc, argc == 4 ? Jim_GetString(argv[3], NULL) : "", JIM_ERRMSG); if (ver == NULL) - return JIM_ERR; + return JIM_ERR_ADDSTACK; Jim_SetResultString(interp, ver, -1); } else if (option == OPT_PROVIDE) { if (argc != 4) { @@ -12125,7 +12283,7 @@ void Jim_RegisterCoreCommands(Jim_Interp *interp) { int i = 0; - while(Jim_CoreCommandsTable[i].name != NULL) { + while (Jim_CoreCommandsTable[i].name != NULL) { Jim_CreateCommand(interp, Jim_CoreCommandsTable[i].name, Jim_CoreCommandsTable[i].cmdProc, @@ -12142,9 +12300,11 @@ void Jim_PrintErrorMessage(Jim_Interp *interp) { int len, i; - Jim_fprintf(interp, interp->cookie_stderr, "Runtime error, file \"%s\", line %d:" JIM_NL, - interp->errorFileName, interp->errorLine); - Jim_fprintf(interp,interp->cookie_stderr, " %s" JIM_NL, + if (*interp->errorFileName) { + Jim_fprintf(interp, interp->cookie_stderr, "Runtime error, file \"%s\", line %d:" JIM_NL " ", + interp->errorFileName, interp->errorLine); + } + Jim_fprintf(interp,interp->cookie_stderr, "%s" JIM_NL, Jim_GetString(interp->result, NULL)); Jim_ListLength(interp, interp->stackTrace, &len); for (i = len-3; i >= 0; i-= 3) { @@ -12153,15 +12313,24 @@ void Jim_PrintErrorMessage(Jim_Interp *interp) Jim_ListIndex(interp, interp->stackTrace, i, &objPtr, JIM_NONE); proc = Jim_GetString(objPtr, NULL); - Jim_ListIndex(interp, interp->stackTrace, i+1, &objPtr, + Jim_ListIndex(interp, interp->stackTrace, i + 1, &objPtr, JIM_NONE); file = Jim_GetString(objPtr, NULL); - Jim_ListIndex(interp, interp->stackTrace, i+2, &objPtr, + Jim_ListIndex(interp, interp->stackTrace, i + 2, &objPtr, JIM_NONE); line = Jim_GetString(objPtr, NULL); - Jim_fprintf( interp, interp->cookie_stderr, - "In procedure '%s' called at file \"%s\", line %s" JIM_NL, - proc, file, line); + if (*proc) { + Jim_fprintf( interp, interp->cookie_stderr, + "in procedure '%s' ", proc); + } + if (*file) { + Jim_fprintf( interp, interp->cookie_stderr, + "called at file \"%s\", line %s", + file, line); + } + if (*file || *proc) { + Jim_fprintf( interp, interp->cookie_stderr, JIM_NL); + } } } @@ -12192,7 +12361,7 @@ int Jim_InteractivePrompt(Jim_Interp *interp) Jim_fflush( interp, interp->cookie_stdout); scriptObjPtr = Jim_NewStringObj(interp, "", 0); Jim_IncrRefCount(scriptObjPtr); - while(1) { + while (1) { const char *str; char state; int len; @@ -12243,7 +12412,7 @@ int Jim_fprintf( Jim_Interp *interp, void *cookie, const char *fmt, ... ) int Jim_vfprintf( Jim_Interp *interp, void *cookie, const char *fmt, va_list ap ) { - if( (interp == NULL) || (interp->cb_vfprintf == NULL) ){ + if ( (interp == NULL) || (interp->cb_vfprintf == NULL) ){ errno = ENOTSUP; return -1; } @@ -12252,7 +12421,7 @@ int Jim_vfprintf( Jim_Interp *interp, void *cookie, const char *fmt, va_list ap size_t Jim_fwrite( Jim_Interp *interp, const void *ptr, size_t size, size_t n, void *cookie ) { - if( (interp == NULL) || (interp->cb_fwrite == NULL) ){ + if ( (interp == NULL) || (interp->cb_fwrite == NULL) ){ errno = ENOTSUP; return 0; } @@ -12261,7 +12430,7 @@ size_t Jim_fwrite( Jim_Interp *interp, const void *ptr, size_t size, size_t n, v size_t Jim_fread( Jim_Interp *interp, void *ptr, size_t size, size_t n, void *cookie ) { - if( (interp == NULL) || (interp->cb_fread == NULL) ){ + if ( (interp == NULL) || (interp->cb_fread == NULL) ){ errno = ENOTSUP; return 0; } @@ -12270,7 +12439,7 @@ size_t Jim_fread( Jim_Interp *interp, void *ptr, size_t size, size_t n, void *co int Jim_fflush( Jim_Interp *interp, void *cookie ) { - if( (interp == NULL) || (interp->cb_fflush == NULL) ){ + if ( (interp == NULL) || (interp->cb_fflush == NULL) ){ /* pretend all is well */ return 0; } @@ -12279,18 +12448,17 @@ int Jim_fflush( Jim_Interp *interp, void *cookie ) char* Jim_fgets( Jim_Interp *interp, char *s, int size, void *cookie ) { - if( (interp == NULL) || (interp->cb_fgets == NULL) ){ + if ( (interp == NULL) || (interp->cb_fgets == NULL) ){ errno = ENOTSUP; return NULL; } return (*(interp->cb_fgets))( s, size, cookie ); } - Jim_Nvp * Jim_Nvp_name2value_simple( const Jim_Nvp *p, const char *name ) { - while( p->name ){ - if( 0 == strcmp( name, p->name ) ){ + while ( p->name ){ + if ( 0 == strcmp( name, p->name ) ){ break; } p++; @@ -12301,8 +12469,8 @@ Jim_Nvp_name2value_simple( const Jim_Nvp *p, const char *name ) Jim_Nvp * Jim_Nvp_name2value_nocase_simple( const Jim_Nvp *p, const char *name ) { - while( p->name ){ - if( 0 == strcasecmp( name, p->name ) ){ + while ( p->name ){ + if ( 0 == strcasecmp( name, p->name ) ){ break; } p++; @@ -12331,12 +12499,12 @@ Jim_Nvp_name2value( Jim_Interp *interp, p = Jim_Nvp_name2value_simple( _p, name ); /* result */ - if( result ){ + if ( result ){ *result = (Jim_Nvp *)(p); } /* found? */ - if( p->name ){ + if ( p->name ){ return JIM_OK; } else { return JIM_ERR; @@ -12356,11 +12524,11 @@ Jim_Nvp_name2value_nocase( Jim_Interp *interp, const Jim_Nvp *_p, const char *na p = Jim_Nvp_name2value_nocase_simple( _p, name ); - if( puthere ){ + if ( puthere ){ *puthere = (Jim_Nvp *)(p); } /* found */ - if( p->name ){ + if ( p->name ){ return JIM_OK; } else { return JIM_ERR; @@ -12375,7 +12543,7 @@ Jim_Nvp_value2name_obj( Jim_Interp *interp, const Jim_Nvp *p, Jim_Obj *o, Jim_Nv jim_wide w; e = Jim_GetWide( interp, o, &w ); - if( e != JIM_OK ){ + if ( e != JIM_OK ){ return e; } @@ -12385,8 +12553,8 @@ Jim_Nvp_value2name_obj( Jim_Interp *interp, const Jim_Nvp *p, Jim_Obj *o, Jim_Nv Jim_Nvp * Jim_Nvp_value2name_simple( const Jim_Nvp *p, int value ) { - while( p->name ){ - if( value == p->value ){ + while ( p->name ){ + if ( value == p->value ){ break; } p++; @@ -12402,11 +12570,11 @@ Jim_Nvp_value2name( Jim_Interp *interp, const Jim_Nvp *_p, int value, Jim_Nvp ** p = Jim_Nvp_value2name_simple( _p, value ); - if( result ){ + if ( result ){ *result = (Jim_Nvp *)(p); } - if( p->name ){ + if ( p->name ){ return JIM_OK; } else { return JIM_ERR; @@ -12431,7 +12599,7 @@ Jim_GetOpt_Debug( Jim_GetOptInfo *p ) int x; Jim_fprintf( p->interp, p->interp->cookie_stderr, "---args---\n"); - for( x = 0 ; x < p->argc ; x++ ){ + for ( x = 0 ; x < p->argc ; x++ ){ Jim_fprintf( p->interp, p->interp->cookie_stderr, "%2d) %s\n", x, @@ -12447,16 +12615,16 @@ Jim_GetOpt_Obj( Jim_GetOptInfo *goi, Jim_Obj **puthere ) Jim_Obj *o; o = NULL; // failure - if( goi->argc ){ + if ( goi->argc ){ // success o = goi->argv[0]; goi->argc -= 1; goi->argv += 1; } - if( puthere ){ + if ( puthere ){ *puthere = o; } - if( o != NULL ){ + if ( o != NULL ){ return JIM_OK; } else { return JIM_ERR; @@ -12472,9 +12640,9 @@ Jim_GetOpt_String( Jim_GetOptInfo *goi, char **puthere, int *len ) r = Jim_GetOpt_Obj( goi, &o ); - if( r == JIM_OK ){ + if ( r == JIM_OK ){ cp = Jim_GetString( o, len ); - if( puthere ){ + if ( puthere ){ /* remove const */ *puthere = (char *)(cp); } @@ -12489,14 +12657,14 @@ Jim_GetOpt_Double( Jim_GetOptInfo *goi, double *puthere ) Jim_Obj *o; double _safe; - if( puthere == NULL ){ + if ( puthere == NULL ){ puthere = &_safe; } r = Jim_GetOpt_Obj( goi, &o ); - if( r == JIM_OK ){ + if ( r == JIM_OK ){ r = Jim_GetDouble( goi->interp, o, puthere ); - if( r != JIM_OK ){ + if ( r != JIM_OK ){ Jim_SetResult_sprintf( goi->interp, "not a number: %s", Jim_GetString( o, NULL ) ); @@ -12512,12 +12680,12 @@ Jim_GetOpt_Wide( Jim_GetOptInfo *goi, jim_wide *puthere ) Jim_Obj *o; jim_wide _safe; - if( puthere == NULL ){ + if ( puthere == NULL ){ puthere = &_safe; } r = Jim_GetOpt_Obj( goi, &o ); - if( r == JIM_OK ){ + if ( r == JIM_OK ){ r = Jim_GetWide( goi->interp, o, puthere ); } return r; @@ -12531,12 +12699,12 @@ int Jim_GetOpt_Nvp( Jim_GetOptInfo *goi, Jim_Obj *o; int e; - if( puthere == NULL ){ + if ( puthere == NULL ){ puthere = &_safe; } e = Jim_GetOpt_Obj( goi, &o ); - if( e == JIM_OK ){ + if ( e == JIM_OK ){ e = Jim_Nvp_name2value_obj( goi->interp, nvp, o, @@ -12551,7 +12719,7 @@ Jim_GetOpt_NvpUnknown( Jim_GetOptInfo *goi, const Jim_Nvp *nvptable, int hadprefix ) { - if( hadprefix ){ + if ( hadprefix ){ Jim_SetResult_NvpUnknown( goi->interp, goi->argv[-2], goi->argv[-1], @@ -12574,11 +12742,11 @@ Jim_GetOpt_Enum( Jim_GetOptInfo *goi, Jim_Obj *o; int e; - if( puthere == NULL ){ + if ( puthere == NULL ){ puthere = &_safe; } e = Jim_GetOpt_Obj( goi, &o ); - if( e == JIM_OK ){ + if ( e == JIM_OK ){ e = Jim_GetEnum( goi->interp, o, lookup, @@ -12596,11 +12764,11 @@ Jim_SetResult_sprintf( Jim_Interp *interp, const char *fmt,... ) { va_list ap; char *buf; - + va_start(ap,fmt); buf = jim_vasprintf( fmt, ap ); va_end(ap); - if( buf ){ + if ( buf ){ Jim_SetResultString( interp, buf, -1 ); jim_vasprintf_done(buf); } @@ -12614,7 +12782,7 @@ Jim_SetResult_NvpUnknown( Jim_Interp *interp, Jim_Obj *param_value, const Jim_Nvp *nvp ) { - if( param_name ){ + if ( param_name ){ Jim_SetResult_sprintf( interp, "%s: Unknown: %s, try one of: ", Jim_GetString( param_name, NULL ), @@ -12624,11 +12792,11 @@ Jim_SetResult_NvpUnknown( Jim_Interp *interp, "Unknown param: %s, try one of: ", Jim_GetString( param_value, NULL ) ); } - while( nvp->name ){ + while ( nvp->name ){ const char *a; const char *b; - if( (nvp+1)->name ){ + if ( (nvp + 1)->name ){ a = nvp->name; b = ", "; } else { @@ -12650,12 +12818,12 @@ Jim_Debug_ArgvString( Jim_Interp *interp, int argc, Jim_Obj *const *argv ) { int x; - if( debug_string_obj ){ + if ( debug_string_obj ){ Jim_FreeObj( interp, debug_string_obj ); } debug_string_obj = Jim_NewEmptyStringObj( interp ); - for( x = 0 ; x < argc ; x++ ){ + for ( x = 0 ; x < argc ; x++ ){ Jim_AppendStrings( interp, debug_string_obj, Jim_GetString( argv[x], NULL ), @@ -12665,12 +12833,3 @@ Jim_Debug_ArgvString( Jim_Interp *interp, int argc, Jim_Obj *const *argv ) return Jim_GetString( debug_string_obj, NULL ); } - - - -/* - * Local Variables: *** - * c-basic-offset: 4 *** - * tab-width: 4 *** - * End: *** - */