git.gag.com Git - fw/openocd/blob - src/jim.h

   1 /* Jim - A small embeddable Tcl interpreter\r
   2  * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>\r
   3  * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>\r
   4  *\r
   5  * Licensed under the Apache License, Version 2.0 (the "License");\r
   6  * you may not use this file except in compliance with the License.\r
   7  * You may obtain a copy of the License at\r
   8  *\r
   9  *     http://www.apache.org/licenses/LICENSE-2.0\r
  10  *\r
  11  * A copy of the license is also included in the source distribution\r
  12  * of Jim, as a TXT file name called LICENSE.\r
  13  *\r
  14  * Unless required by applicable law or agreed to in writing, software\r
  15  * distributed under the License is distributed on an "AS IS" BASIS,\r
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  17  * See the License for the specific language governing permissions and\r
  18  * limitations under the License.\r
  19  */\r
  20 \r
  21 #ifndef __JIM__H\r
  22 #define __JIM__H\r
  23 \r
  24 #ifdef __cplusplus\r
  25 extern "C" {\r
  26 #endif\r
  27 \r
  28 #include <time.h>\r
  29 #include <limits.h>\r
  30 #include <stdio.h>  /* for the FILE typedef definition */\r
  31 #include <stdlib.h> /* In order to export the Jim_Free() macro */\r
  32 \r
  33 /* -----------------------------------------------------------------------------\r
  34 * Some /very/ old compiler maybe do not know how to\r
  35 * handle 'const'. They even do not know, how to ignore\r
  36 * it. For those compiler it may be better to compile with\r
  37 * define JIM_NO_CONST activated\r
  38 * ---------------------------------------------------------------------------*/\r
  39 \r
  40 #ifdef JIM_NO_CONST\r
  41 #  define const\r
  42 #endif\r
  43 \r
  44 /* -----------------------------------------------------------------------------\r
  45  * System configuration\r
  46  * For most modern systems, you can leave the default.\r
  47  * For embedded systems some change may be required.\r
  48  * ---------------------------------------------------------------------------*/\r
  49 \r
  50 #define HAVE_LONG_LONG\r
  51 \r
  52 /* -----------------------------------------------------------------------------\r
  53  * Compiler specific fixes.\r
  54  * ---------------------------------------------------------------------------*/\r
  55 \r
  56 /* MSC has _stricmp instead of strcasecmp */\r
  57 #ifdef _MSC_VER\r
  58 #  define strcasecmp _stricmp\r
  59 #endif /* _MSC_VER */\r
  60 \r
  61 /* Long Long type and related issues */\r
  62 #ifdef HAVE_LONG_LONG\r
  63 #  ifdef _MSC_VER /* MSC compiler */\r
  64 #    define jim_wide _int64\r
  65 #    ifndef LLONG_MAX\r
  66 #      define LLONG_MAX    9223372036854775807I64\r
  67 #    endif\r
  68 #    ifndef LLONG_MIN\r
  69 #      define LLONG_MIN    (-LLONG_MAX - 1I64)\r
  70 #    endif\r
  71 #    define JIM_WIDE_MIN LLONG_MIN\r
  72 #    define JIM_WIDE_MAX LLONG_MAX\r
  73 #  else /* Other compilers (mainly GCC) */\r
  74 #    define jim_wide long long\r
  75 #    ifndef LLONG_MAX\r
  76 #      define LLONG_MAX    9223372036854775807LL\r
  77 #    endif\r
  78 #    ifndef LLONG_MIN\r
  79 #      define LLONG_MIN    (-LLONG_MAX - 1LL)\r
  80 #    endif\r
  81 #    define JIM_WIDE_MIN LLONG_MIN\r
  82 #    define JIM_WIDE_MAX LLONG_MAX\r
  83 #  endif\r
  84 #else\r
  85 #  define jim_wide long\r
  86 #  define JIM_WIDE_MIN LONG_MIN\r
  87 #  define JIM_WIDE_MAX LONG_MAX\r
  88 #endif\r
  89 \r
  90 /* -----------------------------------------------------------------------------\r
  91  * LIBC specific fixes\r
  92  * ---------------------------------------------------------------------------*/\r
  93 \r
  94 #ifdef HAVE_LONG_LONG\r
  95 # if defined(_MSC_VER) || defined(__MSVCRT__)\r
  96 #    define JIM_WIDE_MODIFIER "I64d"\r
  97 # else\r
  98 #    define JIM_WIDE_MODIFIER "lld"\r
  99 # endif\r
 100 #else\r
 101 #    define JIM_WIDE_MODIFIER "ld"\r
 102 #endif\r
 103 \r
 104 /* -----------------------------------------------------------------------------\r
 105  * Exported defines\r
 106  * ---------------------------------------------------------------------------*/\r
 107 \r
 108 /* Jim version numbering: every version of jim is marked with a\r
 109  * successive integer number. This is version 0. The first\r
 110  * stable version will be 1, then 2, 3, and so on. */\r
 111 #define JIM_VERSION 51\r
 112 \r
 113 #define JIM_OK 0\r
 114 #define JIM_ERR 1\r
 115 #define JIM_RETURN 2\r
 116 #define JIM_BREAK 3\r
 117 #define JIM_CONTINUE 4\r
 118 #define JIM_EVAL 5\r
 119 #define JIM_EXIT 6\r
 120 #define JIM_MAX_NESTING_DEPTH 10000 /* default max nesting depth */\r
 121 \r
 122 /* Some function get an integer argument with flags to change\r
 123  * the behaviour. */\r
 124 #define JIM_NONE 0    /* no flags set */\r
 125 #define JIM_ERRMSG 1    /* set an error message in the interpreter. */\r
 126 \r
 127 /* Flags for Jim_SubstObj() */\r
 128 #define JIM_SUBST_NOVAR 1 /* don't perform variables substitutions */\r
 129 #define JIM_SUBST_NOCMD 2 /* don't perform command substitutions */\r
 130 #define JIM_SUBST_NOESC 4 /* don't perform escapes substitutions */\r
 131 \r
 132 /* Unused arguments generate annoying warnings... */\r
 133 #define JIM_NOTUSED(V) ((void) V)\r
 134 \r
 135 /* Flags used by API calls getting a 'nocase' argument. */\r
 136 #define JIM_CASESENS    0   /* case sensitive */\r
 137 #define JIM_NOCASE      1   /* no case */\r
 138 \r
 139 /* Filesystem related */\r
 140 #define JIM_PATH_LEN 1024\r
 141 \r
 142 /* Newline, some embedded system may need -DJIM_CRLF */\r
 143 #ifdef JIM_CRLF\r
 144 #define JIM_NL "\r\n"\r
 145 #else\r
 146 #define JIM_NL "\n"\r
 147 #endif\r
 148 \r
 149 #if defined(__WIN32__) || defined(_WIN32)\r
 150 #define DLLEXPORT __declspec(dllexport)\r
 151 #define DLLIMPORT __declspec(dllimport)\r
 152 #else\r
 153 #define DLLEXPORT\r
 154 #define DLLIMPORT\r
 155 #endif\r
 156 \r
 157 /* -----------------------------------------------------------------------------\r
 158  * Stack\r
 159  * ---------------------------------------------------------------------------*/\r
 160 \r
 161 typedef struct Jim_Stack {\r
 162     int len;\r
 163     int maxlen;\r
 164     void **vector;\r
 165 } Jim_Stack;\r
 166 \r
 167 /* -----------------------------------------------------------------------------\r
 168  * Hash table\r
 169  * ---------------------------------------------------------------------------*/\r
 170 \r
 171 typedef struct Jim_HashEntry {\r
 172     const void *key;\r
 173     void *val;\r
 174     struct Jim_HashEntry *next;\r
 175 } Jim_HashEntry;\r
 176 \r
 177 typedef struct Jim_HashTableType {\r
 178     unsigned int (*hashFunction)(const void *key);\r
 179     const void *(*keyDup)(void *privdata, const void *key);\r
 180     void *(*valDup)(void *privdata, const void *obj);\r
 181     int (*keyCompare)(void *privdata, const void *key1, const void *key2);\r
 182     void (*keyDestructor)(void *privdata, const void *key);\r
 183     void (*valDestructor)(void *privdata, void *obj);\r
 184 } Jim_HashTableType;\r
 185 \r
 186 typedef struct Jim_HashTable {\r
 187     Jim_HashEntry **table;\r
 188     Jim_HashTableType *type;\r
 189     unsigned int size;\r
 190     unsigned int sizemask;\r
 191     unsigned int used;\r
 192     unsigned int collisions;\r
 193     void *privdata;\r
 194 } Jim_HashTable;\r
 195 \r
 196 typedef struct Jim_HashTableIterator {\r
 197     Jim_HashTable *ht;\r
 198     int index;\r
 199     Jim_HashEntry *entry, *nextEntry;\r
 200 } Jim_HashTableIterator;\r
 201 \r
 202 /* This is the initial size of every hash table */\r
 203 #define JIM_HT_INITIAL_SIZE     16\r
 204 \r
 205 /* ------------------------------- Macros ------------------------------------*/\r
 206 #define Jim_FreeEntryVal(ht, entry) \\r
 207     if ((ht)->type->valDestructor) \\r
 208         (ht)->type->valDestructor((ht)->privdata, (entry)->val)\r
 209 \r
 210 #define Jim_SetHashVal(ht, entry, _val_) do { \\r
 211     if ((ht)->type->valDup) \\r
 212         entry->val = (ht)->type->valDup((ht)->privdata, _val_); \\r
 213     else \\r
 214         entry->val = (_val_); \\r
 215 } while(0)\r
 216 \r
 217 #define Jim_FreeEntryKey(ht, entry) \\r
 218     if ((ht)->type->keyDestructor) \\r
 219         (ht)->type->keyDestructor((ht)->privdata, (entry)->key)\r
 220 \r
 221 #define Jim_SetHashKey(ht, entry, _key_) do { \\r
 222     if ((ht)->type->keyDup) \\r
 223         entry->key = (ht)->type->keyDup((ht)->privdata, _key_); \\r
 224     else \\r
 225         entry->key = (_key_); \\r
 226 } while(0)\r
 227 \r
 228 #define Jim_CompareHashKeys(ht, key1, key2) \\r
 229     (((ht)->type->keyCompare) ? \\r
 230         (ht)->type->keyCompare((ht)->privdata, key1, key2) : \\r
 231         (key1) == (key2))\r
 232 \r
 233 #define Jim_HashKey(ht, key) (ht)->type->hashFunction(key)\r
 234 \r
 235 #define Jim_GetHashEntryKey(he) ((he)->key)\r
 236 #define Jim_GetHashEntryVal(he) ((he)->val)\r
 237 #define Jim_GetHashTableCollisions(ht) ((ht)->collisions)\r
 238 #define Jim_GetHashTableSize(ht) ((ht)->size)\r
 239 #define Jim_GetHashTableUsed(ht) ((ht)->used)\r
 240 \r
 241 /* -----------------------------------------------------------------------------\r
 242  * Jim_Obj structure\r
 243  * ---------------------------------------------------------------------------*/\r
 244 \r
 245 /* -----------------------------------------------------------------------------\r
 246  * Jim object. This is mostly the same as Tcl_Obj itself,\r
 247  * with the addition of the 'prev' and 'next' pointers.\r
 248  * In Jim all the objects are stored into a linked list for GC purposes,\r
 249  * so that it's possible to access every object living in a given interpreter\r
 250  * sequentially. When an object is freed, it's moved into a different\r
 251  * linked list, used as object pool.\r
 252  *\r
 253  * The refcount of a freed object is always -1.\r
 254  * ---------------------------------------------------------------------------*/\r
 255 typedef struct Jim_Obj {\r
 256     int refCount; /* reference count */\r
 257     char *bytes; /* string representation buffer. NULL = no string repr. */\r
 258     int length; /* number of bytes in 'bytes', not including the numterm. */\r
 259     struct Jim_ObjType *typePtr; /* object type. */\r
 260     /* Internal representation union */\r
 261     union {\r
 262         /* integer number type */\r
 263         jim_wide wideValue;\r
 264         /* hashed object type value */\r
 265         int hashValue;\r
 266         /* index type */\r
 267         int indexValue;\r
 268         /* return code type */\r
 269         int returnCode;\r
 270         /* double number type */\r
 271         double doubleValue;\r
 272         /* Generic pointer */\r
 273         void *ptr;\r
 274         /* Generic two pointers value */\r
 275         struct {\r
 276             void *ptr1;\r
 277             void *ptr2;\r
 278         } twoPtrValue;\r
 279         /* Variable object */\r
 280         struct {\r
 281             unsigned jim_wide callFrameId;\r
 282             struct Jim_Var *varPtr;\r
 283         } varValue;\r
 284         /* Command object */\r
 285         struct {\r
 286             unsigned jim_wide procEpoch;\r
 287             struct Jim_Cmd *cmdPtr;\r
 288         } cmdValue;\r
 289         /* List object */\r
 290         struct {\r
 291             struct Jim_Obj **ele;    /* Elements vector */\r
 292             int len;        /* Length */\r
 293             int maxLen;        /* Allocated 'ele' length */\r
 294         } listValue;\r
 295         /* String type */\r
 296         struct {\r
 297             int maxLength;\r
 298         } strValue;\r
 299         /* Reference type */\r
 300         struct {\r
 301             jim_wide id;\r
 302             struct Jim_Reference *refPtr;\r
 303         } refValue;\r
 304         /* Source type */\r
 305         struct {\r
 306             const char *fileName;\r
 307             int lineNumber;\r
 308         } sourceValue;\r
 309         /* Dict substitution type */\r
 310         struct {\r
 311             struct Jim_Obj *varNameObjPtr;\r
 312             struct Jim_Obj *indexObjPtr;\r
 313         } dictSubstValue;\r
 314         /* tagged binary type */\r
 315         struct {\r
 316             unsigned char *data;\r
 317             size_t         len;\r
 318         } binaryValue;\r
 319     } internalRep;\r
 320     /* This are 8 or 16 bytes more for every object\r
 321      * but this is required for efficient garbage collection\r
 322      * of Jim references. */\r
 323     struct Jim_Obj *prevObjPtr; /* pointer to the prev object. */\r
 324     struct Jim_Obj *nextObjPtr; /* pointer to the next object. */\r
 325 } Jim_Obj;\r
 326 \r
 327 /* Jim_Obj related macros */\r
 328 #define Jim_IncrRefCount(objPtr) \\r
 329     ++(objPtr)->refCount\r
 330 #define Jim_DecrRefCount(interp, objPtr) \\r
 331     if (--(objPtr)->refCount <= 0) Jim_FreeObj(interp, objPtr)\r
 332 #define Jim_IsShared(objPtr) \\r
 333     ((objPtr)->refCount > 1)\r
 334 \r
 335 /* This macro is used when we allocate a new object using\r
 336  * Jim_New...Obj(), but for some error we need to destroy it.\r
 337  * Instead to use Jim_IncrRefCount() + Jim_DecrRefCount() we\r
 338  * can just call Jim_FreeNewObj. To call Jim_Free directly\r
 339  * seems too raw, the object handling may change and we want\r
 340  * that Jim_FreeNewObj() can be called only against objects\r
 341  * that are belived to have refcount == 0. */\r
 342 #define Jim_FreeNewObj Jim_FreeObj\r
 343 \r
 344 /* Free the internal representation of the object. */\r
 345 #define Jim_FreeIntRep(i,o) \\r
 346     if ((o)->typePtr && (o)->typePtr->freeIntRepProc) \\r
 347         (o)->typePtr->freeIntRepProc(i, o)\r
 348 \r
 349 /* Get the internal representation pointer */\r
 350 #define Jim_GetIntRepPtr(o) (o)->internalRep.ptr\r
 351 \r
 352 /* Set the internal representation pointer */\r
 353 #define Jim_SetIntRepPtr(o, p) \\r
 354     (o)->internalRep.ptr = (p)\r
 355 \r
 356 /* The object type structure.\r
 357  * There are four methods.\r
 358  *\r
 359  * - FreeIntRep is used to free the internal representation of the object.\r
 360  *   Can be NULL if there is nothing to free.\r
 361  * - DupIntRep is used to duplicate the internal representation of the object.\r
 362  *   If NULL, when an object is duplicated, the internalRep union is\r
 363  *   directly copied from an object to another.\r
 364  *   Note that it's up to the caller to free the old internal repr of the\r
 365  *   object before to call the Dup method.\r
 366  * - UpdateString is used to create the string from the internal repr.\r
 367  * - setFromAny is used to convert the current object into one of this type.\r
 368  */\r
 369 \r
 370 struct Jim_Interp;\r
 371 \r
 372 typedef void (Jim_FreeInternalRepProc)(struct Jim_Interp *interp,\r
 373         struct Jim_Obj *objPtr);\r
 374 typedef void (Jim_DupInternalRepProc)(struct Jim_Interp *interp,\r
 375         struct Jim_Obj *srcPtr, Jim_Obj *dupPtr);\r
 376 typedef void (Jim_UpdateStringProc)(struct Jim_Obj *objPtr);\r
 377     \r
 378 typedef struct Jim_ObjType {\r
 379     const char *name; /* The name of the type. */\r
 380     Jim_FreeInternalRepProc *freeIntRepProc;\r
 381     Jim_DupInternalRepProc *dupIntRepProc;\r
 382     Jim_UpdateStringProc *updateStringProc;\r
 383     int flags;\r
 384 } Jim_ObjType;\r
 385 \r
 386 /* Jim_ObjType flags */\r
 387 #define JIM_TYPE_NONE 0        /* No flags */\r
 388 #define JIM_TYPE_REFERENCES 1    /* The object may contain referneces. */\r
 389 \r
 390 /* Starting from 1 << 20 flags are reserved for private uses of\r
 391  * different calls. This way the same 'flags' argument may be used\r
 392  * to pass both global flags and private flags. */\r
 393 #define JIM_PRIV_FLAG_SHIFT 20\r
 394 \r
 395 /* -----------------------------------------------------------------------------\r
 396  * Call frame, vars, commands structures\r
 397  * ---------------------------------------------------------------------------*/\r
 398 \r
 399 /* Call frame */\r
 400 typedef struct Jim_CallFrame {\r
 401     unsigned jim_wide id; /* Call Frame ID. Used for caching. */\r
 402     struct Jim_HashTable vars; /* Where local vars are stored */\r
 403     struct Jim_HashTable *staticVars; /* pointer to procedure static vars */\r
 404     struct Jim_CallFrame *parentCallFrame;\r
 405     Jim_Obj *const *argv; /* object vector of the current procedure call. */\r
 406     int argc; /* number of args of the current procedure call. */\r
 407     Jim_Obj *procArgsObjPtr; /* arglist object of the running procedure */\r
 408     Jim_Obj *procBodyObjPtr; /* body object of the running procedure */\r
 409     struct Jim_CallFrame *nextFramePtr;\r
 410 } Jim_CallFrame;\r
 411 \r
 412 /* The var structure. It just holds the pointer of the referenced\r
 413  * object. If linkFramePtr is not NULL the variable is a link\r
 414  * to a variable of name store on objPtr living on the given callframe\r
 415  * (this happens when the [global] or [upvar] command is used).\r
 416  * The interp in order to always know how to free the Jim_Obj associated\r
 417  * with a given variable because In Jim objects memory managment is\r
 418  * bound to interpreters. */\r
 419 typedef struct Jim_Var {\r
 420     Jim_Obj *objPtr;\r
 421     struct Jim_CallFrame *linkFramePtr;\r
 422 } Jim_Var;\r
 423     \r
 424 /* The cmd structure. */\r
 425 typedef int (*Jim_CmdProc)(struct Jim_Interp *interp, int argc,\r
 426     Jim_Obj *const *argv);\r
 427 typedef void (*Jim_DelCmdProc)(struct Jim_Interp *interp, void *privData);\r
 428 \r
 429 /* A command is implemented in C if funcPtr is != NULL, otherwise\r
 430  * it's a Tcl procedure with the arglist and body represented by the\r
 431  * two objects referenced by arglistObjPtr and bodyoObjPtr. */\r
 432 typedef struct Jim_Cmd {\r
 433     Jim_CmdProc cmdProc; /* Not-NULL for a C command. */\r
 434     void *privData; /* Only used for C commands. */\r
 435     Jim_DelCmdProc delProc; /* Called when the command is deleted if != NULL */\r
 436     Jim_Obj *argListObjPtr;\r
 437     Jim_Obj *bodyObjPtr;\r
 438     Jim_HashTable *staticVars; /* Static vars hash table. NULL if no statics. */\r
 439     int arityMin; /* Min number of arguments. */\r
 440     int arityMax; /* Max number of arguments. */\r
 441 } Jim_Cmd;\r
 442 \r
 443 /* Pseudo Random Number Generator State structure */\r
 444 typedef struct Jim_PrngState {\r
 445     unsigned char sbox[256];\r
 446     unsigned int i, j;\r
 447 } Jim_PrngState;\r
 448 \r
 449 /* -----------------------------------------------------------------------------\r
 450  * Jim interpreter structure.\r
 451  * Fields similar to the real Tcl interpreter structure have the same names.\r
 452  * ---------------------------------------------------------------------------*/\r
 453 typedef struct Jim_Interp {\r
 454     Jim_Obj *result; /* object returned by the last command called. */\r
 455     int errorLine; /* Error line where an error occurred. */\r
 456     const char *errorFileName; /* Error file where an error occurred. */\r
 457     int numLevels; /* Number of current nested calls. */\r
 458     int maxNestingDepth; /* Used for infinite loop detection. */\r
 459     int returnCode; /* Completion code to return on JIM_RETURN. */\r
 460     int exitCode; /* Code to return to the OS on JIM_EXIT. */\r
 461     Jim_CallFrame *framePtr; /* Pointer to the current call frame */\r
 462     Jim_CallFrame *topFramePtr; /* toplevel/global frame pointer. */\r
 463     struct Jim_HashTable commands; /* Commands hash table */\r
 464     unsigned jim_wide procEpoch; /* Incremented every time the result\r
 465                 of procedures names lookup caching\r
 466                 may no longer be valid. */\r
 467     unsigned jim_wide callFrameEpoch; /* Incremented every time a new\r
 468                 callframe is created. This id is used for the\r
 469                 'ID' field contained in the Jim_CallFrame\r
 470                 structure. */\r
 471     Jim_Obj *liveList; /* Linked list of all the live objects. */\r
 472     Jim_Obj *freeList; /* Linked list of all the unused objects. */\r
 473     const char *scriptFileName; /* File name of the script currently in execution. */\r
 474     Jim_Obj *emptyObj; /* Shared empty string object. */\r
 475     unsigned jim_wide referenceNextId; /* Next id for reference. */\r
 476     struct Jim_HashTable references; /* References hash table. */\r
 477     jim_wide lastCollectId; /* reference max Id of the last GC\r
 478                 execution. It's set to -1 while the collection\r
 479                 is running as sentinel to avoid to recursive\r
 480                 calls via the [collect] command inside\r
 481                 finalizers. */\r
 482     time_t lastCollectTime; /* unix time of the last GC execution */\r
 483     struct Jim_HashTable sharedStrings; /* Shared Strings hash table */\r
 484     Jim_Obj *stackTrace; /* Stack trace object. */\r
 485     Jim_Obj *unknown; /* Unknown command cache */\r
 486     int errorFlag; /* Set if an error occurred during execution. */\r
 487     int evalRetcodeLevel; /* Level where the last return with code JIM_EVAL\r
 488                              happened. */\r
 489     void *cmdPrivData; /* Used to pass the private data pointer to\r
 490                   a command. It is set to what the user specified\r
 491                   via Jim_CreateCommand(). */\r
 492 \r
 493     struct Jim_HashTable stub; /* Stub hash table to export API */\r
 494     /* Jim_GetApi() function pointer, used to bootstrap the STUB table */\r
 495     int (*getApiFuncPtr)(struct Jim_Interp *, const char *, void *);\r
 496     struct Jim_CallFrame *freeFramesList; /* list of CallFrame structures. */\r
 497     struct Jim_HashTable assocData; /* per-interp storage for use by packages */\r
 498     Jim_PrngState *prngState; /* per interpreter Random Number Gen. state. */\r
 499     struct Jim_HashTable packages; /* Provided packages hash table */\r
 500     FILE *stdin_; /* input file pointer, 'stdin' by default */\r
 501     FILE *stdout_; /* output file pointer, 'stdout' by default */\r
 502     FILE *stderr_; /* errors file pointer, 'stderr' by default */\r
 503 } Jim_Interp;\r
 504 \r
 505 /* Currently provided as macro that performs the increment.\r
 506  * At some point may be a real function doing more work.\r
 507  * The proc epoch is used in order to know when a command lookup\r
 508  * cached can no longer considered valid. */\r
 509 #define Jim_InterpIncrProcEpoch(i) (i)->procEpoch++\r
 510 #define Jim_SetResultString(i,s,l) Jim_SetResult(i, Jim_NewStringObj(i,s,l))\r
 511 #define Jim_SetEmptyResult(i) Jim_SetResult(i, (i)->emptyObj)\r
 512 #define Jim_GetResult(i) ((i)->result)\r
 513 #define Jim_CmdPrivData(i) ((i)->cmdPrivData)\r
 514 \r
 515 /* Note that 'o' is expanded only one time inside this macro,\r
 516  * so it's safe to use side effects. */\r
 517 #define Jim_SetResult(i,o) do {     \\r
 518     Jim_Obj *_resultObjPtr_ = (o);    \\r
 519     Jim_IncrRefCount(_resultObjPtr_); \\r
 520     Jim_DecrRefCount(i,(i)->result);  \\r
 521     (i)->result = _resultObjPtr_;     \\r
 522 } while(0)\r
 523 \r
 524 /* Reference structure. The interpreter pointer is held within privdata member in HashTable */\r
 525 #define JIM_REFERENCE_TAGLEN 7 /* The tag is fixed-length, because the reference\r
 526                                   string representation must be fixed length. */\r
 527 typedef struct Jim_Reference {\r
 528     Jim_Obj *objPtr;\r
 529     Jim_Obj *finalizerCmdNamePtr;\r
 530     char tag[JIM_REFERENCE_TAGLEN+1];\r
 531 } Jim_Reference;\r
 532 \r
 533 /* -----------------------------------------------------------------------------\r
 534  * Exported API prototypes.\r
 535  * ---------------------------------------------------------------------------*/\r
 536 \r
 537 /* Macros that are common for extensions and core. */\r
 538 #define Jim_NewEmptyStringObj(i) Jim_NewStringObj(i, "", 0)\r
 539 \r
 540 /* The core includes real prototypes, extensions instead\r
 541  * include a global function pointer for every function exported.\r
 542  * Once the extension calls Jim_InitExtension(), the global\r
 543  * functon pointers are set to the value of the STUB table\r
 544  * contained in the Jim_Interp structure.\r
 545  *\r
 546  * This makes Jim able to load extensions even if it is statically\r
 547  * linked itself, and to load extensions compiled with different\r
 548  * versions of Jim (as long as the API is still compatible.) */\r
 549 \r
 550 /* Macros are common for core and extensions */\r
 551 #define Jim_FreeHashTableIterator(iter) Jim_Free(iter)\r
 552 \r
 553 #ifndef __JIM_CORE__\r
 554 # if defined JIM_EXTENSION || defined JIM_EMBEDDED\r
 555 #  define JIM_API(x) (*x)\r
 556 #  define JIM_STATIC\r
 557 # else\r
 558 #  define JIM_API(x) (*x)\r
 559 #  define JIM_STATIC extern\r
 560 # endif\r
 561 #else\r
 562 # define JIM_API(x) x\r
 563 # if defined(BUILD_Jim)\r
 564 #   define JIM_STATIC DLLEXPORT\r
 565 # else\r
 566 #   define JIM_STATIC static\r
 567 # endif\r
 568 #endif /* __JIM_CORE__ */\r
 569 \r
 570 /* Memory allocation */\r
 571 JIM_STATIC void * JIM_API(Jim_Alloc) (int size);\r
 572 JIM_STATIC void JIM_API(Jim_Free) (void *ptr);\r
 573 JIM_STATIC char * JIM_API(Jim_StrDup) (const char *s);\r
 574 \r
 575 /* evaluation */\r
 576 JIM_STATIC int JIM_API(Jim_Eval)(Jim_Interp *interp, const char *script);\r
 577 JIM_STATIC int JIM_API(Jim_EvalGlobal)(Jim_Interp *interp, const char *script);\r
 578 JIM_STATIC int JIM_API(Jim_EvalFile)(Jim_Interp *interp, const char *filename);\r
 579 JIM_STATIC int JIM_API(Jim_EvalObj) (Jim_Interp *interp, Jim_Obj *scriptObjPtr);\r
 580 JIM_STATIC int JIM_API(Jim_EvalObjBackground) (Jim_Interp *interp,\r
 581         Jim_Obj *scriptObjPtr);\r
 582 JIM_STATIC int JIM_API(Jim_EvalObjVector) (Jim_Interp *interp, int objc,\r
 583         Jim_Obj *const *objv);\r
 584 JIM_STATIC int JIM_API(Jim_SubstObj) (Jim_Interp *interp, Jim_Obj *substObjPtr,\r
 585         Jim_Obj **resObjPtrPtr, int flags);\r
 586 \r
 587 /* stack */\r
 588 JIM_STATIC void JIM_API(Jim_InitStack)(Jim_Stack *stack);\r
 589 JIM_STATIC void JIM_API(Jim_FreeStack)(Jim_Stack *stack);\r
 590 JIM_STATIC int JIM_API(Jim_StackLen)(Jim_Stack *stack);\r
 591 JIM_STATIC void JIM_API(Jim_StackPush)(Jim_Stack *stack, void *element);\r
 592 JIM_STATIC void * JIM_API(Jim_StackPop)(Jim_Stack *stack);\r
 593 JIM_STATIC void * JIM_API(Jim_StackPeek)(Jim_Stack *stack);\r
 594 JIM_STATIC void JIM_API(Jim_FreeStackElements)(Jim_Stack *stack, void (*freeFunc)(void *ptr));\r
 595 \r
 596 /* hash table */\r
 597 JIM_STATIC int JIM_API(Jim_InitHashTable) (Jim_HashTable *ht,\r
 598         Jim_HashTableType *type, void *privdata);\r
 599 JIM_STATIC int JIM_API(Jim_ExpandHashTable) (Jim_HashTable *ht,\r
 600         unsigned int size);\r
 601 JIM_STATIC int JIM_API(Jim_AddHashEntry) (Jim_HashTable *ht, const void *key,\r
 602         void *val);\r
 603 JIM_STATIC int JIM_API(Jim_ReplaceHashEntry) (Jim_HashTable *ht,\r
 604         const void *key, void *val);\r
 605 JIM_STATIC int JIM_API(Jim_DeleteHashEntry) (Jim_HashTable *ht,\r
 606         const void *key);\r
 607 JIM_STATIC int JIM_API(Jim_FreeHashTable) (Jim_HashTable *ht);\r
 608 JIM_STATIC Jim_HashEntry * JIM_API(Jim_FindHashEntry) (Jim_HashTable *ht,\r
 609         const void *key);\r
 610 JIM_STATIC int JIM_API(Jim_ResizeHashTable) (Jim_HashTable *ht);\r
 611 JIM_STATIC Jim_HashTableIterator *JIM_API(Jim_GetHashTableIterator)\r
 612         (Jim_HashTable *ht);\r
 613 JIM_STATIC Jim_HashEntry * JIM_API(Jim_NextHashEntry)\r
 614         (Jim_HashTableIterator *iter);\r
 615 \r
 616 /* objects */\r
 617 JIM_STATIC Jim_Obj * JIM_API(Jim_NewObj) (Jim_Interp *interp);\r
 618 JIM_STATIC void JIM_API(Jim_FreeObj) (Jim_Interp *interp, Jim_Obj *objPtr);\r
 619 JIM_STATIC void JIM_API(Jim_InvalidateStringRep) (Jim_Obj *objPtr);\r
 620 JIM_STATIC void JIM_API(Jim_InitStringRep) (Jim_Obj *objPtr, const char *bytes,\r
 621         int length);\r
 622 JIM_STATIC Jim_Obj * JIM_API(Jim_DuplicateObj) (Jim_Interp *interp,\r
 623         Jim_Obj *objPtr);\r
 624 JIM_STATIC const char * JIM_API(Jim_GetString)(Jim_Obj *objPtr,\r
 625         int *lenPtr);\r
 626 JIM_STATIC int JIM_API(Jim_Length)(Jim_Obj *objPtr);\r
 627 \r
 628 /* string object */\r
 629 JIM_STATIC Jim_Obj * JIM_API(Jim_NewStringObj) (Jim_Interp *interp,\r
 630         const char *s, int len);\r
 631 JIM_STATIC Jim_Obj * JIM_API(Jim_NewStringObjNoAlloc) (Jim_Interp *interp,\r
 632         char *s, int len);\r
 633 JIM_STATIC void JIM_API(Jim_AppendString) (Jim_Interp *interp, Jim_Obj *objPtr,\r
 634         const char *str, int len);\r
 635 JIM_STATIC void JIM_API(Jim_AppendObj) (Jim_Interp *interp, Jim_Obj *objPtr,\r
 636         Jim_Obj *appendObjPtr);\r
 637 JIM_STATIC void JIM_API(Jim_AppendStrings) (Jim_Interp *interp,\r
 638         Jim_Obj *objPtr, ...);\r
 639 JIM_STATIC int JIM_API(Jim_StringEqObj) (Jim_Obj *aObjPtr,\r
 640         Jim_Obj *bObjPtr, int nocase);\r
 641 JIM_STATIC int JIM_API(Jim_StringMatchObj) (Jim_Obj *patternObjPtr,\r
 642         Jim_Obj *objPtr, int nocase);\r
 643 JIM_STATIC Jim_Obj * JIM_API(Jim_StringRangeObj) (Jim_Interp *interp,\r
 644         Jim_Obj *strObjPtr, Jim_Obj *firstObjPtr,\r
 645         Jim_Obj *lastObjPtr);\r
 646 JIM_STATIC Jim_Obj * JIM_API(Jim_FormatString) (Jim_Interp *interp,\r
 647         Jim_Obj *fmtObjPtr, int objc, Jim_Obj *const *objv);\r
 648 JIM_STATIC Jim_Obj * JIM_API(Jim_ScanString) (Jim_Interp *interp, Jim_Obj *strObjPtr,\r
 649         Jim_Obj *fmtObjPtr, int flags);\r
 650 JIM_STATIC int JIM_API(Jim_CompareStringImmediate) (Jim_Interp *interp,\r
 651         Jim_Obj *objPtr, const char *str);\r
 652 \r
 653 /* reference object */\r
 654 JIM_STATIC Jim_Obj * JIM_API(Jim_NewReference) (Jim_Interp *interp,\r
 655         Jim_Obj *objPtr, Jim_Obj *tagPtr, Jim_Obj *cmdNamePtr);\r
 656 JIM_STATIC Jim_Reference * JIM_API(Jim_GetReference) (Jim_Interp *interp,\r
 657         Jim_Obj *objPtr);\r
 658 JIM_STATIC int JIM_API(Jim_SetFinalizer) (Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *cmdNamePtr);\r
 659 JIM_STATIC int JIM_API(Jim_GetFinalizer) (Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj **cmdNamePtrPtr);\r
 660 \r
 661 /* interpreter */\r
 662 JIM_STATIC Jim_Interp * JIM_API(Jim_CreateInterp) (void);\r
 663 JIM_STATIC void JIM_API(Jim_FreeInterp) (Jim_Interp *i);\r
 664 JIM_STATIC int JIM_API(Jim_GetExitCode) (Jim_Interp *interp);\r
 665 JIM_STATIC FILE * JIM_API(Jim_SetStdin) (Jim_Interp *interp, FILE *fp);\r
 666 JIM_STATIC FILE * JIM_API(Jim_SetStdout) (Jim_Interp *interp, FILE *fp);\r
 667 JIM_STATIC FILE * JIM_API(Jim_SetStderr) (Jim_Interp *interp, FILE *fp);\r
 668 \r
 669 /* commands */\r
 670 JIM_STATIC void JIM_API(Jim_RegisterCoreCommands) (Jim_Interp *interp);\r
 671 JIM_STATIC int JIM_API(Jim_CreateCommand) (Jim_Interp *interp, \r
 672         const char *cmdName, Jim_CmdProc cmdProc, void *privData,\r
 673          Jim_DelCmdProc delProc);\r
 674 JIM_STATIC int JIM_API(Jim_CreateProcedure) (Jim_Interp *interp, \r
 675         const char *cmdName, Jim_Obj *argListObjPtr, Jim_Obj *staticsListObjPtr,\r
 676         Jim_Obj *bodyObjPtr, int arityMin, int arityMax);\r
 677 JIM_STATIC int JIM_API(Jim_DeleteCommand) (Jim_Interp *interp,\r
 678         const char *cmdName);\r
 679 JIM_STATIC int JIM_API(Jim_RenameCommand) (Jim_Interp *interp, \r
 680         const char *oldName, const char *newName);\r
 681 JIM_STATIC Jim_Cmd * JIM_API(Jim_GetCommand) (Jim_Interp *interp,\r
 682         Jim_Obj *objPtr, int flags);\r
 683 JIM_STATIC int JIM_API(Jim_SetVariable) (Jim_Interp *interp,\r
 684         Jim_Obj *nameObjPtr, Jim_Obj *valObjPtr);\r
 685 JIM_STATIC int JIM_API(Jim_SetVariableStr) (Jim_Interp *interp,\r
 686         const char *name, Jim_Obj *objPtr);\r
 687 JIM_STATIC int JIM_API(Jim_SetGlobalVariableStr) (Jim_Interp *interp,\r
 688         const char *name, Jim_Obj *objPtr);\r
 689 JIM_STATIC int JIM_API(Jim_SetVariableStrWithStr) (Jim_Interp *interp,\r
 690         const char *name, const char *val);\r
 691 JIM_STATIC int JIM_API(Jim_SetVariableLink) (Jim_Interp *interp,\r
 692         Jim_Obj *nameObjPtr, Jim_Obj *targetNameObjPtr,\r
 693         Jim_CallFrame *targetCallFrame);\r
 694 JIM_STATIC Jim_Obj * JIM_API(Jim_GetVariable) (Jim_Interp *interp,\r
 695         Jim_Obj *nameObjPtr, int flags);\r
 696 JIM_STATIC Jim_Obj * JIM_API(Jim_GetGlobalVariable) (Jim_Interp *interp,\r
 697         Jim_Obj *nameObjPtr, int flags);\r
 698 JIM_STATIC Jim_Obj * JIM_API(Jim_GetVariableStr) (Jim_Interp *interp,\r
 699         const char *name, int flags);\r
 700 JIM_STATIC Jim_Obj * JIM_API(Jim_GetGlobalVariableStr) (Jim_Interp *interp,\r
 701         const char *name, int flags);\r
 702 JIM_STATIC int JIM_API(Jim_UnsetVariable) (Jim_Interp *interp,\r
 703         Jim_Obj *nameObjPtr, int flags);\r
 704 \r
 705 /* call frame */\r
 706 JIM_STATIC int JIM_API(Jim_GetCallFrameByLevel) (Jim_Interp *interp,\r
 707         Jim_Obj *levelObjPtr, Jim_CallFrame **framePtrPtr,\r
 708         int *newLevelPtr);\r
 709 \r
 710 /* garbage collection */\r
 711 JIM_STATIC int JIM_API(Jim_Collect) (Jim_Interp *interp);\r
 712 JIM_STATIC void JIM_API(Jim_CollectIfNeeded) (Jim_Interp *interp);\r
 713 \r
 714 /* index object */\r
 715 JIM_STATIC int JIM_API(Jim_GetIndex) (Jim_Interp *interp, Jim_Obj *objPtr,\r
 716         int *indexPtr);\r
 717 \r
 718 /* list object */\r
 719 JIM_STATIC Jim_Obj * JIM_API(Jim_NewListObj) (Jim_Interp *interp,\r
 720         Jim_Obj *const *elements, int len);\r
 721 JIM_STATIC void JIM_API(Jim_ListInsertElements) (Jim_Interp *interp,\r
 722         Jim_Obj *listPtr, int index, int objc, Jim_Obj *const *objVec);\r
 723 JIM_STATIC void JIM_API(Jim_ListAppendElement) (Jim_Interp *interp,\r
 724         Jim_Obj *listPtr, Jim_Obj *objPtr);\r
 725 JIM_STATIC void JIM_API(Jim_ListAppendList) (Jim_Interp *interp,\r
 726         Jim_Obj *listPtr, Jim_Obj *appendListPtr);\r
 727 JIM_STATIC void JIM_API(Jim_ListLength) (Jim_Interp *interp, Jim_Obj *listPtr,\r
 728         int *intPtr);\r
 729 JIM_STATIC int JIM_API(Jim_ListIndex) (Jim_Interp *interp, Jim_Obj *listPrt,\r
 730         int index, Jim_Obj **objPtrPtr, int seterr);\r
 731 JIM_STATIC int JIM_API(Jim_SetListIndex) (Jim_Interp *interp,\r
 732         Jim_Obj *varNamePtr, Jim_Obj *const *indexv, int indexc,\r
 733         Jim_Obj *newObjPtr);\r
 734 JIM_STATIC Jim_Obj * JIM_API(Jim_ConcatObj) (Jim_Interp *interp, int objc,\r
 735         Jim_Obj *const *objv);\r
 736 \r
 737 /* dict object */\r
 738 JIM_STATIC Jim_Obj * JIM_API(Jim_NewDictObj) (Jim_Interp *interp,\r
 739         Jim_Obj *const *elements, int len);\r
 740 JIM_STATIC int JIM_API(Jim_DictKey) (Jim_Interp *interp, Jim_Obj *dictPtr,\r
 741         Jim_Obj *keyPtr, Jim_Obj **objPtrPtr, int flags);\r
 742 JIM_STATIC int JIM_API(Jim_DictKeysVector) (Jim_Interp *interp,\r
 743         Jim_Obj *dictPtr, Jim_Obj *const *keyv, int keyc,\r
 744         Jim_Obj **objPtrPtr, int flags);\r
 745 JIM_STATIC int JIM_API(Jim_SetDictKeysVector) (Jim_Interp *interp,\r
 746         Jim_Obj *varNamePtr, Jim_Obj *const *keyv, int keyc,\r
 747         Jim_Obj *newObjPtr);\r
 748 \r
 749 /* return code object */\r
 750 JIM_STATIC int JIM_API(Jim_GetReturnCode) (Jim_Interp *interp, Jim_Obj *objPtr,\r
 751         int *intPtr);\r
 752 \r
 753 /* expression object */\r
 754 JIM_STATIC int JIM_API(Jim_EvalExpression) (Jim_Interp *interp,\r
 755         Jim_Obj *exprObjPtr, Jim_Obj **exprResultPtrPtr);\r
 756 JIM_STATIC int JIM_API(Jim_GetBoolFromExpr) (Jim_Interp *interp,\r
 757         Jim_Obj *exprObjPtr, int *boolPtr);\r
 758 \r
 759 /* integer object */\r
 760 JIM_STATIC int JIM_API(Jim_GetWide) (Jim_Interp *interp, Jim_Obj *objPtr,\r
 761         jim_wide *widePtr);\r
 762 JIM_STATIC int JIM_API(Jim_GetLong) (Jim_Interp *interp, Jim_Obj *objPtr,\r
 763         long *longPtr);\r
 764 JIM_STATIC void JIM_API(Jim_SetWide) (Jim_Interp *interp, Jim_Obj *objPtr,\r
 765         jim_wide wideValue);\r
 766 JIM_STATIC Jim_Obj * JIM_API(Jim_NewIntObj) (Jim_Interp *interp,\r
 767         jim_wide wideValue);\r
 768 \r
 769 /* double object */\r
 770 JIM_STATIC int JIM_API(Jim_GetDouble)(Jim_Interp *interp, Jim_Obj *objPtr,\r
 771         double *doublePtr);\r
 772 JIM_STATIC void JIM_API(Jim_SetDouble)(Jim_Interp *interp, Jim_Obj *objPtr,\r
 773         double doubleValue);\r
 774 JIM_STATIC Jim_Obj * JIM_API(Jim_NewDoubleObj)(Jim_Interp *interp, double doubleValue);\r
 775 \r
 776 /* shared strings */\r
 777 JIM_STATIC const char * JIM_API(Jim_GetSharedString) (Jim_Interp *interp, \r
 778         const char *str);\r
 779 JIM_STATIC void JIM_API(Jim_ReleaseSharedString) (Jim_Interp *interp,\r
 780         const char *str);\r
 781 \r
 782 /* commands utilities */\r
 783 JIM_STATIC void JIM_API(Jim_WrongNumArgs) (Jim_Interp *interp, int argc,\r
 784         Jim_Obj *const *argv, const char *msg);\r
 785 JIM_STATIC int JIM_API(Jim_GetEnum) (Jim_Interp *interp, Jim_Obj *objPtr,\r
 786         const char **tablePtr, int *indexPtr, const char *name, int flags);\r
 787 JIM_STATIC int JIM_API(Jim_ScriptIsComplete) (const char *s, int len,\r
 788         char *stateCharPtr);\r
 789 \r
 790 /* package utilities */\r
 791 typedef void (Jim_InterpDeleteProc)(Jim_Interp *interp, void *data);\r
 792 JIM_STATIC void * JIM_API(Jim_GetAssocData)(Jim_Interp *interp, const char *key);\r
 793 JIM_STATIC int JIM_API(Jim_SetAssocData)(Jim_Interp *interp, const char *key,\r
 794         Jim_InterpDeleteProc *delProc, void *data);\r
 795 JIM_STATIC int JIM_API(Jim_DeleteAssocData)(Jim_Interp *interp, const char *key);\r
 796 \r
 797 /* API import/export functions */\r
 798 JIM_STATIC int JIM_API(Jim_GetApi) (Jim_Interp *interp, const char *funcname,\r
 799         void *targetPtrPtr);\r
 800 JIM_STATIC int JIM_API(Jim_RegisterApi) (Jim_Interp *interp, \r
 801         const char *funcname, void *funcptr);\r
 802 \r
 803 /* Packages C API */\r
 804 JIM_STATIC int JIM_API(Jim_PackageProvide) (Jim_Interp *interp,\r
 805         const char *name, const char *ver, int flags);\r
 806 JIM_STATIC const char * JIM_API(Jim_PackageRequire) (Jim_Interp *interp,\r
 807         const char *name, const char *ver, int flags);\r
 808 \r
 809 /* error messages */\r
 810 JIM_STATIC void JIM_API(Jim_PrintErrorMessage) (Jim_Interp *interp);\r
 811 \r
 812 /* interactive mode */\r
 813 JIM_STATIC int JIM_API(Jim_InteractivePrompt) (Jim_Interp *interp);\r
 814 \r
 815 /* Misc */\r
 816 JIM_STATIC void JIM_API(Jim_Panic) (Jim_Interp *interp, const char *fmt, ...);\r
 817 \r
 818 #undef JIM_STATIC\r
 819 #undef JIM_API\r
 820 \r
 821 #ifndef __JIM_CORE__\r
 822 \r
 823 #define JIM_GET_API(name) \\r
 824     Jim_GetApi(interp, "Jim_" #name, ((void *)&Jim_ ## name))\r
 825 \r
 826 #if defined JIM_EXTENSION || defined JIM_EMBEDDED\r
 827 /* This must be included "inline" inside the extension */\r
 828 static void Jim_InitExtension(Jim_Interp *interp)\r
 829 {\r
 830   Jim_GetApi = interp->getApiFuncPtr;\r
 831 \r
 832   JIM_GET_API(Alloc);\r
 833   JIM_GET_API(Free);\r
 834   JIM_GET_API(Eval);\r
 835   JIM_GET_API(EvalGlobal);\r
 836   JIM_GET_API(EvalFile);\r
 837   JIM_GET_API(EvalObj);\r
 838   JIM_GET_API(EvalObjBackground);\r
 839   JIM_GET_API(EvalObjVector);\r
 840   JIM_GET_API(InitHashTable);\r
 841   JIM_GET_API(ExpandHashTable);\r
 842   JIM_GET_API(AddHashEntry);\r
 843   JIM_GET_API(ReplaceHashEntry);\r
 844   JIM_GET_API(DeleteHashEntry);\r
 845   JIM_GET_API(FreeHashTable);\r
 846   JIM_GET_API(FindHashEntry);\r
 847   JIM_GET_API(ResizeHashTable);\r
 848   JIM_GET_API(GetHashTableIterator);\r
 849   JIM_GET_API(NextHashEntry);\r
 850   JIM_GET_API(NewObj);\r
 851   JIM_GET_API(FreeObj);\r
 852   JIM_GET_API(InvalidateStringRep);\r
 853   JIM_GET_API(InitStringRep);\r
 854   JIM_GET_API(DuplicateObj);\r
 855   JIM_GET_API(GetString);\r
 856   JIM_GET_API(Length);\r
 857   JIM_GET_API(InvalidateStringRep);\r
 858   JIM_GET_API(NewStringObj);\r
 859   JIM_GET_API(NewStringObjNoAlloc);\r
 860   JIM_GET_API(AppendString);\r
 861   JIM_GET_API(AppendObj);\r
 862   JIM_GET_API(AppendStrings);\r
 863   JIM_GET_API(StringEqObj);\r
 864   JIM_GET_API(StringMatchObj);\r
 865   JIM_GET_API(StringRangeObj);\r
 866   JIM_GET_API(FormatString);\r
 867   JIM_GET_API(ScanString);\r
 868   JIM_GET_API(CompareStringImmediate);\r
 869   JIM_GET_API(NewReference);\r
 870   JIM_GET_API(GetReference);\r
 871   JIM_GET_API(SetFinalizer);\r
 872   JIM_GET_API(GetFinalizer);\r
 873   JIM_GET_API(CreateInterp);\r
 874   JIM_GET_API(FreeInterp);\r
 875   JIM_GET_API(GetExitCode);\r
 876   JIM_GET_API(SetStdin);\r
 877   JIM_GET_API(SetStdout);\r
 878   JIM_GET_API(SetStderr);\r
 879   JIM_GET_API(CreateCommand);\r
 880   JIM_GET_API(CreateProcedure);\r
 881   JIM_GET_API(DeleteCommand);\r
 882   JIM_GET_API(RenameCommand);\r
 883   JIM_GET_API(GetCommand);\r
 884   JIM_GET_API(SetVariable);\r
 885   JIM_GET_API(SetVariableStr);\r
 886   JIM_GET_API(SetGlobalVariableStr);\r
 887   JIM_GET_API(SetVariableStrWithStr);\r
 888   JIM_GET_API(SetVariableLink);\r
 889   JIM_GET_API(GetVariable);\r
 890   JIM_GET_API(GetCallFrameByLevel);\r
 891   JIM_GET_API(Collect);\r
 892   JIM_GET_API(CollectIfNeeded);\r
 893   JIM_GET_API(GetIndex);\r
 894   JIM_GET_API(NewListObj);\r
 895   JIM_GET_API(ListInsertElements);\r
 896   JIM_GET_API(ListAppendElement);\r
 897   JIM_GET_API(ListAppendList);\r
 898   JIM_GET_API(ListLength);\r
 899   JIM_GET_API(ListIndex);\r
 900   JIM_GET_API(SetListIndex);\r
 901   JIM_GET_API(ConcatObj);\r
 902   JIM_GET_API(NewDictObj);\r
 903   JIM_GET_API(DictKey);\r
 904   JIM_GET_API(DictKeysVector);\r
 905   JIM_GET_API(GetIndex);\r
 906   JIM_GET_API(GetReturnCode);\r
 907   JIM_GET_API(EvalExpression);\r
 908   JIM_GET_API(GetBoolFromExpr);\r
 909   JIM_GET_API(GetWide);\r
 910   JIM_GET_API(GetLong);\r
 911   JIM_GET_API(SetWide);\r
 912   JIM_GET_API(NewIntObj);\r
 913   JIM_GET_API(GetDouble);\r
 914   JIM_GET_API(SetDouble);\r
 915   JIM_GET_API(NewDoubleObj);\r
 916   JIM_GET_API(WrongNumArgs);\r
 917   JIM_GET_API(SetDictKeysVector);\r
 918   JIM_GET_API(SubstObj);\r
 919   JIM_GET_API(RegisterApi);\r
 920   JIM_GET_API(PrintErrorMessage);\r
 921   JIM_GET_API(InteractivePrompt);\r
 922   JIM_GET_API(RegisterCoreCommands);\r
 923   JIM_GET_API(GetSharedString);\r
 924   JIM_GET_API(ReleaseSharedString);\r
 925   JIM_GET_API(Panic);\r
 926   JIM_GET_API(StrDup);\r
 927   JIM_GET_API(UnsetVariable);\r
 928   JIM_GET_API(GetVariableStr);\r
 929   JIM_GET_API(GetGlobalVariable);\r
 930   JIM_GET_API(GetGlobalVariableStr);\r
 931   JIM_GET_API(GetAssocData);\r
 932   JIM_GET_API(SetAssocData);\r
 933   JIM_GET_API(DeleteAssocData);\r
 934   JIM_GET_API(GetEnum);\r
 935   JIM_GET_API(ScriptIsComplete);\r
 936   JIM_GET_API(PackageProvide);\r
 937   JIM_GET_API(PackageRequire);\r
 938   JIM_GET_API(InitStack);\r
 939   JIM_GET_API(FreeStack);\r
 940   JIM_GET_API(StackLen);\r
 941   JIM_GET_API(StackPush);\r
 942   JIM_GET_API(StackPop);\r
 943   JIM_GET_API(StackPeek);\r
 944   JIM_GET_API(FreeStackElements);\r
 945 }\r
 946 #endif /* defined JIM_EXTENSION || defined JIM_EMBEDDED */\r
 947 \r
 948 #undef JIM_GET_API\r
 949 \r
 950 #ifdef JIM_EMBEDDED\r
 951 Jim_Interp *ExportedJimCreateInterp(void);\r
 952 static void Jim_InitEmbedded(void) {\r
 953     Jim_Interp *i = ExportedJimCreateInterp();\r
 954     Jim_InitExtension(i);\r
 955     Jim_FreeInterp(i);\r
 956 }\r
 957 #endif /* JIM_EMBEDDED */\r
 958 #endif /* __JIM_CORE__ */\r
 959 \r
 960 #ifdef __cplusplus\r
 961 }\r
 962 #endif\r
 963 \r
 964 #endif /* __JIM__H */\r