Code Review / openocd.git / blob
? search:


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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)