-/* Jim - A small embeddable Tcl interpreter\r
- * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>\r
- * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * A copy of the license is also included in the source distribution\r
- * of Jim, as a TXT file name called LICENSE.\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- */\r
-\r
-#ifndef __JIM__H\r
-#define __JIM__H\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-\r
-#include <time.h>\r
-#include <limits.h>\r
-#include <stdio.h> /* for the FILE typedef definition */\r
-#include <stdlib.h> /* In order to export the Jim_Free() macro */\r
-\r
-/* -----------------------------------------------------------------------------\r
-* Some /very/ old compiler maybe do not know how to\r
-* handle 'const'. They even do not know, how to ignore\r
-* it. For those compiler it may be better to compile with\r
-* define JIM_NO_CONST activated\r
-* ---------------------------------------------------------------------------*/\r
-\r
-#ifdef JIM_NO_CONST\r
-# define const\r
-#endif\r
-\r
-/* -----------------------------------------------------------------------------\r
- * System configuration\r
- * For most modern systems, you can leave the default.\r
- * For embedded systems some change may be required.\r
- * ---------------------------------------------------------------------------*/\r
-\r
-#define HAVE_LONG_LONG\r
-\r
-/* -----------------------------------------------------------------------------\r
- * Compiler specific fixes.\r
- * ---------------------------------------------------------------------------*/\r
-\r
-/* MSC has _stricmp instead of strcasecmp */\r
-#ifdef _MSC_VER\r
-# define strcasecmp _stricmp\r
-#endif /* _MSC_VER */\r
-\r
-/* Long Long type and related issues */\r
-#ifdef HAVE_LONG_LONG\r
-# ifdef _MSC_VER /* MSC compiler */\r
-# define jim_wide _int64\r
-# ifndef LLONG_MAX\r
-# define LLONG_MAX 9223372036854775807I64\r
-# endif\r
-# ifndef LLONG_MIN\r
-# define LLONG_MIN (-LLONG_MAX - 1I64)\r
-# endif\r
-# define JIM_WIDE_MIN LLONG_MIN\r
-# define JIM_WIDE_MAX LLONG_MAX\r
-# else /* Other compilers (mainly GCC) */\r
-# define jim_wide long long\r
-# ifndef LLONG_MAX\r
-# define LLONG_MAX 9223372036854775807LL\r
-# endif\r
-# ifndef LLONG_MIN\r
-# define LLONG_MIN (-LLONG_MAX - 1LL)\r
-# endif\r
-# define JIM_WIDE_MIN LLONG_MIN\r
-# define JIM_WIDE_MAX LLONG_MAX\r
-# endif\r
-#else\r
-# define jim_wide long\r
-# define JIM_WIDE_MIN LONG_MIN\r
-# define JIM_WIDE_MAX LONG_MAX\r
-#endif\r
-\r
-/* -----------------------------------------------------------------------------\r
- * LIBC specific fixes\r
- * ---------------------------------------------------------------------------*/\r
-\r
-#ifdef HAVE_LONG_LONG\r
-# if defined(_MSC_VER) || defined(__MSVCRT__)\r
-# define JIM_WIDE_MODIFIER "I64d"\r
-# else\r
-# define JIM_WIDE_MODIFIER "lld"\r
-# endif\r
-#else\r
-# define JIM_WIDE_MODIFIER "ld"\r
-#endif\r
-\r
-/* -----------------------------------------------------------------------------\r
- * Exported defines\r
- * ---------------------------------------------------------------------------*/\r
-\r
-/* Jim version numbering: every version of jim is marked with a\r
- * successive integer number. This is version 0. The first\r
- * stable version will be 1, then 2, 3, and so on. */\r
-#define JIM_VERSION 51\r
-\r
-#define JIM_OK 0\r
-#define JIM_ERR 1\r
-#define JIM_RETURN 2\r
-#define JIM_BREAK 3\r
-#define JIM_CONTINUE 4\r
-#define JIM_EVAL 5\r
-#define JIM_EXIT 6\r
-#define JIM_MAX_NESTING_DEPTH 10000 /* default max nesting depth */\r
-\r
-/* Some function get an integer argument with flags to change\r
- * the behaviour. */\r
-#define JIM_NONE 0 /* no flags set */\r
-#define JIM_ERRMSG 1 /* set an error message in the interpreter. */\r
-\r
-/* Flags for Jim_SubstObj() */\r
-#define JIM_SUBST_NOVAR 1 /* don't perform variables substitutions */\r
-#define JIM_SUBST_NOCMD 2 /* don't perform command substitutions */\r
-#define JIM_SUBST_NOESC 4 /* don't perform escapes substitutions */\r
-\r
-/* Unused arguments generate annoying warnings... */\r
-#define JIM_NOTUSED(V) ((void) V)\r
-\r
-/* Flags used by API calls getting a 'nocase' argument. */\r
-#define JIM_CASESENS 0 /* case sensitive */\r
-#define JIM_NOCASE 1 /* no case */\r
-\r
-/* Filesystem related */\r
-#define JIM_PATH_LEN 1024\r
-\r
-/* Newline, some embedded system may need -DJIM_CRLF */\r
-#ifdef JIM_CRLF\r
-#define JIM_NL "\r\n"\r
-#else\r
-#define JIM_NL "\n"\r
-#endif\r
-\r
-#if defined(__WIN32__) || defined(_WIN32)\r
-#define DLLEXPORT __declspec(dllexport)\r
-#define DLLIMPORT __declspec(dllimport)\r
-#else\r
-#define DLLEXPORT\r
-#define DLLIMPORT\r
-#endif\r
-\r
-/* -----------------------------------------------------------------------------\r
- * Stack\r
- * ---------------------------------------------------------------------------*/\r
-\r
-typedef struct Jim_Stack {\r
- int len;\r
- int maxlen;\r
- void **vector;\r
-} Jim_Stack;\r
-\r
-/* -----------------------------------------------------------------------------\r
- * Hash table\r
- * ---------------------------------------------------------------------------*/\r
-\r
-typedef struct Jim_HashEntry {\r
- const void *key;\r
- void *val;\r
- struct Jim_HashEntry *next;\r
-} Jim_HashEntry;\r
-\r
-typedef struct Jim_HashTableType {\r
- unsigned int (*hashFunction)(const void *key);\r
- const void *(*keyDup)(void *privdata, const void *key);\r
- void *(*valDup)(void *privdata, const void *obj);\r
- int (*keyCompare)(void *privdata, const void *key1, const void *key2);\r
- void (*keyDestructor)(void *privdata, const void *key);\r
- void (*valDestructor)(void *privdata, void *obj);\r
-} Jim_HashTableType;\r
-\r
-typedef struct Jim_HashTable {\r
- Jim_HashEntry **table;\r
- Jim_HashTableType *type;\r
- unsigned int size;\r
- unsigned int sizemask;\r
- unsigned int used;\r
- unsigned int collisions;\r
- void *privdata;\r
-} Jim_HashTable;\r
-\r
-typedef struct Jim_HashTableIterator {\r
- Jim_HashTable *ht;\r
- int index;\r
- Jim_HashEntry *entry, *nextEntry;\r
-} Jim_HashTableIterator;\r
-\r
-/* This is the initial size of every hash table */\r
-#define JIM_HT_INITIAL_SIZE 16\r
-\r
-/* ------------------------------- Macros ------------------------------------*/\r
-#define Jim_FreeEntryVal(ht, entry) \\r
- if ((ht)->type->valDestructor) \\r
- (ht)->type->valDestructor((ht)->privdata, (entry)->val)\r
-\r
-#define Jim_SetHashVal(ht, entry, _val_) do { \\r
- if ((ht)->type->valDup) \\r
- entry->val = (ht)->type->valDup((ht)->privdata, _val_); \\r
- else \\r
- entry->val = (_val_); \\r
-} while(0)\r
-\r
-#define Jim_FreeEntryKey(ht, entry) \\r
- if ((ht)->type->keyDestructor) \\r
- (ht)->type->keyDestructor((ht)->privdata, (entry)->key)\r
-\r
-#define Jim_SetHashKey(ht, entry, _key_) do { \\r
- if ((ht)->type->keyDup) \\r
- entry->key = (ht)->type->keyDup((ht)->privdata, _key_); \\r
- else \\r
- entry->key = (_key_); \\r
-} while(0)\r
-\r
-#define Jim_CompareHashKeys(ht, key1, key2) \\r
- (((ht)->type->keyCompare) ? \\r
- (ht)->type->keyCompare((ht)->privdata, key1, key2) : \\r
- (key1) == (key2))\r
-\r
-#define Jim_HashKey(ht, key) (ht)->type->hashFunction(key)\r
-\r
-#define Jim_GetHashEntryKey(he) ((he)->key)\r
-#define Jim_GetHashEntryVal(he) ((he)->val)\r
-#define Jim_GetHashTableCollisions(ht) ((ht)->collisions)\r
-#define Jim_GetHashTableSize(ht) ((ht)->size)\r
-#define Jim_GetHashTableUsed(ht) ((ht)->used)\r
-\r
-/* -----------------------------------------------------------------------------\r
- * Jim_Obj structure\r
- * ---------------------------------------------------------------------------*/\r
-\r
-/* -----------------------------------------------------------------------------\r
- * Jim object. This is mostly the same as Tcl_Obj itself,\r
- * with the addition of the 'prev' and 'next' pointers.\r
- * In Jim all the objects are stored into a linked list for GC purposes,\r
- * so that it's possible to access every object living in a given interpreter\r
- * sequentially. When an object is freed, it's moved into a different\r
- * linked list, used as object pool.\r
- *\r
- * The refcount of a freed object is always -1.\r
- * ---------------------------------------------------------------------------*/\r
-typedef struct Jim_Obj {\r
- int refCount; /* reference count */\r
- char *bytes; /* string representation buffer. NULL = no string repr. */\r
- int length; /* number of bytes in 'bytes', not including the numterm. */\r
- struct Jim_ObjType *typePtr; /* object type. */\r
- /* Internal representation union */\r
- union {\r
- /* integer number type */\r
- jim_wide wideValue;\r
- /* hashed object type value */\r
- int hashValue;\r
- /* index type */\r
- int indexValue;\r
- /* return code type */\r
- int returnCode;\r
- /* double number type */\r
- double doubleValue;\r
- /* Generic pointer */\r
- void *ptr;\r
- /* Generic two pointers value */\r
- struct {\r
- void *ptr1;\r
- void *ptr2;\r
- } twoPtrValue;\r
- /* Variable object */\r
- struct {\r
- unsigned jim_wide callFrameId;\r
- struct Jim_Var *varPtr;\r
- } varValue;\r
- /* Command object */\r
- struct {\r
- unsigned jim_wide procEpoch;\r
- struct Jim_Cmd *cmdPtr;\r
- } cmdValue;\r
- /* List object */\r
- struct {\r
- struct Jim_Obj **ele; /* Elements vector */\r
- int len; /* Length */\r
- int maxLen; /* Allocated 'ele' length */\r
- } listValue;\r
- /* String type */\r
- struct {\r
- int maxLength;\r
- } strValue;\r
- /* Reference type */\r
- struct {\r
- jim_wide id;\r
- struct Jim_Reference *refPtr;\r
- } refValue;\r
- /* Source type */\r
- struct {\r
- const char *fileName;\r
- int lineNumber;\r
- } sourceValue;\r
- /* Dict substitution type */\r
- struct {\r
- struct Jim_Obj *varNameObjPtr;\r
- struct Jim_Obj *indexObjPtr;\r
- } dictSubstValue;\r
- /* tagged binary type */\r
- struct {\r
- unsigned char *data;\r
- size_t len;\r
- } binaryValue;\r
- } internalRep;\r
- /* This are 8 or 16 bytes more for every object\r
- * but this is required for efficient garbage collection\r
- * of Jim references. */\r
- struct Jim_Obj *prevObjPtr; /* pointer to the prev object. */\r
- struct Jim_Obj *nextObjPtr; /* pointer to the next object. */\r
-} Jim_Obj;\r
-\r
-/* Jim_Obj related macros */\r
-#define Jim_IncrRefCount(objPtr) \\r
- ++(objPtr)->refCount\r
-#define Jim_DecrRefCount(interp, objPtr) \\r
- if (--(objPtr)->refCount <= 0) Jim_FreeObj(interp, objPtr)\r
-#define Jim_IsShared(objPtr) \\r
- ((objPtr)->refCount > 1)\r
-\r
-/* This macro is used when we allocate a new object using\r
- * Jim_New...Obj(), but for some error we need to destroy it.\r
- * Instead to use Jim_IncrRefCount() + Jim_DecrRefCount() we\r
- * can just call Jim_FreeNewObj. To call Jim_Free directly\r
- * seems too raw, the object handling may change and we want\r
- * that Jim_FreeNewObj() can be called only against objects\r
- * that are belived to have refcount == 0. */\r
-#define Jim_FreeNewObj Jim_FreeObj\r
-\r
-/* Free the internal representation of the object. */\r
-#define Jim_FreeIntRep(i,o) \\r
- if ((o)->typePtr && (o)->typePtr->freeIntRepProc) \\r
- (o)->typePtr->freeIntRepProc(i, o)\r
-\r
-/* Get the internal representation pointer */\r
-#define Jim_GetIntRepPtr(o) (o)->internalRep.ptr\r
-\r
-/* Set the internal representation pointer */\r
-#define Jim_SetIntRepPtr(o, p) \\r
- (o)->internalRep.ptr = (p)\r
-\r
-/* The object type structure.\r
- * There are four methods.\r
- *\r
- * - FreeIntRep is used to free the internal representation of the object.\r
- * Can be NULL if there is nothing to free.\r
- * - DupIntRep is used to duplicate the internal representation of the object.\r
- * If NULL, when an object is duplicated, the internalRep union is\r
- * directly copied from an object to another.\r
- * Note that it's up to the caller to free the old internal repr of the\r
- * object before to call the Dup method.\r
- * - UpdateString is used to create the string from the internal repr.\r
- * - setFromAny is used to convert the current object into one of this type.\r
- */\r
-\r
-struct Jim_Interp;\r
-\r
-typedef void (Jim_FreeInternalRepProc)(struct Jim_Interp *interp,\r
- struct Jim_Obj *objPtr);\r
-typedef void (Jim_DupInternalRepProc)(struct Jim_Interp *interp,\r
- struct Jim_Obj *srcPtr, Jim_Obj *dupPtr);\r
-typedef void (Jim_UpdateStringProc)(struct Jim_Obj *objPtr);\r
- \r
-typedef struct Jim_ObjType {\r
- const char *name; /* The name of the type. */\r
- Jim_FreeInternalRepProc *freeIntRepProc;\r
- Jim_DupInternalRepProc *dupIntRepProc;\r
- Jim_UpdateStringProc *updateStringProc;\r
- int flags;\r
-} Jim_ObjType;\r
-\r
-/* Jim_ObjType flags */\r
-#define JIM_TYPE_NONE 0 /* No flags */\r
-#define JIM_TYPE_REFERENCES 1 /* The object may contain referneces. */\r
-\r
-/* Starting from 1 << 20 flags are reserved for private uses of\r
- * different calls. This way the same 'flags' argument may be used\r
- * to pass both global flags and private flags. */\r
-#define JIM_PRIV_FLAG_SHIFT 20\r
-\r
-/* -----------------------------------------------------------------------------\r
- * Call frame, vars, commands structures\r
- * ---------------------------------------------------------------------------*/\r
-\r
-/* Call frame */\r
-typedef struct Jim_CallFrame {\r
- unsigned jim_wide id; /* Call Frame ID. Used for caching. */\r
- struct Jim_HashTable vars; /* Where local vars are stored */\r
- struct Jim_HashTable *staticVars; /* pointer to procedure static vars */\r
- struct Jim_CallFrame *parentCallFrame;\r
- Jim_Obj *const *argv; /* object vector of the current procedure call. */\r
- int argc; /* number of args of the current procedure call. */\r
- Jim_Obj *procArgsObjPtr; /* arglist object of the running procedure */\r
- Jim_Obj *procBodyObjPtr; /* body object of the running procedure */\r
- struct Jim_CallFrame *nextFramePtr;\r
-} Jim_CallFrame;\r
-\r
-/* The var structure. It just holds the pointer of the referenced\r
- * object. If linkFramePtr is not NULL the variable is a link\r
- * to a variable of name store on objPtr living on the given callframe\r
- * (this happens when the [global] or [upvar] command is used).\r
- * The interp in order to always know how to free the Jim_Obj associated\r
- * with a given variable because In Jim objects memory managment is\r
- * bound to interpreters. */\r
-typedef struct Jim_Var {\r
- Jim_Obj *objPtr;\r
- struct Jim_CallFrame *linkFramePtr;\r
-} Jim_Var;\r
- \r
-/* The cmd structure. */\r
-typedef int (*Jim_CmdProc)(struct Jim_Interp *interp, int argc,\r
- Jim_Obj *const *argv);\r
-typedef void (*Jim_DelCmdProc)(struct Jim_Interp *interp, void *privData);\r
-\r
-/* A command is implemented in C if funcPtr is != NULL, otherwise\r
- * it's a Tcl procedure with the arglist and body represented by the\r
- * two objects referenced by arglistObjPtr and bodyoObjPtr. */\r
-typedef struct Jim_Cmd {\r
- Jim_CmdProc cmdProc; /* Not-NULL for a C command. */\r
- void *privData; /* Only used for C commands. */\r
- Jim_DelCmdProc delProc; /* Called when the command is deleted if != NULL */\r
- Jim_Obj *argListObjPtr;\r
- Jim_Obj *bodyObjPtr;\r
- Jim_HashTable *staticVars; /* Static vars hash table. NULL if no statics. */\r
- int arityMin; /* Min number of arguments. */\r
- int arityMax; /* Max number of arguments. */\r
-} Jim_Cmd;\r
-\r
-/* Pseudo Random Number Generator State structure */\r
-typedef struct Jim_PrngState {\r
- unsigned char sbox[256];\r
- unsigned int i, j;\r
-} Jim_PrngState;\r
-\r
-/* -----------------------------------------------------------------------------\r
- * Jim interpreter structure.\r
- * Fields similar to the real Tcl interpreter structure have the same names.\r
- * ---------------------------------------------------------------------------*/\r
-typedef struct Jim_Interp {\r
- Jim_Obj *result; /* object returned by the last command called. */\r
- int errorLine; /* Error line where an error occurred. */\r
- const char *errorFileName; /* Error file where an error occurred. */\r
- int numLevels; /* Number of current nested calls. */\r
- int maxNestingDepth; /* Used for infinite loop detection. */\r
- int returnCode; /* Completion code to return on JIM_RETURN. */\r
- int exitCode; /* Code to return to the OS on JIM_EXIT. */\r
- Jim_CallFrame *framePtr; /* Pointer to the current call frame */\r
- Jim_CallFrame *topFramePtr; /* toplevel/global frame pointer. */\r
- struct Jim_HashTable commands; /* Commands hash table */\r
- unsigned jim_wide procEpoch; /* Incremented every time the result\r
- of procedures names lookup caching\r
- may no longer be valid. */\r
- unsigned jim_wide callFrameEpoch; /* Incremented every time a new\r
- callframe is created. This id is used for the\r
- 'ID' field contained in the Jim_CallFrame\r
- structure. */\r
- Jim_Obj *liveList; /* Linked list of all the live objects. */\r
- Jim_Obj *freeList; /* Linked list of all the unused objects. */\r
- const char *scriptFileName; /* File name of the script currently in execution. */\r
- Jim_Obj *emptyObj; /* Shared empty string object. */\r
- unsigned jim_wide referenceNextId; /* Next id for reference. */\r
- struct Jim_HashTable references; /* References hash table. */\r
- jim_wide lastCollectId; /* reference max Id of the last GC\r
- execution. It's set to -1 while the collection\r
- is running as sentinel to avoid to recursive\r
- calls via the [collect] command inside\r
- finalizers. */\r
- time_t lastCollectTime; /* unix time of the last GC execution */\r
- struct Jim_HashTable sharedStrings; /* Shared Strings hash table */\r
- Jim_Obj *stackTrace; /* Stack trace object. */\r
- Jim_Obj *unknown; /* Unknown command cache */\r
- int errorFlag; /* Set if an error occurred during execution. */\r
- int evalRetcodeLevel; /* Level where the last return with code JIM_EVAL\r
- happened. */\r
- void *cmdPrivData; /* Used to pass the private data pointer to\r
- a command. It is set to what the user specified\r
- via Jim_CreateCommand(). */\r
-\r
- struct Jim_HashTable stub; /* Stub hash table to export API */\r
- /* Jim_GetApi() function pointer, used to bootstrap the STUB table */\r
- int (*getApiFuncPtr)(struct Jim_Interp *, const char *, void *);\r
- struct Jim_CallFrame *freeFramesList; /* list of CallFrame structures. */\r
- struct Jim_HashTable assocData; /* per-interp storage for use by packages */\r
- Jim_PrngState *prngState; /* per interpreter Random Number Gen. state. */\r
- struct Jim_HashTable packages; /* Provided packages hash table */\r
- FILE *stdin_; /* input file pointer, 'stdin' by default */\r
- FILE *stdout_; /* output file pointer, 'stdout' by default */\r
- FILE *stderr_; /* errors file pointer, 'stderr' by default */\r
-} Jim_Interp;\r
-\r
-/* Currently provided as macro that performs the increment.\r
- * At some point may be a real function doing more work.\r
- * The proc epoch is used in order to know when a command lookup\r
- * cached can no longer considered valid. */\r
-#define Jim_InterpIncrProcEpoch(i) (i)->procEpoch++\r
-#define Jim_SetResultString(i,s,l) Jim_SetResult(i, Jim_NewStringObj(i,s,l))\r
-#define Jim_SetEmptyResult(i) Jim_SetResult(i, (i)->emptyObj)\r
-#define Jim_GetResult(i) ((i)->result)\r
-#define Jim_CmdPrivData(i) ((i)->cmdPrivData)\r
-\r
-/* Note that 'o' is expanded only one time inside this macro,\r
- * so it's safe to use side effects. */\r
-#define Jim_SetResult(i,o) do { \\r
- Jim_Obj *_resultObjPtr_ = (o); \\r
- Jim_IncrRefCount(_resultObjPtr_); \\r
- Jim_DecrRefCount(i,(i)->result); \\r
- (i)->result = _resultObjPtr_; \\r
-} while(0)\r
-\r
-/* Reference structure. The interpreter pointer is held within privdata member in HashTable */\r
-#define JIM_REFERENCE_TAGLEN 7 /* The tag is fixed-length, because the reference\r
- string representation must be fixed length. */\r
-typedef struct Jim_Reference {\r
- Jim_Obj *objPtr;\r
- Jim_Obj *finalizerCmdNamePtr;\r
- char tag[JIM_REFERENCE_TAGLEN+1];\r
-} Jim_Reference;\r
-\r
-/* -----------------------------------------------------------------------------\r
- * Exported API prototypes.\r
- * ---------------------------------------------------------------------------*/\r
-\r
-/* Macros that are common for extensions and core. */\r
-#define Jim_NewEmptyStringObj(i) Jim_NewStringObj(i, "", 0)\r
-\r
-/* The core includes real prototypes, extensions instead\r
- * include a global function pointer for every function exported.\r
- * Once the extension calls Jim_InitExtension(), the global\r
- * functon pointers are set to the value of the STUB table\r
- * contained in the Jim_Interp structure.\r
- *\r
- * This makes Jim able to load extensions even if it is statically\r
- * linked itself, and to load extensions compiled with different\r
- * versions of Jim (as long as the API is still compatible.) */\r
-\r
-/* Macros are common for core and extensions */\r
-#define Jim_FreeHashTableIterator(iter) Jim_Free(iter)\r
-\r
-#ifndef __JIM_CORE__\r
-# if defined JIM_EXTENSION || defined JIM_EMBEDDED\r
-# define JIM_API(x) (*x)\r
-# define JIM_STATIC\r
-# else\r
-# define JIM_API(x) (*x)\r
-# define JIM_STATIC extern\r
-# endif\r
-#else\r
-# define JIM_API(x) x\r
-# if defined(BUILD_Jim)\r
-# define JIM_STATIC DLLEXPORT\r
-# else\r
-# define JIM_STATIC static\r
-# endif\r
-#endif /* __JIM_CORE__ */\r
-\r
-/* Memory allocation */\r
-JIM_STATIC void * JIM_API(Jim_Alloc) (int size);\r
-JIM_STATIC void JIM_API(Jim_Free) (void *ptr);\r
-JIM_STATIC char * JIM_API(Jim_StrDup) (const char *s);\r
-\r
-/* evaluation */\r
-JIM_STATIC int JIM_API(Jim_Eval)(Jim_Interp *interp, const char *script);\r
-JIM_STATIC int JIM_API(Jim_EvalGlobal)(Jim_Interp *interp, const char *script);\r
-JIM_STATIC int JIM_API(Jim_EvalFile)(Jim_Interp *interp, const char *filename);\r
-JIM_STATIC int JIM_API(Jim_EvalObj) (Jim_Interp *interp, Jim_Obj *scriptObjPtr);\r
-JIM_STATIC int JIM_API(Jim_EvalObjBackground) (Jim_Interp *interp,\r
- Jim_Obj *scriptObjPtr);\r
-JIM_STATIC int JIM_API(Jim_EvalObjVector) (Jim_Interp *interp, int objc,\r
- Jim_Obj *const *objv);\r
-JIM_STATIC int JIM_API(Jim_SubstObj) (Jim_Interp *interp, Jim_Obj *substObjPtr,\r
- Jim_Obj **resObjPtrPtr, int flags);\r
-\r
-/* stack */\r
-JIM_STATIC void JIM_API(Jim_InitStack)(Jim_Stack *stack);\r
-JIM_STATIC void JIM_API(Jim_FreeStack)(Jim_Stack *stack);\r
-JIM_STATIC int JIM_API(Jim_StackLen)(Jim_Stack *stack);\r
-JIM_STATIC void JIM_API(Jim_StackPush)(Jim_Stack *stack, void *element);\r
-JIM_STATIC void * JIM_API(Jim_StackPop)(Jim_Stack *stack);\r
-JIM_STATIC void * JIM_API(Jim_StackPeek)(Jim_Stack *stack);\r
-JIM_STATIC void JIM_API(Jim_FreeStackElements)(Jim_Stack *stack, void (*freeFunc)(void *ptr));\r
-\r
-/* hash table */\r
-JIM_STATIC int JIM_API(Jim_InitHashTable) (Jim_HashTable *ht,\r
- Jim_HashTableType *type, void *privdata);\r
-JIM_STATIC int JIM_API(Jim_ExpandHashTable) (Jim_HashTable *ht,\r
- unsigned int size);\r
-JIM_STATIC int JIM_API(Jim_AddHashEntry) (Jim_HashTable *ht, const void *key,\r
- void *val);\r
-JIM_STATIC int JIM_API(Jim_ReplaceHashEntry) (Jim_HashTable *ht,\r
- const void *key, void *val);\r
-JIM_STATIC int JIM_API(Jim_DeleteHashEntry) (Jim_HashTable *ht,\r
- const void *key);\r
-JIM_STATIC int JIM_API(Jim_FreeHashTable) (Jim_HashTable *ht);\r
-JIM_STATIC Jim_HashEntry * JIM_API(Jim_FindHashEntry) (Jim_HashTable *ht,\r
- const void *key);\r
-JIM_STATIC int JIM_API(Jim_ResizeHashTable) (Jim_HashTable *ht);\r
-JIM_STATIC Jim_HashTableIterator *JIM_API(Jim_GetHashTableIterator)\r
- (Jim_HashTable *ht);\r
-JIM_STATIC Jim_HashEntry * JIM_API(Jim_NextHashEntry)\r
- (Jim_HashTableIterator *iter);\r
-\r
-/* objects */\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_NewObj) (Jim_Interp *interp);\r
-JIM_STATIC void JIM_API(Jim_FreeObj) (Jim_Interp *interp, Jim_Obj *objPtr);\r
-JIM_STATIC void JIM_API(Jim_InvalidateStringRep) (Jim_Obj *objPtr);\r
-JIM_STATIC void JIM_API(Jim_InitStringRep) (Jim_Obj *objPtr, const char *bytes,\r
- int length);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_DuplicateObj) (Jim_Interp *interp,\r
- Jim_Obj *objPtr);\r
-JIM_STATIC const char * JIM_API(Jim_GetString)(Jim_Obj *objPtr,\r
- int *lenPtr);\r
-JIM_STATIC int JIM_API(Jim_Length)(Jim_Obj *objPtr);\r
-\r
-/* string object */\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_NewStringObj) (Jim_Interp *interp,\r
- const char *s, int len);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_NewStringObjNoAlloc) (Jim_Interp *interp,\r
- char *s, int len);\r
-JIM_STATIC void JIM_API(Jim_AppendString) (Jim_Interp *interp, Jim_Obj *objPtr,\r
- const char *str, int len);\r
-JIM_STATIC void JIM_API(Jim_AppendObj) (Jim_Interp *interp, Jim_Obj *objPtr,\r
- Jim_Obj *appendObjPtr);\r
-JIM_STATIC void JIM_API(Jim_AppendStrings) (Jim_Interp *interp,\r
- Jim_Obj *objPtr, ...);\r
-JIM_STATIC int JIM_API(Jim_StringEqObj) (Jim_Obj *aObjPtr,\r
- Jim_Obj *bObjPtr, int nocase);\r
-JIM_STATIC int JIM_API(Jim_StringMatchObj) (Jim_Obj *patternObjPtr,\r
- Jim_Obj *objPtr, int nocase);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_StringRangeObj) (Jim_Interp *interp,\r
- Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr,\r
- Jim_Obj *lastObjPtr);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_FormatString) (Jim_Interp *interp,\r
- Jim_Obj *fmtObjPtr, int objc, Jim_Obj *const *objv);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_ScanString) (Jim_Interp *interp, Jim_Obj *strObjPtr,\r
- Jim_Obj *fmtObjPtr, int flags);\r
-JIM_STATIC int JIM_API(Jim_CompareStringImmediate) (Jim_Interp *interp,\r
- Jim_Obj *objPtr, const char *str);\r
-\r
-/* reference object */\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_NewReference) (Jim_Interp *interp,\r
- Jim_Obj *objPtr, Jim_Obj *tagPtr, Jim_Obj *cmdNamePtr);\r
-JIM_STATIC Jim_Reference * JIM_API(Jim_GetReference) (Jim_Interp *interp,\r
- Jim_Obj *objPtr);\r
-JIM_STATIC int JIM_API(Jim_SetFinalizer) (Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *cmdNamePtr);\r
-JIM_STATIC int JIM_API(Jim_GetFinalizer) (Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj **cmdNamePtrPtr);\r
-\r
-/* interpreter */\r
-JIM_STATIC Jim_Interp * JIM_API(Jim_CreateInterp) (void);\r
-JIM_STATIC void JIM_API(Jim_FreeInterp) (Jim_Interp *i);\r
-JIM_STATIC int JIM_API(Jim_GetExitCode) (Jim_Interp *interp);\r
-JIM_STATIC FILE * JIM_API(Jim_SetStdin) (Jim_Interp *interp, FILE *fp);\r
-JIM_STATIC FILE * JIM_API(Jim_SetStdout) (Jim_Interp *interp, FILE *fp);\r
-JIM_STATIC FILE * JIM_API(Jim_SetStderr) (Jim_Interp *interp, FILE *fp);\r
-\r
-/* commands */\r
-JIM_STATIC void JIM_API(Jim_RegisterCoreCommands) (Jim_Interp *interp);\r
-JIM_STATIC int JIM_API(Jim_CreateCommand) (Jim_Interp *interp, \r
- const char *cmdName, Jim_CmdProc cmdProc, void *privData,\r
- Jim_DelCmdProc delProc);\r
-JIM_STATIC int JIM_API(Jim_CreateProcedure) (Jim_Interp *interp, \r
- const char *cmdName, Jim_Obj *argListObjPtr, Jim_Obj *staticsListObjPtr,\r
- Jim_Obj *bodyObjPtr, int arityMin, int arityMax);\r
-JIM_STATIC int JIM_API(Jim_DeleteCommand) (Jim_Interp *interp,\r
- const char *cmdName);\r
-JIM_STATIC int JIM_API(Jim_RenameCommand) (Jim_Interp *interp, \r
- const char *oldName, const char *newName);\r
-JIM_STATIC Jim_Cmd * JIM_API(Jim_GetCommand) (Jim_Interp *interp,\r
- Jim_Obj *objPtr, int flags);\r
-JIM_STATIC int JIM_API(Jim_SetVariable) (Jim_Interp *interp,\r
- Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr);\r
-JIM_STATIC int JIM_API(Jim_SetVariableStr) (Jim_Interp *interp,\r
- const char *name, Jim_Obj *objPtr);\r
-JIM_STATIC int JIM_API(Jim_SetGlobalVariableStr) (Jim_Interp *interp,\r
- const char *name, Jim_Obj *objPtr);\r
-JIM_STATIC int JIM_API(Jim_SetVariableStrWithStr) (Jim_Interp *interp,\r
- const char *name, const char *val);\r
-JIM_STATIC int JIM_API(Jim_SetVariableLink) (Jim_Interp *interp,\r
- Jim_Obj *nameObjPtr, Jim_Obj *targetNameObjPtr,\r
- Jim_CallFrame *targetCallFrame);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_GetVariable) (Jim_Interp *interp,\r
- Jim_Obj *nameObjPtr, int flags);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_GetGlobalVariable) (Jim_Interp *interp,\r
- Jim_Obj *nameObjPtr, int flags);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_GetVariableStr) (Jim_Interp *interp,\r
- const char *name, int flags);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_GetGlobalVariableStr) (Jim_Interp *interp,\r
- const char *name, int flags);\r
-JIM_STATIC int JIM_API(Jim_UnsetVariable) (Jim_Interp *interp,\r
- Jim_Obj *nameObjPtr, int flags);\r
-\r
-/* call frame */\r
-JIM_STATIC int JIM_API(Jim_GetCallFrameByLevel) (Jim_Interp *interp,\r
- Jim_Obj *levelObjPtr, Jim_CallFrame **framePtrPtr,\r
- int *newLevelPtr);\r
-\r
-/* garbage collection */\r
-JIM_STATIC int JIM_API(Jim_Collect) (Jim_Interp *interp);\r
-JIM_STATIC void JIM_API(Jim_CollectIfNeeded) (Jim_Interp *interp);\r
-\r
-/* index object */\r
-JIM_STATIC int JIM_API(Jim_GetIndex) (Jim_Interp *interp, Jim_Obj *objPtr,\r
- int *indexPtr);\r
-\r
-/* list object */\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_NewListObj) (Jim_Interp *interp,\r
- Jim_Obj *const *elements, int len);\r
-JIM_STATIC void JIM_API(Jim_ListInsertElements) (Jim_Interp *interp,\r
- Jim_Obj *listPtr, int index, int objc, Jim_Obj *const *objVec);\r
-JIM_STATIC void JIM_API(Jim_ListAppendElement) (Jim_Interp *interp,\r
- Jim_Obj *listPtr, Jim_Obj *objPtr);\r
-JIM_STATIC void JIM_API(Jim_ListAppendList) (Jim_Interp *interp,\r
- Jim_Obj *listPtr, Jim_Obj *appendListPtr);\r
-JIM_STATIC void JIM_API(Jim_ListLength) (Jim_Interp *interp, Jim_Obj *listPtr,\r
- int *intPtr);\r
-JIM_STATIC int JIM_API(Jim_ListIndex) (Jim_Interp *interp, Jim_Obj *listPrt,\r
- int index, Jim_Obj **objPtrPtr, int seterr);\r
-JIM_STATIC int JIM_API(Jim_SetListIndex) (Jim_Interp *interp,\r
- Jim_Obj *varNamePtr, Jim_Obj *const *indexv, int indexc,\r
- Jim_Obj *newObjPtr);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_ConcatObj) (Jim_Interp *interp, int objc,\r
- Jim_Obj *const *objv);\r
-\r
-/* dict object */\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_NewDictObj) (Jim_Interp *interp,\r
- Jim_Obj *const *elements, int len);\r
-JIM_STATIC int JIM_API(Jim_DictKey) (Jim_Interp *interp, Jim_Obj *dictPtr,\r
- Jim_Obj *keyPtr, Jim_Obj **objPtrPtr, int flags);\r
-JIM_STATIC int JIM_API(Jim_DictKeysVector) (Jim_Interp *interp,\r
- Jim_Obj *dictPtr, Jim_Obj *const *keyv, int keyc,\r
- Jim_Obj **objPtrPtr, int flags);\r
-JIM_STATIC int JIM_API(Jim_SetDictKeysVector) (Jim_Interp *interp,\r
- Jim_Obj *varNamePtr, Jim_Obj *const *keyv, int keyc,\r
- Jim_Obj *newObjPtr);\r
-\r
-/* return code object */\r
-JIM_STATIC int JIM_API(Jim_GetReturnCode) (Jim_Interp *interp, Jim_Obj *objPtr,\r
- int *intPtr);\r
-\r
-/* expression object */\r
-JIM_STATIC int JIM_API(Jim_EvalExpression) (Jim_Interp *interp,\r
- Jim_Obj *exprObjPtr, Jim_Obj **exprResultPtrPtr);\r
-JIM_STATIC int JIM_API(Jim_GetBoolFromExpr) (Jim_Interp *interp,\r
- Jim_Obj *exprObjPtr, int *boolPtr);\r
-\r
-/* integer object */\r
-JIM_STATIC int JIM_API(Jim_GetWide) (Jim_Interp *interp, Jim_Obj *objPtr,\r
- jim_wide *widePtr);\r
-JIM_STATIC int JIM_API(Jim_GetLong) (Jim_Interp *interp, Jim_Obj *objPtr,\r
- long *longPtr);\r
-JIM_STATIC void JIM_API(Jim_SetWide) (Jim_Interp *interp, Jim_Obj *objPtr,\r
- jim_wide wideValue);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_NewIntObj) (Jim_Interp *interp,\r
- jim_wide wideValue);\r
-\r
-/* double object */\r
-JIM_STATIC int JIM_API(Jim_GetDouble)(Jim_Interp *interp, Jim_Obj *objPtr,\r
- double *doublePtr);\r
-JIM_STATIC void JIM_API(Jim_SetDouble)(Jim_Interp *interp, Jim_Obj *objPtr,\r
- double doubleValue);\r
-JIM_STATIC Jim_Obj * JIM_API(Jim_NewDoubleObj)(Jim_Interp *interp, double doubleValue);\r
-\r
-/* shared strings */\r
-JIM_STATIC const char * JIM_API(Jim_GetSharedString) (Jim_Interp *interp, \r
- const char *str);\r
-JIM_STATIC void JIM_API(Jim_ReleaseSharedString) (Jim_Interp *interp,\r
- const char *str);\r
-\r
-/* commands utilities */\r
-JIM_STATIC void JIM_API(Jim_WrongNumArgs) (Jim_Interp *interp, int argc,\r
- Jim_Obj *const *argv, const char *msg);\r
-JIM_STATIC int JIM_API(Jim_GetEnum) (Jim_Interp *interp, Jim_Obj *objPtr,\r
- const char **tablePtr, int *indexPtr, const char *name, int flags);\r
-JIM_STATIC int JIM_API(Jim_ScriptIsComplete) (const char *s, int len,\r
- char *stateCharPtr);\r
-\r
-/* package utilities */\r
-typedef void (Jim_InterpDeleteProc)(Jim_Interp *interp, void *data);\r
-JIM_STATIC void * JIM_API(Jim_GetAssocData)(Jim_Interp *interp, const char *key);\r
-JIM_STATIC int JIM_API(Jim_SetAssocData)(Jim_Interp *interp, const char *key,\r
- Jim_InterpDeleteProc *delProc, void *data);\r
-JIM_STATIC int JIM_API(Jim_DeleteAssocData)(Jim_Interp *interp, const char *key);\r
-\r
-/* API import/export functions */\r
-JIM_STATIC int JIM_API(Jim_GetApi) (Jim_Interp *interp, const char *funcname,\r
- void *targetPtrPtr);\r
-JIM_STATIC int JIM_API(Jim_RegisterApi) (Jim_Interp *interp, \r
- const char *funcname, void *funcptr);\r
-\r
-/* Packages C API */\r
-JIM_STATIC int JIM_API(Jim_PackageProvide) (Jim_Interp *interp,\r
- const char *name, const char *ver, int flags);\r
-JIM_STATIC const char * JIM_API(Jim_PackageRequire) (Jim_Interp *interp,\r
- const char *name, const char *ver, int flags);\r
-\r
-/* error messages */\r
-JIM_STATIC void JIM_API(Jim_PrintErrorMessage) (Jim_Interp *interp);\r
-\r
-/* interactive mode */\r
-JIM_STATIC int JIM_API(Jim_InteractivePrompt) (Jim_Interp *interp);\r
-\r
-/* Misc */\r
-JIM_STATIC void JIM_API(Jim_Panic) (Jim_Interp *interp, const char *fmt, ...);\r
-\r
-#undef JIM_STATIC\r
-#undef JIM_API\r
-\r
-#ifndef __JIM_CORE__\r
-\r
-#define JIM_GET_API(name) \\r
- Jim_GetApi(interp, "Jim_" #name, ((void *)&Jim_ ## name))\r
-\r
-#if defined JIM_EXTENSION || defined JIM_EMBEDDED\r
-/* This must be included "inline" inside the extension */\r
-static void Jim_InitExtension(Jim_Interp *interp)\r
-{\r
- Jim_GetApi = interp->getApiFuncPtr;\r
-\r
- JIM_GET_API(Alloc);\r
- JIM_GET_API(Free);\r
- JIM_GET_API(Eval);\r
- JIM_GET_API(EvalGlobal);\r
- JIM_GET_API(EvalFile);\r
- JIM_GET_API(EvalObj);\r
- JIM_GET_API(EvalObjBackground);\r
- JIM_GET_API(EvalObjVector);\r
- JIM_GET_API(InitHashTable);\r
- JIM_GET_API(ExpandHashTable);\r
- JIM_GET_API(AddHashEntry);\r
- JIM_GET_API(ReplaceHashEntry);\r
- JIM_GET_API(DeleteHashEntry);\r
- JIM_GET_API(FreeHashTable);\r
- JIM_GET_API(FindHashEntry);\r
- JIM_GET_API(ResizeHashTable);\r
- JIM_GET_API(GetHashTableIterator);\r
- JIM_GET_API(NextHashEntry);\r
- JIM_GET_API(NewObj);\r
- JIM_GET_API(FreeObj);\r
- JIM_GET_API(InvalidateStringRep);\r
- JIM_GET_API(InitStringRep);\r
- JIM_GET_API(DuplicateObj);\r
- JIM_GET_API(GetString);\r
- JIM_GET_API(Length);\r
- JIM_GET_API(InvalidateStringRep);\r
- JIM_GET_API(NewStringObj);\r
- JIM_GET_API(NewStringObjNoAlloc);\r
- JIM_GET_API(AppendString);\r
- JIM_GET_API(AppendObj);\r
- JIM_GET_API(AppendStrings);\r
- JIM_GET_API(StringEqObj);\r
- JIM_GET_API(StringMatchObj);\r
- JIM_GET_API(StringRangeObj);\r
- JIM_GET_API(FormatString);\r
- JIM_GET_API(ScanString);\r
- JIM_GET_API(CompareStringImmediate);\r
- JIM_GET_API(NewReference);\r
- JIM_GET_API(GetReference);\r
- JIM_GET_API(SetFinalizer);\r
- JIM_GET_API(GetFinalizer);\r
- JIM_GET_API(CreateInterp);\r
- JIM_GET_API(FreeInterp);\r
- JIM_GET_API(GetExitCode);\r
- JIM_GET_API(SetStdin);\r
- JIM_GET_API(SetStdout);\r
- JIM_GET_API(SetStderr);\r
- JIM_GET_API(CreateCommand);\r
- JIM_GET_API(CreateProcedure);\r
- JIM_GET_API(DeleteCommand);\r
- JIM_GET_API(RenameCommand);\r
- JIM_GET_API(GetCommand);\r
- JIM_GET_API(SetVariable);\r
- JIM_GET_API(SetVariableStr);\r
- JIM_GET_API(SetGlobalVariableStr);\r
- JIM_GET_API(SetVariableStrWithStr);\r
- JIM_GET_API(SetVariableLink);\r
- JIM_GET_API(GetVariable);\r
- JIM_GET_API(GetCallFrameByLevel);\r
- JIM_GET_API(Collect);\r
- JIM_GET_API(CollectIfNeeded);\r
- JIM_GET_API(GetIndex);\r
- JIM_GET_API(NewListObj);\r
- JIM_GET_API(ListInsertElements);\r
- JIM_GET_API(ListAppendElement);\r
- JIM_GET_API(ListAppendList);\r
- JIM_GET_API(ListLength);\r
- JIM_GET_API(ListIndex);\r
- JIM_GET_API(SetListIndex);\r
- JIM_GET_API(ConcatObj);\r
- JIM_GET_API(NewDictObj);\r
- JIM_GET_API(DictKey);\r
- JIM_GET_API(DictKeysVector);\r
- JIM_GET_API(GetIndex);\r
- JIM_GET_API(GetReturnCode);\r
- JIM_GET_API(EvalExpression);\r
- JIM_GET_API(GetBoolFromExpr);\r
- JIM_GET_API(GetWide);\r
- JIM_GET_API(GetLong);\r
- JIM_GET_API(SetWide);\r
- JIM_GET_API(NewIntObj);\r
- JIM_GET_API(GetDouble);\r
- JIM_GET_API(SetDouble);\r
- JIM_GET_API(NewDoubleObj);\r
- JIM_GET_API(WrongNumArgs);\r
- JIM_GET_API(SetDictKeysVector);\r
- JIM_GET_API(SubstObj);\r
- JIM_GET_API(RegisterApi);\r
- JIM_GET_API(PrintErrorMessage);\r
- JIM_GET_API(InteractivePrompt);\r
- JIM_GET_API(RegisterCoreCommands);\r
- JIM_GET_API(GetSharedString);\r
- JIM_GET_API(ReleaseSharedString);\r
- JIM_GET_API(Panic);\r
- JIM_GET_API(StrDup);\r
- JIM_GET_API(UnsetVariable);\r
- JIM_GET_API(GetVariableStr);\r
- JIM_GET_API(GetGlobalVariable);\r
- JIM_GET_API(GetGlobalVariableStr);\r
- JIM_GET_API(GetAssocData);\r
- JIM_GET_API(SetAssocData);\r
- JIM_GET_API(DeleteAssocData);\r
- JIM_GET_API(GetEnum);\r
- JIM_GET_API(ScriptIsComplete);\r
- JIM_GET_API(PackageProvide);\r
- JIM_GET_API(PackageRequire);\r
- JIM_GET_API(InitStack);\r
- JIM_GET_API(FreeStack);\r
- JIM_GET_API(StackLen);\r
- JIM_GET_API(StackPush);\r
- JIM_GET_API(StackPop);\r
- JIM_GET_API(StackPeek);\r
- JIM_GET_API(FreeStackElements);\r
-}\r
-#endif /* defined JIM_EXTENSION || defined JIM_EMBEDDED */\r
-\r
-#undef JIM_GET_API\r
-\r
-#ifdef JIM_EMBEDDED\r
-Jim_Interp *ExportedJimCreateInterp(void);\r
-static void Jim_InitEmbedded(void) {\r
- Jim_Interp *i = ExportedJimCreateInterp();\r
- Jim_InitExtension(i);\r
- Jim_FreeInterp(i);\r
-}\r
-#endif /* JIM_EMBEDDED */\r
-#endif /* __JIM_CORE__ */\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
-#endif /* __JIM__H */\r
+/* Jim - A small embeddable Tcl interpreter
+ * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
+ * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * A copy of the license is also included in the source distribution
+ * of Jim, as a TXT file name called LICENSE.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __JIM__H
+#define __JIM__H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <time.h>
+#include <limits.h>
+#include <stdio.h> /* for the FILE typedef definition */
+#include <stdlib.h> /* In order to export the Jim_Free() macro */
+
+/* -----------------------------------------------------------------------------
+* Some /very/ old compiler maybe do not know how to
+* handle 'const'. They even do not know, how to ignore
+* it. For those compiler it may be better to compile with
+* define JIM_NO_CONST activated
+* ---------------------------------------------------------------------------*/
+
+#ifdef JIM_NO_CONST
+# define const
+#endif
+
+/* -----------------------------------------------------------------------------
+ * System configuration
+ * For most modern systems, you can leave the default.
+ * For embedded systems some change may be required.
+ * ---------------------------------------------------------------------------*/
+
+#define HAVE_LONG_LONG
+
+/* -----------------------------------------------------------------------------
+ * Compiler specific fixes.
+ * ---------------------------------------------------------------------------*/
+
+/* MSC has _stricmp instead of strcasecmp */
+#ifdef _MSC_VER
+# define strcasecmp _stricmp
+#endif /* _MSC_VER */
+
+/* Long Long type and related issues */
+#ifdef HAVE_LONG_LONG
+# ifdef _MSC_VER /* MSC compiler */
+# define jim_wide _int64
+# ifndef LLONG_MAX
+# define LLONG_MAX 9223372036854775807I64
+# endif
+# ifndef LLONG_MIN
+# define LLONG_MIN (-LLONG_MAX - 1I64)
+# endif
+# define JIM_WIDE_MIN LLONG_MIN
+# define JIM_WIDE_MAX LLONG_MAX
+# else /* Other compilers (mainly GCC) */
+# define jim_wide long long
+# ifndef LLONG_MAX
+# define LLONG_MAX 9223372036854775807LL
+# endif
+# ifndef LLONG_MIN
+# define LLONG_MIN (-LLONG_MAX - 1LL)
+# endif
+# define JIM_WIDE_MIN LLONG_MIN
+# define JIM_WIDE_MAX LLONG_MAX
+# endif
+#else
+# define jim_wide long
+# define JIM_WIDE_MIN LONG_MIN
+# define JIM_WIDE_MAX LONG_MAX
+#endif
+
+/* -----------------------------------------------------------------------------
+ * LIBC specific fixes
+ * ---------------------------------------------------------------------------*/
+
+#ifdef HAVE_LONG_LONG
+# if defined(_MSC_VER) || defined(__MSVCRT__)
+# define JIM_WIDE_MODIFIER "I64d"
+# else
+# define JIM_WIDE_MODIFIER "lld"
+# endif
+#else
+# define JIM_WIDE_MODIFIER "ld"
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Exported defines
+ * ---------------------------------------------------------------------------*/
+
+/* Jim version numbering: every version of jim is marked with a
+ * successive integer number. This is version 0. The first
+ * stable version will be 1, then 2, 3, and so on. */
+#define JIM_VERSION 51
+
+#define JIM_OK 0
+#define JIM_ERR 1
+#define JIM_RETURN 2
+#define JIM_BREAK 3
+#define JIM_CONTINUE 4
+#define JIM_EVAL 5
+#define JIM_EXIT 6
+#define JIM_MAX_NESTING_DEPTH 10000 /* default max nesting depth */
+
+/* Some function get an integer argument with flags to change
+ * the behaviour. */
+#define JIM_NONE 0 /* no flags set */
+#define JIM_ERRMSG 1 /* set an error message in the interpreter. */
+
+/* Flags for Jim_SubstObj() */
+#define JIM_SUBST_NOVAR 1 /* don't perform variables substitutions */
+#define JIM_SUBST_NOCMD 2 /* don't perform command substitutions */
+#define JIM_SUBST_NOESC 4 /* don't perform escapes substitutions */
+
+/* Unused arguments generate annoying warnings... */
+#define JIM_NOTUSED(V) ((void) V)
+
+/* Flags used by API calls getting a 'nocase' argument. */
+#define JIM_CASESENS 0 /* case sensitive */
+#define JIM_NOCASE 1 /* no case */
+
+/* Filesystem related */
+#define JIM_PATH_LEN 1024
+
+/* Newline, some embedded system may need -DJIM_CRLF */
+#ifdef JIM_CRLF
+#define JIM_NL "\r\n"
+#else
+#define JIM_NL "\n"
+#endif
+
+#if defined(__WIN32__) || defined(_WIN32)
+#define DLLEXPORT __declspec(dllexport)
+#define DLLIMPORT __declspec(dllimport)
+#else
+#define DLLEXPORT
+#define DLLIMPORT
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Stack
+ * ---------------------------------------------------------------------------*/
+
+typedef struct Jim_Stack {
+ int len;
+ int maxlen;
+ void **vector;
+} Jim_Stack;
+
+/* -----------------------------------------------------------------------------
+ * Hash table
+ * ---------------------------------------------------------------------------*/
+
+typedef struct Jim_HashEntry {
+ const void *key;
+ void *val;
+ struct Jim_HashEntry *next;
+} Jim_HashEntry;
+
+typedef struct Jim_HashTableType {
+ unsigned int (*hashFunction)(const void *key);
+ const void *(*keyDup)(void *privdata, const void *key);
+ void *(*valDup)(void *privdata, const void *obj);
+ int (*keyCompare)(void *privdata, const void *key1, const void *key2);
+ void (*keyDestructor)(void *privdata, const void *key);
+ void (*valDestructor)(void *privdata, void *obj);
+} Jim_HashTableType;
+
+typedef struct Jim_HashTable {
+ Jim_HashEntry **table;
+ Jim_HashTableType *type;
+ unsigned int size;
+ unsigned int sizemask;
+ unsigned int used;
+ unsigned int collisions;
+ void *privdata;
+} Jim_HashTable;
+
+typedef struct Jim_HashTableIterator {
+ Jim_HashTable *ht;
+ int index;
+ Jim_HashEntry *entry, *nextEntry;
+} Jim_HashTableIterator;
+
+/* This is the initial size of every hash table */
+#define JIM_HT_INITIAL_SIZE 16
+
+/* ------------------------------- Macros ------------------------------------*/
+#define Jim_FreeEntryVal(ht, entry) \
+ if ((ht)->type->valDestructor) \
+ (ht)->type->valDestructor((ht)->privdata, (entry)->val)
+
+#define Jim_SetHashVal(ht, entry, _val_) do { \
+ if ((ht)->type->valDup) \
+ entry->val = (ht)->type->valDup((ht)->privdata, _val_); \
+ else \
+ entry->val = (_val_); \
+} while(0)
+
+#define Jim_FreeEntryKey(ht, entry) \
+ if ((ht)->type->keyDestructor) \
+ (ht)->type->keyDestructor((ht)->privdata, (entry)->key)
+
+#define Jim_SetHashKey(ht, entry, _key_) do { \
+ if ((ht)->type->keyDup) \
+ entry->key = (ht)->type->keyDup((ht)->privdata, _key_); \
+ else \
+ entry->key = (_key_); \
+} while(0)
+
+#define Jim_CompareHashKeys(ht, key1, key2) \
+ (((ht)->type->keyCompare) ? \
+ (ht)->type->keyCompare((ht)->privdata, key1, key2) : \
+ (key1) == (key2))
+
+#define Jim_HashKey(ht, key) (ht)->type->hashFunction(key)
+
+#define Jim_GetHashEntryKey(he) ((he)->key)
+#define Jim_GetHashEntryVal(he) ((he)->val)
+#define Jim_GetHashTableCollisions(ht) ((ht)->collisions)
+#define Jim_GetHashTableSize(ht) ((ht)->size)
+#define Jim_GetHashTableUsed(ht) ((ht)->used)
+
+/* -----------------------------------------------------------------------------
+ * Jim_Obj structure
+ * ---------------------------------------------------------------------------*/
+
+/* -----------------------------------------------------------------------------
+ * Jim object. This is mostly the same as Tcl_Obj itself,
+ * with the addition of the 'prev' and 'next' pointers.
+ * In Jim all the objects are stored into a linked list for GC purposes,
+ * so that it's possible to access every object living in a given interpreter
+ * sequentially. When an object is freed, it's moved into a different
+ * linked list, used as object pool.
+ *
+ * The refcount of a freed object is always -1.
+ * ---------------------------------------------------------------------------*/
+typedef struct Jim_Obj {
+ int refCount; /* reference count */
+ char *bytes; /* string representation buffer. NULL = no string repr. */
+ int length; /* number of bytes in 'bytes', not including the numterm. */
+ struct Jim_ObjType *typePtr; /* object type. */
+ /* Internal representation union */
+ union {
+ /* integer number type */
+ jim_wide wideValue;
+ /* hashed object type value */
+ int hashValue;
+ /* index type */
+ int indexValue;
+ /* return code type */
+ int returnCode;
+ /* double number type */
+ double doubleValue;
+ /* Generic pointer */
+ void *ptr;
+ /* Generic two pointers value */
+ struct {
+ void *ptr1;
+ void *ptr2;
+ } twoPtrValue;
+ /* Variable object */
+ struct {
+ unsigned jim_wide callFrameId;
+ struct Jim_Var *varPtr;
+ } varValue;
+ /* Command object */
+ struct {
+ unsigned jim_wide procEpoch;
+ struct Jim_Cmd *cmdPtr;
+ } cmdValue;
+ /* List object */
+ struct {
+ struct Jim_Obj **ele; /* Elements vector */
+ int len; /* Length */
+ int maxLen; /* Allocated 'ele' length */
+ } listValue;
+ /* String type */
+ struct {
+ int maxLength;
+ } strValue;
+ /* Reference type */
+ struct {
+ jim_wide id;
+ struct Jim_Reference *refPtr;
+ } refValue;
+ /* Source type */
+ struct {
+ const char *fileName;
+ int lineNumber;
+ } sourceValue;
+ /* Dict substitution type */
+ struct {
+ struct Jim_Obj *varNameObjPtr;
+ struct Jim_Obj *indexObjPtr;
+ } dictSubstValue;
+ /* tagged binary type */
+ struct {
+ unsigned char *data;
+ size_t len;
+ } binaryValue;
+ } internalRep;
+ /* This are 8 or 16 bytes more for every object
+ * but this is required for efficient garbage collection
+ * of Jim references. */
+ struct Jim_Obj *prevObjPtr; /* pointer to the prev object. */
+ struct Jim_Obj *nextObjPtr; /* pointer to the next object. */
+} Jim_Obj;
+
+/* Jim_Obj related macros */
+#define Jim_IncrRefCount(objPtr) \
+ ++(objPtr)->refCount
+#define Jim_DecrRefCount(interp, objPtr) \
+ if (--(objPtr)->refCount <= 0) Jim_FreeObj(interp, objPtr)
+#define Jim_IsShared(objPtr) \
+ ((objPtr)->refCount > 1)
+
+/* This macro is used when we allocate a new object using
+ * Jim_New...Obj(), but for some error we need to destroy it.
+ * Instead to use Jim_IncrRefCount() + Jim_DecrRefCount() we
+ * can just call Jim_FreeNewObj. To call Jim_Free directly
+ * seems too raw, the object handling may change and we want
+ * that Jim_FreeNewObj() can be called only against objects
+ * that are belived to have refcount == 0. */
+#define Jim_FreeNewObj Jim_FreeObj
+
+/* Free the internal representation of the object. */
+#define Jim_FreeIntRep(i,o) \
+ if ((o)->typePtr && (o)->typePtr->freeIntRepProc) \
+ (o)->typePtr->freeIntRepProc(i, o)
+
+/* Get the internal representation pointer */
+#define Jim_GetIntRepPtr(o) (o)->internalRep.ptr
+
+/* Set the internal representation pointer */
+#define Jim_SetIntRepPtr(o, p) \
+ (o)->internalRep.ptr = (p)
+
+/* The object type structure.
+ * There are four methods.
+ *
+ * - FreeIntRep is used to free the internal representation of the object.
+ * Can be NULL if there is nothing to free.
+ * - DupIntRep is used to duplicate the internal representation of the object.
+ * If NULL, when an object is duplicated, the internalRep union is
+ * directly copied from an object to another.
+ * Note that it's up to the caller to free the old internal repr of the
+ * object before to call the Dup method.
+ * - UpdateString is used to create the string from the internal repr.
+ * - setFromAny is used to convert the current object into one of this type.
+ */
+
+struct Jim_Interp;
+
+typedef void (Jim_FreeInternalRepProc)(struct Jim_Interp *interp,
+ struct Jim_Obj *objPtr);
+typedef void (Jim_DupInternalRepProc)(struct Jim_Interp *interp,
+ struct Jim_Obj *srcPtr, Jim_Obj *dupPtr);
+typedef void (Jim_UpdateStringProc)(struct Jim_Obj *objPtr);
+
+typedef struct Jim_ObjType {
+ const char *name; /* The name of the type. */
+ Jim_FreeInternalRepProc *freeIntRepProc;
+ Jim_DupInternalRepProc *dupIntRepProc;
+ Jim_UpdateStringProc *updateStringProc;
+ int flags;
+} Jim_ObjType;
+
+/* Jim_ObjType flags */
+#define JIM_TYPE_NONE 0 /* No flags */
+#define JIM_TYPE_REFERENCES 1 /* The object may contain referneces. */
+
+/* Starting from 1 << 20 flags are reserved for private uses of
+ * different calls. This way the same 'flags' argument may be used
+ * to pass both global flags and private flags. */
+#define JIM_PRIV_FLAG_SHIFT 20
+
+/* -----------------------------------------------------------------------------
+ * Call frame, vars, commands structures
+ * ---------------------------------------------------------------------------*/
+
+/* Call frame */
+typedef struct Jim_CallFrame {
+ unsigned jim_wide id; /* Call Frame ID. Used for caching. */
+ struct Jim_HashTable vars; /* Where local vars are stored */
+ struct Jim_HashTable *staticVars; /* pointer to procedure static vars */
+ struct Jim_CallFrame *parentCallFrame;
+ Jim_Obj *const *argv; /* object vector of the current procedure call. */
+ int argc; /* number of args of the current procedure call. */
+ Jim_Obj *procArgsObjPtr; /* arglist object of the running procedure */
+ Jim_Obj *procBodyObjPtr; /* body object of the running procedure */
+ struct Jim_CallFrame *nextFramePtr;
+} Jim_CallFrame;
+
+/* The var structure. It just holds the pointer of the referenced
+ * object. If linkFramePtr is not NULL the variable is a link
+ * to a variable of name store on objPtr living on the given callframe
+ * (this happens when the [global] or [upvar] command is used).
+ * The interp in order to always know how to free the Jim_Obj associated
+ * with a given variable because In Jim objects memory managment is
+ * bound to interpreters. */
+typedef struct Jim_Var {
+ Jim_Obj *objPtr;
+ struct Jim_CallFrame *linkFramePtr;
+} Jim_Var;
+
+/* The cmd structure. */
+typedef int (*Jim_CmdProc)(struct Jim_Interp *interp, int argc,
+ Jim_Obj *const *argv);
+typedef void (*Jim_DelCmdProc)(struct Jim_Interp *interp, void *privData);
+
+/* A command is implemented in C if funcPtr is != NULL, otherwise
+ * it's a Tcl procedure with the arglist and body represented by the
+ * two objects referenced by arglistObjPtr and bodyoObjPtr. */
+typedef struct Jim_Cmd {
+ Jim_CmdProc cmdProc; /* Not-NULL for a C command. */
+ void *privData; /* Only used for C commands. */
+ Jim_DelCmdProc delProc; /* Called when the command is deleted if != NULL */
+ Jim_Obj *argListObjPtr;
+ Jim_Obj *bodyObjPtr;
+ Jim_HashTable *staticVars; /* Static vars hash table. NULL if no statics. */
+ int arityMin; /* Min number of arguments. */
+ int arityMax; /* Max number of arguments. */
+} Jim_Cmd;
+
+/* Pseudo Random Number Generator State structure */
+typedef struct Jim_PrngState {
+ unsigned char sbox[256];
+ unsigned int i, j;
+} Jim_PrngState;
+
+/* -----------------------------------------------------------------------------
+ * Jim interpreter structure.
+ * Fields similar to the real Tcl interpreter structure have the same names.
+ * ---------------------------------------------------------------------------*/
+typedef struct Jim_Interp {
+ Jim_Obj *result; /* object returned by the last command called. */
+ int errorLine; /* Error line where an error occurred. */
+ const char *errorFileName; /* Error file where an error occurred. */
+ int numLevels; /* Number of current nested calls. */
+ int maxNestingDepth; /* Used for infinite loop detection. */
+ int returnCode; /* Completion code to return on JIM_RETURN. */
+ int exitCode; /* Code to return to the OS on JIM_EXIT. */
+ Jim_CallFrame *framePtr; /* Pointer to the current call frame */
+ Jim_CallFrame *topFramePtr; /* toplevel/global frame pointer. */
+ struct Jim_HashTable commands; /* Commands hash table */
+ unsigned jim_wide procEpoch; /* Incremented every time the result
+ of procedures names lookup caching
+ may no longer be valid. */
+ unsigned jim_wide callFrameEpoch; /* Incremented every time a new
+ callframe is created. This id is used for the
+ 'ID' field contained in the Jim_CallFrame
+ structure. */
+ Jim_Obj *liveList; /* Linked list of all the live objects. */
+ Jim_Obj *freeList; /* Linked list of all the unused objects. */
+ const char *scriptFileName; /* File name of the script currently in execution. */
+ Jim_Obj *emptyObj; /* Shared empty string object. */
+ unsigned jim_wide referenceNextId; /* Next id for reference. */
+ struct Jim_HashTable references; /* References hash table. */
+ jim_wide lastCollectId; /* reference max Id of the last GC
+ execution. It's set to -1 while the collection
+ is running as sentinel to avoid to recursive
+ calls via the [collect] command inside
+ finalizers. */
+ time_t lastCollectTime; /* unix time of the last GC execution */
+ struct Jim_HashTable sharedStrings; /* Shared Strings hash table */
+ Jim_Obj *stackTrace; /* Stack trace object. */
+ Jim_Obj *unknown; /* Unknown command cache */
+ int errorFlag; /* Set if an error occurred during execution. */
+ int evalRetcodeLevel; /* Level where the last return with code JIM_EVAL
+ happened. */
+ void *cmdPrivData; /* Used to pass the private data pointer to
+ a command. It is set to what the user specified
+ via Jim_CreateCommand(). */
+
+ struct Jim_HashTable stub; /* Stub hash table to export API */
+ /* Jim_GetApi() function pointer, used to bootstrap the STUB table */
+ int (*getApiFuncPtr)(struct Jim_Interp *, const char *, void *);
+ struct Jim_CallFrame *freeFramesList; /* list of CallFrame structures. */
+ struct Jim_HashTable assocData; /* per-interp storage for use by packages */
+ Jim_PrngState *prngState; /* per interpreter Random Number Gen. state. */
+ struct Jim_HashTable packages; /* Provided packages hash table */
+ FILE *stdin_; /* input file pointer, 'stdin' by default */
+ FILE *stdout_; /* output file pointer, 'stdout' by default */
+ FILE *stderr_; /* errors file pointer, 'stderr' by default */
+} Jim_Interp;
+
+/* Currently provided as macro that performs the increment.
+ * At some point may be a real function doing more work.
+ * The proc epoch is used in order to know when a command lookup
+ * cached can no longer considered valid. */
+#define Jim_InterpIncrProcEpoch(i) (i)->procEpoch++
+#define Jim_SetResultString(i,s,l) Jim_SetResult(i, Jim_NewStringObj(i,s,l))
+#define Jim_SetEmptyResult(i) Jim_SetResult(i, (i)->emptyObj)
+#define Jim_GetResult(i) ((i)->result)
+#define Jim_CmdPrivData(i) ((i)->cmdPrivData)
+
+/* Note that 'o' is expanded only one time inside this macro,
+ * so it's safe to use side effects. */
+#define Jim_SetResult(i,o) do { \
+ Jim_Obj *_resultObjPtr_ = (o); \
+ Jim_IncrRefCount(_resultObjPtr_); \
+ Jim_DecrRefCount(i,(i)->result); \
+ (i)->result = _resultObjPtr_; \
+} while(0)
+
+/* Reference structure. The interpreter pointer is held within privdata member in HashTable */
+#define JIM_REFERENCE_TAGLEN 7 /* The tag is fixed-length, because the reference
+ string representation must be fixed length. */
+typedef struct Jim_Reference {
+ Jim_Obj *objPtr;
+ Jim_Obj *finalizerCmdNamePtr;
+ char tag[JIM_REFERENCE_TAGLEN+1];
+} Jim_Reference;
+
+/* -----------------------------------------------------------------------------
+ * Exported API prototypes.
+ * ---------------------------------------------------------------------------*/
+
+/* Macros that are common for extensions and core. */
+#define Jim_NewEmptyStringObj(i) Jim_NewStringObj(i, "", 0)
+
+/* The core includes real prototypes, extensions instead
+ * include a global function pointer for every function exported.
+ * Once the extension calls Jim_InitExtension(), the global
+ * functon pointers are set to the value of the STUB table
+ * contained in the Jim_Interp structure.
+ *
+ * This makes Jim able to load extensions even if it is statically
+ * linked itself, and to load extensions compiled with different
+ * versions of Jim (as long as the API is still compatible.) */
+
+/* Macros are common for core and extensions */
+#define Jim_FreeHashTableIterator(iter) Jim_Free(iter)
+
+#ifndef __JIM_CORE__
+# if defined JIM_EXTENSION || defined JIM_EMBEDDED
+# define JIM_API(x) (*x)
+# define JIM_STATIC
+# else
+# define JIM_API(x) (*x)
+# define JIM_STATIC extern
+# endif
+#else
+# define JIM_API(x) x
+# if defined(BUILD_Jim)
+# define JIM_STATIC DLLEXPORT
+# else
+# define JIM_STATIC static
+# endif
+#endif /* __JIM_CORE__ */
+
+/* Memory allocation */
+JIM_STATIC void * JIM_API(Jim_Alloc) (int size);
+JIM_STATIC void JIM_API(Jim_Free) (void *ptr);
+JIM_STATIC char * JIM_API(Jim_StrDup) (const char *s);
+
+/* evaluation */
+JIM_STATIC int JIM_API(Jim_Eval)(Jim_Interp *interp, const char *script);
+JIM_STATIC int JIM_API(Jim_EvalGlobal)(Jim_Interp *interp, const char *script);
+JIM_STATIC int JIM_API(Jim_EvalFile)(Jim_Interp *interp, const char *filename);
+JIM_STATIC int JIM_API(Jim_EvalObj) (Jim_Interp *interp, Jim_Obj *scriptObjPtr);
+JIM_STATIC int JIM_API(Jim_EvalObjBackground) (Jim_Interp *interp,
+ Jim_Obj *scriptObjPtr);
+JIM_STATIC int JIM_API(Jim_EvalObjVector) (Jim_Interp *interp, int objc,
+ Jim_Obj *const *objv);
+JIM_STATIC int JIM_API(Jim_SubstObj) (Jim_Interp *interp, Jim_Obj *substObjPtr,
+ Jim_Obj **resObjPtrPtr, int flags);
+
+/* stack */
+JIM_STATIC void JIM_API(Jim_InitStack)(Jim_Stack *stack);
+JIM_STATIC void JIM_API(Jim_FreeStack)(Jim_Stack *stack);
+JIM_STATIC int JIM_API(Jim_StackLen)(Jim_Stack *stack);
+JIM_STATIC void JIM_API(Jim_StackPush)(Jim_Stack *stack, void *element);
+JIM_STATIC void * JIM_API(Jim_StackPop)(Jim_Stack *stack);
+JIM_STATIC void * JIM_API(Jim_StackPeek)(Jim_Stack *stack);
+JIM_STATIC void JIM_API(Jim_FreeStackElements)(Jim_Stack *stack, void (*freeFunc)(void *ptr));
+
+/* hash table */
+JIM_STATIC int JIM_API(Jim_InitHashTable) (Jim_HashTable *ht,
+ Jim_HashTableType *type, void *privdata);
+JIM_STATIC int JIM_API(Jim_ExpandHashTable) (Jim_HashTable *ht,
+ unsigned int size);
+JIM_STATIC int JIM_API(Jim_AddHashEntry) (Jim_HashTable *ht, const void *key,
+ void *val);
+JIM_STATIC int JIM_API(Jim_ReplaceHashEntry) (Jim_HashTable *ht,
+ const void *key, void *val);
+JIM_STATIC int JIM_API(Jim_DeleteHashEntry) (Jim_HashTable *ht,
+ const void *key);
+JIM_STATIC int JIM_API(Jim_FreeHashTable) (Jim_HashTable *ht);
+JIM_STATIC Jim_HashEntry * JIM_API(Jim_FindHashEntry) (Jim_HashTable *ht,
+ const void *key);
+JIM_STATIC int JIM_API(Jim_ResizeHashTable) (Jim_HashTable *ht);
+JIM_STATIC Jim_HashTableIterator *JIM_API(Jim_GetHashTableIterator)
+ (Jim_HashTable *ht);
+JIM_STATIC Jim_HashEntry * JIM_API(Jim_NextHashEntry)
+ (Jim_HashTableIterator *iter);
+
+/* objects */
+JIM_STATIC Jim_Obj * JIM_API(Jim_NewObj) (Jim_Interp *interp);
+JIM_STATIC void JIM_API(Jim_FreeObj) (Jim_Interp *interp, Jim_Obj *objPtr);
+JIM_STATIC void JIM_API(Jim_InvalidateStringRep) (Jim_Obj *objPtr);
+JIM_STATIC void JIM_API(Jim_InitStringRep) (Jim_Obj *objPtr, const char *bytes,
+ int length);
+JIM_STATIC Jim_Obj * JIM_API(Jim_DuplicateObj) (Jim_Interp *interp,
+ Jim_Obj *objPtr);
+JIM_STATIC const char * JIM_API(Jim_GetString)(Jim_Obj *objPtr,
+ int *lenPtr);
+JIM_STATIC int JIM_API(Jim_Length)(Jim_Obj *objPtr);
+
+/* string object */
+JIM_STATIC Jim_Obj * JIM_API(Jim_NewStringObj) (Jim_Interp *interp,
+ const char *s, int len);
+JIM_STATIC Jim_Obj * JIM_API(Jim_NewStringObjNoAlloc) (Jim_Interp *interp,
+ char *s, int len);
+JIM_STATIC void JIM_API(Jim_AppendString) (Jim_Interp *interp, Jim_Obj *objPtr,
+ const char *str, int len);
+JIM_STATIC void JIM_API(Jim_AppendObj) (Jim_Interp *interp, Jim_Obj *objPtr,
+ Jim_Obj *appendObjPtr);
+JIM_STATIC void JIM_API(Jim_AppendStrings) (Jim_Interp *interp,
+ Jim_Obj *objPtr, ...);
+JIM_STATIC int JIM_API(Jim_StringEqObj) (Jim_Obj *aObjPtr,
+ Jim_Obj *bObjPtr, int nocase);
+JIM_STATIC int JIM_API(Jim_StringMatchObj) (Jim_Obj *patternObjPtr,
+ Jim_Obj *objPtr, int nocase);
+JIM_STATIC Jim_Obj * JIM_API(Jim_StringRangeObj) (Jim_Interp *interp,
+ Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr,
+ Jim_Obj *lastObjPtr);
+JIM_STATIC Jim_Obj * JIM_API(Jim_FormatString) (Jim_Interp *interp,
+ Jim_Obj *fmtObjPtr, int objc, Jim_Obj *const *objv);
+JIM_STATIC Jim_Obj * JIM_API(Jim_ScanString) (Jim_Interp *interp, Jim_Obj *strObjPtr,
+ Jim_Obj *fmtObjPtr, int flags);
+JIM_STATIC int JIM_API(Jim_CompareStringImmediate) (Jim_Interp *interp,
+ Jim_Obj *objPtr, const char *str);
+
+/* reference object */
+JIM_STATIC Jim_Obj * JIM_API(Jim_NewReference) (Jim_Interp *interp,
+ Jim_Obj *objPtr, Jim_Obj *tagPtr, Jim_Obj *cmdNamePtr);
+JIM_STATIC Jim_Reference * JIM_API(Jim_GetReference) (Jim_Interp *interp,
+ Jim_Obj *objPtr);
+JIM_STATIC int JIM_API(Jim_SetFinalizer) (Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *cmdNamePtr);
+JIM_STATIC int JIM_API(Jim_GetFinalizer) (Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj **cmdNamePtrPtr);
+
+/* interpreter */
+JIM_STATIC Jim_Interp * JIM_API(Jim_CreateInterp) (void);
+JIM_STATIC void JIM_API(Jim_FreeInterp) (Jim_Interp *i);
+JIM_STATIC int JIM_API(Jim_GetExitCode) (Jim_Interp *interp);
+JIM_STATIC FILE * JIM_API(Jim_SetStdin) (Jim_Interp *interp, FILE *fp);
+JIM_STATIC FILE * JIM_API(Jim_SetStdout) (Jim_Interp *interp, FILE *fp);
+JIM_STATIC FILE * JIM_API(Jim_SetStderr) (Jim_Interp *interp, FILE *fp);
+
+/* commands */
+JIM_STATIC void JIM_API(Jim_RegisterCoreCommands) (Jim_Interp *interp);
+JIM_STATIC int JIM_API(Jim_CreateCommand) (Jim_Interp *interp,
+ const char *cmdName, Jim_CmdProc cmdProc, void *privData,
+ Jim_DelCmdProc delProc);
+JIM_STATIC int JIM_API(Jim_CreateProcedure) (Jim_Interp *interp,
+ const char *cmdName, Jim_Obj *argListObjPtr, Jim_Obj *staticsListObjPtr,
+ Jim_Obj *bodyObjPtr, int arityMin, int arityMax);
+JIM_STATIC int JIM_API(Jim_DeleteCommand) (Jim_Interp *interp,
+ const char *cmdName);
+JIM_STATIC int JIM_API(Jim_RenameCommand) (Jim_Interp *interp,
+ const char *oldName, const char *newName);
+JIM_STATIC Jim_Cmd * JIM_API(Jim_GetCommand) (Jim_Interp *interp,
+ Jim_Obj *objPtr, int flags);
+JIM_STATIC int JIM_API(Jim_SetVariable) (Jim_Interp *interp,
+ Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr);
+JIM_STATIC int JIM_API(Jim_SetVariableStr) (Jim_Interp *interp,
+ const char *name, Jim_Obj *objPtr);
+JIM_STATIC int JIM_API(Jim_SetGlobalVariableStr) (Jim_Interp *interp,
+ const char *name, Jim_Obj *objPtr);
+JIM_STATIC int JIM_API(Jim_SetVariableStrWithStr) (Jim_Interp *interp,
+ const char *name, const char *val);
+JIM_STATIC int JIM_API(Jim_SetVariableLink) (Jim_Interp *interp,
+ Jim_Obj *nameObjPtr, Jim_Obj *targetNameObjPtr,
+ Jim_CallFrame *targetCallFrame);
+JIM_STATIC Jim_Obj * JIM_API(Jim_GetVariable) (Jim_Interp *interp,
+ Jim_Obj *nameObjPtr, int flags);
+JIM_STATIC Jim_Obj * JIM_API(Jim_GetGlobalVariable) (Jim_Interp *interp,
+ Jim_Obj *nameObjPtr, int flags);
+JIM_STATIC Jim_Obj * JIM_API(Jim_GetVariableStr) (Jim_Interp *interp,
+ const char *name, int flags);
+JIM_STATIC Jim_Obj * JIM_API(Jim_GetGlobalVariableStr) (Jim_Interp *interp,
+ const char *name, int flags);
+JIM_STATIC int JIM_API(Jim_UnsetVariable) (Jim_Interp *interp,
+ Jim_Obj *nameObjPtr, int flags);
+
+/* call frame */
+JIM_STATIC int JIM_API(Jim_GetCallFrameByLevel) (Jim_Interp *interp,
+ Jim_Obj *levelObjPtr, Jim_CallFrame **framePtrPtr,
+ int *newLevelPtr);
+
+/* garbage collection */
+JIM_STATIC int JIM_API(Jim_Collect) (Jim_Interp *interp);
+JIM_STATIC void JIM_API(Jim_CollectIfNeeded) (Jim_Interp *interp);
+
+/* index object */
+JIM_STATIC int JIM_API(Jim_GetIndex) (Jim_Interp *interp, Jim_Obj *objPtr,
+ int *indexPtr);
+
+/* list object */
+JIM_STATIC Jim_Obj * JIM_API(Jim_NewListObj) (Jim_Interp *interp,
+ Jim_Obj *const *elements, int len);
+JIM_STATIC void JIM_API(Jim_ListInsertElements) (Jim_Interp *interp,
+ Jim_Obj *listPtr, int index, int objc, Jim_Obj *const *objVec);
+JIM_STATIC void JIM_API(Jim_ListAppendElement) (Jim_Interp *interp,
+ Jim_Obj *listPtr, Jim_Obj *objPtr);
+JIM_STATIC void JIM_API(Jim_ListAppendList) (Jim_Interp *interp,
+ Jim_Obj *listPtr, Jim_Obj *appendListPtr);
+JIM_STATIC void JIM_API(Jim_ListLength) (Jim_Interp *interp, Jim_Obj *listPtr,
+ int *intPtr);
+JIM_STATIC int JIM_API(Jim_ListIndex) (Jim_Interp *interp, Jim_Obj *listPrt,
+ int index, Jim_Obj **objPtrPtr, int seterr);
+JIM_STATIC int JIM_API(Jim_SetListIndex) (Jim_Interp *interp,
+ Jim_Obj *varNamePtr, Jim_Obj *const *indexv, int indexc,
+ Jim_Obj *newObjPtr);
+JIM_STATIC Jim_Obj * JIM_API(Jim_ConcatObj) (Jim_Interp *interp, int objc,
+ Jim_Obj *const *objv);
+
+/* dict object */
+JIM_STATIC Jim_Obj * JIM_API(Jim_NewDictObj) (Jim_Interp *interp,
+ Jim_Obj *const *elements, int len);
+JIM_STATIC int JIM_API(Jim_DictKey) (Jim_Interp *interp, Jim_Obj *dictPtr,
+ Jim_Obj *keyPtr, Jim_Obj **objPtrPtr, int flags);
+JIM_STATIC int JIM_API(Jim_DictKeysVector) (Jim_Interp *interp,
+ Jim_Obj *dictPtr, Jim_Obj *const *keyv, int keyc,
+ Jim_Obj **objPtrPtr, int flags);
+JIM_STATIC int JIM_API(Jim_SetDictKeysVector) (Jim_Interp *interp,
+ Jim_Obj *varNamePtr, Jim_Obj *const *keyv, int keyc,
+ Jim_Obj *newObjPtr);
+
+/* return code object */
+JIM_STATIC int JIM_API(Jim_GetReturnCode) (Jim_Interp *interp, Jim_Obj *objPtr,
+ int *intPtr);
+
+/* expression object */
+JIM_STATIC int JIM_API(Jim_EvalExpression) (Jim_Interp *interp,
+ Jim_Obj *exprObjPtr, Jim_Obj **exprResultPtrPtr);
+JIM_STATIC int JIM_API(Jim_GetBoolFromExpr) (Jim_Interp *interp,
+ Jim_Obj *exprObjPtr, int *boolPtr);
+
+/* integer object */
+JIM_STATIC int JIM_API(Jim_GetWide) (Jim_Interp *interp, Jim_Obj *objPtr,
+ jim_wide *widePtr);
+JIM_STATIC int JIM_API(Jim_GetLong) (Jim_Interp *interp, Jim_Obj *objPtr,
+ long *longPtr);
+JIM_STATIC void JIM_API(Jim_SetWide) (Jim_Interp *interp, Jim_Obj *objPtr,
+ jim_wide wideValue);
+JIM_STATIC Jim_Obj * JIM_API(Jim_NewIntObj) (Jim_Interp *interp,
+ jim_wide wideValue);
+
+/* double object */
+JIM_STATIC int JIM_API(Jim_GetDouble)(Jim_Interp *interp, Jim_Obj *objPtr,
+ double *doublePtr);
+JIM_STATIC void JIM_API(Jim_SetDouble)(Jim_Interp *interp, Jim_Obj *objPtr,
+ double doubleValue);
+JIM_STATIC Jim_Obj * JIM_API(Jim_NewDoubleObj)(Jim_Interp *interp, double doubleValue);
+
+/* shared strings */
+JIM_STATIC const char * JIM_API(Jim_GetSharedString) (Jim_Interp *interp,
+ const char *str);
+JIM_STATIC void JIM_API(Jim_ReleaseSharedString) (Jim_Interp *interp,
+ const char *str);
+
+/* commands utilities */
+JIM_STATIC void JIM_API(Jim_WrongNumArgs) (Jim_Interp *interp, int argc,
+ Jim_Obj *const *argv, const char *msg);
+JIM_STATIC int JIM_API(Jim_GetEnum) (Jim_Interp *interp, Jim_Obj *objPtr,
+ const char **tablePtr, int *indexPtr, const char *name, int flags);
+JIM_STATIC int JIM_API(Jim_ScriptIsComplete) (const char *s, int len,
+ char *stateCharPtr);
+
+/* package utilities */
+typedef void (Jim_InterpDeleteProc)(Jim_Interp *interp, void *data);
+JIM_STATIC void * JIM_API(Jim_GetAssocData)(Jim_Interp *interp, const char *key);
+JIM_STATIC int JIM_API(Jim_SetAssocData)(Jim_Interp *interp, const char *key,
+ Jim_InterpDeleteProc *delProc, void *data);
+JIM_STATIC int JIM_API(Jim_DeleteAssocData)(Jim_Interp *interp, const char *key);
+
+/* API import/export functions */
+JIM_STATIC int JIM_API(Jim_GetApi) (Jim_Interp *interp, const char *funcname,
+ void *targetPtrPtr);
+JIM_STATIC int JIM_API(Jim_RegisterApi) (Jim_Interp *interp,
+ const char *funcname, void *funcptr);
+
+/* Packages C API */
+JIM_STATIC int JIM_API(Jim_PackageProvide) (Jim_Interp *interp,
+ const char *name, const char *ver, int flags);
+JIM_STATIC const char * JIM_API(Jim_PackageRequire) (Jim_Interp *interp,
+ const char *name, const char *ver, int flags);
+
+/* error messages */
+JIM_STATIC void JIM_API(Jim_PrintErrorMessage) (Jim_Interp *interp);
+
+/* interactive mode */
+JIM_STATIC int JIM_API(Jim_InteractivePrompt) (Jim_Interp *interp);
+
+/* Misc */
+JIM_STATIC void JIM_API(Jim_Panic) (Jim_Interp *interp, const char *fmt, ...);
+
+#undef JIM_STATIC
+#undef JIM_API
+
+#ifndef __JIM_CORE__
+
+#define JIM_GET_API(name) \
+ Jim_GetApi(interp, "Jim_" #name, ((void *)&Jim_ ## name))
+
+#if defined JIM_EXTENSION || defined JIM_EMBEDDED
+/* This must be included "inline" inside the extension */
+static void Jim_InitExtension(Jim_Interp *interp)
+{
+ Jim_GetApi = interp->getApiFuncPtr;
+
+ JIM_GET_API(Alloc);
+ JIM_GET_API(Free);
+ JIM_GET_API(Eval);
+ JIM_GET_API(EvalGlobal);
+ JIM_GET_API(EvalFile);
+ JIM_GET_API(EvalObj);
+ JIM_GET_API(EvalObjBackground);
+ JIM_GET_API(EvalObjVector);
+ JIM_GET_API(InitHashTable);
+ JIM_GET_API(ExpandHashTable);
+ JIM_GET_API(AddHashEntry);
+ JIM_GET_API(ReplaceHashEntry);
+ JIM_GET_API(DeleteHashEntry);
+ JIM_GET_API(FreeHashTable);
+ JIM_GET_API(FindHashEntry);
+ JIM_GET_API(ResizeHashTable);
+ JIM_GET_API(GetHashTableIterator);
+ JIM_GET_API(NextHashEntry);
+ JIM_GET_API(NewObj);
+ JIM_GET_API(FreeObj);
+ JIM_GET_API(InvalidateStringRep);
+ JIM_GET_API(InitStringRep);
+ JIM_GET_API(DuplicateObj);
+ JIM_GET_API(GetString);
+ JIM_GET_API(Length);
+ JIM_GET_API(InvalidateStringRep);
+ JIM_GET_API(NewStringObj);
+ JIM_GET_API(NewStringObjNoAlloc);
+ JIM_GET_API(AppendString);
+ JIM_GET_API(AppendObj);
+ JIM_GET_API(AppendStrings);
+ JIM_GET_API(StringEqObj);
+ JIM_GET_API(StringMatchObj);
+ JIM_GET_API(StringRangeObj);
+ JIM_GET_API(FormatString);
+ JIM_GET_API(ScanString);
+ JIM_GET_API(CompareStringImmediate);
+ JIM_GET_API(NewReference);
+ JIM_GET_API(GetReference);
+ JIM_GET_API(SetFinalizer);
+ JIM_GET_API(GetFinalizer);
+ JIM_GET_API(CreateInterp);
+ JIM_GET_API(FreeInterp);
+ JIM_GET_API(GetExitCode);
+ JIM_GET_API(SetStdin);
+ JIM_GET_API(SetStdout);
+ JIM_GET_API(SetStderr);
+ JIM_GET_API(CreateCommand);
+ JIM_GET_API(CreateProcedure);
+ JIM_GET_API(DeleteCommand);
+ JIM_GET_API(RenameCommand);
+ JIM_GET_API(GetCommand);
+ JIM_GET_API(SetVariable);
+ JIM_GET_API(SetVariableStr);
+ JIM_GET_API(SetGlobalVariableStr);
+ JIM_GET_API(SetVariableStrWithStr);
+ JIM_GET_API(SetVariableLink);
+ JIM_GET_API(GetVariable);
+ JIM_GET_API(GetCallFrameByLevel);
+ JIM_GET_API(Collect);
+ JIM_GET_API(CollectIfNeeded);
+ JIM_GET_API(GetIndex);
+ JIM_GET_API(NewListObj);
+ JIM_GET_API(ListInsertElements);
+ JIM_GET_API(ListAppendElement);
+ JIM_GET_API(ListAppendList);
+ JIM_GET_API(ListLength);
+ JIM_GET_API(ListIndex);
+ JIM_GET_API(SetListIndex);
+ JIM_GET_API(ConcatObj);
+ JIM_GET_API(NewDictObj);
+ JIM_GET_API(DictKey);
+ JIM_GET_API(DictKeysVector);
+ JIM_GET_API(GetIndex);
+ JIM_GET_API(GetReturnCode);
+ JIM_GET_API(EvalExpression);
+ JIM_GET_API(GetBoolFromExpr);
+ JIM_GET_API(GetWide);
+ JIM_GET_API(GetLong);
+ JIM_GET_API(SetWide);
+ JIM_GET_API(NewIntObj);
+ JIM_GET_API(GetDouble);
+ JIM_GET_API(SetDouble);
+ JIM_GET_API(NewDoubleObj);
+ JIM_GET_API(WrongNumArgs);
+ JIM_GET_API(SetDictKeysVector);
+ JIM_GET_API(SubstObj);
+ JIM_GET_API(RegisterApi);
+ JIM_GET_API(PrintErrorMessage);
+ JIM_GET_API(InteractivePrompt);
+ JIM_GET_API(RegisterCoreCommands);
+ JIM_GET_API(GetSharedString);
+ JIM_GET_API(ReleaseSharedString);
+ JIM_GET_API(Panic);
+ JIM_GET_API(StrDup);
+ JIM_GET_API(UnsetVariable);
+ JIM_GET_API(GetVariableStr);
+ JIM_GET_API(GetGlobalVariable);
+ JIM_GET_API(GetGlobalVariableStr);
+ JIM_GET_API(GetAssocData);
+ JIM_GET_API(SetAssocData);
+ JIM_GET_API(DeleteAssocData);
+ JIM_GET_API(GetEnum);
+ JIM_GET_API(ScriptIsComplete);
+ JIM_GET_API(PackageProvide);
+ JIM_GET_API(PackageRequire);
+ JIM_GET_API(InitStack);
+ JIM_GET_API(FreeStack);
+ JIM_GET_API(StackLen);
+ JIM_GET_API(StackPush);
+ JIM_GET_API(StackPop);
+ JIM_GET_API(StackPeek);
+ JIM_GET_API(FreeStackElements);
+}
+#endif /* defined JIM_EXTENSION || defined JIM_EMBEDDED */
+
+#undef JIM_GET_API
+
+#ifdef JIM_EMBEDDED
+Jim_Interp *ExportedJimCreateInterp(void);
+static void Jim_InitEmbedded(void) {
+ Jim_Interp *i = ExportedJimCreateInterp();
+ Jim_InitExtension(i);
+ Jim_FreeInterp(i);
+}
+#endif /* JIM_EMBEDDED */
+#endif /* __JIM_CORE__ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __JIM__H */
projects / fw / openocd / blobdiff