#define JIM_OPTIMIZATION
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
#include <limits.h>
#include <assert.h>
#include <errno.h>
#include <time.h>
#include <setjmp.h>
#include "jim.h"
#include "jimautoconf.h"
#include "utf8.h"
#include <sys/time.h>
#include <execinfo.h>
#include <crt_externs.h>
#include <math.h>
#define TCL_LIBRARY
#define TCL_PLATFORM_OS
#define TCL_PLATFORM_PLATFORM
#define TCL_PLATFORM_PATH_SEPARATOR
#define JIM_DEBUG_COMMAND
#define JIM_DEBUG_PANIC
#define JIM_INTEGER_SPACE
#define JimPanic
#define JimPanic
#define JIM_IF_OPTIM
#define JIM_IF_OPTIM
JimEmptyStringRep
#define JimWideValue
#define JimObjTypeName
utf8_tounicode_case(const char *, int *, int)
if
(upper)
#define JIM_CHARSET_SCAN
#define JIM_CHARSET_GLOB
JimCharsetMatch(const char *, int, int, int)
if
(flags & JIM_NOCASE)
if
(flags & JIM_CHARSET_SCAN)
if
(*pattern == '^')
if
(*pattern == ']')
while
(plen && *pattern != ']')
if
(pattern[0] == '\\')
else
if
(pattern[0] == '-' && plen > 1)
if
((c >= start && c <= end) || (c >= end && c <= start))
if
(pchar == c)
if
(not)
JimGlobMatch(const char *, int, const char *, int, int)
while
(plen)
switch
(pattern[0])
case
'*':
while
(pattern[1] == '*' && plen)
if
(!plen)
while
(slen)
case
'?':
case
'[':
if
(!p)
if
(!plen)
case
'\\':
if
(pattern[1])
default
if
(pchar != c)
if
(!slen)
while
(*pattern == '*' && plen)
if
(!plen && !slen)
JimStringCompareUtf8(const char *, int, const char *, int, int)
if
(l2 < l1)
while
(minlen)
if
(c1 != c2)
if
(l1 < l2)
if
(l1 > l2)
JimStringFirst(const char *, int, const char *, int, int)
if
(!l1 || !l2 || l1 > l2)
for
(i = idx; i <= l2 - l1; i++)
if
(memcmp(s2, s1, l1bytelen) == 0)
JimStringLast(const char *, int, const char *, int)
for
(p = s2 + l2 - 1; p != s2 - 1; p--)
if
(*p == *s1 && memcmp(s1, p, l1) == 0)
JimCheckConversion(const char *, const char *)
if
(str[0] == '\0' || str == endptr)
if
(endptr[0] != '\0')
while
(*endptr)
if
(!isspace(UCHAR(*endptr)))
JimNumberBase(const char *, int *, int *)
while
(isspace(UCHAR(str[i])))
if
(str[i] == '-')
else
if
(str[i] == '+')
if
(str[i] != '0')
switch
(str[i + 1])
case
'x':
case
'o':
case
'b':
case
'd':
default
if
(str[i] != '-' && str[i] != '+' && !isspace(UCHAR(str[i])))
jim_strtol(const char *, char **)
if
(base != 0)
if
(endptr == NULL || *endptr != str + i)
jim_strtoull(const char *, char **)
if
(base != 0)
if
(endptr == NULL || *endptr != str + i)
Jim_StringToWide(const char *, long long *, int)
if
(base)
else
Jim_StringToDouble(const char *, double *)
JimPowWide(long long, long long)
if
(b == 1)
if
(e < 0)
if
(b != -1)
while
(e)
if
(e & 1)
Jim_Alloc(int)
Jim_Free(void *)
Jim_Realloc(void *, int)
Jim_StrDup(const char *)
Jim_StrDupLen(const char *, int)
JimClock()
-------------------------- private prototypes
-------------------------- hash functions
Jim_IntHashFunction(unsigned int)
Jim_GenHashFunction(const unsigned char *, int)
while
(length--)
----------------------------- API implementation
JimResetHashTable(Jim_HashTable *)
JimInitHashTableIterator(Jim_HashTable *, Jim_HashTableIterator *)
Jim_InitHashTable(Jim_HashTable *, const Jim_HashTableType *, void *)
Jim_ExpandHashTable(Jim_HashTable *, unsigned int)
for
(i = 0; ht->used > 0; i++)
while
(he)
Jim_AddHashEntry(Jim_HashTable *, const void *, void *)
Jim_ReplaceHashEntry(Jim_HashTable *, const void *, void *)
if
(entry->key)
if
(ht->type->valDestructor && ht->type->valDup)
else
else
Jim_DeleteHashEntry(Jim_HashTable *, const void *)
if
(ht->used)
while
(he)
if
(Jim_CompareHashKeys(ht, key, he->key))
Jim_ClearHashTable(Jim_HashTable *)
for
(i = 0; ht->used > 0; i++)
while
(he)
Jim_FreeHashTable(Jim_HashTable *)
Jim_FindHashEntry(Jim_HashTable *, const void *)
while
(he)
Jim_GetHashTableIterator(Jim_HashTable *)
Jim_NextHashEntry(Jim_HashTableIterator *)
while
(1)
if
(iter->entry == NULL)
else
if
(iter->entry)
------------------------- private functions
JimExpandHashTableIfNeeded(Jim_HashTable *)
JimHashTableNextPower(unsigned int)
while
(1)
JimInsertHashEntry(Jim_HashTable *, const void *, int)
while
(he)
----------------------- StringCopy Hash Table Type
JimStringCopyHTHashFunction(const void *)
JimStringCopyHTDup(void *, const void *)
JimStringCopyHTKeyCompare(void *, const void *, const void *)
JimStringCopyHTKeyDestructor(void *, void *)
JimPackageHashTableType
AssocDataValue
delProc
data
JimAssocDataHashTableValueDestructor(void *, void *)
JimAssocDataHashTableType
Jim_InitStack(Jim_Stack *)
Jim_FreeStack(Jim_Stack *)
Jim_StackLen(Jim_Stack *)
Jim_StackPush(Jim_Stack *, void *)
if
(neededLen > stack->maxlen)
Jim_StackPop(Jim_Stack *)
Jim_StackPeek(Jim_Stack *)
Jim_FreeStackElements(Jim_Stack *, void (*)(void *))
#define JIM_TT_NONE
#define JIM_TT_STR
#define JIM_TT_ESC
#define JIM_TT_VAR
#define JIM_TT_DICTSUGAR
#define JIM_TT_CMD
#define JIM_TT_SEP
#define JIM_TT_EOL
#define JIM_TT_EOF
#define JIM_TT_LINE
#define JIM_TT_WORD
#define JIM_TT_SUBEXPR_START
#define JIM_TT_SUBEXPR_END
#define JIM_TT_SUBEXPR_COMMA
#define JIM_TT_EXPR_INT
#define JIM_TT_EXPR_DOUBLE
#define JIM_TT_EXPR_BOOLEAN
#define JIM_TT_EXPRSUGAR
#define JIM_TT_EXPR_OP
#define TOKEN_IS_SEP
#define TOKEN_IS_EXPR_START
#define TOKEN_IS_EXPR_OP
JimParseMissing
ch
line
JimParserCtx
p
len
linenr
tstart
tend
tline
tt
eof
inquote
comment
missing
JimParserInit(struct JimParserCtx *, const char *, int, int)
JimParseScript(struct JimParserCtx *)
while
(1)
if
(!pc->len)
if
(pc->inquote)
switch
(*(pc->p))
case
'\\':
if
(*(pc->p + 1) == '\n' && !pc->inquote)
case
' ':
case
'\t':
case
'\r':
case
'\f':
case
'\n':
case
';':
case
'[':
case
'$':
if
(JimParseVar(pc) == JIM_ERR)
case
'#':
if
(pc->comment)
default
JimParseSep(struct JimParserCtx *)
while
(isspace(UCHAR(*pc->p)) || (*pc->p == '\\' && *(pc->p + 1) == '\n'))
if
(*pc->p == '\n')
if
(*pc->p == '\\')
JimParseEol(struct JimParserCtx *)
while
(isspace(UCHAR(*pc->p)) || *pc->p == ';')
JimParseSubBrace(struct JimParserCtx *)
while
(pc->len)
switch
(*pc->p)
case
'\\':
if
(pc->len > 1)
if
(*++pc->p == '\n')
case
'{':
case
'}':
if
(--level == 0)
case
'\n':
JimParseSubQuote(struct JimParserCtx *)
while
(pc->len)
switch
(*pc->p)
case
'\\':
if
(pc->len > 1)
if
(*++pc->p == '\n')
case
'"':
case
'[':
case
'\n':
case
'$':
JimParseSubCmd(struct JimParserCtx *)
while
(pc->len)
switch
(*pc->p)
case
'\\':
if
(pc->len > 1)
if
(*++pc->p == '\n')
case
'[':
case
']':
if
(--level == 0)
case
'"':
if
(startofword)
if
(pc->missing.ch == '"')
case
'{':
case
'\n':
JimParseBrace(struct JimParserCtx *)
JimParseCmd(struct JimParserCtx *)
JimParseQuote(struct JimParserCtx *)
JimParseVar(struct JimParserCtx *)
if
(*pc->p == '[')
if
(*pc->p == '{')
while
(pc->len && *pc->p != '}')
if
(*pc->p == '\n')
if
(pc->len)
else
while
(1)
if
(pc->p[0] == ':' && pc->p[1] == ':')
while
(*pc->p == ':')
if
(isalnum(UCHAR(*pc->p)) || *pc->p == '_' || UCHAR(*pc->p) >= 0x80)
if
(*pc->p == '(')
while
(count && pc->len)
if
(*pc->p == '\\' && pc->len >= 1)
else if
(*pc->p == '(')
else if
(*pc->p == ')')
if
(count == 0)
else if
(paren)
if
(*pc->tstart == '(')
if
(pc->tstart == pc->p)
JimParseStr(struct JimParserCtx *)
if
(pc->tt == JIM_TT_SEP || pc->tt == JIM_TT_EOL || pc->tt == JIM_TT_NONE || pc->tt == JIM_TT_STR)
if
(*pc->p == '{')
if
(*pc->p == '"')
while
(1)
if
(pc->len == 0)
if
(pc->inquote)
switch
(*pc->p)
case
'\\':
if
(!pc->inquote && *(pc->p + 1) == '\n')
if
(pc->len >= 2)
if
(*(pc->p + 1) == '\n')
else if
(pc->len == 1)
case
'(':
if
(pc->len > 1 && pc->p[1] != '$')
case
')':
if
(*pc->p == '(' || pc->tt == JIM_TT_VAR)
if
(pc->p == pc->tstart)
case
'$':
case
'[':
case
' ':
case
'\t':
case
'\n':
case
'\r':
case
'\f':
case
';':
if
(!pc->inquote)
else if
(*pc->p == '\n')
case
'"':
if
(pc->inquote)
JimParseComment(struct JimParserCtx *)
while
(*pc->p)
if
(*pc->p == '\\')
if
(pc->len == 0)
if
(*pc->p == '\n')
else if
(*pc->p == '\n')
xdigitval(int)
odigitval(int)
JimEscape(char *, const char *, int)
for
(i = 0; i < slen; i++)
switch
(s[i])
case
'\\':
switch
(s[i + 1])
case
'a':
case
'b':
case
'f':
case
'n':
case
'r':
case
't':
case
'u':
case
'U':
case
'x':
if
(s[i] == 'U')
else if
(s[i] == 'u')
if
(s[i + 1] == '{')
else
for
(k = 0; k < maxchars; k++)
if
(c == -1)
if
(s[i] == '{')
if
(k == 0 || val > 0x1fffff || s[i + k + 1] != '}')
else
if
(k)
if
(s[i] == 'x')
else
case
'v':
case
'\0':
case
'\n':
case
'0':
case
'1':
case
'2':
case
'3':
case
'4':
case
'5':
case
'6':
case
'7':
if
(c == -1)
if
(c == -1)
default
default
JimParserGetTokenObj(Jim_Interp *, struct JimParserCtx *)
if
(len < 0)
if
(pc->tt != JIM_TT_ESC)
else
JimParseList(struct JimParserCtx *)
if
(isspace(UCHAR(*pc->p)))
switch
(*pc->p)
case
'"':
case
'{':
default
if
(pc->len)
JimParseListSep(struct JimParserCtx *)
while
(isspace(UCHAR(*pc->p)))
if
(*pc->p == '\n')
JimParseListQuote(struct JimParserCtx *)
while
(pc->len)
switch
(*pc->p)
case
'\\':
if
(--pc->len == 0)
case
'\n':
case
'"':
JimParseListStr(struct JimParserCtx *)
while
(pc->len)
if
(isspace(UCHAR(*pc->p)))
if
(*pc->p == '\\')
if
(--pc->len == 0)
Jim_NewObj(Jim_Interp *)
if
(interp->freeList != NULL)
else
Jim_FreeObj(Jim_Interp *, Jim_Obj *)
if
(objPtr->bytes != NULL)
Jim_InvalidateStringRep(Jim_Obj *)
if
(objPtr->bytes != NULL)
Jim_DuplicateObj(Jim_Interp *, Jim_Obj *)
if
(objPtr->bytes == NULL)
else if
(objPtr->length == 0)
else
if
(objPtr->typePtr != NULL)
if
(objPtr->typePtr->dupIntRepProc == NULL)
else
Jim_GetString(Jim_Obj *, int *)
if
(objPtr->bytes == NULL)
Jim_Length(Jim_Obj *)
if
(objPtr->bytes == NULL)
Jim_String(Jim_Obj *)
if
(objPtr->bytes == NULL)
JimSetStringBytes(Jim_Obj *, const char *)
dictSubstObjType
interpolatedObjType
FreeInterpolatedInternalRep(Jim_Interp *, Jim_Obj *)
DupInterpolatedInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
stringObjType
DupStringInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
SetStringFromAny(Jim_Interp *, Jim_Obj *)
if
(objPtr->typePtr != &stringObjType)
if
(objPtr->bytes == NULL)
Jim_Utf8Length(Jim_Interp *, Jim_Obj *)
if
(objPtr->internalRep.strValue.charLength < 0)
Jim_NewStringObj(Jim_Interp *, const char *, int)
if
(len == 0)
else
Jim_NewStringObjUtf8(Jim_Interp *, const char *, int)
Jim_NewStringObjNoAlloc(Jim_Interp *, char *, int)
StringAppendString(Jim_Obj *, const char *, int)
if
(objPtr->internalRep.strValue.maxLength < needlen || objPtr->internalRep.strValue.maxLength == 0)
if
(needlen < 7)
if
(objPtr->bytes == JimEmptyStringRep)
else
if
(objPtr->internalRep.strValue.charLength >= 0)
Jim_AppendString(Jim_Interp *, Jim_Obj *, const char *, int)
Jim_AppendObj(Jim_Interp *, Jim_Obj *, Jim_Obj *)
Jim_AppendStrings(Jim_Interp *, Jim_Obj *, ...)
while
(1)
Jim_StringEqObj(Jim_Obj *, Jim_Obj *)
if
(aObjPtr == bObjPtr)
else
Jim_StringMatchObj(Jim_Interp *, Jim_Obj *, Jim_Obj *, int)
Jim_StringCompareObj(Jim_Interp *, Jim_Obj *, Jim_Obj *, int)
JimRelToAbsIndex(int, int)
JimRelToAbsRange(int, int *, int *, int *)
if
(*firstPtr > *lastPtr)
else
if
(rangeLen)
if
(*firstPtr < 0)
if
(*lastPtr >= len)
JimStringGetRange(Jim_Interp *, Jim_Obj *, Jim_Obj *, int, int *, int *, int *)
if
(Jim_GetIndex(interp, firstObjPtr, first) != JIM_OK)
if
(Jim_GetIndex(interp, lastObjPtr, last) != JIM_OK)
Jim_StringByteRangeObj(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj *)
if
(JimStringGetRange(interp, firstObjPtr, lastObjPtr, bytelen, &first, &last, &rangeLen) != JIM_OK)
if
(first == 0 && rangeLen == bytelen)
Jim_StringRangeObj(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj *)
if
(JimStringGetRange(interp, firstObjPtr, lastObjPtr, len, &first, &last, &rangeLen) != JIM_OK)
if
(first == 0 && rangeLen == len)
if
(len == bytelen)
JimStringReplaceObj(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj *, Jim_Obj *)
if
(JimStringGetRange(interp, firstObjPtr, lastObjPtr, len, &first, &last, &rangeLen) != JIM_OK)
if
(last < first)
if
(newStrObj)
JimStrCopyUpperLower(char *, const char *, int)
while
(*str)
JimStringToLower(Jim_Interp *, Jim_Obj *)
JimStringToUpper(Jim_Interp *, Jim_Obj *)
JimStringToTitle(Jim_Interp *, Jim_Obj *)
utf8_memchr(const char *, int, int)
while
(len)
if
(sc == c)
JimFindTrimLeft(const char *, int, const char *, int)
while
(len)
if
(utf8_memchr(trimchars, trimlen, c) == NULL)
JimFindTrimRight(const char *, int, const char *, int)
while
(len)
if
(utf8_memchr(trimchars, trimlen, c) == NULL)
default_trim_chars
default_trim_chars_len
JimStringTrimLeft(Jim_Interp *, Jim_Obj *, Jim_Obj *)
if
(trimcharsObjPtr)
if
(newstr == str)
JimStringTrimRight(Jim_Interp *, Jim_Obj *, Jim_Obj *)
if
(trimcharsObjPtr)
if
(nontrim == NULL)
if
(nontrim == strObjPtr->bytes + len)
if
(Jim_IsShared(strObjPtr))
else
JimStringTrim(Jim_Interp *, Jim_Obj *, Jim_Obj *)
if
(objPtr != strObjPtr && objPtr->refCount == 0)
#define jim_isascii
JimStringIs(Jim_Interp *, Jim_Obj *, Jim_Obj *, int)
if
(Jim_GetEnum(interp, strClass, strclassnames, &strclass, "class", JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK)
if
(len == 0)
switch
(strclass)
case
STR_IS_INTEGER:
case
STR_IS_DOUBLE:
case
STR_IS_BOOLEAN:
case
STR_IS_ALPHA:
case
STR_IS_ALNUM:
case
STR_IS_ASCII:
case
STR_IS_DIGIT:
case
STR_IS_LOWER:
case
STR_IS_UPPER:
case
STR_IS_SPACE:
case
STR_IS_XDIGIT:
case
STR_IS_CONTROL:
case
STR_IS_PRINT:
case
STR_IS_GRAPH:
case
STR_IS_PUNCT:
default
for
(i = 0; i < len; i++)
if
(!isclassfunc(UCHAR(str[i])))
comparedStringObjType
Jim_CompareStringImmediate(Jim_Interp *, Jim_Obj *, const char *)
if
(objPtr->typePtr == &comparedStringObjType && objPtr->internalRep.ptr == str)
else
if
(objPtr->typePtr != &comparedStringObjType)
qsortCompareStringPointers(const void *, const void *)
sourceObjType
FreeSourceInternalRep(Jim_Interp *, Jim_Obj *)
DupSourceInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
JimSetSourceInfo(Jim_Interp *, Jim_Obj *, Jim_Obj *, int)
scriptLineObjType
JimNewScriptLineObj(Jim_Interp *, int, int)
scriptObjType
ScriptToken
objPtr
type
ScriptObj
token
fileNameObj
len
substFlags
inUse
firstline
linenr
missing
FreeScriptInternalRep(Jim_Interp *, Jim_Obj *)
for
(i = 0; i < script->len; i++)
DupScriptInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
ParseToken
token
len
type
line
ParseTokenList
list
size
count
static_list
ScriptTokenListInit(ParseTokenList *)
ScriptTokenListFree(ParseTokenList *)
if
(tokenlist->list != tokenlist->static_list)
ScriptAddToken(ParseTokenList *, const char *, int, int, int)
if
(tokenlist->count == tokenlist->size)
if
(tokenlist->list != tokenlist->static_list)
else
JimCountWordTokens(struct ScriptObj *, ParseToken *)
if
(t->type == JIM_TT_STR && !TOKEN_IS_SEP(t[1].type))
if
((t->len == 1 && *t->token == '*') || (t->len == 6 && strncmp(t->token, "expand", 6) == 0))
else
if
(script->missing == ' ')
while
(!TOKEN_IS_SEP(t->type))
JimMakeScriptObj(Jim_Interp *, const ParseToken *)
if
(t->type == JIM_TT_ESC && memchr(t->token, '\\', t->len) != NULL)
else
ScriptObjAddTokens(Jim_Interp *, struct ScriptObj *, ParseTokenList *)
for
(i = 0; i < tokenlist->count; i++)
for
(i = 0; i < tokenlist->count; i++)
if
(tokenlist->list[i].type == JIM_TT_EOL)
for
(i = 0; i < tokenlist->count;)
while
(tokenlist->list[i].type == JIM_TT_SEP)
if
(wordtokens == 0)
if
(lineargs)
else if
(wordtokens != 1)
if
(wordtokens < 0)
if
(lineargs == 0)
while
(wordtokens--)
if
(lineargs == 0)
for
(i = 0; i < script->len; i++)
Jim_ScriptIsComplete(Jim_Interp *, Jim_Obj *, char *)
if
(stateCharPtr)
JimParseCheckMissing(Jim_Interp *, int)
switch
(ch)
case
'\\':
case
' ':
case
'[':
case
'{':
case
'}':
case
'"':
default
SubstObjAddTokens(Jim_Interp *, struct ScriptObj *, ParseTokenList *)
for
(i = 0; i < tokenlist->count; i++)
JimSetScriptFromAny(Jim_Interp *, struct Jim_Obj *)
if
(objPtr->typePtr == &sourceObjType)
while
(!parser.eof)
if
(objPtr->typePtr == &sourceObjType)
else
JimGetScript(Jim_Interp *, Jim_Obj *)
if
(objPtr == interp->emptyObj)
if
(objPtr->typePtr != &scriptObjType || ((struct ScriptObj *)Jim_GetIntRepPtr(objPtr))->substFlags)
JimScriptValid(Jim_Interp *, ScriptObj *)
if
(JimParseCheckMissing(interp, script->missing) == JIM_ERR)
Jim_InterpIncrProcEpoch(Jim_Interp *)
while
(interp->oldCmdCache)
JimIncrCmdRefCount(Jim_Cmd *)
JimDecrCmdRefCount(Jim_Interp *, Jim_Cmd *)
if
(--cmdPtr->inUse == 0)
if
(cmdPtr->isproc)
if
(cmdPtr->u.proc.staticVars)
else
if
(cmdPtr->u.native.delProc)
if
(cmdPtr->prevCmd)
if
(interp->quitting)
else
if
(++interp->oldCmdCacheSize >= 1000)
JimVariablesHTValDestructor(void *, void *)
JimObjectHTHashFunction(const void *)
if
(JimIsWide(keyObj) && keyObj->bytes == NULL)
if
(objValue > INT_MIN && objValue < INT_MAX)
if
(objValue < 0)
if
(objValue < 0)
JimObjectHTKeyCompare(void *, const void *, const void *)
JimObjectHTKeyValDup(void *, const void *)
JimObjectHTKeyValDestructor(void *, void *)
JimVariablesHashTableType
Jim_GetStringNoQualifier(Jim_Obj *, int *)
if
(len >= 2 && str[0] == ':' && str[1] == ':')
while
(len && *str == ':')
JimCommandsHT_HashFunction(const void *)
JimCommandsHT_KeyCompare(void *, const void *, const void *)
JimCommandsHT_ValDestructor(void *, void *)
JimCommandsHashTableType
------------------------- Commands related functions
Jim_MakeGlobalNamespaceName(Jim_Interp *, Jim_Obj *)
if
(name[0] == ':' && name[1] == ':')
JimQualifyName(Jim_Interp *, Jim_Obj *)
if
(Jim_Length(interp->framePtr->nsObj))
if
(len < 2 || name[0] != ':' || name[1] != ':')
JimCreateCommand(Jim_Interp *, Jim_Obj *, Jim_Cmd *)
if
(interp->local)
if
(he)
Jim_CreateCommandObj(Jim_Interp *, Jim_Obj *, Jim_CmdProc *, void *, Jim_DelCmdProc *)
Jim_CreateCommand(Jim_Interp *, const char *, Jim_CmdProc *, void *, Jim_DelCmdProc *)
JimCreateProcedureStatics(Jim_Interp *, Jim_Cmd *, Jim_Obj *)
if
(len == 0)
for
(i = 0; i < len; i++)
if
(subLen == 1 || subLen == 2)
if
(subLen == 1)
if
(initObjPtr == NULL)
else
if
(JimSetNewVariable(cmdPtr->u.proc.staticVars, nameObjPtr, varPtr) != JIM_OK)
else
Jim_memrchr(const char *, int, int)
for
(i = len; i > 0; i--)
if
(p[i] == c)
JimUpdateProcNamespace(Jim_Interp *, Jim_Cmd *, Jim_Obj *)
if
(cmdPtr->isproc)
if
(pt && pt != cmdname && pt[-1] == ':')
if
(Jim_FindHashEntry(&interp->commands, tempObj))
JimCreateProcedureCmd(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj *, Jim_Obj *)
if
(staticsListObjPtr && JimCreateProcedureStatics(interp, cmdPtr, staticsListObjPtr) != JIM_OK)
for
(i = 0; i < argListLen; i++)
if
(len == 0)
if
(len > 2)
if
(len == 2)
else
if
(Jim_CompareStringImmediate(interp, nameObjPtr, "args"))
if
(cmdPtr->u.proc.argsPos >= 0)
else
if
(len == 2)
else
Jim_DeleteCommand(Jim_Interp *, Jim_Obj *)
if
(Jim_DeleteHashEntry(&interp->commands, nameObj) == JIM_ERR)
Jim_RenameCommand(Jim_Interp *, Jim_Obj *, Jim_Obj *)
if
(Jim_Length(newNameObj) == 0)
if
(he == NULL)
else if
(Jim_FindHashEntry(&interp->commands, newNameObj))
else
if
(cmdPtr->prevCmd)
else
FreeCommandInternalRep(Jim_Interp *, Jim_Obj *)
DupCommandInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
commandObjType
Jim_GetCommand(Jim_Interp *, Jim_Obj *, int)
if
(objPtr->typePtr == &commandObjType && objPtr->internalRep.cmdValue.procEpoch == interp->procEpoch #ifdef jim_ext_namespace && Jim_StringEqObj(objPtr->internalRep.cmdValue.nsObj, interp->framePtr->nsObj) #endif && objPtr->internalRep.cmdValue.cmdPtr->inUse)
else
if
(he == NULL && Jim_Length(interp->framePtr->nsObj))
if
(he == NULL)
if
(flags & JIM_ERRMSG)
while
(cmd->u.proc.upcall)
#define JIM_DICT_SUGAR
variableObjType
SetVariableFromAny(Jim_Interp *, struct Jim_Obj *)
if
(objPtr->typePtr == &variableObjType)
if
(objPtr->internalRep.varValue.callFrameId == framePtr->id)
else if
(objPtr->typePtr == &dictSubstObjType)
if
(len && varName[len - 1] == ')' && strchr(varName, '(') != NULL)
if
(varName[0] == ':' && varName[1] == ':')
while
(*varName == ':')
else
if
(var == NULL && framePtr->staticVars)
if
(var == NULL)
-------------------- Variables related functions
JimSetNewVariable(Jim_HashTable *, Jim_Obj *, Jim_Var *)
JimFindVariable(Jim_HashTable *, Jim_Obj *)
if
(he)
JimUnsetVariable(Jim_HashTable *, Jim_Obj *)
JimCreateVariable(Jim_Interp *, Jim_Obj *, Jim_Obj *)
if
(name[0] == ':' && name[1] == ':')
while
(*name == ':')
else
Jim_SetVariable(Jim_Interp *, Jim_Obj *, Jim_Obj *)
switch
(SetVariableFromAny(interp, nameObjPtr))
case
JIM_DICT_SUGAR:
case
JIM_ERR:
case
JIM_OK:
if
(var->linkFramePtr == NULL)
else
Jim_SetVariableStr(Jim_Interp *, const char *, Jim_Obj *)
Jim_SetGlobalVariableStr(Jim_Interp *, const char *, Jim_Obj *)
Jim_SetVariableStrWithStr(Jim_Interp *, const char *, const char *)
Jim_SetVariableLink(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_CallFrame *)
switch
(SetVariableFromAny(interp, nameObjPtr))
case
JIM_DICT_SUGAR:
case
JIM_OK:
if
(varPtr->linkFramePtr == NULL)
if
(varName[0] == ':' && varName[1] == ':')
while
(*varName == ':')
else
if
(targetName[0] == ':' && targetName[1] == ':')
while
(*targetName == ':')
if
(framePtr->level < targetCallFrame->level)
if
(framePtr == targetCallFrame)
while
(1)
if
(Jim_Length(objPtr) == varnamelen && memcmp(Jim_String(objPtr), varName, varnamelen) == 0)
Jim_GetVariable(Jim_Interp *, Jim_Obj *, int)
if
(interp->safeexpr)
switch
(SetVariableFromAny(interp, nameObjPtr))
case
JIM_OK:
if
(varPtr->linkFramePtr == NULL)
else
if
(objPtr)
case
JIM_DICT_SUGAR:
if
(flags & JIM_ERRMSG)
Jim_GetGlobalVariable(Jim_Interp *, Jim_Obj *, int)
Jim_GetVariableStr(Jim_Interp *, const char *, int)
Jim_GetGlobalVariableStr(Jim_Interp *, const char *, int)
Jim_UnsetVariable(Jim_Interp *, Jim_Obj *, int)
if
(retval == JIM_DICT_SUGAR)
else if
(retval == JIM_OK)
if
(varPtr->linkFramePtr)
else
if
(nameObjPtr->internalRep.varValue.global)
while
(*name == ':')
else
if
(retval == JIM_OK)
if
(retval != JIM_OK && (flags & JIM_ERRMSG))
---------- Dict syntax sugar (similar to array Tcl syntax)
JimDictSugarParseVarKey(Jim_Interp *, Jim_Obj *, Jim_Obj **, Jim_Obj **)
if
(str[len - 1] == ')')
JimDictSugarSet(Jim_Interp *, Jim_Obj *, Jim_Obj *)
if
(err == JIM_OK)
else
if
(!valObjPtr)
if
(Jim_GetVariable(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr, JIM_NONE))
JimDictExpandArrayVariable(Jim_Interp *, Jim_Obj *, Jim_Obj *, int)
if
(!dictObjPtr)
if
(ret != JIM_OK)
else if
((flags & JIM_UNSHARED) && Jim_IsShared(dictObjPtr))
JimDictSugarGet(Jim_Interp *, Jim_Obj *, int)
FreeDictSubstInternalRep(Jim_Interp *, Jim_Obj *)
DupDictSubstInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
SetDictSubstFromAny(Jim_Interp *, Jim_Obj *)
if
(objPtr->typePtr != &dictSubstObjType)
if
(objPtr->typePtr == &interpolatedObjType)
else
JimExpandDictSugar(Jim_Interp *, Jim_Obj *)
if
(interp->safeexpr)
if
(Jim_SubstObj(interp, objPtr->internalRep.dictSubstValue.indexObjPtr, &substKeyObjPtr, JIM_NONE) != JIM_OK)
JimCreateCallFrame(Jim_Interp *, Jim_CallFrame *, Jim_Obj *)
if
(interp->freeFramesList)
else
JimDeleteLocalProcs(Jim_Interp *, Jim_Stack *)
if
(localCommands)
while
((cmdNameObj = Jim_StackPop(localCommands)) != NULL)
if
(he)
if
(cmd->prevCmd)
else
JimInvokeDefer(Jim_Interp *, int)
if
(JimFindVariable(&interp->framePtr->vars, interp->defer) == NULL)
if
(objPtr)
for
(i = listLen; i > 0; i--)
if
(ret != JIM_OK)
if
(ret == JIM_OK || retcode == JIM_ERR)
else
#define JIM_FCF_FULL
#define JIM_FCF_REUSE
JimFreeCallFrame(Jim_Interp *, Jim_CallFrame *, int)
else
JimReferencesHTValDestructor(void *, void *)
if
(refPtr->finalizerCmdNamePtr != NULL)
JimReferencesHTHashFunction(const void *)
JimReferencesHTKeyDup(void *, const void *)
JimReferencesHTKeyCompare(void *, const void *, const void *)
JimReferencesHTKeyDestructor(void *, void *)
JimReferencesHashTableType
#define JIM_REFERENCE_SPACE
JimFormatReference(char *, Jim_Reference *, unsigned long)
referenceObjType
UpdateStringOfReference(struct Jim_Obj *)
isrefchar(int)
SetReferenceFromAny(Jim_Interp *, Jim_Obj *)
for
(i = 0; i < JIM_REFERENCE_TAGLEN; i++)
if
(he == NULL)
Jim_NewReference(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj *)
for
(i = 0; i < JIM_REFERENCE_TAGLEN; i++)
Jim_GetReference(Jim_Interp *, Jim_Obj *)
Jim_SetFinalizer(Jim_Interp *, Jim_Obj *, Jim_Obj *)
Jim_GetFinalizer(Jim_Interp *, Jim_Obj *, Jim_Obj **)
JimRefMarkHashTableType
Jim_Collect(Jim_Interp *)
if
(interp->lastCollectId == (unsigned long)~0)
while
(objPtr)
if
(objPtr->typePtr == NULL || objPtr->typePtr->flags & JIM_TYPE_REFERENCES)
if
(objPtr->typePtr == &referenceObjType)
if
(len < JIM_REFERENCE_SPACE)
if
(str[0] == ':' && str[1] == ':')
while
(1)
if
(p == str && objPtr->refCount == 1 && Jim_FindHashEntry(&interp->commands, objPtr))
while
((he = Jim_NextHashEntry(&htiter)) != NULL)
if
(Jim_FindHashEntry(&marks, refId) == NULL)
if
(refPtr->finalizerCmdNamePtr)
#define JIM_COLLECT_ID_PERIOD
#define JIM_COLLECT_TIME_PERIOD
Jim_CollectIfNeeded(Jim_Interp *)
if
(elapsedId > JIM_COLLECT_ID_PERIOD || elapsedTime > JIM_COLLECT_TIME_PERIOD)
Jim_IsBigEndian()
Jim_CreateInterp()
Jim_FreeInterp(Jim_Interp *)
for
(cf = i->framePtr; cf; cf = cfx)
if
(i->traceCmdObj)
if
(i->liveList != NULL)
while
(objPtr)
if
(objPtr->bytes && strlen(objPtr->bytes) > 20)
else
if
(objPtr->typePtr == &sourceObjType)
while
(objPtr)
for
(cf = i->freeFramesList; cf; cf = cfx)
Jim_GetCallFrameByLevel(Jim_Interp *, Jim_Obj *)
if
(levelObjPtr)
if
(str[0] == '#')
if
(str[1] == '\0' || endptr[0] != '\0')
else
if
(Jim_GetLong(interp, levelObjPtr, &level) != JIM_OK || level < 0)
else
else
if
(level == 0)
if
(level > 0)
for
(framePtr = interp->framePtr; framePtr; framePtr = framePtr->parent)
if
(framePtr->level == level)
JimGetCallFrameByInteger(Jim_Interp *, Jim_Obj *)
if
(Jim_GetLong(interp, levelObjPtr, &level) == JIM_OK)
if
(level <= 0)
if
(level == 0)
for
(framePtr = interp->framePtr; framePtr; framePtr = framePtr->parent)
if
(framePtr->level == level)
JimResetStackTrace(Jim_Interp *)
JimSetStackTrace(Jim_Interp *, Jim_Obj *)
if
(len >= 3)
if
(Jim_Length(Jim_ListGetIndex(interp, interp->stackTrace, len - 2)) == 0)
JimAppendStackTrace(Jim_Interp *, const char *, Jim_Obj *, int)
if
(strcmp(procname, "unknown") == 0)
if
(!*procname && !Jim_Length(fileNameObj))
if
(Jim_IsShared(interp->stackTrace))
if
(!*procname && Jim_Length(fileNameObj))
if
(len >= 3)
if
(Jim_Length(objPtr))
if
(Jim_Length(objPtr) == 0)
Jim_SetAssocData(Jim_Interp *, const char *, Jim_InterpDeleteProc *, void *)
Jim_GetAssocData(Jim_Interp *, const char *)
if
(entryPtr != NULL)
Jim_DeleteAssocData(Jim_Interp *, const char *)
Jim_GetExitCode(Jim_Interp *)
intObjType
coercedDoubleObjType
UpdateStringOfInt(struct Jim_Obj *)
if
(wideValue == 0)
else
if
(wideValue < 0)
while
(wideValue)
for
(i = 0; i < num; i++)
SetIntFromAny(Jim_Interp *, Jim_Obj *, int)
if
(objPtr->typePtr == &coercedDoubleObjType)
if
(Jim_StringToWide(str, &wideValue, 0) != JIM_OK)
if
(flags & JIM_ERRMSG)
if
((wideValue == JIM_WIDE_MIN || wideValue == JIM_WIDE_MAX) && errno == ERANGE)
JimIsWide(Jim_Obj *)
Jim_GetWide(Jim_Interp *, Jim_Obj *, long long *)
Jim_GetWideExpr(Jim_Interp *, Jim_Obj *, long long *)
if
(objPtr->typePtr == &intObjType)
else
if
(ret == JIM_OK)
if
(ret != JIM_OK)
JimGetWideNoErr(Jim_Interp *, Jim_Obj *, long long *)
Jim_GetLong(Jim_Interp *, Jim_Obj *, long *)
if
(retval == JIM_OK)
Jim_NewIntObj(Jim_Interp *, long long)
#define JIM_DOUBLE_SPACE
doubleObjType
#define isnan
#define isinf
UpdateStringOfDouble(struct Jim_Obj *)
if
(isnan(value))
if
(isinf(value))
if
(value < 0)
else
for
(i = 0; i < len; i++)
if
(buf[i] == '.' || buf[i] == 'e')
if
(buf[i] == '\0')
SetDoubleFromAny(Jim_Interp *, Jim_Obj *)
#define MIN_INT_IN_DOUBLE
#define MAX_INT_IN_DOUBLE
if
(objPtr->typePtr == &intObjType && JimWideValue(objPtr) >= MIN_INT_IN_DOUBLE && JimWideValue(objPtr) <= MAX_INT_IN_DOUBLE)
if
(Jim_StringToWide(str, &wideValue, 10) == JIM_OK)
else
if
(Jim_StringToDouble(str, &doubleValue) != JIM_OK)
Jim_GetDouble(Jim_Interp *, Jim_Obj *, double *)
if
(objPtr->typePtr == &coercedDoubleObjType)
if
(objPtr->typePtr == &coercedDoubleObjType)
else
Jim_NewDoubleObj(Jim_Interp *, double)
Jim_GetBoolean(Jim_Interp *, Jim_Obj *, int *)
jim_true_false_strings
jim_true_false_lens
SetBooleanFromAny(Jim_Interp *, Jim_Obj *, int)
if
(index < 0)
if
(flags & JIM_ERRMSG)
listObjType
FreeListInternalRep(Jim_Interp *, Jim_Obj *)
for
(i = 0; i < objPtr->internalRep.listValue.len; i++)
DupListInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
for
(i = 0; i < dupPtr->internalRep.listValue.len; i++)
#define JIM_ELESTR_SIMPLE
#define JIM_ELESTR_BRACE
#define JIM_ELESTR_QUOTE
ListElementQuotingType(const char *, int)
if
(s[0] == '"' || s[0] == '{')
for
(i = 0; i < len; i++)
switch
(s[i])
case
' ':
case
'$':
case
'"':
case
'[':
case
']':
case
';':
case
'\\':
case
'\r':
case
'\n':
case
'\t':
case
'\f':
case
'\v':
case
'{':
case
'}':
for
(i = 0; i < len; i++)
switch
(s[i])
case
'{':
case
'}':
case
'[':
case
']':
case
'\\':
if
(blevel < 0)
if
(level == 0)
for
(i = 0; i < len; i++)
switch
(s[i])
case
' ':
case
'$':
case
'"':
case
'[':
case
']':
case
';':
case
'\\':
case
'\r':
case
'\n':
case
'\t':
case
'\f':
case
'\v':
BackslashQuoteString(const char *, int, char *)
while
(len--)
switch
(*s)
case
' ':
case
'$':
case
'"':
case
'[':
case
']':
case
'{':
case
'}':
case
';':
case
'\\':
case
'\n':
case
'\r':
case
'\t':
case
'\f':
case
'\v':
default
JimMakeListStringRep(Jim_Obj *, Jim_Obj **, int)
#define STATIC_QUOTING_LEN
if
(objc > STATIC_QUOTING_LEN)
else
for
(i = 0; i < objc; i++)
switch
(quotingType[i])
case
JIM_ELESTR_SIMPLE:
if
(i != 0 || strRep[0] != '#')
case
JIM_ELESTR_BRACE:
case
JIM_ELESTR_QUOTE:
for
(i = 0; i < objc; i++)
switch
(quotingType[i])
case
JIM_ELESTR_SIMPLE:
case
JIM_ELESTR_BRACE:
case
JIM_ELESTR_QUOTE:
if
(i == 0 && strRep[0] == '#')
if
(i + 1 != objc)
if
(quotingType != staticQuoting)
UpdateStringOfList(struct Jim_Obj *)
SetListFromAny(Jim_Interp *, struct Jim_Obj *)
if
(objPtr->typePtr == &listObjType)
if
(Jim_IsDict(objPtr) && objPtr->bytes == NULL)
if
(objPtr->typePtr == &sourceObjType)
else
if
(strLen)
while
(!parser.eof)
Jim_NewListObj(Jim_Interp *, Jim_Obj *const *, int)
if
(len)
JimListGetElements(Jim_Interp *, Jim_Obj *, int *, Jim_Obj ***)
JimSign(long long)
if
(w == 0)
else if
(w < 0)
lsort_info
jmpbuf
command
interp
<anonymous enum>
JIM_LSORT_ASCII
JIM_LSORT_NOCASE
JIM_LSORT_INTEGER
JIM_LSORT_REAL
JIM_LSORT_COMMAND
type
order
indexv
indexc
unique
subfn
sort_info
ListSortIndexHelper(Jim_Obj **, Jim_Obj **)
if
(Jim_ListIndices(sort_info->interp, *lhsObj, sort_info->indexv, sort_info->indexc, &lObj, JIM_ERRMSG) != JIM_OK || Jim_ListIndices(sort_info->interp, *rhsObj, sort_info->indexv, sort_info->indexc, &rObj, JIM_ERRMSG) != JIM_OK)
ListSortString(Jim_Obj **, Jim_Obj **)
ListSortStringNoCase(Jim_Obj **, Jim_Obj **)
ListSortInteger(Jim_Obj **, Jim_Obj **)
if
(Jim_GetWide(sort_info->interp, *lhsObj, &lhs) != JIM_OK || Jim_GetWide(sort_info->interp, *rhsObj, &rhs) != JIM_OK)
ListSortReal(Jim_Obj **, Jim_Obj **)
if
(Jim_GetDouble(sort_info->interp, *lhsObj, &lhs) != JIM_OK || Jim_GetDouble(sort_info->interp, *rhsObj, &rhs) != JIM_OK)
if
(lhs == rhs)
if
(lhs > rhs)
ListSortCommand(Jim_Obj **, Jim_Obj **)
if
(rc != JIM_OK || Jim_GetWide(sort_info->interp, Jim_GetResult(sort_info->interp), &ret) != JIM_OK)
ListRemoveDuplicates(Jim_Obj *, int (*)(Jim_Obj **, Jim_Obj **))
for
(src = 1; src < listObjPtr->internalRep.listValue.len; src++)
if
(comp(&ele[dst], &ele[src]) == 0)
else
if
(dst < listObjPtr->internalRep.listValue.len)
ListSortElements(Jim_Interp *, Jim_Obj *, struct lsort_info *)
switch
(info->type)
case
JIM_LSORT_ASCII:
case
JIM_LSORT_NOCASE:
case
JIM_LSORT_INTEGER:
case
JIM_LSORT_REAL:
case
JIM_LSORT_COMMAND:
default
if
(info->indexc)
if
((rc = setjmp(info->jmpbuf)) == 0)
if
(info->unique && len > 1)
ListEnsureLength(Jim_Obj *, int)
if
(idx >= listPtr->internalRep.listValue.maxLen)
if
(idx < 4)
ListInsertElements(Jim_Obj *, int, int, Jim_Obj *const *)
if
(requiredLen > listPtr->internalRep.listValue.maxLen)
if
(currentLen)
if
(idx < 0)
for
(i = 0; i < elemc; ++i)
ListAppendElement(Jim_Obj *, Jim_Obj *)
ListAppendList(Jim_Obj *, Jim_Obj *)
Jim_ListAppendElement(Jim_Interp *, Jim_Obj *, Jim_Obj *)
Jim_ListAppendList(Jim_Interp *, Jim_Obj *, Jim_Obj *)
Jim_ListLength(Jim_Interp *, Jim_Obj *)
Jim_ListInsertElements(Jim_Interp *, Jim_Obj *, int, int, Jim_Obj *const *)
Jim_ListGetIndex(Jim_Interp *, Jim_Obj *, int)
if
((idx >= 0 && idx >= listPtr->internalRep.listValue.len) || (idx < 0 && (-idx - 1) >= listPtr->internalRep.listValue.len))
Jim_ListIndex(Jim_Interp *, Jim_Obj *, int, Jim_Obj **, int)
if
(*objPtrPtr == NULL)
if
(flags & JIM_ERRMSG)
Jim_ListIndices(Jim_Interp *, Jim_Obj *, Jim_Obj *const *, int, Jim_Obj **, int)
if
(indexc > sizeof(static_idxes) / sizeof(*static_idxes))
for
(i = 0; i < indexc; i++)
if
(ret != JIM_OK)
for
(i = 0; i < indexc; i++)
if
(!objPtr)
if
(flags & JIM_ERRMSG)
if
(idxes[i] < 0 || idxes[i] > Jim_ListLength(interp, listPtr))
else
ListSetIndex(Jim_Interp *, Jim_Obj *, int, Jim_Obj *, int)
if
((idx >= 0 && idx >= listPtr->internalRep.listValue.len) || (idx < 0 && (-idx - 1) >= listPtr->internalRep.listValue.len))
if
(flags & JIM_ERRMSG)
Jim_ListSetIndex(Jim_Interp *, Jim_Obj *, Jim_Obj *const *, int, Jim_Obj *)
for
(i = 0; i < indexc - 1; i++)
if
(objPtr == NULL)
if
(Jim_IsShared(objPtr))
if
(shared)
Jim_ListJoin(Jim_Interp *, Jim_Obj *, const char *, int)
for
(i = 0; i < listLen;)
if
(++i != listLen)
Jim_ConcatObj(Jim_Interp *, int, Jim_Obj *const *)
for
(i = 0; i < objc; i++)
if
(i == objc)
else
for
(i = 0; i < objc; i++)
for
(i = 0; i < objc; i++)
while
(objLen && isspace(UCHAR(*s)))
while
(objLen && isspace(UCHAR(s[objLen - 1])))
if
(objLen > 1 && s[objLen - 2] == '\\')
if
(i + 1 != objc)
else
Jim_ListRange(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj *)
if
(first == 0 && last == len)
dictObjType
JimFreeDict(Jim_Interp *, Jim_Dict *)
for
(i = 0; i < dict->len; i++)
<anonymous enum>
DICT_HASH_FIND
DICT_HASH_REMOVE
DICT_HASH_ADD
JimDictHashFind(Jim_Dict *, Jim_Obj *, int)
if
(dict->len)
while
((tvoffset = dict->ht[idx].offset))
if
(tvoffset == -1)
if
(op_tvoffset == DICT_HASH_ADD)
else if
(dict->ht[idx].hash == h)
if
(Jim_StringEqObj(keyObjPtr, dict->table[tvoffset - 1]))
switch
(op_tvoffset)
case
DICT_HASH_FIND:
case
DICT_HASH_REMOVE:
if
(tvoffset)
case
DICT_HASH_ADD:
if
(tvoffset == 0)
default
JimDictExpandHashTable(Jim_Dict *, unsigned int)
for
(i = 0; i < prevsize; i++)
if
(prevht[i].offset > 0)
while
(dict->ht[idx].offset)
JimDictAdd(Jim_Dict *, Jim_Obj *)
if
(dict->size <= dict->len)
JimDictNew(Jim_Interp *, int, int)
if
(ht_size)
if
(table_size)
FreeDictInternalRep(Jim_Interp *, Jim_Obj *)
DupDictInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
for
(i = 0; i < oldDict->len; i++)
UpdateStringOfDict(struct Jim_Obj *)
SetDictFromAny(Jim_Interp *, struct Jim_Obj *)
if
(objPtr->typePtr == &dictObjType)
if
(Jim_IsList(objPtr) && Jim_IsShared(objPtr))
if
(listlen % 2)
else
for
(i = 0; i < listlen; i += 2)
if
(tvoffset)
else
if
(dict->len != i)
else
DictAddElement(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj *)
if
(valueObjPtr == NULL)
if
(tvoffset)
if
(tvoffset != dict->len + 1)
else
if
(tvoffset)
else
if
(dict->maxLen == dict->len)
if
(dict->maxLen < 4)
else
Jim_DictAddElement(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj *)
if
(SetDictFromAny(interp, objPtr) != JIM_OK)
Jim_NewDictObj(Jim_Interp *, Jim_Obj *const *, int)
Jim_DictKey(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj **, int)
if
(SetDictFromAny(interp, dictPtr) != JIM_OK)
if
(tvoffset == 0)
if
(flags & JIM_ERRMSG)
Jim_DictPairs(Jim_Interp *, Jim_Obj *, int *)
if
(Jim_IsList(dictPtr))
if
(*len % 2 == 0)
if
(SetDictFromAny(interp, dictPtr) != JIM_OK)
Jim_DictKeysVector(Jim_Interp *, Jim_Obj *, Jim_Obj *const *, int, Jim_Obj **, int)
if
(keyc == 0)
for
(i = 0; i < keyc; i++)
if
(rc != JIM_OK)
Jim_SetDictKeysVector(Jim_Interp *, Jim_Obj *, Jim_Obj *const *, int, Jim_Obj *, int)
if
(objPtr == NULL)
if
(newObjPtr == NULL && (flags & JIM_MUSTEXIST))
if
(Jim_SetVariable(interp, varNamePtr, objPtr) != JIM_OK)
for
(i = 0; i < keyc; i++)
if
(SetDictFromAny(interp, dictObjPtr) != JIM_OK)
if
(i == keyc - 1)
if
(Jim_DictAddElement(interp, objPtr, keyv[keyc - 1], newObjPtr) != JIM_OK)
if
(newObjPtr || (flags & JIM_MUSTEXIST))
if
(Jim_DictKey(interp, dictObjPtr, keyv[i], &objPtr, newObjPtr ? JIM_NONE : JIM_ERRMSG) == JIM_OK)
if
(Jim_IsShared(objPtr))
else
if
(newObjPtr == NULL)
if
(Jim_SetVariable(interp, varNamePtr, varObjPtr) != JIM_OK)
if
(shared)
indexObjType
UpdateStringOfIndex(struct Jim_Obj *)
if
(objPtr->internalRep.intValue == -1)
else
if
(objPtr->internalRep.intValue >= 0 || objPtr->internalRep.intValue == -INT_MAX)
else
SetIndexFromAny(Jim_Interp *, Jim_Obj *)
if
(strncmp(str, "end", 3) == 0)
switch
(*str)
case
'\0':
case
'-':
case
'+':
default
if
(exprObj)
if
(ret != JIM_OK)
if
(end)
if
(idx > 0)
else
else if
(idx < 0)
Jim_GetIndex(Jim_Interp *, Jim_Obj *, int *)
if
(objPtr->typePtr == &intObjType)
jimReturnCodes
#define jimReturnCodesSize
returnCodeObjType
Jim_ReturnCode(int)
if
(code < 0 || code >= (int)jimReturnCodesSize)
else
SetReturnCodeFromAny(Jim_Interp *, Jim_Obj *)
else if
(Jim_GetEnum(interp, objPtr, jimReturnCodes, &returnCode, NULL, JIM_NONE) != JIM_OK)
Jim_GetReturnCode(Jim_Interp *, Jim_Obj *, int *)
<anonymous enum>
JIM_EXPROP_MUL
JIM_EXPROP_DIV
JIM_EXPROP_MOD
JIM_EXPROP_SUB
JIM_EXPROP_ADD
JIM_EXPROP_LSHIFT
JIM_EXPROP_RSHIFT
JIM_EXPROP_ROTL
JIM_EXPROP_ROTR
JIM_EXPROP_LT
JIM_EXPROP_GT
JIM_EXPROP_LTE
JIM_EXPROP_GTE
JIM_EXPROP_NUMEQ
JIM_EXPROP_NUMNE
JIM_EXPROP_BITAND
JIM_EXPROP_BITXOR
JIM_EXPROP_BITOR
JIM_EXPROP_LOGICAND
JIM_EXPROP_LOGICOR
JIM_EXPROP_TERNARY
JIM_EXPROP_COLON
JIM_EXPROP_POW
JIM_EXPROP_STREQ
JIM_EXPROP_STRNE
JIM_EXPROP_STRIN
JIM_EXPROP_STRNI
JIM_EXPROP_STRLT
JIM_EXPROP_STRGT
JIM_EXPROP_STRLE
JIM_EXPROP_STRGE
JIM_EXPROP_NOT
JIM_EXPROP_BITNOT
JIM_EXPROP_UNARYMINUS
JIM_EXPROP_UNARYPLUS
JIM_EXPROP_FUNC_INT
JIM_EXPROP_FUNC_WIDE
JIM_EXPROP_FUNC_ABS
JIM_EXPROP_FUNC_DOUBLE
JIM_EXPROP_FUNC_ROUND
JIM_EXPROP_FUNC_RAND
JIM_EXPROP_FUNC_SRAND
JIM_EXPROP_FUNC_SIN
JIM_EXPROP_FUNC_COS
JIM_EXPROP_FUNC_TAN
JIM_EXPROP_FUNC_ASIN
JIM_EXPROP_FUNC_ACOS
JIM_EXPROP_FUNC_ATAN
JIM_EXPROP_FUNC_ATAN2
JIM_EXPROP_FUNC_SINH
JIM_EXPROP_FUNC_COSH
JIM_EXPROP_FUNC_TANH
JIM_EXPROP_FUNC_CEIL
JIM_EXPROP_FUNC_FLOOR
JIM_EXPROP_FUNC_EXP
JIM_EXPROP_FUNC_LOG
JIM_EXPROP_FUNC_LOG10
JIM_EXPROP_FUNC_SQRT
JIM_EXPROP_FUNC_POW
JIM_EXPROP_FUNC_HYPOT
JIM_EXPROP_FUNC_FMOD
JimExprNode
type
objPtr
left
right
ternary
Jim_ExprOperator
name
funcop
precedence
arity
attr
namelen
JimExprOpNumUnary(Jim_Interp *, struct JimExprNode *)
if
((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK)
if
((A->typePtr != &doubleObjType || A->bytes) && JimGetWideNoErr(interp, A, &wA) == JIM_OK)
switch
(node->type)
case
JIM_EXPROP_FUNC_INT:
case
JIM_EXPROP_FUNC_WIDE:
case
JIM_EXPROP_FUNC_ROUND:
case
JIM_EXPROP_UNARYPLUS:
case
JIM_EXPROP_FUNC_DOUBLE:
case
JIM_EXPROP_FUNC_ABS:
case
JIM_EXPROP_UNARYMINUS:
case
JIM_EXPROP_NOT:
default
else if
((rc = Jim_GetDouble(interp, A, &dA)) == JIM_OK)
switch
(node->type)
case
JIM_EXPROP_FUNC_INT:
case
JIM_EXPROP_FUNC_WIDE:
case
JIM_EXPROP_FUNC_ROUND:
case
JIM_EXPROP_FUNC_DOUBLE:
case
JIM_EXPROP_UNARYPLUS:
case
JIM_EXPROP_FUNC_ABS:
case
JIM_EXPROP_UNARYMINUS:
case
JIM_EXPROP_NOT:
default
else if
((rc = Jim_GetBoolean(interp, A, &bA)) == JIM_OK)
switch
(node->type)
case
JIM_EXPROP_NOT:
default
if
(rc == JIM_OK)
if
(intresult)
else
JimRandDouble(Jim_Interp *)
JimExprOpIntUnary(Jim_Interp *, struct JimExprNode *)
if
((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK)
if
(rc == JIM_OK)
switch
(node->type)
case
JIM_EXPROP_BITNOT:
case
JIM_EXPROP_FUNC_SRAND:
default
JimExprOpNone(Jim_Interp *, struct JimExprNode *)
JimExprOpIntBin(Jim_Interp *, struct JimExprNode *)
if
((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK)
if
((rc = JimExprGetTerm(interp, node->right, &B)) != JIM_OK)
if
(Jim_GetWide(interp, A, &wA) == JIM_OK && Jim_GetWide(interp, B, &wB) == JIM_OK)
switch
(node->type)
case
JIM_EXPROP_LSHIFT:
case
JIM_EXPROP_RSHIFT:
case
JIM_EXPROP_BITAND:
case
JIM_EXPROP_BITXOR:
case
JIM_EXPROP_BITOR:
case
JIM_EXPROP_MOD:
if
(wB == 0)
else
if
(wB < 0)
if
(wC < 0)
if
(negative)
case
JIM_EXPROP_ROTL:
case
JIM_EXPROP_ROTR:
if
(node->type == JIM_EXPROP_ROTR)
default
JimExprOpBin(Jim_Interp *, struct JimExprNode *)
if
((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK)
if
((rc = JimExprGetTerm(interp, node->right, &B)) != JIM_OK)
if
((A->typePtr != &doubleObjType || A->bytes) && (B->typePtr != &doubleObjType || B->bytes) && JimGetWideNoErr(interp, A, &wA) == JIM_OK && JimGetWideNoErr(interp, B, &wB) == JIM_OK)
switch
(node->type)
case
JIM_EXPROP_POW:
case
JIM_EXPROP_FUNC_POW:
if
(wA == 0 && wB < 0)
case
JIM_EXPROP_ADD:
case
JIM_EXPROP_SUB:
case
JIM_EXPROP_MUL:
case
JIM_EXPROP_DIV:
if
(wB == 0)
if
(wB < 0)
if
(wA % wB < 0)
case
JIM_EXPROP_LT:
case
JIM_EXPROP_GT:
case
JIM_EXPROP_LTE:
case
JIM_EXPROP_GTE:
case
JIM_EXPROP_NUMEQ:
case
JIM_EXPROP_NUMNE:
if
(Jim_GetDouble(interp, A, &dA) == JIM_OK && Jim_GetDouble(interp, B, &dB) == JIM_OK)
switch
(node->type)
case
JIM_EXPROP_POW:
case
JIM_EXPROP_FUNC_POW:
case
JIM_EXPROP_FUNC_ATAN2:
case
JIM_EXPROP_FUNC_HYPOT:
case
JIM_EXPROP_POW:
case
JIM_EXPROP_FUNC_POW:
case
JIM_EXPROP_FUNC_ATAN2:
case
JIM_EXPROP_FUNC_HYPOT:
case
JIM_EXPROP_ADD:
case
JIM_EXPROP_SUB:
case
JIM_EXPROP_MUL:
case
JIM_EXPROP_DIV:
if
(dB == 0)
else
case
JIM_EXPROP_LT:
case
JIM_EXPROP_GT:
case
JIM_EXPROP_LTE:
case
JIM_EXPROP_GTE:
case
JIM_EXPROP_NUMEQ:
case
JIM_EXPROP_NUMNE:
else
switch
(node->type)
case
JIM_EXPROP_LT:
case
JIM_EXPROP_GT:
case
JIM_EXPROP_LTE:
case
JIM_EXPROP_GTE:
case
JIM_EXPROP_NUMEQ:
case
JIM_EXPROP_NUMNE:
JimSearchList(Jim_Interp *, Jim_Obj *, Jim_Obj *)
for
(i = 0; i < listlen; i++)
if
(Jim_StringEqObj(Jim_ListGetIndex(interp, listObjPtr, i), valObj))
JimExprOpStrBin(Jim_Interp *, struct JimExprNode *)
if
((rc = JimExprGetTerm(interp, node->left, &A)) != JIM_OK)
if
((rc = JimExprGetTerm(interp, node->right, &B)) != JIM_OK)
switch
(node->type)
case
JIM_EXPROP_STREQ:
case
JIM_EXPROP_STRNE:
if
(node->type == JIM_EXPROP_STRNE)
case
JIM_EXPROP_STRLT:
case
JIM_EXPROP_STRGT:
case
JIM_EXPROP_STRLE:
case
JIM_EXPROP_STRGE:
if
(node->type == JIM_EXPROP_STRLT)
else if
(node->type == JIM_EXPROP_STRGT)
else if
(node->type == JIM_EXPROP_STRLE)
else
case
JIM_EXPROP_STRIN:
case
JIM_EXPROP_STRNI:
default
ExprBool(Jim_Interp *, Jim_Obj *)
if
(Jim_GetLong(interp, obj, &l) == JIM_OK)
else if
(Jim_GetDouble(interp, obj, &d) == JIM_OK)
else if
(Jim_GetBoolean(interp, obj, &b) == JIM_OK)
JimExprOpAnd(Jim_Interp *, struct JimExprNode *)
if
(result == 1)
if
(result == -1)
JimExprOpOr(Jim_Interp *, struct JimExprNode *)
if
(result == 0)
if
(result == -1)
JimExprOpTernary(Jim_Interp *, struct JimExprNode *)
if
(result == 1)
else if
(result == 0)
<anonymous enum>
OP_FUNC
OP_RIGHT_ASSOC
#define OPRINIT_ATTR
#define OPRINIT
Jim_ExprOperators
JimParseExpression(struct JimParserCtx *)
while
(1)
while
(isspace(UCHAR(*pc->p)) || (*(pc->p) == '\\' && *(pc->p + 1) == '\n'))
if
(*pc->p == '\n')
if
(*pc->p == '#')
if
(pc->len == 0)
switch
(*(pc->p))
case
'(':
case
')':
case
',':
case
'[':
case
'$':
else
if
(pc->tt == JIM_TT_EXPRSUGAR)
case
'0':
case
'1':
case
'2':
case
'3':
case
'4':
case
'5':
case
'6':
case
'7':
case
'8':
case
'9':
case
'.':
case
'"':
case
'{':
case
'N':
case
'I':
case
'n':
case
'i':
case
't':
case
'f':
case
'o':
case
'y':
default
JimParseExprNumber(struct JimParserCtx *)
if
(strchr("eENnIi.", *pc->p) || pc->p == pc->tstart)
if
(end > pc->p)
JimParseExprIrrational(struct JimParserCtx *)
for
(i = 0; irrationals[i]; i++)
if
(strncmp(irr, pc->p, 3) == 0)
JimParseExprBoolean(struct JimParserCtx *)
for
(i = 0; i < sizeof(jim_true_false_strings) / sizeof(*jim_true_false_strings); i++)
if
(strncmp(pc->p, jim_true_false_strings[i], jim_true_false_lens[i]) == 0)
JimExprOperatorInfoByOpcode(int)
if
(opcode < JIM_TT_EXPR_OP)
JimParseExprOperator(struct JimParserCtx *)
for
(i = 0; i < (signed)JIM_EXPR_OPERATORS_NUM; i++)
if
(op->name[0] != pc->p[0])
if
(op->namelen > bestLen && strncmp(op->name, pc->p, op->namelen) == 0)
if
(bestOp == NULL)
if
(bestOp->attr & OP_FUNC)
while
(len && isspace(UCHAR(*p)))
if
(*p != '(')
jim_tt_name(int)
if
(type < JIM_TT_EXPR_OP)
else if
(type == JIM_EXPROP_UNARYMINUS)
else if
(type == JIM_EXPROP_UNARYPLUS)
else
if
(op->name)
exprObjType
ExprTree
expr
nodes
len
inUse
ExprTreeFreeNodes(Jim_Interp *, struct JimExprNode *, int)
for
(i = 0; i < num; i++)
if
(nodes[i].objPtr)
ExprTreeFree(Jim_Interp *, struct ExprTree *)
FreeExprInternalRep(Jim_Interp *, Jim_Obj *)
if
(expr)
if
(--expr->inUse != 0)
DupExprInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
ExprBuilder
parencount
level
token
first_token
stack
exprObjPtr
fileNameObj
nodes
next
#define EXPR_UNTIL_CLOSE
#define EXPR_FUNC_ARGS
#define EXPR_TERNARY
ExprTreeBuildTree(Jim_Interp *, struct ExprBuilder *, int, int, int)
if
(builder->level++ > 200)
while
(builder->token->type != JIM_TT_EOL)
if
(t == builder->first_token)
else
if
(t->type == JIM_TT_SUBEXPR_START)
if
(builder->stack.len == exp_stacklen)
if
(rc != JIM_OK)
else if
(t->type == JIM_TT_SUBEXPR_END)
if
(!(flags & EXPR_UNTIL_CLOSE))
if
(builder->stack.len == exp_stacklen && builder->level > 1)
if
(builder->stack.len == exp_stacklen)
else if
(t->type == JIM_TT_SUBEXPR_COMMA)
if
(!(flags & EXPR_FUNC_ARGS))
if
(builder->stack.len == exp_stacklen)
else
if
(builder->stack.len > exp_stacklen)
else if
(t->type == JIM_EXPROP_COLON)
if
(!(flags & EXPR_TERNARY))
if
(builder->level != 1)
if
(builder->stack.len == exp_stacklen)
else if
(TOKEN_IS_EXPR_OP(t->type))
if
(TOKEN_IS_EXPR_OP(prevtt) || TOKEN_IS_EXPR_START(prevtt))
if
(t->type == JIM_EXPROP_SUB)
else if
(t->type == JIM_EXPROP_ADD)
if
(op->precedence < precedence || (!(op->attr & OP_RIGHT_ASSOC) && op->precedence == precedence))
if
(op->attr & OP_FUNC)
if
(builder->token->type != JIM_TT_SUBEXPR_START)
if
(op->arity == 0)
if
(builder->token->type != JIM_TT_SUBEXPR_END)
else if
(t->type == JIM_EXPROP_TERNARY)
else
if
(rc != JIM_OK)
if
(op->arity >= 3)
if
(node->ternary == NULL)
if
(op->arity >= 2)
if
(node->right == NULL)
if
(op->arity >= 1)
if
(node->left == NULL)
else
if
(!TOKEN_IS_EXPR_START(prevtt) && !TOKEN_IS_EXPR_OP(prevtt))
if
(t->type == JIM_TT_EXPR_INT || t->type == JIM_TT_EXPR_DOUBLE)
if
(t->type == JIM_TT_EXPR_INT)
else
if
(endptr != t->token + t->len)
if
(!objPtr)
if
(t->type == JIM_TT_CMD)
if
(builder->stack.len == exp_stacklen)
if
((flags & EXPR_FUNC_ARGS))
else
if
(builder->stack.len < exp_stacklen)
if
(builder->level == 0)
else
else
ExprTreeCreateTree(Jim_Interp *, const ParseTokenList *, Jim_Obj *, Jim_Obj *)
if
(rc == JIM_OK)
if
(builder.parencount)
if
(rc != JIM_OK)
SetExprFromAny(Jim_Interp *, struct Jim_Obj *)
if
(objPtr->typePtr == &sourceObjType)
else
while
(!parser.eof)
if
(JimParseExpression(&parser) != JIM_OK)
for
(i = 0; i < tokenlist.count; i++)
if
(JimParseCheckMissing(interp, parser.missing.ch) == JIM_ERR)
if
(!expr)
JimGetExpression(Jim_Interp *, Jim_Obj *)
if
(objPtr->typePtr != &exprObjType)
if
(SetExprFromAny(interp, objPtr) != JIM_OK)
JimExprIntValOrVar(Jim_Interp *, struct JimExprNode *)
JimExprEvalTermNode(Jim_Interp *, struct JimExprNode *)
if
(TOKEN_IS_EXPR_OP(node->type))
else
switch
(node->type)
case
JIM_TT_EXPR_INT:
case
JIM_TT_EXPR_DOUBLE:
case
JIM_TT_EXPR_BOOLEAN:
case
JIM_TT_STR:
case
JIM_TT_VAR:
if
(objPtr)
case
JIM_TT_DICTSUGAR:
if
(objPtr)
case
JIM_TT_ESC:
if
(interp->safeexpr)
if
(Jim_SubstObj(interp, node->objPtr, &objPtr, JIM_NONE) == JIM_OK)
case
JIM_TT_CMD:
if
(interp->safeexpr)
default
JimExprGetTerm(Jim_Interp *, struct JimExprNode *, Jim_Obj **)
if
(rc == JIM_OK)
JimExprGetTermBoolean(Jim_Interp *, struct JimExprNode *)
if
(JimExprEvalTermNode(interp, node) == JIM_OK)
Jim_EvalExpression(Jim_Interp *, Jim_Obj *)
if
(!expr)
if
(!interp->safeexpr)
switch
(expr->len)
case
1:
if
(objPtr)
case
2:
if
(expr->expr->type == JIM_EXPROP_NOT)
if
(objPtr && JimIsWide(objPtr))
case
3:
if
(objPtr && JimIsWide(objPtr))
if
(objPtr2 && JimIsWide(objPtr2))
switch
(expr->expr->type)
case
JIM_EXPROP_LT:
case
JIM_EXPROP_LTE:
case
JIM_EXPROP_GT:
case
JIM_EXPROP_GTE:
case
JIM_EXPROP_NUMEQ:
case
JIM_EXPROP_NUMNE:
default
Jim_GetBoolFromExpr(Jim_Interp *, Jim_Obj *, int *)
if
(retcode == JIM_OK)
switch
(ExprBool(interp, Jim_GetResult(interp)))
case
0:
case
1:
case
-1:
ScanFmtPartDescr
arg
prefix
width
pos
type
modifier
ScanFmtStringObj
size
stringRep
count
convCount
maxPos
error
scratch
descr
scanFmtStringObjType
FreeScanFmtInternalRep(Jim_Interp *, Jim_Obj *)
DupScanFmtInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
UpdateStringOfScanFmt(Jim_Obj *)
SetScanFmtFromAny(Jim_Interp *, Jim_Obj *)
for
(i = 0, curr = 0; fmt < fmtEnd; ++fmt)
if
(*fmt != '%' || fmt[1] == '%')
for
(; fmt < fmtEnd; ++fmt)
if
(*fmt == '%')
if
(*fmt == '*')
if
(sscanf(fmt, "%d%n", &width, &skip) == 1)
if
(descr->pos != -1 && *fmt == '$')
if
((lastPos == 0 && descr->pos > 0) || (lastPos > 0 && descr->pos == 0))
for
(prev = 0; prev < curr; ++prev)
if
(fmtObj->descr[prev].pos == descr->pos)
if
(descr->pos < 0)
if
(sscanf(fmt, "%d%n", &width, &skip) == 1)
else
if
(*fmt == '[')
if
(*fmt != ']')
while
(swapped)
for
(j = beg + 1; j < end - 1; ++j)
if
(buffer[j] == '-' && buffer[j - 1] > buffer[j + 1])
else
if
(fmt >= fmtEnd)
if
(strchr("efgcsndoxui", *fmt) == 0)
else if
(*fmt == 'c' && descr->width != 0)
else if
(*fmt == 'u' && descr->modifier == 'l')
JimScanAString(Jim_Interp *, const char *, const char *)
while
(*str)
ScanOneEntry(Jim_Interp *, const char *, int, int, ScanFmtStringObj *, long, Jim_Obj **)
if
(descr->prefix)
for
(i = 0; pos < str_bytelen && descr->prefix[i]; ++i)
if
(pos >= str_bytelen)
if
(descr->type == 'n')
else if
(pos >= str_bytelen)
else if
(descr->type == 'c')
else
if
(descr->width > 0)
else
switch
(descr->type)
case
'd':
case
'o':
case
'x':
case
'u':
case
'i':
if
(base == 0)
else
if
(endp != tok)
else
case
's':
case
'[':
case
'e':
case
'f':
case
'g':
if
(endp != tok)
else
if
(tmpObj)
Jim_ScanString(Jim_Interp *, Jim_Obj *, Jim_Obj *, int)
if
(fmtObj->error != 0)
if
(fmtObj->maxPos > 0)
for
(i = 0, pos = 0; i < fmtObj->count; ++i)
if
(descr->pos == -1)
else if
(resultVec[descr->pos - 1] == emptyStr)
else
JimPrngInit(Jim_Interp *)
#define PRNG_SEED_SIZE
for
(i = 0; i < PRNG_SEED_SIZE; i++)
JimRandomBytes(Jim_Interp *, void *, unsigned int)
for
(x = 0; x < len; x++)
JimPrngSeed(Jim_Interp *, unsigned char *, int)
for
(i = 0; i < seedLen; i++)
for
(i = 0; i < 256; i += seedLen)
Jim_IncrCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 2 && argc != 3)
if
(argc == 3)
if
(!intObjPtr)
else if
(Jim_GetWide(interp, intObjPtr, &wideValue) != JIM_OK)
if
(!intObjPtr || Jim_IsShared(intObjPtr))
if
(Jim_SetVariable(interp, argv[1], intObjPtr) != JIM_OK)
else
if
(argv[1]->typePtr != &variableObjType)
#define JIM_EVAL_SARGV_LEN
#define JIM_EVAL_SINTV_LEN
JimTraceCallback(Jim_Interp *, const char *, int, Jim_Obj *const *)
if
(ret == JIM_OK || ret == JIM_RETURN)
else
JimUnknown(Jim_Interp *, int, Jim_Obj *const *)
if
(interp->unknown_called > 50)
JimInvokeCommand(Jim_Interp *, int, Jim_Obj *const *)
for
(j = 0; j < objc; j++)
if
(cmdPtr == NULL)
if
(interp->evalDepth == interp->maxEvalDepth)
if
(!interp->traceCmdObj || (retcode = JimTraceCallback(interp, "cmd", objc, objv)) == JIM_OK)
if
(cmdPtr->isproc)
else
if
(tailcallObj)
if
(retcode == JIM_EVAL && interp->framePtr->tailcallObj)
if
(interp->framePtr->tailcallObj)
Jim_EvalObjVector(Jim_Interp *, int, Jim_Obj *const *)
Jim_EvalObjPrefix(Jim_Interp *, Jim_Obj *, int, Jim_Obj *const *)
JimAddErrorToStack(Jim_Interp *, ScriptObj *)
if
(!interp->errorFlag)
if
(interp->addStackTrace > 0)
if
(Jim_Length(script->fileNameObj))
JimSubstOneToken(Jim_Interp *, const ScriptToken *, Jim_Obj **)
switch
(token->type)
case
JIM_TT_STR:
case
JIM_TT_ESC:
case
JIM_TT_VAR:
case
JIM_TT_DICTSUGAR:
case
JIM_TT_EXPRSUGAR:
if
(ret == JIM_OK)
else
case
JIM_TT_CMD:
if
(ret == JIM_OK || ret == JIM_RETURN)
else
default
if
(objPtr)
JimInterpolateTokens(Jim_Interp *, const ScriptToken *, int, int)
for
(i = 0; i < tokens; i++)
switch
(JimSubstOneToken(interp, &token[i], &intv[i]))
case
JIM_OK:
case
JIM_RETURN:
case
JIM_BREAK:
if
(flags & JIM_SUBST_FLAG)
case
JIM_CONTINUE:
if
(flags & JIM_SUBST_FLAG)
default
while
(i--)
if
(intv != sintv)
if
(tokens == 1 && intv[0] && intv == sintv)
if
(tokens == 4 && token[0].type == JIM_TT_ESC && token[1].type == JIM_TT_ESC && token[2].type == JIM_TT_VAR)
else if
(tokens && intv[0] && intv[0]->typePtr == &sourceObjType)
for
(i = 0; i < tokens; i++)
if
(intv[i])
if
(intv != sintv)
JimEvalObjList(Jim_Interp *, Jim_Obj *)
if
(listPtr->internalRep.listValue.len)
Jim_EvalObjList(Jim_Interp *, Jim_Obj *)
Jim_EvalObj(Jim_Interp *, Jim_Obj *)
if
(Jim_IsList(scriptObjPtr) && scriptObjPtr->bytes == NULL)
if
(!JimScriptValid(interp, script))
if
(script->len == 0)
if
(script->len == 3 && token[1].objPtr->typePtr == &commandObjType && token[1].objPtr->internalRep.cmdValue.cmdPtr->isproc == 0 && token[1].objPtr->internalRep.cmdValue.cmdPtr->u.native.cmdProc == Jim_IncrCoreCommand && token[2].objPtr->typePtr == &variableObjType)
if
(objPtr && !Jim_IsShared(objPtr) && objPtr->typePtr == &intObjType)
for
(i = 0; i < script->len && retcode == JIM_OK;)
for
(j = 0; j < argc; j++)
if
(token[i].type == JIM_TT_WORD)
if
(wordtokens < 0)
if
(wordtokens == 1)
switch
(token[i].type)
case
JIM_TT_ESC:
case
JIM_TT_STR:
case
JIM_TT_VAR:
case
JIM_TT_EXPRSUGAR:
if
(retcode == JIM_OK)
else
case
JIM_TT_DICTSUGAR:
case
JIM_TT_CMD:
if
(retcode == JIM_OK)
default
else
if
(!wordObjPtr)
if
(retcode == JIM_OK)
if
(!expand)
else
if
(len > 1)
if
(argv == sargv)
if
(newargc > JIM_EVAL_SARGV_LEN)
else
for
(k = 0; k < len; k++)
if
(retcode == JIM_OK && argc)
if
(Jim_CheckSignal(interp))
while
(j-- > 0)
if
(argv != sargv)
if
(retcode == JIM_ERR)
else if
(retcode != JIM_RETURN || interp->returnCode != JIM_ERR)
JimSetProcArg(Jim_Interp *, Jim_Obj *, Jim_Obj *)
if
(*varname == '&')
if
(!objPtr)
else
JimSetProcWrongArgs(Jim_Interp *, Jim_Obj *, Jim_Cmd *)
for
(i = 0; i < cmd->u.proc.argListLen; i++)
if
(i == cmd->u.proc.argsPos)
if
(cmd->u.proc.arglist[i].defaultObjPtr)
else
else
if
(cmd->u.proc.arglist[i].defaultObjPtr)
else
if
(*arg == '&')
Jim_EvalNamespace(Jim_Interp *, Jim_Obj *, Jim_Obj *)
if
(interp->framePtr->level == interp->maxCallFrameDepth)
else
JimCallProcedure(Jim_Interp *, Jim_Cmd *, int, Jim_Obj *const *)
if
(argc - 1 < cmd->u.proc.reqArity || (cmd->u.proc.argsPos < 0 && argc - 1 > cmd->u.proc.reqArity + cmd->u.proc.optArity))
if
(Jim_Length(cmd->u.proc.bodyObjPtr) == 0)
if
(interp->framePtr->level == interp->maxCallFrameDepth)
for
(d = 0; d < cmd->u.proc.argListLen; d++)
if
(d == cmd->u.proc.argsPos)
if
(cmd->u.proc.reqArity + cmd->u.proc.optArity < argc - 1)
if
(cmd->u.proc.arglist[d].defaultObjPtr)
if
(retcode != JIM_OK)
if
(cmd->u.proc.arglist[d].defaultObjPtr == NULL || optargs-- > 0)
else
if
(retcode != JIM_OK)
if
(interp->traceCmdObj == NULL || (retcode = JimTraceCallback(interp, "proc", argc, argv)) == JIM_OK)
if
(retcode == JIM_RETURN)
if
(--interp->returnLevel <= 0)
else if
(retcode == JIM_ERR)
Jim_EvalSource(Jim_Interp *, const char *, int, const char *)
if
(filename)
else
Jim_Eval(Jim_Interp *, const char *)
Jim_EvalGlobal(Jim_Interp *, const char *)
Jim_EvalFileGlobal(Jim_Interp *, const char *)
#include <sys/stat.h>
Jim_EvalFile(Jim_Interp *, const char *)
if
(stat(filename, &sb) != 0 || (fp = fopen(filename, "rt")) == NULL)
if
(sb.st_size == 0)
if
(ferror(fp))
if
(retcode == JIM_RETURN)
if
(--interp->returnLevel <= 0)
if
(retcode == JIM_ERR)
JimParseSubst(struct JimParserCtx *, int)
if
(pc->len == 0)
if
(*pc->p == '[' && !(flags & JIM_SUBST_NOCMD))
if
(*pc->p == '$' && !(flags & JIM_SUBST_NOVAR))
if
(JimParseVar(pc) == JIM_OK)
while
(pc->len)
if
(*pc->p == '$' && !(flags & JIM_SUBST_NOVAR))
if
(*pc->p == '[' && !(flags & JIM_SUBST_NOCMD))
if
(*pc->p == '\\' && pc->len > 1)
SetSubstFromAny(Jim_Interp *, struct Jim_Obj *, int)
while
(1)
if
(parser.eof)
for
(i = 0; i < script->len; i++)
Jim_GetSubst(Jim_Interp *, Jim_Obj *, int)
Jim_SubstObj(Jim_Interp *, Jim_Obj *, Jim_Obj **, int)
if
(*resObjPtrPtr == NULL)
Jim_WrongNumArgs(Jim_Interp *, int, Jim_Obj *const *, const char *)
if
(msg && *msg)
JimHashtableIteratorCallbackType
#define JimTrivialMatch
JimHashtablePatternMatch(Jim_Interp *, Jim_HashTable *, Jim_Obj *, JimHashtableIteratorCallbackType *, int)
if
(patternObjPtr && JimTrivialMatch(Jim_String(patternObjPtr)))
if
(he)
else
while
((he = Jim_NextHashEntry(&htiter)) != NULL)
#define JIM_CMDLIST_COMMANDS
#define JIM_CMDLIST_PROCS
#define JIM_CMDLIST_CHANNELS
JimCommandMatch(Jim_Interp *, Jim_Obj *, Jim_Obj *, void *, Jim_Obj *, int)
if
(type == JIM_CMDLIST_PROCS && !cmdPtr->isproc)
if
(type != JIM_CMDLIST_CHANNELS || Jim_AioFilehandle(interp, keyObj))
if
(patternObj)
if
(match)
JimCommandsList(Jim_Interp *, Jim_Obj *, int)
#define JIM_VARLIST_GLOBALS
#define JIM_VARLIST_LOCALS
#define JIM_VARLIST_VARS
#define JIM_VARLIST_MASK
#define JIM_VARLIST_VALUES
JimVariablesMatch(Jim_Interp *, Jim_Obj *, Jim_Obj *, void *, Jim_Obj *, int)
if
((type & JIM_VARLIST_MASK) != JIM_VARLIST_LOCALS || varPtr->linkFramePtr == NULL)
if
(patternObj == NULL || Jim_StringMatchObj(interp, patternObj, keyObj, 0))
if
(type & JIM_VARLIST_VALUES)
JimVariablesList(Jim_Interp *, Jim_Obj *, int)
if
(mode == JIM_VARLIST_LOCALS && interp->framePtr == interp->topFramePtr)
else
JimInfoLevel(Jim_Interp *, Jim_Obj *, Jim_Obj **, int)
if
(targetCallFrame == NULL)
if
(targetCallFrame == interp->topFramePtr)
if
(info_level_cmd)
else
Jim_PutsCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 2 && argc != 3)
if
(argc == 3)
if
(!Jim_CompareStringImmediate(interp, argv[1], "-nonewline"))
else
else
JimAddMulHelper(Jim_Interp *, int, Jim_Obj *const *, int)
for
(i = 1; i < argc; i++)
for
(; i < argc; i++)
JimSubDivHelper(Jim_Interp *, int, Jim_Obj *const *, int)
if
(argc < 2)
else if
(argc == 2)
if
(Jim_GetWide(interp, argv[1], &wideValue) != JIM_OK)
if
(Jim_GetDouble(interp, argv[1], &doubleValue) != JIM_OK)
else
if
(op == JIM_EXPROP_SUB)
else
else
if
(Jim_GetWide(interp, argv[1], &res) != JIM_OK)
if
(Jim_GetDouble(interp, argv[1], &doubleRes) != JIM_OK)
else
for
(i = 2; i < argc; i++)
if
(Jim_GetWide(interp, argv[i], &wideValue) != JIM_OK)
else
if
(wideValue == 0)
for
(; i < argc; i++)
Jim_AddCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
Jim_MulCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
Jim_SubCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
Jim_DivCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
Jim_SetCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 2 && argc != 3)
if
(argc == 2)
Jim_UnsetCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
while
(i < argc)
if
(Jim_CompareStringImmediate(interp, argv[i], "--"))
if
(Jim_CompareStringImmediate(interp, argv[i], "-nocomplain"))
while
(i < argc)
if
(Jim_UnsetVariable(interp, argv[i], complain ? JIM_ERRMSG : JIM_NONE) != JIM_OK && complain)
Jim_WhileCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 3)
while
(1)
if
((retval = Jim_EvalObj(interp, argv[2])) != JIM_OK)
switch
(retval)
case
JIM_BREAK:
case
JIM_CONTINUE:
default
Jim_ForCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 5)
if
((retval = Jim_EvalObj(interp, argv[1])) != JIM_OK)
if
(retval == JIM_OK && boolean)
if
(incrScript == NULL || incrScript->len != 3 || !expr || expr->len != 3)
if
(incrScript->token[1].type != JIM_TT_ESC)
if
(expr->expr->type == JIM_EXPROP_LT)
else if
(expr->expr->type == JIM_EXPROP_LTE)
else
if
(expr->expr->left->type != JIM_TT_VAR)
if
(expr->expr->right->type != JIM_TT_VAR && expr->expr->right->type != JIM_TT_EXPR_INT)
if
(!Jim_CompareStringImmediate(interp, incrScript->token[1].objPtr, "incr"))
if
(!Jim_StringEqObj(incrScript->token[2].objPtr, expr->expr->left->objPtr))
if
(expr->expr->right->type == JIM_TT_EXPR_INT)
if
(Jim_GetWideExpr(interp, expr->expr->right->objPtr, &stop) == JIM_ERR)
else
if
(objPtr == NULL || Jim_GetWide(interp, objPtr, ¤tVal) != JIM_OK)
while
(retval == JIM_OK)
if
(stopVarNamePtr)
if
(objPtr == NULL || Jim_GetWide(interp, objPtr, &stop) != JIM_OK)
if
(currentVal >= stop + cmpOffset)
if
(retval == JIM_OK || retval == JIM_CONTINUE)
if
(objPtr == NULL)
if
(!Jim_IsShared(objPtr) && objPtr->typePtr == &intObjType)
else
if
(Jim_GetWide(interp, objPtr, ¤tVal) != JIM_OK || Jim_SetVariable(interp, varNamePtr, Jim_NewIntObj(interp, ++currentVal)) != JIM_OK)
while
(boolean && (retval == JIM_OK || retval == JIM_CONTINUE))
if
(retval == JIM_OK || retval == JIM_CONTINUE)
if
(retval == JIM_OK || retval == JIM_CONTINUE)
if
(stopVarNamePtr)
if
(varNamePtr)
if
(retval == JIM_CONTINUE || retval == JIM_BREAK || retval == JIM_OK)
Jim_LoopCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 4 || argc > 6)
if
(argc > 4 && retval == JIM_OK)
if
(argc > 5 && retval == JIM_OK)
if
(retval != JIM_OK)
if
(argc == 4)
while
(((i < limit && incr > 0) || (i > limit && incr < 0)) && retval == JIM_OK)
if
(retval == JIM_OK || retval == JIM_CONTINUE)
if
(objPtr && !Jim_IsShared(objPtr) && objPtr->typePtr == &intObjType)
if
(argv[1]->typePtr != &variableObjType)
if
(Jim_SetVariable(interp, argv[1], objPtr) != JIM_OK)
if
(argv[1]->typePtr != &variableObjType)
if
(Jim_SetVariable(interp, argv[1], objPtr) != JIM_OK)
else
if
(retval != JIM_OK)
if
(retval == JIM_OK || retval == JIM_CONTINUE || retval == JIM_BREAK)
Jim_ListIter
objPtr
idx
JimListIterInit(Jim_ListIter *, Jim_Obj *)
JimListIterNext(Jim_Interp *, Jim_ListIter *)
if
(iter->idx >= Jim_ListLength(interp, iter->objPtr))
JimListIterDone(Jim_Interp *, Jim_ListIter *)
JimForeachMapHelper(Jim_Interp *, int, Jim_Obj *const *, int)
if
(argc < 4 || argc % 2 != 0)
if
(numargs == 2)
else
for
(i = 0; i < numargs; i++)
if
(i % 2 == 0 && JimListIterDone(interp, &iters[i]))
if
(result != JIM_OK)
if
(doMap)
else
while
(1)
for
(i = 0; i < numargs; i += 2)
if
(!JimListIterDone(interp, &iters[i + 1]))
if
(i == numargs)
for
(i = 0; i < numargs; i += 2)
while
((varName = JimListIterNext(interp, &iters[i])) != NULL)
if
(!valObj)
if
(result != JIM_OK)
switch
(result = Jim_EvalObj(interp, script))
case
JIM_OK:
if
(doMap)
case
JIM_CONTINUE:
case
JIM_BREAK:
default
if
(numargs > 2)
Jim_ForeachCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
Jim_LmapCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
Jim_LassignCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
for
(i = 2; i < argc; i++)
if
(result != JIM_OK)
while
(!JimListIterDone(interp, &iter))
Jim_IfCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc >= 3)
while
(1)
if
(++current >= argc)
if
(Jim_CompareStringImmediate(interp, argv[falsebody], "else"))
Jim_CommandMatchObj(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj *, int)
if
(flags & JIM_NOCASE)
if
(flags & JIM_OPT_END)
if
(rc != JIM_OK || Jim_GetLong(interp, Jim_GetResult(interp), &eq) != JIM_OK)
Jim_SwitchCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 3)
for
(opt = 1; opt < argc; ++opt)
else if
(strncmp(option, "--", 2) == 0)
else if
(strncmp(option, "-regexp", 2) == 0)
else if
(strncmp(option, "-command", 2) == 0)
else
if
(patCount == 1)
for
(i = 0; scriptObj == NULL && i < patCount; i += 2)
if
(!Jim_CompareStringImmediate(interp, patObj, "default") || i < (patCount - 2))
switch
(matchOpt)
case
SWITCH_EXACT:
case
SWITCH_GLOB:
case
SWITCH_RE:
case
SWITCH_CMD:
if
(argc - opt == 1)
if
(rc < 0)
else
if
(scriptObj && Jim_CompareStringImmediate(interp, scriptObj, "-"))
if
(scriptObj)
Jim_ListCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
Jim_LindexCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
if
(ret < 0)
else if
(ret == JIM_OK)
Jim_LlengthCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 2)
Jim_LsearchCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 3)
for
(i = 1; i < argc - 2; i++)
if
(Jim_GetEnum(interp, argv[i], options, &option, NULL, JIM_ERRMSG) != JIM_OK)
switch
(option)
case
OPT_BOOL:
case
OPT_NOT:
case
OPT_NOCASE:
case
OPT_INLINE:
case
OPT_ALL:
case
OPT_REGEXP:
case
OPT_COMMAND:
if
(i >= argc - 2)
case
OPT_EXACT:
case
OPT_GLOB:
case
OPT_INDEX:
if
(i >= argc - 2)
case
OPT_STRIDE:
if
(i >= argc - 2)
if
(Jim_GetLong(interp, argv[++i], &stride) != JIM_OK)
if
(stride < 1)
if
(argc < 2)
if
(listlen % stride)
if
(opt_all)
if
(opt_match == OPT_REGEXP)
if
(commandObj)
for
(i = 0; i < listlen; i += stride)
if
(indexObj)
if
(stride == 1)
else
if
(rc != JIM_OK)
else
switch
(opt_match)
case
OPT_EXACT:
case
OPT_GLOB:
case
OPT_REGEXP:
case
OPT_COMMAND:
if
(eq < 0)
if
((!opt_bool && eq == !opt_not) || (opt_bool && (eq || opt_all)))
if
(opt_bool)
else if
(!opt_inline)
else if
(stride == 1)
else if
(opt_all)
else
if
(opt_all)
if
(stride == 1)
else
if
(opt_all)
else
if
(opt_bool)
else if
(!opt_inline)
if
(listObjPtr)
if
(commandObj)
Jim_LappendCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
if
(!listObjPtr)
else if
(Jim_IsShared(listObjPtr))
if
(Jim_SetVariable(interp, argv[1], listObjPtr) != JIM_OK)
Jim_LinsertCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 3)
if
(listPtr != argv[1])
Jim_LreplaceCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 4)
if
(Jim_GetIndex(interp, argv[2], &first) != JIM_OK || Jim_GetIndex(interp, argv[3], &last) != JIM_OK)
if
(first > len)
Jim_LsetCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 3)
else if
(argc == 3)
Jim_LsortCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
for
(i = 1; i < (argc - 1); i++)
switch
(option)
case
OPT_ASCII:
case
OPT_NOCASE:
case
OPT_INTEGER:
case
OPT_REAL:
case
OPT_INCREASING:
case
OPT_DECREASING:
case
OPT_UNIQUE:
case
OPT_COMMAND:
if
(i >= (argc - 2))
case
OPT_STRIDE:
if
(i >= argc - 2)
if
(Jim_GetLong(interp, argv[++i], &stride) != JIM_OK)
if
(stride < 2)
case
OPT_INDEX:
if
(i >= (argc - 2))
if
(info.indexc == 0)
if
(stride > 1)
if
(listlen % stride)
for
(i = 0; i < listlen; i += stride)
if
(retCode == JIM_OK)
for
(i = 0; i < listlen; i += stride)
else
if
((shared = Jim_IsShared(resObj)))
if
(retCode == JIM_OK)
else if
(shared)
Jim_AppendCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
if
(argc == 2)
else
if
(!stringObjPtr)
else if
(Jim_IsShared(stringObjPtr))
for
(i = 2; i < argc; i++)
if
(Jim_SetVariable(interp, argv[1], stringObjPtr) != JIM_OK)
if
(new_obj)
Jim_EvalCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
if
(argc == 2)
else
if
(rc == JIM_ERR)
Jim_UplevelCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc >= 2)
if
((str[0] >= '0' && str[0] <= '9') || str[0] == '#')
else
if
(targetCallFrame == NULL)
if
(argc < 2)
if
(argc == 2)
else
else
Jim_ExprCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc == 2)
else
else if
(argc > 2)
else
Jim_BreakCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 1)
Jim_ContinueCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 1)
Jim_ReturnCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
for
(i = 1; i < argc - 1; i += 2)
if
(Jim_CompareStringImmediate(interp, argv[i], "-code"))
if
(Jim_GetReturnCode(interp, argv[i + 1], &returnCode) == JIM_ERR)
else if
(Jim_CompareStringImmediate(interp, argv[i], "-errorinfo"))
else if
(Jim_CompareStringImmediate(interp, argv[i], "-errorcode"))
else if
(Jim_CompareStringImmediate(interp, argv[i], "-level"))
if
(Jim_GetLong(interp, argv[i + 1], &level) != JIM_OK || level < 0)
else
if
(i != argc - 1 && i != argc)
if
(stackTraceObj && returnCode == JIM_ERR)
if
(errorCodeObj && returnCode == JIM_ERR)
if
(i == argc - 1)
Jim_TailcallCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(interp->framePtr->level == 0)
else if
(argc >= 2)
if
(cmdPtr == NULL)
JimAliasCmd(Jim_Interp *, int, Jim_Obj *const *)
JimAliasCmdDelete(Jim_Interp *, void *)
Jim_AliasCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 3)
Jim_ProcCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 4 && argc != 5)
if
(argc == 4)
else
if
(cmd)
Jim_XtraceCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 2)
if
(interp->traceCmdObj)
if
(Jim_Length(argv[1]))
Jim_LocalCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
if
(retcode == 0)
if
(Jim_GetCommand(interp, cmdNameObj, JIM_ERRMSG) == NULL)
if
(interp->framePtr->localCommands == NULL)
Jim_UpcallCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
else
if
(cmdPtr == NULL || !cmdPtr->isproc || !cmdPtr->prevCmd)
Jim_ApplyCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
else
if
(len != 2 && len != 3)
if
(len == 3)
if
(cmd)
Jim_ConcatCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
Jim_UpvarCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc > 3 && (argc % 2 == 0))
else
if
(targetCallFrame == NULL)
if
(argc < 3)
for
(i = 1; i < argc; i += 2)
Jim_GlobalCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
for
(i = 1; i < argc; i++)
if
(name[0] != ':' || name[1] != ':')
JimStringMap(Jim_Interp *, Jim_Obj *, Jim_Obj *, int)
if
(numMaps % 2)
while
(strLen)
for
(i = 0; i < numMaps; i += 2)
if
(strLen >= kl && kl)
if
(rc == 0)
if
(noMatchStart)
if
(i == numMaps)
if
(noMatchStart)
Jim_StringCoreCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 2)
switch
(option)
case
OPT_LENGTH:
case
OPT_BYTELENGTH:
if
(argc != 3)
if
(option == OPT_LENGTH)
else
case
OPT_CAT:
if
(argc == 3)
else
for
(i = 2; i < argc; i++)
case
OPT_COMPARE:
case
OPT_EQUAL:
while
(n > 0)
if
(Jim_GetEnum(interp, argv[i++], nocase_length_options, &subopt, NULL, JIM_ENUM_ABBREV) != JIM_OK)
if
(subopt == 0)
else
if
(n < 2)
if
(Jim_GetLong(interp, argv[i++], &opt_length) != JIM_OK)
if
(n)
if
(opt_length < 0 && option != OPT_COMPARE && opt_case)
else
if
(opt_length >= 0)
if
(l1 > opt_length)
if
(l2 > opt_length)
case
OPT_MATCH:
if
(argc != 4 && (argc != 5 || Jim_GetEnum(interp, argv[2], nocase_options, &opt_case, NULL, JIM_ENUM_ABBREV) != JIM_OK))
if
(opt_case == 0)
case
OPT_MAP:
if
(argc != 4 && (argc != 5 || Jim_GetEnum(interp, argv[2], nocase_options, &opt_case, NULL, JIM_ENUM_ABBREV) != JIM_OK))
if
(opt_case == 0)
if
(objPtr == NULL)
case
OPT_RANGE:
case
OPT_BYTERANGE:
if
(argc != 5)
if
(option == OPT_RANGE)
else
if
(objPtr == NULL)
case