#define JIM_TCL_COMPAT
#define JIM_ANSIC
#define JIM_REGEXP
#define HAVE_NO_AUTOCONF
#define _JIMAUTOCONF_H
#define TCL_LIBRARY
#define jim_ext_bootstrap
#define jim_ext_aio
#define jim_ext_readdir
#define jim_ext_regexp
#define jim_ext_file
#define jim_ext_glob
#define jim_ext_exec
#define jim_ext_clock
#define jim_ext_array
#define jim_ext_stdlib
#define jim_ext_tclcompat
#define TCL_PLATFORM_OS
#define TCL_PLATFORM_PLATFORM
#define TCL_PLATFORM_PATH_SEPARATOR
#define HAVE_MKDIR_ONE_ARG
#define HAVE_SYSTEM
#define TCL_PLATFORM_OS
#define TCL_PLATFORM_PLATFORM
#define TCL_PLATFORM_PATH_SEPARATOR
#define HAVE_MKDIR_ONE_ARG
#define HAVE_SYSTEM
#define HAVE_SYS_TIME_H
#define HAVE_DIRENT_H
#define HAVE_UNISTD_H
#define HAVE_UMASK
#include <sys/stat.h>
#define S_IRWXG
#define S_IRWXO
#define TCL_PLATFORM_OS
#define TCL_PLATFORM_PLATFORM
#define TCL_PLATFORM_PATH_SEPARATOR
#define vfork
#define _POSIX_SOURCE
#define _GNU_SOURCE
#define HAVE_VFORK
#define HAVE_WAITPID
#define HAVE_ISATTY
#define HAVE_MKSTEMP
#define HAVE_LINK
#define HAVE_SYS_TIME_H
#define HAVE_DIRENT_H
#define HAVE_UNISTD_H
#define HAVE_UMASK
#define JIM_VERSION
#define JIM_WIN32COMPAT_H
#define HAVE_DLOPEN
#define JIM_SPRINTF_DOUBLE_NEEDS_FIX
#include <limits.h>
#define jim_wide
#define LLONG_MAX
#define LLONG_MIN
#define JIM_WIDE_MIN
#define JIM_WIDE_MAX
#define JIM_WIDE_MODIFIER
#define strcasecmp
#define strtoull
#include <io.h>
#define HAVE_OPENDIR
#define UTF8_UTIL_H
#define MAX_UTF8_LEN
#include <ctype.h>
#define utf8_strlen
#define utf8_strwidth
#define utf8_tounicode
#define utf8_getchars
#define utf8_upper
#define utf8_title
#define utf8_lower
#define utf8_index
#define utf8_charlen
#define utf8_prev_len
#define utf8_width
#define __JIM__H
#include <time.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#define UCHAR
#define JIM_OK
#define JIM_ERR
#define JIM_RETURN
#define JIM_BREAK
#define JIM_CONTINUE
#define JIM_SIGNAL
#define JIM_EXIT
#define JIM_EVAL
#define JIM_MAX_CALLFRAME_DEPTH
#define JIM_MAX_EVAL_DEPTH
#define JIM_PRIV_FLAG_SHIFT
#define JIM_NONE
#define JIM_ERRMSG
#define JIM_ENUM_ABBREV
#define JIM_UNSHARED
#define JIM_MUSTEXIST
#define JIM_SUBST_NOVAR
#define JIM_SUBST_NOCMD
#define JIM_SUBST_NOESC
#define JIM_SUBST_FLAG
#define JIM_CASESENS
#define JIM_NOCASE
#define JIM_PATH_LEN
#define JIM_NOTUSED
#define JIM_LIBPATH
#define JIM_INTERACTIVE
Jim_Stack
len
maxlen
vector
Jim_HashEntry
key
<anonymous union>
val
intval
u
next
Jim_HashTableType
hashFunction
keyDup
valDup
keyCompare
keyDestructor
valDestructor
Jim_HashTable
table
type
privdata
size
sizemask
used
collisions
uniq
Jim_HashTableIterator
ht
entry
nextEntry
index
#define JIM_HT_INITIAL_SIZE
#define Jim_HashKey
#define Jim_GetHashEntryKey
#define Jim_GetHashEntryVal
#define Jim_GetHashTableCollisions
#define Jim_GetHashTableSize
#define Jim_GetHashTableUsed
Jim_Obj
bytes
typePtr
Jim_ObjType
refCount
length
<anonymous union>
wideValue
intValue
doubleValue
ptr
<anonymous struct>
ptr1
ptr2
twoPtrValue
<anonymous struct>
ptr
int1
int2
ptrIntValue
<anonymous struct>
Jim_Var
varPtr
callFrameId
global
varValue
<anonymous struct>
nsObj
Jim_Cmd
cmdPtr
procEpoch
cmdValue
<anonymous struct>
ele
len
maxLen
listValue
<anonymous struct>
maxLength
charLength
strValue
<anonymous struct>
id
Jim_Reference
refPtr
refValue
<anonymous struct>
fileNameObj
lineNumber
sourceValue
<anonymous struct>
varNameObjPtr
indexObjPtr
dictSubstValue
<anonymous struct>
line
argc
scriptLineValue
internalRep
prevObjPtr
nextObjPtr
#define Jim_FreeNewObj
#define Jim_GetIntRepPtr
Jim_Interp
Jim_FreeInternalRepProc
Jim_DupInternalRepProc
Jim_ObjType
name
freeIntRepProc
dupIntRepProc
updateStringProc
flags
#define JIM_TYPE_NONE
#define JIM_TYPE_REFERENCES
Jim_CallFrame
id
level
vars
staticVars
parent
argv
argc
procArgsObjPtr
procBodyObjPtr
next
nsObj
fileNameObj
line
localCommands
tailcallObj
tailcallCmd
Jim_Var
objPtr
linkFramePtr
Jim_CmdProc
Jim_DelCmdProc
Jim_Cmd
inUse
isproc
prevCmd
<anonymous union>
<anonymous struct>
cmdProc
delProc
privData
native
<anonymous struct>
argListObjPtr
bodyObjPtr
staticVars
argListLen
reqArity
optArity
argsPos
upcall
Jim_ProcArg
nameObjPtr
defaultObjPtr
arglist
nsObj
proc
u
Jim_PrngState
sbox
i
j
Jim_Interp
result
errorLine
errorFileNameObj
addStackTrace
maxCallFrameDepth
maxEvalDepth
evalDepth
returnCode
returnLevel
exitCode
id
signal_level
sigmask
signal_set_result
framePtr
topFramePtr
commands
procEpoch
callFrameEpoch
local
liveList
freeList
currentScriptObj
nullScriptObj
emptyObj
trueObj
falseObj
referenceNextId
references
lastCollectId
lastCollectTime
stackTrace
errorProc
unknown
unknown_called
errorFlag
cmdPrivData
freeFramesList
assocData
prngState
packages
loadHandles
#define Jim_InterpIncrProcEpoch
#define Jim_SetResultString
#define Jim_SetResultInt
#define Jim_SetResultBool
#define Jim_SetEmptyResult
#define Jim_GetResult
#define Jim_CmdPrivData
#define Jim_GetId
Jim_Reference
objPtr
finalizerCmdNamePtr
tag
#define Jim_NewEmptyStringObj
#define Jim_FreeHashTableIterator
#define JIM_EXPORT
#define Jim_Eval_Named
#define Jim_EvalPrefix
#define JIM_DICTMATCH_KEYS
#define JIM_DICTMATCH_VALUES
#define Jim_NewWideObj
Jim_InterpDeleteProc
#define Jim_CheckSignal
#define JIM_SUBCMD_H
#define JIM_MODFLAG_HIDDEN
#define JIM_MODFLAG_FULLARGV
jim_subcmd_function
jim_subcmd_type
cmd
args
function
minargs
maxargs
flags
#define JIMREGEXP_H
#include <stdlib.h>
regmatch_t
rm_so
rm_eo
regexp
re_nsub
cflags
err
regstart
reganch
regmust
regmlen
program
regparse
p
proglen
eflags
start
reginput
regbol
pmatch
nmatch
regex_t
#define REG_EXTENDED
#define REG_NEWLINE
#define REG_ICASE
#define REG_NOTBOL
<anonymous enum>
REG_NOERROR
REG_NOMATCH
REG_BADPAT
REG_ERR_NULL_ARGUMENT
REG_ERR_UNKNOWN
REG_ERR_TOO_BIG
REG_ERR_NOMEM
REG_ERR_TOO_MANY_PAREN
REG_ERR_UNMATCHED_PAREN
REG_ERR_UNMATCHED_BRACES
REG_ERR_BAD_COUNT
REG_ERR_JUNK_ON_END
REG_ERR_OPERAND_COULD_BE_EMPTY
REG_ERR_NESTED_COUNT
REG_ERR_INTERNAL
REG_ERR_COUNT_FOLLOWS_NOTHING
REG_ERR_TRAILING_BACKSLASH
REG_ERR_CORRUPTED
REG_ERR_NULL_CHAR
REG_ERR_NUM
#define JIM_SIGNAL_H
#define JIMIOCOMPAT_H
#include <stdio.h>
#include <errno.h>
#define STRICT
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <fcntl.h>
#include <io.h>
#include <process.h>
pidtype
#define JIM_BAD_PID
#define JIM_NO_PID
#define WIFEXITED
#define WEXITSTATUS
#define WIFSIGNALED
#define WTERMSIG
#define WNOHANG
#define HAVE_PIPE
#define pipe
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/stat.h>
#define Jim_Errno
#define JIM_BAD_PID
#define JIM_NO_PID
#define execvpe
Jim_bootstrapInit(Jim_Interp *)
Jim_initjimshInit(Jim_Interp *)
Jim_globInit(Jim_Interp *)
Jim_stdlibInit(Jim_Interp *)
Jim_tclcompatInit(Jim_Interp *)
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/un.h>
#define HAVE_SOCKETS
#define JIM_ANSIC
#include <openssl/ssl.h>
#include <openssl/err.h>
#define AIO_CMD_LEN
#define AIO_BUF_LEN
#define ftello
#define fseeko
#define AIO_KEEPOPEN
#define IPV6
#define IPV6
#define PF_INET6
AioFile
JimAioFopsType
writer
reader
getline
error
strerror
verify
AioFile
fp
filename
type
openFlags
fd
rEvent
wEvent
eEvent
addr_family
ssl
fops
stdio_writer(struct AioFile *, const char *, int)
stdio_reader(struct AioFile *, char *, int)
stdio_getline(struct AioFile *, char *, int)
stdio_error(const AioFile *)
if
(!ferror(af->fp))
if
(feof(af->fp) || errno == EAGAIN || errno == EINTR)
if
(errno == ECONNRESET)
if
(errno == ECONNABORTED)
stdio_strerror(struct AioFile *)
stdio_fops
JimAioErrorString(AioFile *)
JimAioSetError(Jim_Interp *, Jim_Obj *)
if
(name)
else
JimCheckStreamError(Jim_Interp *, AioFile *)
if
(ret)
JimAioDelProc(Jim_Interp *, void *)
if
(af->ssl != NULL)
if
(!(af->openFlags & AIO_KEEPOPEN))
aio_cmd_read(Jim_Interp *, int, Jim_Obj *const *)
if
(argc && Jim_CompareStringImmediate(interp, argv[0], "-nonewline"))
if
(argc == 1)
if
(neededLen < 0)
else if
(argc)
while
(neededLen != 0)
if
(neededLen == -1)
else
if
(retval > 0)
if
(neededLen != -1)
if
(JimCheckStreamError(interp, af))
if
(nonewline)
if
(len > 0 && s[len - 1] == '\n')
Jim_AioFile(Jim_Interp *, Jim_Obj *)
if
(cmdPtr && !cmdPtr->isproc && cmdPtr->u.native.cmdProc == JimAioSubCmdProc)
Jim_AioFilehandle(Jim_Interp *, Jim_Obj *)
if
(af == NULL)
aio_cmd_getfd(Jim_Interp *, int, Jim_Obj *const *)
aio_cmd_copy(Jim_Interp *, int, Jim_Obj *const *)
if
(outf == NULL)
if
(argc == 2)
if
(Jim_GetWide(interp, argv[1], &maxlen) != JIM_OK)
while
(count < maxlen)
if
(af->fops->reader(af, &ch, 1) != 1)
if
(outf->fops->writer(outf, &ch, 1) != 1)
if
(JimCheckStreamError(interp, af) || JimCheckStreamError(interp, outf))
aio_cmd_gets(Jim_Interp *, int, Jim_Obj *const *)
while
(1)
if
(buf[AIO_BUF_LEN - 1] == '\0' && buf[AIO_BUF_LEN - 2] != '\n')
else
if
(len && (buf[len - 1] == '\n'))
if
(JimCheckStreamError(interp, af))
if
(argc)
if
(Jim_SetVariable(interp, argv[0], objPtr) != JIM_OK)
if
(len == 0 && feof(af->fp))
else
aio_cmd_puts(Jim_Interp *, int, Jim_Obj *const *)
if
(argc == 2)
if
(!Jim_CompareStringImmediate(interp, argv[0], "-nonewline"))
else
if
(af->fops->writer(af, wdata, wlen) == wlen)
if
(argc == 2 || af->fops->writer(af, "\n", 1) == 1)
aio_cmd_isatty(Jim_Interp *, int, Jim_Obj *const *)
aio_cmd_flush(Jim_Interp *, int, Jim_Obj *const *)
if
(fflush(af->fp) == EOF)
aio_cmd_eof(Jim_Interp *, int, Jim_Obj *const *)
aio_cmd_close(Jim_Interp *, int, Jim_Obj *const *)
if
(argc == 3)
if
(Jim_GetEnum(interp, argv[2], options, &option, NULL, JIM_ERRMSG) != JIM_OK)
if
(shutdown(af->fd, option == OPT_R ? SHUT_RD : SHUT_WR) == 0)
aio_cmd_seek(Jim_Interp *, int, Jim_Obj *const *)
if
(argc == 2)
else
if
(Jim_GetWide(interp, argv[0], &offset) != JIM_OK)
if
(fseeko(af->fp, offset, orig) == -1)
aio_cmd_tell(Jim_Interp *, int, Jim_Obj *const *)
aio_cmd_filename(Jim_Interp *, int, Jim_Obj *const *)
aio_cmd_buffering(Jim_Interp *, int, Jim_Obj *const *)
if
(Jim_GetEnum(interp, argv[0], options, &option, NULL, JIM_ERRMSG) != JIM_OK)
switch
(option)
case
OPT_NONE:
case
OPT_LINE:
case
OPT_FULL:
aio_command_table
JimAioSubCmdProc(Jim_Interp *, int, Jim_Obj *const *)
JimAioOpenCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 2 && argc != 3)
if
(*filename == '|')
JimMakeChannel(Jim_Interp *, FILE *, int, Jim_Obj *, const char *, int, const char *)
if
(fh)
if
(!filename)
if
(fh == NULL)
if
(fd >= 0)
if
(fh == NULL)
if
(fd >= 0)
if
((openFlags & AIO_KEEPOPEN) == 0)
Jim_aioInit(Jim_Interp *)
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <dirent.h>
Jim_ReaddirCmd(Jim_Interp *, int, Jim_Obj *const *)
if
(argc == 3 && Jim_CompareStringImmediate(interp, argv[1], "-nocomplain"))
if
(argc != 2 && !nocomplain)
if
(dirPtr == NULL)
if
(nocomplain)
else
while
((entryPtr = readdir(dirPtr)) != NULL)
if
(entryPtr->d_name[0] == '.')
if
(entryPtr->d_name[1] == '\0')
Jim_readdirInit(Jim_Interp *)
#include <stdlib.h>
#include <string.h>
#include <regex.h>
FreeRegexpInternalRep(Jim_Interp *, Jim_Obj *)
regexpObjType
SetRegexpFromAny(Jim_Interp *, Jim_Obj *, unsigned int)
if
(objPtr->typePtr == ®expObjType && objPtr->internalRep.ptrIntValue.ptr && objPtr->internalRep.ptrIntValue.int1 == flags)
if
((ret = regcomp(compre, pattern, REG_EXTENDED | flags)) != 0)
Jim_RegexpCmd(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 3)
for
(i = 1; i < argc; i++)
if
(*opt != '-')
if
(Jim_GetEnum(interp, argv[i], options, &option, "switch", JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK)
if
(option == OPT_END)
switch
(option)
case
OPT_INDICES:
case
OPT_NOCASE:
case
OPT_LINE:
case
OPT_ALL:
case
OPT_INLINE:
case
OPT_START:
if
(++i == argc)
if
(Jim_GetIndex(interp, argv[i], &offset) != JIM_OK)
if
(argc - i < 2)
if
(!regex)
if
(opt_inline)
if
(num_vars)
if
(offset)
if
(offset < 0)
if
(offset > source_len)
else if
(offset > 0)
if
(opt_inline)
if
(match >= REG_BADPAT)
if
(match == REG_NOMATCH)
if
(opt_all && !opt_inline)
for
(i += 2; opt_inline ? j < num_vars : i < argc; i++, j++)
if
(opt_indices)
else
if
(pmatch[j].rm_so == -1)
if
(opt_indices)
else
if
(opt_indices)
else
if
(opt_inline)
else
if
(result != JIM_OK)
if
(opt_all && (pattern[0] != '^' || (regcomp_flags & REG_NEWLINE)) && *source_str)
if
(pmatch[0].rm_eo)
else
if
(*source_str)
if
(result == JIM_OK)
if
(opt_inline)
else
#define MAX_SUB_MATCHES
Jim_RegsubCmd(Jim_Interp *, int, Jim_Obj *const *)
if
(argc < 4)
for
(i = 1; i < argc; i++)
if
(*opt != '-')
if
(Jim_GetEnum(interp, argv[i], options, &option, "switch", JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK)
if
(option == OPT_END)
switch
(option)
case
OPT_NOCASE:
case
OPT_LINE:
case
OPT_ALL:
case
OPT_START:
if
(++i == argc)
if
(Jim_GetIndex(interp, argv[i], &offset) != JIM_OK)
if
(argc - i != 3 && argc - i != 4)
if
(!regex)
if
(offset)
if
(offset < 0)
if
(offset > source_len)
else if
(offset < 0)
if
(match >= REG_BADPAT)
if
(match == REG_NOMATCH)
for
(j = 0; j < replace_len; j++)
if
(c == '&')
else if
(c == '\\' && j < replace_len)
if
((c >= '0') && (c <= '9'))
else if
((c == '\\') || (c == '&'))
else
else
if
((idx < MAX_SUB_MATCHES) && pmatch[idx].rm_so != -1 && pmatch[idx].rm_eo != -1)
if
(!opt_all || n == 0)
if
((regcomp_flags & REG_NEWLINE) == 0 && pattern[0] == '^')
if
(pattern[0] == '\0' && n)
if
(argc - i == 4)
if
(result == JIM_OK)
else
else
Jim_regexpInit(Jim_Interp *)
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include <direct.h>
#define F_OK
#define W_OK
#define R_OK
#define S_ISREG
#define S_ISDIR
#define ISWINDOWS
#define ISWINDOWS
#define STAT_MTIME_US
#define STAT_MTIME_US
JimGetFileType(int)
if
(S_ISREG(mode))
else if
(S_ISDIR(mode))
else if
(S_ISCHR(mode))
else if
(S_ISBLK(mode))
else if
(S_ISFIFO(mode))
else if
(S_ISLNK(mode))
else if
(S_ISSOCK(mode))
AppendStatElement(Jim_Interp *, Jim_Obj *, const char *, long)
StoreStatData(Jim_Interp *, Jim_Obj *, const struct stat *)
if
(varName)
if
(objPtr)
if
(objPtr == NULL)
file_cmd_dirname(Jim_Interp *, int, Jim_Obj *const *)
if
(!p && path[0] == '.' && path[1] == '.' && path[2] == '\0')
else if
(!p)
else if
(p == path)
else if
(ISWINDOWS && p[-1] == ':')
else
file_cmd_rootname(Jim_Interp *, int, Jim_Obj *const *)
if
(p == NULL || (lastSlash != NULL && lastSlash > p))
else
file_cmd_extension(Jim_Interp *, int, Jim_Obj *const *)
if
(p == NULL || (lastSlash != NULL && lastSlash >= p))
file_cmd_tail(Jim_Interp *, int, Jim_Obj *const *)
if
(lastSlash)
else
file_cmd_normalize(Jim_Interp *, int, Jim_Obj *const *)
if
(realpath(path, newname))
else
file_cmd_join(Jim_Interp *, int, Jim_Obj *const *)
for
(i = 0; i < argc; i++)
if
(*part == '/')
else if
(ISWINDOWS && strchr(part, ':'))
else if
(part[0] == '.')
if
(part[1] == '/')
else if
(part[1] == 0 && last != newname)
if
(last != newname && last[-1] != '/')
if
(len)
if
(last + len - newname >= MAXPATHLEN)
if
(last > newname + 1 && last[-1] == '/')
if
(!ISWINDOWS || !(last > newname + 2 && last[-2] == ':'))
file_access(Jim_Interp *, Jim_Obj *, int)
file_cmd_readable(Jim_Interp *, int, Jim_Obj *const *)
file_cmd_writable(Jim_Interp *, int, Jim_Obj *const *)
file_cmd_executable(Jim_Interp *, int, Jim_Obj *const *)
file_cmd_exists(Jim_Interp *, int, Jim_Obj *const *)
file_cmd_delete(Jim_Interp *, int, Jim_Obj *const *)
if
(force || Jim_CompareStringImmediate(interp, argv[0], "--"))
while
(argc--)
if
(unlink(path) == -1 && errno != ENOENT)
if
(rmdir(path) == -1)
if
(!force || Jim_EvalPrefix(interp, "file delete force", 1, argv) != JIM_OK)
#define MKDIR_DEFAULT
#define MKDIR_DEFAULT
mkdir_all(char *)
while
(ok--)
while
(ok--)
if
(slash && slash != path)
if
(mkdir_all(path) != 0)
if
(MKDIR_DEFAULT(path) == 0)
if
(errno == ENOENT)
if
(errno == EEXIST)
if
(stat(path, &sb) == 0 && S_ISDIR(sb.st_mode))
file_cmd_mkdir(Jim_Interp *, int, Jim_Obj *const *)
while
(argc--)
if
(rc != 0)
file_cmd_tempfile(Jim_Interp *, int, Jim_Obj *const *)
if
(fd < 0)
file_cmd_rename(Jim_Interp *, int, Jim_Obj *const *)
if
(argc == 3)
if
(!Jim_CompareStringImmediate(interp, argv[0], "-force"))
if
(!force && access(dest, F_OK) == 0)
if
(rename(source, dest) != 0)
file_stat(Jim_Interp *, Jim_Obj *, struct stat *)
if
(stat(path, sb) == -1)
#define file_lstat
file_cmd_atime(Jim_Interp *, int, Jim_Obj *const *)
if
(file_stat(interp, argv[0], &sb) != JIM_OK)
JimSetFileTimes(Jim_Interp *, const char *, long)
if
(utimes(filename, times) != 0)
file_cmd_mtime(Jim_Interp *, int, Jim_Obj *const *)
if
(argc == 2)
if
(Jim_GetWide(interp, argv[1], &secs) != JIM_OK)
if
(file_stat(interp, argv[0], &sb) != JIM_OK)
file_cmd_copy(Jim_Interp *, int, Jim_Obj *const *)
file_cmd_size(Jim_Interp *, int, Jim_Obj *const *)
if
(file_stat(interp, argv[0], &sb) != JIM_OK)
file_cmd_isdirectory(Jim_Interp *, int, Jim_Obj *const *)
if
(file_stat(interp, argv[0], &sb) == JIM_OK)
file_cmd_isfile(Jim_Interp *, int, Jim_Obj *const *)
if
(file_stat(interp, argv[0], &sb) == JIM_OK)
file_cmd_type(Jim_Interp *, int, Jim_Obj *const *)
if
(file_lstat(interp, argv[0], &sb) != JIM_OK)
#define file_cmd_lstat
file_cmd_stat(Jim_Interp *, int, Jim_Obj *const *)
if
(file_stat(interp, argv[0], &sb) != JIM_OK)
file_command_table
Jim_CdCmd(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 2)
if
(chdir(path) != 0)
Jim_PwdCmd(Jim_Interp *, int, Jim_Obj *const *)
if
(getcwd(cwd, MAXPATHLEN) == NULL)
else if
(ISWINDOWS)
while
((p = strchr(p, '\\')) != NULL)
Jim_fileInit(Jim_Interp *)
#define _GNU_SOURCE
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <sys/stat.h>
WaitInfoTable
Jim_RemoveTrailingNewline(Jim_Obj *)
if
(len > 0 && s[len - 1] == '\n')
JimAppendStreamToString(Jim_Interp *, int, Jim_Obj *)
if
(fh == NULL)
while
(1)
if
(retval > 0)
if
(retval != sizeof(buf))
JimBuildEnv(Jim_Interp *)
if
(!objPtr)
if
(num % 2)
for
(i = 0; i < num; i += 2)
JimFreeEnv(char **, char **)
if
(env != original_environ)
JimMakeErrorCode(Jim_Interp *, pidtype, int, Jim_Obj *)
if
(pid == JIM_BAD_PID || pid == JIM_NO_PID)
else if
(WIFEXITED(waitStatus))
else
if
(WIFSIGNALED(waitStatus))
else
if
(errStrObj)
JimCheckWaitStatus(Jim_Interp *, pidtype, int, Jim_Obj *)
if
(WIFEXITED(waitStatus) && WEXITSTATUS(waitStatus) == 0)
WaitInfo
pid
status
flags
WaitInfoTable
info
size
used
refcount
#define WI_DETACHED
#define WAIT_TABLE_GROW_BY
JimFreeWaitInfoTable(struct Jim_Interp *, void *)
if
(--table->refcount == 0)
JimAllocWaitInfoTable()
JimWaitRemove(struct WaitInfoTable *, pidtype)
for
(i = 0; i < table->used; i++)
if
(pid == table->info[i].pid)
if
(i != table->used - 1)
Jim_ExecCmd(Jim_Interp *, int, Jim_Obj *const *)
if
(argc > 1 && Jim_CompareStringImmediate(interp, argv[argc - 1], "&"))
if
(numPids < 0)
for
(i = 0; i < numPids; i++)
if
(numPids < 0)
if
(outputId != -1)
if
(JimAppendStreamToString(interp, outputId, errStrObj) < 0)
if
(JimCleanupChildren(interp, numPids, pidPtr, childErrObj) != JIM_OK)
if
(errorId != -1)
if
(ret < 0)
else if
(ret > 0)
if
(child_siginfo)
JimWaitForProcess(struct WaitInfoTable *, pidtype, int *)
if
(JimWaitRemove(table, pid) == 0)
JimDetachPids(struct WaitInfoTable *, int, const pidtype *)
for
(j = 0; j < numPids; j++)
for
(i = 0; i < table->used; i++)
if
(pidPtr[j] == table->info[i].pid)
JimGetChannelFd(Jim_Interp *, const char *)
if
(Jim_EvalObjVector(interp, 2, objv) == JIM_OK)
if
(Jim_GetWide(interp, Jim_GetResult(interp), &fd) == JIM_OK)
JimReapDetachedPids(struct WaitInfoTable *)
if
(!table)
for
(count = table->used; count > 0; waitPtr++, count--)
if
(waitPtr->flags & WI_DETACHED)
if
(pid == waitPtr->pid)
if
(waitPtr != &table->info[dest])
Jim_WaitCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc == 1)
if
(argc > 1 && Jim_CompareStringImmediate(interp, argv[1], "-nohang"))
if
(argc != nohang + 2)
if
(Jim_GetLong(interp, argv[nohang + 1], &pidarg) != JIM_OK)
if
(pid != JIM_BAD_PID && (WIFEXITED(status) || WIFSIGNALED(status)))
Jim_PidCommand(Jim_Interp *, int, Jim_Obj *const *)
if
(argc != 1)
JimCreatePipeline(Jim_Interp *, int, Jim_Obj *const *, pidtype **, int *, int *, int *)
#define FILE_NAME
#define FILE_APPEND
#define FILE_HANDLE
#define FILE_TEXT
if
(inPipePtr != NULL)
if
(outPipePtr != NULL)
if
(errFilePtr != NULL)
for
(i = 0; i < argc; i++)
if
(arg[0] == '<')
if
(*input == '<')
else if
(*input == '@')
if
(!*input && ++i < argc)
else if
(arg[0] == '>')
if
(*output == '>')
if
(*output == '&')
if
(*output == '@')
if
(!*output && ++i < argc)
if
(dup_error)
else if
(arg[0] == '2' && arg[1] == '>')
if
(*error == '@')
else if
(*error == '>')
if
(!*error && ++i < argc)
else
if
(strcmp(arg, "|") == 0 || strcmp(arg, "|&") == 0)
if
(i == lastBar + 1 || i == argc - 1)
if
(i >= argc)
if
(arg_count == 0)
if
(input != NULL)
if
(inputFile == FILE_TEXT)
if
(inputId == -1)
if
(write(inputId, input, input_len) != input_len)
else if
(inputFile == FILE_HANDLE)
if
(fd < 0)
else
if
(inputId == -1)
else if
(inPipePtr != NULL)
if
(pipe(pipeIds) != 0)
if
(output != NULL)
if
(outputFile == FILE_HANDLE)
if
(fd < 0)
else
if
(lastOutputId == -1)
else if
(outPipePtr != NULL)
if
(pipe(pipeIds) != 0)
if
(error != NULL)
if
(errorFile == FILE_HANDLE)
if
(strcmp(error, "1") == 0)
if
(lastOutputId != -1)
else
if
(errorId == -1)
if
(fd < 0)
else
if
(errorId == -1)
else if
(errFilePtr != NULL)
if
(errorId == -1)
for
(i = 0; i < numPids; i++)
for
(firstArg = 0; firstArg < arg_count; numPids++, firstArg = lastArg + 1)
for
(lastArg = firstArg; lastArg < arg_count; lastArg++)
if
(strcmp(arg_array[lastArg], "|") == 0)
if
(strcmp(arg_array[lastArg], "|&") == 0)
if
(lastArg == firstArg)
if
(lastArg == arg_count)
else
if
(pipe(pipeIds) != 0)
if
(pipe_dup_err)
if
(pid == JIM_BAD_PID)
if
(pid < 0)
if
(pid == 0)
if
(inputId != -1)
if
(outputId != -1)
if
(outputId != errorId)
if
(errorId != -1)
if
(outPipePtr)
if
(errFilePtr)
if
(pipeIds[0] != -1)
if
(lastOutputId != -1)
if
(write(fileno(stderr), "couldn't exec \"", 15) && write(fileno(stderr), arg_array[firstArg], i) && write(fileno(stderr), "\"\n", 2))
if
(write(fileno(stderr), "couldn't exec \"", 15) && write(fileno(stderr), arg_array[firstArg], i) && write(fileno(stderr), "\"\n", 2))
if
(table->used == table->size)
if
(inputId != -1)
if
(outputId != -1)
if
(inputId != -1)
if
(lastOutputId != -1)
if
(errorId != -1)
if
((inPipePtr != NULL) && (*inPipePtr != -1))
if
((outPipePtr != NULL) && (*outPipePtr != -1))
if
((errFilePtr != NULL) && (*errFilePtr != -1))
if
(pipeIds[0] != -1)
if
(pipeIds[1] != -1)
if
(pidPtr != NULL)
for
(i = 0; i < numPids; i++)
if
(pidPtr[i] != JIM_BAD_PID)
JimCleanupChildren(Jim_Interp *, int, pidtype *, Jim_Obj *)
for
(i = 0; i < numPids; i++)
if
(JimWaitForProcess(table, pidPtr[i], &waitStatus) != JIM_BAD_PID)
if
(JimCheckWaitStatus(interp, pidPtr[i], waitStatus, errStrObj) != JIM_OK)
Jim_execInit(Jim_Interp *)
JimWinFindExecutable(const char *, char *)
for
(i = 0; i < (int) (sizeof(extensions) / sizeof(extensions[0])); i++)
if
(SearchPath(NULL, fullPath, NULL, MAX_PATH, fullPath, NULL) == 0)
if
(GetFileAttributes(fullPath) & FILE_ATTRIBUTE_DIRECTORY)
JimSaveEnv(char **)
JimRestoreEnv(char **)
JimOriginalEnviron()
JimWinBuildCommandLine(Jim_Interp *, char **)
for
(i = 0; argv[i]; i++)
if
(i > 0)
if
(argv[i][0] == '\0')
else
for
(start = argv[i]; *start != '\0'; start++)
if
(isspace(UCHAR(*start)))
if
(quote)
for
(special = argv[i]; ;)
if
((*special == '\\') && (special[1] == '\\' || special[1] == '"' || (quote && special[1] == '\0')))
while
(1)
if
(*special == '"' || (quote && *special == '\0'))
if
(*special != '\\')
if
(*special == '"')
if
(special == start)
else
if
(*special == '\0')
if
(quote)
JimStartWinProcess(Jim_Interp *, char **, char **, int, int, int)
if
(JimWinFindExecutable(argv[0], execPath) < 0)
if
(inputId == -1)
if
(startInfo.hStdInput == INVALID_HANDLE_VALUE)
if
(outputId == -1)
if
(startInfo.hStdOutput == INVALID_HANDLE_VALUE)
if
(errorId == -1)
if
(startInfo.hStdError == INVALID_HANDLE_VALUE)
if
(env == NULL)
else if
(env[0] == NULL)
else
if
(!CreateProcess(NULL, (char *)Jim_String(cmdLineObj), NULL, NULL, TRUE, 0, winenv, NULL, &startInfo, &procInfo))
if
(startInfo.hStdInput != INVALID_HANDLE_VALUE)
if
(startInfo.hStdOutput != INVALID_HANDLE_VALUE)
if
(startInfo.hStdError != INVALID_HANDLE_VALUE)
#define _XOPEN_SOURCE
#define _GNU_SOURCE
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include <sys/time.h>
clock_options
gmt
format
parse_clock_options(Jim_Interp *, int, Jim_Obj *const *, struct clock_options *)
for
(i = 0; i < argc; i += 2)
if
(Jim_GetEnum(interp, argv[i], options, &option, NULL, JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK)
switch
(option)
case
OPT_GMT:
if
(Jim_GetBoolean(interp, argv[i + 1], &opts->gmt) != JIM_OK)
case
OPT_FORMAT:
clock_cmd_format(Jim_Interp *, int, Jim_Obj *const *)
if
(Jim_GetWide(interp, argv[0], &seconds) != JIM_OK)
if
(argc % 2 == 0)
if
(parse_clock_options(interp, argc - 1, argv + 1, &options) == JIM_ERR)
if
(tm == NULL || strftime(buf, sizeof(buf), options.format, tm) == 0)
clock_cmd_seconds(Jim_Interp *, int, Jim_Obj *const *)
clock_cmd_micros(Jim_Interp *, int, Jim_Obj *const *)
clock_cmd_millis(Jim_Interp *, int, Jim_Obj *const *)
clock_command_table
Jim_clockInit(Jim_Interp *)
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
array_cmd_exists(Jim_Interp *, int, Jim_Obj *const *)
array_cmd_get(Jim_Interp *, int, Jim_Obj *const *)
if
(!objPtr)
if
(patternObj == NULL || Jim_CompareStringImmediate(interp, patternObj, "*"))
if
(Jim_IsList(objPtr) && Jim_ListLength(interp, objPtr) % 2 == 0)
array_cmd_names(Jim_Interp *, int, Jim_Obj *const *)
if
(!objPtr)
array_cmd_unset(Jim_Interp *, int, Jim_Obj *const *)
if
(argc == 1 || Jim_CompareStringImmediate(interp, argv[1], "*"))
if
(objPtr == NULL)
if
(Jim_DictPairs(interp, objPtr, &dictValuesObj, &len) != JIM_OK)
for
(i = 0; i < len; i += 2)
if
(!Jim_StringMatchObj(interp, argv[1], dictValuesObj[i], 0))
array_cmd_size(Jim_Interp *, int, Jim_Obj *const *)
if
(objPtr)
if
(len < 0)
array_cmd_stat(Jim_Interp *, int, Jim_Obj *const *)
if
(objPtr)
array_cmd_set(Jim_Interp *, int, Jim_Obj *const *)
if
(len % 2)
if
(!dictObj)
else if
(Jim_DictSize(interp, dictObj) < 0)
if
(Jim_IsShared(dictObj))
for
(i = 0; i < len; i += 2)
array_command_table
Jim_arrayInit(Jim_Interp *)
Jim_InitStaticExtensions(Jim_Interp *)
#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 <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)
if
(flags & JIM_NOCASE)
if
(flags & JIM_CHARSET_SCAN)
if
(*pattern == '^')
if
(*pattern == ']')
while
(*pattern && *pattern != ']')
if
(pattern[0] == '\\')
else
if
(pattern[0] == '-' && pattern[1])
if
((c >= start && c <= end) || (c >= end && c <= start))
if
(pchar == c)
if
(not)
JimGlobMatch(const char *, const char *, int)
while
(*pattern)
switch
(pattern[0])
case
'*':
while
(pattern[1] == '*')
if
(!pattern[0])
while
(*string)
case
'?':
case
'[':
if
(!pattern)
if
(!*pattern)
case
'\\':
if
(pattern[1])
default
if
(pchar != c)
if
(!*string)
while
(*pattern == '*')
if
(!*pattern && !*string)
JimStringCompare(const char *, int, const char *, int)
if
(l1 < l2)
else if
(l2 < l1)
else
JimStringCompareLen(const char *, const char *, int, int)
while
(*s1 && *s2 && maxchars)
if
(c1 != c2)
if
(!maxchars)
if
(*s1)
if
(*s2)
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':
default
if
(str[i] != '-' && str[i] != '+' && !isspace(UCHAR(str[i])))
jim_strtol(const char *, char **)
if
(base != 10)
if
(endptr == NULL || *endptr != str + i)
jim_strtoull(const char *, char **)
if
(base != 10)
if
(endptr == NULL || *endptr != str + i)
Jim_StringToWide(const char *, long *, int)
if
(base)
else
Jim_StringToDouble(const char *, double *)
JimPowWide(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()
Jim_IntHashFunction(unsigned int)
Jim_GenHashFunction(const unsigned char *, int)
JimResetHashTable(Jim_HashTable *)
JimInitHashTableIterator(Jim_HashTable *, Jim_HashTableIterator *)
Jim_InitHashTable(Jim_HashTable *, const Jim_HashTableType *, void *)
Jim_ResizeHashTable(Jim_HashTable *)
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 *)
while
(he)
if
(Jim_CompareHashKeys(ht, key, he->key))
Jim_FreeHashTable(Jim_HashTable *)
for
(i = 0; ht->used > 0; i++)
while
(he)
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)
JimExpandHashTableIfNeeded(Jim_HashTable *)
JimHashTableNextPower(unsigned int)
while
(1)
JimInsertHashEntry(Jim_HashTable *, const void *, int)
while
(he)
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)
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)
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)
if
(nocase)
Jim_StringCompareLenObj(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
jim_isascii(int)
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)
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)
JimVariablesHTValDestructor(void *, void *)
JimVariablesHashTableType
JimCommandsHT_ValDestructor(void *, void *)
JimCommandsHashTableType
#define JimFreeQualifiedName
#define JimQualifyName
#define JimFreeQualifiedName
Jim_MakeGlobalNamespaceName(Jim_Interp *, Jim_Obj *)
JimCreateCommand(Jim_Interp *, const char *, Jim_Cmd *)
if
(he)
if
(he && interp->local)
else
if
(he)
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
(JimValidName(interp, "static variable", nameObjPtr) != JIM_OK)
if
(Jim_AddHashEntry(cmdPtr->u.proc.staticVars, Jim_String(nameObjPtr), varPtr) != JIM_OK)
else
JimUpdateProcNamespace(Jim_Interp *, Jim_Cmd *, const char *)
if
(cmdPtr->isproc)
if
(pt && pt != cmdname && pt[-1] == ':')
if
(Jim_FindHashEntry(&interp->commands, pt + 1))
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 *, const char *)
if
(Jim_DeleteHashEntry(&interp->commands, qualname) == JIM_ERR)
else
Jim_RenameCommand(Jim_Interp *, const char *, const char *)
if
(newName[0] == 0)
if
(he == NULL)
else if
(Jim_FindHashEntry(&interp->commands, fqnew))
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)
if
(name[0] == ':' && name[1] == ':')
while
(*++name == ':')
else if
(Jim_Length(interp->framePtr->nsObj))
if
(he)
if
(he == NULL)
if
(flags & JIM_ERRMSG)
else
while
(cmd->u.proc.upcall)
#define JIM_DICT_SUGAR
variableObjType
JimValidName(Jim_Interp *, const char *, Jim_Obj *)
if
(nameObjPtr->typePtr != &variableObjType)
if
(memchr(str, '\0', len))
SetVariableFromAny(Jim_Interp *, struct Jim_Obj *)
if
(objPtr->typePtr == &variableObjType)
if
(objPtr->internalRep.varValue.callFrameId == framePtr->id)
else if
(objPtr->typePtr == &dictSubstObjType)
else if
(JimValidName(interp, "variable", objPtr) != JIM_OK)
if
(len && varName[len - 1] == ')' && strchr(varName, '(') != NULL)
if
(varName[0] == ':' && varName[1] == ':')
while
(*++varName == ':')
else
if
(he == NULL)
if
(!global && framePtr->staticVars)
if
(he == NULL)
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:
if
(JimValidName(interp, "variable", nameObjPtr) != JIM_OK)
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
(strcmp(Jim_String(objPtr), varName) == 0)
Jim_GetVariable(Jim_Interp *, Jim_Obj *, int)
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)
else
if
(retval == JIM_OK)
if
(retval != JIM_OK && (flags & JIM_ERRMSG))
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
(Jim_SubstObj(interp, objPtr->internalRep.dictSubstValue.indexObjPtr, &substKeyObjPtr, JIM_NONE) != JIM_OK)
JimExpandExprSugar(Jim_Interp *, Jim_Obj *)
if
(Jim_EvalExpression(interp, objPtr) == 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
(Jim_FindHashEntry(&interp->framePtr->vars, "jim::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
for
(i = 0; i < JIM_HT_INITIAL_SIZE; i++)
while
(he != NULL)
Jim_IsBigEndian()
Jim_CreateInterp()
Jim_FreeInterp(Jim_Interp *)
for
(cf = i->framePtr; cf; cf = cfx)
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 *)
JimGetWideNoErr(Jim_Interp *, Jim_Obj *, long *)
Jim_GetLong(Jim_Interp *, Jim_Obj *, long *)
if
(retval == JIM_OK)
Jim_NewIntObj(Jim_Interp *, 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 *)
SetBooleanFromAny(Jim_Interp *, Jim_Obj *, int)
if
(Jim_GetEnum(interp, objPtr, falses, &index, NULL, 0) == JIM_OK)
else if
(Jim_GetEnum(interp, objPtr, trues, &index, NULL, 0) == JIM_OK)
else
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)
for
(i = 0; i < len; i++)
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)
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
index
indexed
unique
subfn
sort_info
ListSortIndexHelper(Jim_Obj **, Jim_Obj **)
if
(Jim_ListIndex(sort_info->interp, *lhsObj, sort_info->index, &lObj, JIM_ERRMSG) != JIM_OK || Jim_ListIndex(sort_info->interp, *rhsObj, sort_info->index, &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->indexed)
if
((rc = setjmp(info->jmpbuf)) == 0)
if
(info->unique && len > 1)
ListInsertElements(Jim_Obj *, int, int, Jim_Obj *const *)
if
(requiredLen > listPtr->internalRep.listValue.maxLen)
if
(requiredLen < 2)
else
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)
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
(Jim_ListIndex(interp, listObjPtr, idx, &objPtr, JIM_ERRMSG) != JIM_OK)
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)
JimObjectHTHashFunction(const void *)
JimObjectHTKeyCompare(void *, const void *, const void *)
JimObjectHTKeyValDup(void *, const void *)
JimObjectHTKeyValDestructor(void *, void *)
JimDictHashTableType
dictObjType
FreeDictInternalRep(Jim_Interp *, Jim_Obj *)
DupDictInternalRep(Jim_Interp *, Jim_Obj *, Jim_Obj *)
while
((he = Jim_NextHashEntry(&htiter)) != NULL)
JimDictPairs(Jim_Obj *, int *)
while
((he = Jim_NextHashEntry(&htiter)) != NULL)
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)
DictAddElement(Jim_Interp *, Jim_Obj *, Jim_Obj *, Jim_Obj *)
if
(valueObjPtr == NULL)
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
((he = Jim_FindHashEntry(ht, keyPtr)) == NULL)
if
(flags & JIM_ERRMSG)
else
Jim_DictPairs(Jim_Interp *, Jim_Obj *, Jim_Obj ***, int *)
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)
else
SetIndexFromAny(Jim_Interp *, Jim_Obj *)
if
(strncmp(str, "end", 3) == 0)
else
if
(endptr == str)
if
(*str == '+' || *str == '-')
if
(str == endptr || *endptr)
while
(isspace(UCHAR(*str)))
if
(*str)
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_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
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_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
(isspace(UCHAR(*pc->p)) || (*(pc->p) == '\\' && *(pc->p + 1) == '\n'))
if
(*pc->p == '\n')
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; booleans[i]; i++)
if
(strncmp(boolean, pc->p, length) == 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
(Jim_SubstObj(interp, node->objPtr, &objPtr, JIM_NONE) == JIM_OK)
case
JIM_TT_CMD:
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)
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