4 * Declarations of things used internally by the Tcl interpreter.
6 * Copyright (c) 1987-1993 The Regents of the University of California.
7 * Copyright (c) 1993-1997 Lucent Technologies.
8 * Copyright (c) 1994-1998 Sun Microsystems, Inc.
9 * Copyright (c) 1998-1999 by Scriptics Corporation.
10 * Copyright (c) 2001, 2002 by Kevin B. Kenny. All rights reserved.
11 * Copyright (c) 2007 Daniel A. Steffen <das@users.sourceforge.net>
12 * Copyright (c) 2006-2008 by Joe Mistachkin. All rights reserved.
13 * Copyright (c) 2008 by Miguel Sofer. All rights reserved.
15 * See the file "license.terms" for information on usage and redistribution of
16 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
23 * Some numerics configuration options.
29 * Common include files needed by most of the Tcl source files are included
30 * here, so that system-dependent personalizations for the include files only
31 * have to be made in once place. This results in a few extra includes, but
32 * greater modularity. The order of the three groups of #includes is
33 * important. For example, stdio.h is needed by tcl.h.
42 # include "../compat/stdlib.h"
47 #include "../compat/string.h"
51 #if defined(STDC_HEADERS) || defined(__STDC__) || defined(__C99__FUNC__) \
52 || defined(__cplusplus) || defined(_MSC_VER) || defined(__ICC)
55 typedef int ptrdiff_t;
59 * Ensure WORDS_BIGENDIAN is defined correctly:
60 * Needs to happen here in addition to configure to work with fat compiles on
61 * Darwin (where configure runs only once for multiple architectures).
64 #ifdef HAVE_SYS_TYPES_H
65 # include <sys/types.h>
67 #ifdef HAVE_SYS_PARAM_H
68 # include <sys/param.h>
72 # if BYTE_ORDER == BIG_ENDIAN
73 # undef WORDS_BIGENDIAN
74 # define WORDS_BIGENDIAN 1
78 # if BYTE_ORDER == LITTLE_ENDIAN
79 # undef WORDS_BIGENDIAN
85 * Used to tag functions that are only to be visible within the module being
86 * built and not outside it (where this is supported by the linker).
91 # define MODULE_SCOPE extern "C"
93 # define MODULE_SCOPE extern
98 * Macros used to cast between pointers and integers (e.g. when storing an int
99 * in ClientData), on 64-bit architectures they avoid gcc warning about "cast
100 * to/from pointer from/to integer of different size".
103 #if !defined(INT2PTR) && !defined(PTR2INT)
104 # if defined(HAVE_INTPTR_T) || defined(intptr_t)
105 # define INT2PTR(p) ((void *)(intptr_t)(p))
106 # define PTR2INT(p) ((int)(intptr_t)(p))
108 # define INT2PTR(p) ((void *)(p))
109 # define PTR2INT(p) ((int)(p))
112 #if !defined(UINT2PTR) && !defined(PTR2UINT)
113 # if defined(HAVE_UINTPTR_T) || defined(uintptr_t)
114 # define UINT2PTR(p) ((void *)(uintptr_t)(p))
115 # define PTR2UINT(p) ((unsigned int)(uintptr_t)(p))
117 # define UINT2PTR(p) ((void *)(p))
118 # define PTR2UINT(p) ((unsigned int)(p))
122 #if defined(_WIN32) && defined(_MSC_VER)
123 # define vsnprintf _vsnprintf
127 * The following procedures allow namespaces to be customized to support
128 * special name resolution rules for commands/variables.
131 struct Tcl_ResolvedVarInfo;
133 typedef Tcl_Var (Tcl_ResolveRuntimeVarProc)(Tcl_Interp *interp,
134 struct Tcl_ResolvedVarInfo *vinfoPtr);
136 typedef void (Tcl_ResolveVarDeleteProc)(struct Tcl_ResolvedVarInfo *vinfoPtr);
139 * The following structure encapsulates the routines needed to resolve a
140 * variable reference at runtime. Any variable specific state will typically
141 * be appended to this structure.
144 typedef struct Tcl_ResolvedVarInfo {
145 Tcl_ResolveRuntimeVarProc *fetchProc;
146 Tcl_ResolveVarDeleteProc *deleteProc;
147 } Tcl_ResolvedVarInfo;
149 typedef int (Tcl_ResolveCompiledVarProc)(Tcl_Interp *interp,
150 CONST84 char *name, int length, Tcl_Namespace *context,
151 Tcl_ResolvedVarInfo **rPtr);
153 typedef int (Tcl_ResolveVarProc)(Tcl_Interp *interp, CONST84 char *name,
154 Tcl_Namespace *context, int flags, Tcl_Var *rPtr);
156 typedef int (Tcl_ResolveCmdProc)(Tcl_Interp *interp, CONST84 char *name,
157 Tcl_Namespace *context, int flags, Tcl_Command *rPtr);
159 typedef struct Tcl_ResolverInfo {
160 Tcl_ResolveCmdProc *cmdResProc;
161 /* Procedure handling command name
163 Tcl_ResolveVarProc *varResProc;
164 /* Procedure handling variable name resolution
165 * for variables that can only be handled at
167 Tcl_ResolveCompiledVarProc *compiledVarResProc;
168 /* Procedure handling variable name resolution
169 * at compile time. */
173 * This flag bit should not interfere with TCL_GLOBAL_ONLY,
174 * TCL_NAMESPACE_ONLY, or TCL_LEAVE_ERR_MSG; it signals that the variable
175 * lookup is performed for upvar (or similar) purposes, with slightly
177 * - Bug #696893 - variable is either proc-local or in the current
178 * namespace; never follow the second (global) resolution path
179 * - Bug #631741 - do not use special namespace or interp resolvers
181 * It should also not collide with the (deprecated) TCL_PARSE_PART1 flag
185 #define TCL_AVOID_RESOLVERS 0x40000
188 *----------------------------------------------------------------
189 * Data structures related to namespaces.
190 *----------------------------------------------------------------
193 typedef struct Tcl_Ensemble Tcl_Ensemble;
194 typedef struct NamespacePathEntry NamespacePathEntry;
197 * Special hashtable for variables: this is just a Tcl_HashTable with an nsPtr
198 * field added at the end: in this way variables can find their namespace
199 * without having to copy a pointer in their struct: they can access it via
200 * their hPtr->tablePtr.
203 typedef struct TclVarHashTable {
205 struct Namespace *nsPtr;
209 * This is for itcl - it likes to search our varTables directly :(
212 #define TclVarHashFindVar(tablePtr, key) \
213 TclVarHashCreateVar((tablePtr), (key), NULL)
216 * Define this to reduce the amount of space that the average namespace
217 * consumes by only allocating the table of child namespaces when necessary.
218 * Defining it breaks compatibility for Tcl extensions (e.g., itcl) which
219 * reach directly into the Namespace structure.
222 #undef BREAK_NAMESPACE_COMPAT
225 * The structure below defines a namespace.
226 * Note: the first five fields must match exactly the fields in a
227 * Tcl_Namespace structure (see tcl.h). If you change one, be sure to change
231 typedef struct Namespace {
232 char *name; /* The namespace's simple (unqualified) name.
233 * This contains no ::'s. The name of the
234 * global namespace is "" although "::" is an
236 char *fullName; /* The namespace's fully qualified name. This
238 ClientData clientData; /* An arbitrary value associated with this
240 Tcl_NamespaceDeleteProc *deleteProc;
241 /* Procedure invoked when deleting the
242 * namespace to, e.g., free clientData. */
243 struct Namespace *parentPtr;/* Points to the namespace that contains this
244 * one. NULL if this is the global
246 #ifndef BREAK_NAMESPACE_COMPAT
247 Tcl_HashTable childTable; /* Contains any child namespaces. Indexed by
248 * strings; values have type (Namespace *). */
250 Tcl_HashTable *childTablePtr;
251 /* Contains any child namespaces. Indexed by
252 * strings; values have type (Namespace *). If
253 * NULL, there are no children. */
255 long nsId; /* Unique id for the namespace. */
256 Tcl_Interp *interp; /* The interpreter containing this
258 int flags; /* OR-ed combination of the namespace status
259 * flags NS_DYING and NS_DEAD listed below. */
260 int activationCount; /* Number of "activations" or active call
261 * frames for this namespace that are on the
262 * Tcl call stack. The namespace won't be
263 * freed until activationCount becomes zero. */
264 int refCount; /* Count of references by namespaceName
265 * objects. The namespace can't be freed until
266 * refCount becomes zero. */
267 Tcl_HashTable cmdTable; /* Contains all the commands currently
268 * registered in the namespace. Indexed by
269 * strings; values have type (Command *).
270 * Commands imported by Tcl_Import have
271 * Command structures that point (via an
272 * ImportedCmdRef structure) to the Command
273 * structure in the source namespace's command
275 TclVarHashTable varTable; /* Contains all the (global) variables
276 * currently in this namespace. Indexed by
277 * strings; values have type (Var *). */
278 char **exportArrayPtr; /* Points to an array of string patterns
279 * specifying which commands are exported. A
280 * pattern may include "string match" style
281 * wildcard characters to specify multiple
282 * commands; however, no namespace qualifiers
283 * are allowed. NULL if no export patterns are
285 int numExportPatterns; /* Number of export patterns currently
286 * registered using "namespace export". */
287 int maxExportPatterns; /* Mumber of export patterns for which space
288 * is currently allocated. */
289 int cmdRefEpoch; /* Incremented if a newly added command
290 * shadows a command for which this namespace
291 * has already cached a Command* pointer; this
292 * causes all its cached Command* pointers to
294 int resolverEpoch; /* Incremented whenever (a) the name
295 * resolution rules change for this namespace
296 * or (b) a newly added command shadows a
297 * command that is compiled to bytecodes. This
298 * invalidates all byte codes compiled in the
299 * namespace, causing the code to be
300 * recompiled under the new rules.*/
301 Tcl_ResolveCmdProc *cmdResProc;
302 /* If non-null, this procedure overrides the
303 * usual command resolution mechanism in Tcl.
304 * This procedure is invoked within
305 * Tcl_FindCommand to resolve all command
306 * references within the namespace. */
307 Tcl_ResolveVarProc *varResProc;
308 /* If non-null, this procedure overrides the
309 * usual variable resolution mechanism in Tcl.
310 * This procedure is invoked within
311 * Tcl_FindNamespaceVar to resolve all
312 * variable references within the namespace at
314 Tcl_ResolveCompiledVarProc *compiledVarResProc;
315 /* If non-null, this procedure overrides the
316 * usual variable resolution mechanism in Tcl.
317 * This procedure is invoked within
318 * LookupCompiledLocal to resolve variable
319 * references within the namespace at compile
321 int exportLookupEpoch; /* Incremented whenever a command is added to
322 * a namespace, removed from a namespace or
323 * the exports of a namespace are changed.
324 * Allows TIP#112-driven command lists to be
325 * validated efficiently. */
326 Tcl_Ensemble *ensembles; /* List of structures that contain the details
327 * of the ensembles that are implemented on
328 * top of this namespace. */
329 Tcl_Obj *unknownHandlerPtr; /* A script fragment to be used when command
330 * resolution in this namespace fails. TIP
332 int commandPathLength; /* The length of the explicit path. */
333 NamespacePathEntry *commandPathArray;
334 /* The explicit path of the namespace as an
336 NamespacePathEntry *commandPathSourceList;
337 /* Linked list of path entries that point to
339 Tcl_NamespaceDeleteProc *earlyDeleteProc;
340 /* Just like the deleteProc field (and called
341 * with the same clientData) but called at the
342 * start of the deletion process, so there is
343 * a chance for code to do stuff inside the
344 * namespace before deletion completes. */
348 * An entry on a namespace's command resolution path.
351 struct NamespacePathEntry {
352 Namespace *nsPtr; /* What does this path entry point to? If it
353 * is NULL, this path entry points is
354 * redundant and should be skipped. */
355 Namespace *creatorNsPtr; /* Where does this path entry point from? This
356 * allows for efficient invalidation of
357 * references when the path entry's target
358 * updates its current list of defined
360 NamespacePathEntry *prevPtr, *nextPtr;
361 /* Linked list pointers or NULL at either end
362 * of the list that hangs off Namespace's
363 * commandPathSourceList field. */
367 * Flags used to represent the status of a namespace:
369 * NS_DYING - 1 means Tcl_DeleteNamespace has been called to delete the
370 * namespace but there are still active call frames on the Tcl
371 * stack that refer to the namespace. When the last call frame
372 * referring to it has been popped, it's variables and command
373 * will be destroyed and it will be marked "dead" (NS_DEAD). The
374 * namespace can no longer be looked up by name.
375 * NS_DEAD - 1 means Tcl_DeleteNamespace has been called to delete the
376 * namespace and no call frames still refer to it. Its variables
377 * and command have already been destroyed. This bit allows the
378 * namespace resolution code to recognize that the namespace is
379 * "deleted". When the last namespaceName object in any byte code
380 * unit that refers to the namespace has been freed (i.e., when
381 * the namespace's refCount is 0), the namespace's storage will
383 * NS_KILLED - 1 means that TclTeardownNamespace has already been called on
384 * this namespace and it should not be called again [Bug 1355942]
385 * NS_SUPPRESS_COMPILATION -
386 * Marks the commands in this namespace for not being compiled,
387 * forcing them to be looked up every time.
390 #define NS_DYING 0x01
392 #define NS_KILLED 0x04
393 #define NS_SUPPRESS_COMPILATION 0x08
396 * Flags passed to TclGetNamespaceForQualName:
398 * TCL_GLOBAL_ONLY - (see tcl.h) Look only in the global ns.
399 * TCL_NAMESPACE_ONLY - (see tcl.h) Look only in the context ns.
400 * TCL_CREATE_NS_IF_UNKNOWN - Create unknown namespaces.
401 * TCL_FIND_ONLY_NS - The name sought is a namespace name.
404 #define TCL_CREATE_NS_IF_UNKNOWN 0x800
405 #define TCL_FIND_ONLY_NS 0x1000
408 * The client data for an ensemble command. This consists of the table of
409 * commands that are actually exported by the namespace, and an epoch counter
410 * that, combined with the exportLookupEpoch field of the namespace structure,
411 * defines whether the table contains valid data or will need to be recomputed
412 * next time the ensemble command is called.
415 typedef struct EnsembleConfig {
416 Namespace *nsPtr; /* The namespace backing this ensemble up. */
417 Tcl_Command token; /* The token for the command that provides
418 * ensemble support for the namespace, or NULL
419 * if the command has been deleted (or never
420 * existed; the global namespace never has an
421 * ensemble command.) */
422 int epoch; /* The epoch at which this ensemble's table of
423 * exported commands is valid. */
424 char **subcommandArrayPtr; /* Array of ensemble subcommand names. At all
425 * consistent points, this will have the same
426 * number of entries as there are entries in
427 * the subcommandTable hash. */
428 Tcl_HashTable subcommandTable;
429 /* Hash table of ensemble subcommand names,
430 * which are its keys so this also provides
431 * the storage management for those subcommand
432 * names. The contents of the entry values are
433 * object version the prefix lists to use when
434 * substituting for the command/subcommand to
435 * build the ensemble implementation command.
436 * Has to be stored here as well as in
437 * subcommandDict because that field is NULL
438 * when we are deriving the ensemble from the
439 * namespace exports list. FUTURE WORK: use
440 * object hash table here. */
441 struct EnsembleConfig *next;/* The next ensemble in the linked list of
442 * ensembles associated with a namespace. If
443 * this field points to this ensemble, the
444 * structure has already been unlinked from
445 * all lists, and cannot be found by scanning
446 * the list from the namespace's ensemble
448 int flags; /* ORed combo of TCL_ENSEMBLE_PREFIX,
449 * ENSEMBLE_DEAD and ENSEMBLE_COMPILE. */
451 /* OBJECT FIELDS FOR ENSEMBLE CONFIGURATION */
453 Tcl_Obj *subcommandDict; /* Dictionary providing mapping from
454 * subcommands to their implementing command
455 * prefixes, or NULL if we are to build the
456 * map automatically from the namespace
458 Tcl_Obj *subcmdList; /* List of commands that this ensemble
459 * actually provides, and whose implementation
460 * will be built using the subcommandDict (if
461 * present and defined) and by simple mapping
462 * to the namespace otherwise. If NULL,
463 * indicates that we are using the (dynamic)
464 * list of currently exported commands. */
465 Tcl_Obj *unknownHandler; /* Script prefix used to handle the case when
466 * no match is found (according to the rule
467 * defined by flag bit TCL_ENSEMBLE_PREFIX) or
468 * NULL to use the default error-generating
469 * behaviour. The script execution gets all
470 * the arguments to the ensemble command
471 * (including objv[0]) and will have the
472 * results passed directly back to the caller
473 * (including the error code) unless the code
474 * is TCL_CONTINUE in which case the
475 * subcommand will be reparsed by the ensemble
476 * core, presumably because the ensemble
477 * itself has been updated. */
478 Tcl_Obj *parameterList; /* List of ensemble parameter names. */
479 int numParameters; /* Cached number of parameters. This is either
480 * 0 (if the parameterList field is NULL) or
481 * the length of the list in the parameterList
486 * Various bits for the EnsembleConfig.flags field.
489 #define ENSEMBLE_DEAD 0x1 /* Flag value to say that the ensemble is dead
490 * and on its way out. */
491 #define ENSEMBLE_COMPILE 0x4 /* Flag to enable bytecode compilation of an
495 *----------------------------------------------------------------
496 * Data structures related to variables. These are used primarily in tclVar.c
497 *----------------------------------------------------------------
501 * The following structure defines a variable trace, which is used to invoke a
502 * specific C procedure whenever certain operations are performed on a
506 typedef struct VarTrace {
507 Tcl_VarTraceProc *traceProc;/* Procedure to call when operations given by
508 * flags are performed on variable. */
509 ClientData clientData; /* Argument to pass to proc. */
510 int flags; /* What events the trace procedure is
511 * interested in: OR-ed combination of
512 * TCL_TRACE_READS, TCL_TRACE_WRITES,
513 * TCL_TRACE_UNSETS and TCL_TRACE_ARRAY. */
514 struct VarTrace *nextPtr; /* Next in list of traces associated with a
515 * particular variable. */
519 * The following structure defines a command trace, which is used to invoke a
520 * specific C procedure whenever certain operations are performed on a
524 typedef struct CommandTrace {
525 Tcl_CommandTraceProc *traceProc;
526 /* Procedure to call when operations given by
527 * flags are performed on command. */
528 ClientData clientData; /* Argument to pass to proc. */
529 int flags; /* What events the trace procedure is
530 * interested in: OR-ed combination of
531 * TCL_TRACE_RENAME, TCL_TRACE_DELETE. */
532 struct CommandTrace *nextPtr;
533 /* Next in list of traces associated with a
534 * particular command. */
535 int refCount; /* Used to ensure this structure is not
536 * deleted too early. Keeps track of how many
537 * pieces of code have a pointer to this
542 * When a command trace is active (i.e. its associated procedure is executing)
543 * one of the following structures is linked into a list associated with the
544 * command's interpreter. The information in the structure is needed in order
545 * for Tcl to behave reasonably if traces are deleted while traces are active.
548 typedef struct ActiveCommandTrace {
549 struct Command *cmdPtr; /* Command that's being traced. */
550 struct ActiveCommandTrace *nextPtr;
551 /* Next in list of all active command traces
552 * for the interpreter, or NULL if no more. */
553 CommandTrace *nextTracePtr; /* Next trace to check after current trace
554 * procedure returns; if this trace gets
555 * deleted, must update pointer to avoid using
557 int reverseScan; /* Boolean set true when traces are scanning
558 * in reverse order. */
559 } ActiveCommandTrace;
562 * When a variable trace is active (i.e. its associated procedure is
563 * executing) one of the following structures is linked into a list associated
564 * with the variable's interpreter. The information in the structure is needed
565 * in order for Tcl to behave reasonably if traces are deleted while traces
569 typedef struct ActiveVarTrace {
570 struct Var *varPtr; /* Variable that's being traced. */
571 struct ActiveVarTrace *nextPtr;
572 /* Next in list of all active variable traces
573 * for the interpreter, or NULL if no more. */
574 VarTrace *nextTracePtr; /* Next trace to check after current trace
575 * procedure returns; if this trace gets
576 * deleted, must update pointer to avoid using
581 * The structure below defines a variable, which associates a string name with
582 * a Tcl_Obj value. These structures are kept in procedure call frames (for
583 * local variables recognized by the compiler) or in the heap (for global
584 * variables and any variable not known to the compiler). For each Var
585 * structure in the heap, a hash table entry holds the variable name and a
586 * pointer to the Var structure.
590 int flags; /* Miscellaneous bits of information about
591 * variable. See below for definitions. */
593 Tcl_Obj *objPtr; /* The variable's object value. Used for
594 * scalar variables and array elements. */
595 TclVarHashTable *tablePtr;/* For array variables, this points to
596 * information about the hash table used to
597 * implement the associative array. Points to
598 * ckalloc-ed data. */
599 struct Var *linkPtr; /* If this is a global variable being referred
600 * to in a procedure, or a variable created by
601 * "upvar", this field points to the
602 * referenced variable's Var struct. */
606 typedef struct VarInHash {
608 int refCount; /* Counts number of active uses of this
609 * variable: 1 for the entry in the hash
610 * table, 1 for each additional variable whose
611 * linkPtr points here, 1 for each nested
612 * trace active on variable, and 1 if the
613 * variable is a namespace variable. This
614 * record can't be deleted until refCount
616 Tcl_HashEntry entry; /* The hash table entry that refers to this
617 * variable. This is used to find the name of
618 * the variable and to delete it from its
619 * hashtable if it is no longer needed. It
620 * also holds the variable's name. */
624 * Flag bits for variables. The first two (VAR_ARRAY and VAR_LINK) are
625 * mutually exclusive and give the "type" of the variable. If none is set,
626 * this is a scalar variable.
628 * VAR_ARRAY - 1 means this is an array variable rather than
629 * a scalar variable or link. The "tablePtr"
630 * field points to the array's hashtable for its
632 * VAR_LINK - 1 means this Var structure contains a pointer
633 * to another Var structure that either has the
634 * real value or is itself another VAR_LINK
635 * pointer. Variables like this come about
636 * through "upvar" and "global" commands, or
637 * through references to variables in enclosing
640 * Flags that indicate the type and status of storage; none is set for
641 * compiled local variables (Var structs).
643 * VAR_IN_HASHTABLE - 1 means this variable is in a hashtable and
644 * the Var structure is malloced. 0 if it is a
645 * local variable that was assigned a slot in a
646 * procedure frame by the compiler so the Var
647 * storage is part of the call frame.
648 * VAR_DEAD_HASH 1 means that this var's entry in the hashtable
649 * has already been deleted.
650 * VAR_ARRAY_ELEMENT - 1 means that this variable is an array
651 * element, so it is not legal for it to be an
652 * array itself (the VAR_ARRAY flag had better
654 * VAR_NAMESPACE_VAR - 1 means that this variable was declared as a
655 * namespace variable. This flag ensures it
656 * persists until its namespace is destroyed or
657 * until the variable is unset; it will persist
658 * even if it has not been initialized and is
659 * marked undefined. The variable's refCount is
660 * incremented to reflect the "reference" from
663 * Flag values relating to the variable's trace and search status.
669 * VAR_TRACE_ACTIVE - 1 means that trace processing is currently
670 * underway for a read or write access, so new
671 * read or write accesses should not cause trace
672 * procedures to be called and the variable can't
676 * The following additional flags are used with the CompiledLocal type defined
679 * VAR_ARGUMENT - 1 means that this variable holds a procedure
681 * VAR_TEMPORARY - 1 if the local variable is an anonymous
682 * temporary variable. Temporaries have a NULL
684 * VAR_RESOLVED - 1 if name resolution has been done for this
686 * VAR_IS_ARGS 1 if this variable is the last argument and is
691 * FLAGS RENUMBERED: everything breaks already, make things simpler.
693 * IMPORTANT: skip the values 0x10, 0x20, 0x40, 0x800 corresponding to
694 * TCL_TRACE_(READS/WRITES/UNSETS/ARRAY): makes code simpler in tclTrace.c
696 * Keep the flag values for VAR_ARGUMENT and VAR_TEMPORARY so that old values
697 * in precompiled scripts keep working.
700 /* Type of value (0 is scalar) */
701 #define VAR_ARRAY 0x1
704 /* Type of storage (0 is compiled local) */
705 #define VAR_IN_HASHTABLE 0x4
706 #define VAR_DEAD_HASH 0x8
707 #define VAR_ARRAY_ELEMENT 0x1000
708 #define VAR_NAMESPACE_VAR 0x80 /* KEEP OLD VALUE for Itcl */
710 #define VAR_ALL_HASH \
711 (VAR_IN_HASHTABLE|VAR_DEAD_HASH|VAR_NAMESPACE_VAR|VAR_ARRAY_ELEMENT)
713 /* Trace and search state. */
715 #define VAR_TRACED_READ 0x10 /* TCL_TRACE_READS */
716 #define VAR_TRACED_WRITE 0x20 /* TCL_TRACE_WRITES */
717 #define VAR_TRACED_UNSET 0x40 /* TCL_TRACE_UNSETS */
718 #define VAR_TRACED_ARRAY 0x800 /* TCL_TRACE_ARRAY */
719 #define VAR_TRACE_ACTIVE 0x2000
720 #define VAR_SEARCH_ACTIVE 0x4000
721 #define VAR_ALL_TRACES \
722 (VAR_TRACED_READ|VAR_TRACED_WRITE|VAR_TRACED_ARRAY|VAR_TRACED_UNSET)
724 /* Special handling on initialisation (only CompiledLocal). */
725 #define VAR_ARGUMENT 0x100 /* KEEP OLD VALUE! See tclProc.c */
726 #define VAR_TEMPORARY 0x200 /* KEEP OLD VALUE! See tclProc.c */
727 #define VAR_IS_ARGS 0x400
728 #define VAR_RESOLVED 0x8000
731 * Macros to ensure that various flag bits are set properly for variables.
732 * The ANSI C "prototypes" for these macros are:
734 * MODULE_SCOPE void TclSetVarScalar(Var *varPtr);
735 * MODULE_SCOPE void TclSetVarArray(Var *varPtr);
736 * MODULE_SCOPE void TclSetVarLink(Var *varPtr);
737 * MODULE_SCOPE void TclSetVarArrayElement(Var *varPtr);
738 * MODULE_SCOPE void TclSetVarUndefined(Var *varPtr);
739 * MODULE_SCOPE void TclClearVarUndefined(Var *varPtr);
742 #define TclSetVarScalar(varPtr) \
743 (varPtr)->flags &= ~(VAR_ARRAY|VAR_LINK)
745 #define TclSetVarArray(varPtr) \
746 (varPtr)->flags = ((varPtr)->flags & ~VAR_LINK) | VAR_ARRAY
748 #define TclSetVarLink(varPtr) \
749 (varPtr)->flags = ((varPtr)->flags & ~VAR_ARRAY) | VAR_LINK
751 #define TclSetVarArrayElement(varPtr) \
752 (varPtr)->flags = ((varPtr)->flags & ~VAR_ARRAY) | VAR_ARRAY_ELEMENT
754 #define TclSetVarUndefined(varPtr) \
755 (varPtr)->flags &= ~(VAR_ARRAY|VAR_LINK);\
756 (varPtr)->value.objPtr = NULL
758 #define TclClearVarUndefined(varPtr)
760 #define TclSetVarTraceActive(varPtr) \
761 (varPtr)->flags |= VAR_TRACE_ACTIVE
763 #define TclClearVarTraceActive(varPtr) \
764 (varPtr)->flags &= ~VAR_TRACE_ACTIVE
766 #define TclSetVarNamespaceVar(varPtr) \
767 if (!TclIsVarNamespaceVar(varPtr)) {\
768 (varPtr)->flags |= VAR_NAMESPACE_VAR;\
769 if (TclIsVarInHash(varPtr)) {\
770 ((VarInHash *)(varPtr))->refCount++;\
774 #define TclClearVarNamespaceVar(varPtr) \
775 if (TclIsVarNamespaceVar(varPtr)) {\
776 (varPtr)->flags &= ~VAR_NAMESPACE_VAR;\
777 if (TclIsVarInHash(varPtr)) {\
778 ((VarInHash *)(varPtr))->refCount--;\
783 * Macros to read various flag bits of variables.
784 * The ANSI C "prototypes" for these macros are:
786 * MODULE_SCOPE int TclIsVarScalar(Var *varPtr);
787 * MODULE_SCOPE int TclIsVarLink(Var *varPtr);
788 * MODULE_SCOPE int TclIsVarArray(Var *varPtr);
789 * MODULE_SCOPE int TclIsVarUndefined(Var *varPtr);
790 * MODULE_SCOPE int TclIsVarArrayElement(Var *varPtr);
791 * MODULE_SCOPE int TclIsVarTemporary(Var *varPtr);
792 * MODULE_SCOPE int TclIsVarArgument(Var *varPtr);
793 * MODULE_SCOPE int TclIsVarResolved(Var *varPtr);
796 #define TclIsVarScalar(varPtr) \
797 !((varPtr)->flags & (VAR_ARRAY|VAR_LINK))
799 #define TclIsVarLink(varPtr) \
800 ((varPtr)->flags & VAR_LINK)
802 #define TclIsVarArray(varPtr) \
803 ((varPtr)->flags & VAR_ARRAY)
805 #define TclIsVarUndefined(varPtr) \
806 ((varPtr)->value.objPtr == NULL)
808 #define TclIsVarArrayElement(varPtr) \
809 ((varPtr)->flags & VAR_ARRAY_ELEMENT)
811 #define TclIsVarNamespaceVar(varPtr) \
812 ((varPtr)->flags & VAR_NAMESPACE_VAR)
814 #define TclIsVarTemporary(varPtr) \
815 ((varPtr)->flags & VAR_TEMPORARY)
817 #define TclIsVarArgument(varPtr) \
818 ((varPtr)->flags & VAR_ARGUMENT)
820 #define TclIsVarResolved(varPtr) \
821 ((varPtr)->flags & VAR_RESOLVED)
823 #define TclIsVarTraceActive(varPtr) \
824 ((varPtr)->flags & VAR_TRACE_ACTIVE)
826 #define TclIsVarTraced(varPtr) \
827 ((varPtr)->flags & VAR_ALL_TRACES)
829 #define TclIsVarInHash(varPtr) \
830 ((varPtr)->flags & VAR_IN_HASHTABLE)
832 #define TclIsVarDeadHash(varPtr) \
833 ((varPtr)->flags & VAR_DEAD_HASH)
835 #define TclGetVarNsPtr(varPtr) \
836 (TclIsVarInHash(varPtr) \
837 ? ((TclVarHashTable *) ((((VarInHash *) (varPtr))->entry.tablePtr)))->nsPtr \
840 #define VarHashRefCount(varPtr) \
841 ((VarInHash *) (varPtr))->refCount
844 * Macros for direct variable access by TEBC.
847 #define TclIsVarDirectReadable(varPtr) \
848 ( !((varPtr)->flags & (VAR_ARRAY|VAR_LINK|VAR_TRACED_READ)) \
849 && (varPtr)->value.objPtr)
851 #define TclIsVarDirectWritable(varPtr) \
852 !((varPtr)->flags & (VAR_ARRAY|VAR_LINK|VAR_TRACED_WRITE|VAR_DEAD_HASH))
854 #define TclIsVarDirectUnsettable(varPtr) \
855 !((varPtr)->flags & (VAR_ARRAY|VAR_LINK|VAR_TRACED_READ|VAR_TRACED_WRITE|VAR_TRACED_UNSET|VAR_DEAD_HASH))
857 #define TclIsVarDirectModifyable(varPtr) \
858 ( !((varPtr)->flags & (VAR_ARRAY|VAR_LINK|VAR_TRACED_READ|VAR_TRACED_WRITE)) \
859 && (varPtr)->value.objPtr)
861 #define TclIsVarDirectReadable2(varPtr, arrayPtr) \
862 (TclIsVarDirectReadable(varPtr) &&\
863 (!(arrayPtr) || !((arrayPtr)->flags & VAR_TRACED_READ)))
865 #define TclIsVarDirectWritable2(varPtr, arrayPtr) \
866 (TclIsVarDirectWritable(varPtr) &&\
867 (!(arrayPtr) || !((arrayPtr)->flags & VAR_TRACED_WRITE)))
869 #define TclIsVarDirectModifyable2(varPtr, arrayPtr) \
870 (TclIsVarDirectModifyable(varPtr) &&\
871 (!(arrayPtr) || !((arrayPtr)->flags & (VAR_TRACED_READ|VAR_TRACED_WRITE))))
874 *----------------------------------------------------------------
875 * Data structures related to procedures. These are used primarily in
876 * tclProc.c, tclCompile.c, and tclExecute.c.
877 *----------------------------------------------------------------
880 #if defined(__GNUC__) && (__GNUC__ > 2)
881 # define TCLFLEXARRAY 0
883 # define TCLFLEXARRAY 1
887 * Forward declaration to prevent an error when the forward reference to
888 * Command is encountered in the Proc and ImportRef types declared below.
894 * The variable-length structure below describes a local variable of a
895 * procedure that was recognized by the compiler. These variables have a name,
896 * an element in the array of compiler-assigned local variables in the
897 * procedure's call frame, and various other items of information. If the
898 * local variable is a formal argument, it may also have a default value. The
899 * compiler can't recognize local variables whose names are expressions (these
900 * names are only known at runtime when the expressions are evaluated) or
901 * local variables that are created as a result of an "upvar" or "uplevel"
902 * command. These other local variables are kept separately in a hash table in
906 typedef struct CompiledLocal {
907 struct CompiledLocal *nextPtr;
908 /* Next compiler-recognized local variable for
909 * this procedure, or NULL if this is the last
911 int nameLength; /* The number of bytes in local variable's name.
912 * Among others used to speed up var lookups. */
913 int frameIndex; /* Index in the array of compiler-assigned
914 * variables in the procedure call frame. */
915 int flags; /* Flag bits for the local variable. Same as
916 * the flags for the Var structure above,
917 * although only VAR_ARGUMENT, VAR_TEMPORARY,
918 * and VAR_RESOLVED make sense. */
919 Tcl_Obj *defValuePtr; /* Pointer to the default value of an
920 * argument, if any. NULL if not an argument
921 * or, if an argument, no default value. */
922 Tcl_ResolvedVarInfo *resolveInfo;
923 /* Customized variable resolution info
924 * supplied by the Tcl_ResolveCompiledVarProc
925 * associated with a namespace. Each variable
926 * is marked by a unique ClientData tag during
927 * compilation, and that same tag is used to
928 * find the variable at runtime. */
929 char name[TCLFLEXARRAY]; /* Name of the local variable starts here. If
930 * the name is NULL, this will just be '\0'.
931 * The actual size of this field will be large
932 * enough to hold the name. MUST BE THE LAST
933 * FIELD IN THE STRUCTURE! */
937 * The structure below defines a command procedure, which consists of a
938 * collection of Tcl commands plus information about arguments and other local
939 * variables recognized at compile time.
942 typedef struct Proc {
943 struct Interp *iPtr; /* Interpreter for which this command is
945 int refCount; /* Reference count: 1 if still present in
946 * command table plus 1 for each call to the
947 * procedure that is currently active. This
948 * structure can be freed when refCount
950 struct Command *cmdPtr; /* Points to the Command structure for this
951 * procedure. This is used to get the
952 * namespace in which to execute the
954 Tcl_Obj *bodyPtr; /* Points to the ByteCode object for
955 * procedure's body command. */
956 int numArgs; /* Number of formal parameters. */
957 int numCompiledLocals; /* Count of local variables recognized by the
958 * compiler including arguments and
960 CompiledLocal *firstLocalPtr;
961 /* Pointer to first of the procedure's
962 * compiler-allocated local variables, or NULL
963 * if none. The first numArgs entries in this
964 * list describe the procedure's formal
966 CompiledLocal *lastLocalPtr;/* Pointer to the last allocated local
967 * variable or NULL if none. This has frame
968 * index (numCompiledLocals-1). */
972 * The type of functions called to process errors found during the execution
973 * of a procedure (or lambda term or ...).
976 typedef void (ProcErrorProc)(Tcl_Interp *interp, Tcl_Obj *procNameObj);
979 * The structure below defines a command trace. This is used to allow Tcl
980 * clients to find out whenever a command is about to be executed.
983 typedef struct Trace {
984 int level; /* Only trace commands at nesting level less
985 * than or equal to this. */
986 Tcl_CmdObjTraceProc *proc; /* Procedure to call to trace command. */
987 ClientData clientData; /* Arbitrary value to pass to proc. */
988 struct Trace *nextPtr; /* Next in list of traces for this interp. */
989 int flags; /* Flags governing the trace - see
990 * Tcl_CreateObjTrace for details. */
991 Tcl_CmdObjTraceDeleteProc *delProc;
992 /* Procedure to call when trace is deleted. */
996 * When an interpreter trace is active (i.e. its associated procedure is
997 * executing), one of the following structures is linked into a list
998 * associated with the interpreter. The information in the structure is needed
999 * in order for Tcl to behave reasonably if traces are deleted while traces
1003 typedef struct ActiveInterpTrace {
1004 struct ActiveInterpTrace *nextPtr;
1005 /* Next in list of all active command traces
1006 * for the interpreter, or NULL if no more. */
1007 Trace *nextTracePtr; /* Next trace to check after current trace
1008 * procedure returns; if this trace gets
1009 * deleted, must update pointer to avoid using
1011 int reverseScan; /* Boolean set true when traces are scanning
1012 * in reverse order. */
1013 } ActiveInterpTrace;
1016 * Flag values designating types of execution traces. See tclTrace.c for
1017 * related flag values.
1019 * TCL_TRACE_ENTER_EXEC - triggers enter/enterstep traces.
1020 * - passed to Tcl_CreateObjTrace to set up
1021 * "enterstep" traces.
1022 * TCL_TRACE_LEAVE_EXEC - triggers leave/leavestep traces.
1023 * - passed to Tcl_CreateObjTrace to set up
1024 * "leavestep" traces.
1027 #define TCL_TRACE_ENTER_EXEC 1
1028 #define TCL_TRACE_LEAVE_EXEC 2
1031 * The structure below defines an entry in the assocData hash table which is
1032 * associated with an interpreter. The entry contains a pointer to a function
1033 * to call when the interpreter is deleted, and a pointer to a user-defined
1037 typedef struct AssocData {
1038 Tcl_InterpDeleteProc *proc; /* Proc to call when deleting. */
1039 ClientData clientData; /* Value to pass to proc. */
1043 * The structure below defines a call frame. A call frame defines a naming
1044 * context for a procedure call: its local naming scope (for local variables)
1045 * and its global naming scope (a namespace, perhaps the global :: namespace).
1046 * A call frame can also define the naming context for a namespace eval or
1047 * namespace inscope command: the namespace in which the command's code should
1048 * execute. The Tcl_CallFrame structures exist only while procedures or
1049 * namespace eval/inscope's are being executed, and provide a kind of Tcl call
1052 * WARNING!! The structure definition must be kept consistent with the
1053 * Tcl_CallFrame structure in tcl.h. If you change one, change the other.
1057 * Will be grown to contain: pointers to the varnames (allocated at the end),
1058 * plus the init values for each variable (suitable to be memcopied on init)
1061 typedef struct LocalCache {
1067 #define localName(framePtr, i) \
1068 ((&((framePtr)->localCachePtr->varName0))[(i)])
1070 MODULE_SCOPE void TclFreeLocalCache(Tcl_Interp *interp,
1071 LocalCache *localCachePtr);
1073 typedef struct CallFrame {
1074 Namespace *nsPtr; /* Points to the namespace used to resolve
1075 * commands and global variables. */
1076 int isProcCallFrame; /* If 0, the frame was pushed to execute a
1077 * namespace command and var references are
1078 * treated as references to namespace vars;
1079 * varTablePtr and compiledLocals are ignored.
1080 * If FRAME_IS_PROC is set, the frame was
1081 * pushed to execute a Tcl procedure and may
1082 * have local vars. */
1083 int objc; /* This and objv below describe the arguments
1084 * for this procedure call. */
1085 Tcl_Obj *const *objv; /* Array of argument objects. */
1086 struct CallFrame *callerPtr;
1087 /* Value of interp->framePtr when this
1088 * procedure was invoked (i.e. next higher in
1089 * stack of all active procedures). */
1090 struct CallFrame *callerVarPtr;
1091 /* Value of interp->varFramePtr when this
1092 * procedure was invoked (i.e. determines
1093 * variable scoping within caller). Same as
1094 * callerPtr unless an "uplevel" command or
1095 * something equivalent was active in the
1097 int level; /* Level of this procedure, for "uplevel"
1098 * purposes (i.e. corresponds to nesting of
1099 * callerVarPtr's, not callerPtr's). 1 for
1100 * outermost procedure, 0 for top-level. */
1101 Proc *procPtr; /* Points to the structure defining the called
1102 * procedure. Used to get information such as
1103 * the number of compiled local variables
1104 * (local variables assigned entries ["slots"]
1105 * in the compiledLocals array below). */
1106 TclVarHashTable *varTablePtr;
1107 /* Hash table containing local variables not
1108 * recognized by the compiler, or created at
1109 * execution time through, e.g., upvar.
1110 * Initially NULL and created if needed. */
1111 int numCompiledLocals; /* Count of local variables recognized by the
1112 * compiler including arguments. */
1113 Var *compiledLocals; /* Points to the array of local variables
1114 * recognized by the compiler. The compiler
1115 * emits code that refers to these variables
1116 * using an index into this array. */
1117 ClientData clientData; /* Pointer to some context that is used by
1118 * object systems. The meaning of the contents
1119 * of this field is defined by the code that
1120 * sets it, and it should only ever be set by
1121 * the code that is pushing the frame. In that
1122 * case, the code that sets it should also
1123 * have some means of discovering what the
1124 * meaning of the value is, which we do not
1126 LocalCache *localCachePtr;
1127 Tcl_Obj *tailcallPtr;
1128 /* NULL if no tailcall is scheduled */
1131 #define FRAME_IS_PROC 0x1
1132 #define FRAME_IS_LAMBDA 0x2
1133 #define FRAME_IS_METHOD 0x4 /* The frame is a method body, and the frame's
1134 * clientData field contains a CallContext
1135 * reference. Part of TIP#257. */
1136 #define FRAME_IS_OO_DEFINE 0x8 /* The frame is part of the inside workings of
1137 * the [oo::define] command; the clientData
1138 * field contains an Object reference that has
1139 * been confirmed to refer to a class. Part of
1144 * The structure below defines a command frame. A command frame provides
1145 * location information for all commands executing a tcl script (source, eval,
1146 * uplevel, procedure bodies, ...). The runtime structure essentially contains
1147 * the stack trace as it would be if the currently executing command were to
1150 * For commands where it makes sense it refers to the associated CallFrame as
1153 * The structures are chained in a single list, with the top of the stack
1154 * anchored in the Interp structure.
1156 * Instances can be allocated on the C stack, or the heap, the former making
1157 * cleanup a bit simpler.
1160 typedef struct CmdFrame {
1162 * General data. Always available.
1165 int type; /* Values see below. */
1166 int level; /* Number of frames in stack, prevent O(n)
1168 int *line; /* Lines the words of the command start on. */
1170 CallFrame *framePtr; /* Procedure activation record, may be
1172 struct CmdFrame *nextPtr; /* Link to calling frame. */
1174 * Data needed for Eval vs TEBC
1176 * EXECUTION CONTEXTS and usage of CmdFrame
1179 * ======= ==== ======
1181 * type BC/PREBC SRC/EVAL
1184 * ======= ==== ======
1186 * ======= ==== ========= union data
1190 * ------- ---- ------
1193 * ======= ==== ======
1195 * ======= ==== ========= union cmd
1198 * ------- ---- ------
1203 Tcl_Obj *path; /* Path of the sourced file the command is
1207 const void *codePtr;/* Byte code currently executed... */
1208 const char *pc; /* ... and instruction pointer. */
1212 const char *cmd; /* The executed command, if possible... */
1213 int len; /* ... and its length. */
1214 const struct CFWordBC *litarg;
1215 /* Link to set of literal arguments which have
1216 * ben pushed on the lineLABCPtr stack by
1217 * TclArgumentBCEnter(). These will be removed
1218 * by TclArgumentBCRelease. */
1221 typedef struct CFWord {
1222 CmdFrame *framePtr; /* CmdFrame to access. */
1223 int word; /* Index of the word in the command. */
1224 int refCount; /* Number of times the word is on the
1228 typedef struct CFWordBC {
1229 CmdFrame *framePtr; /* CmdFrame to access. */
1230 int pc; /* Instruction pointer of a command in
1231 * ExtCmdLoc.loc[.] */
1232 int word; /* Index of word in
1233 * ExtCmdLoc.loc[cmd]->line[.] */
1234 struct CFWordBC *prevPtr; /* Previous entry in stack for same Tcl_Obj. */
1235 struct CFWordBC *nextPtr; /* Next entry for same command call. See
1236 * CmdFrame litarg field for the list start. */
1237 Tcl_Obj *obj; /* Back reference to hashtable key */
1241 * Structure to record the locations of invisible continuation lines in
1242 * literal scripts, as character offset from the beginning of the script. Both
1243 * compiler and direct evaluator use this information to adjust their line
1244 * counters when tracking through the script, because when it is invoked the
1245 * continuation line marker as a whole has been removed already, meaning that
1246 * the \n which was part of it is gone as well, breaking regular line
1249 * These structures are allocated and filled by both the function
1250 * TclSubstTokens() in the file "tclParse.c" and its caller TclEvalEx() in the
1251 * file "tclBasic.c", and stored in the thread-global hashtable "lineCLPtr" in
1252 * file "tclObj.c". They are used by the functions TclSetByteCodeFromAny() and
1253 * TclCompileScript(), both found in the file "tclCompile.c". Their memory is
1254 * released by the function TclFreeObj(), in the file "tclObj.c", and also by
1255 * the function TclThreadFinalizeObjects(), in the same file.
1258 #define CLL_END (-1)
1260 typedef struct ContLineLoc {
1261 int num; /* Number of entries in loc, not counting the
1262 * final -1 marker entry. */
1263 int loc[TCLFLEXARRAY];/* Table of locations, as character offsets.
1264 * The table is allocated as part of the
1265 * structure, extending behind the nominal end
1266 * of the structure. An entry containing the
1267 * value -1 is put after the last location, as
1268 * end-marker/sentinel. */
1272 * The following macros define the allowed values for the type field of the
1273 * CmdFrame structure above. Some of the values occur only in the extended
1274 * location data referenced via the 'baseLocPtr'.
1276 * TCL_LOCATION_EVAL : Frame is for a script evaluated by EvalEx.
1277 * TCL_LOCATION_BC : Frame is for bytecode.
1278 * TCL_LOCATION_PREBC : Frame is for precompiled bytecode.
1279 * TCL_LOCATION_SOURCE : Frame is for a script evaluated by EvalEx, from a
1281 * TCL_LOCATION_PROC : Frame is for bytecode of a procedure.
1283 * A TCL_LOCATION_BC type in a frame can be overridden by _SOURCE and _PROC
1284 * types, per the context of the byte code in execution.
1287 #define TCL_LOCATION_EVAL (0) /* Location in a dynamic eval script. */
1288 #define TCL_LOCATION_BC (2) /* Location in byte code. */
1289 #define TCL_LOCATION_PREBC (3) /* Location in precompiled byte code, no
1291 #define TCL_LOCATION_SOURCE (4) /* Location in a file. */
1292 #define TCL_LOCATION_PROC (5) /* Location in a dynamic proc. */
1293 #define TCL_LOCATION_LAST (6) /* Number of values in the enum. */
1296 * Structure passed to describe procedure-like "procedures" that are not
1297 * procedures (e.g. a lambda) so that their details can be reported correctly
1298 * by [info frame]. Contains a sub-structure for each extra field.
1301 typedef Tcl_Obj * (GetFrameInfoValueProc)(ClientData clientData);
1303 const char *name; /* Name of this field. */
1304 GetFrameInfoValueProc *proc; /* Function to generate a Tcl_Obj* from the
1305 * clientData, or just use the clientData
1306 * directly (after casting) if NULL. */
1307 ClientData clientData; /* Context for above function, or Tcl_Obj* if
1308 * proc field is NULL. */
1309 } ExtraFrameInfoField;
1311 int length; /* Length of array. */
1312 ExtraFrameInfoField fields[2];
1313 /* Really as long as necessary, but this is
1314 * long enough for nearly anything. */
1318 *----------------------------------------------------------------
1319 * Data structures and procedures related to TclHandles, which are a very
1320 * lightweight method of preserving enough information to determine if an
1321 * arbitrary malloc'd block has been deleted.
1322 *----------------------------------------------------------------
1325 typedef void **TclHandle;
1328 *----------------------------------------------------------------
1329 * Experimental flag value passed to Tcl_GetRegExpFromObj. Intended for use
1330 * only by Expect. It will probably go away in a later release.
1331 *----------------------------------------------------------------
1334 #define TCL_REG_BOSONLY 002000 /* Prepend \A to pattern so it only matches at
1335 * the beginning of the string. */
1338 * These are a thin layer over TclpThreadKeyDataGet and TclpThreadKeyDataSet
1339 * when threads are used, or an emulation if there are no threads. These are
1340 * really internal and Tcl clients should use Tcl_GetThreadData.
1343 MODULE_SCOPE void * TclThreadDataKeyGet(Tcl_ThreadDataKey *keyPtr);
1344 MODULE_SCOPE void TclThreadDataKeySet(Tcl_ThreadDataKey *keyPtr,
1348 * This is a convenience macro used to initialize a thread local storage ptr.
1351 #define TCL_TSD_INIT(keyPtr) \
1352 (ThreadSpecificData *)Tcl_GetThreadData((keyPtr), sizeof(ThreadSpecificData))
1355 *----------------------------------------------------------------
1356 * Data structures related to bytecode compilation and execution. These are
1357 * used primarily in tclCompile.c, tclExecute.c, and tclBasic.c.
1358 *----------------------------------------------------------------
1362 * Forward declaration to prevent errors when the forward references to
1363 * Tcl_Parse and CompileEnv are encountered in the procedure type CompileProc
1370 * The type of procedures called by the Tcl bytecode compiler to compile
1371 * commands. Pointers to these procedures are kept in the Command structure
1372 * describing each command. The integer value returned by a CompileProc must
1373 * be one of the following:
1375 * TCL_OK Compilation completed normally.
1376 * TCL_ERROR Compilation could not be completed. This can be just a
1377 * judgment by the CompileProc that the command is too
1378 * complex to compile effectively, or it can indicate
1379 * that in the current state of the interp, the command
1380 * would raise an error. The bytecode compiler will not
1381 * do any error reporting at compiler time. Error
1382 * reporting is deferred until the actual runtime,
1383 * because by then changes in the interp state may allow
1384 * the command to be successfully evaluated.
1385 * TCL_OUT_LINE_COMPILE A source-compatible alias for TCL_ERROR, kept for the
1386 * sake of old code only.
1389 #define TCL_OUT_LINE_COMPILE TCL_ERROR
1391 typedef int (CompileProc)(Tcl_Interp *interp, Tcl_Parse *parsePtr,
1392 struct Command *cmdPtr, struct CompileEnv *compEnvPtr);
1395 * The type of procedure called from the compilation hook point in
1396 * SetByteCodeFromAny.
1399 typedef int (CompileHookProc)(Tcl_Interp *interp,
1400 struct CompileEnv *compEnvPtr, ClientData clientData);
1403 * The data structure for a (linked list of) execution stacks.
1406 typedef struct ExecStack {
1407 struct ExecStack *prevPtr;
1408 struct ExecStack *nextPtr;
1409 Tcl_Obj **markerPtr;
1412 Tcl_Obj *stackWords[TCLFLEXARRAY];
1416 * The data structure defining the execution environment for ByteCode's.
1417 * There is one ExecEnv structure per Tcl interpreter. It holds the evaluation
1418 * stack that holds command operands and results. The stack grows towards
1419 * increasing addresses. The member stackPtr points to the stackItems of the
1420 * currently active execution stack.
1423 typedef struct CorContext {
1424 struct CallFrame *framePtr;
1425 struct CallFrame *varFramePtr;
1426 struct CmdFrame *cmdFramePtr; /* See Interp.cmdFramePtr */
1427 Tcl_HashTable *lineLABCPtr; /* See Interp.lineLABCPtr */
1430 typedef struct CoroutineData {
1431 struct Command *cmdPtr; /* The command handle for the coroutine. */
1432 struct ExecEnv *eePtr; /* The special execution environment (stacks,
1433 * etc.) for the coroutine. */
1434 struct ExecEnv *callerEEPtr;/* The execution environment for the caller of
1435 * the coroutine, which might be the
1436 * interpreter global environment or another
1440 Tcl_HashTable *lineLABCPtr; /* See Interp.lineLABCPtr */
1442 int auxNumLevels; /* While the coroutine is running the
1443 * numLevels of the create/resume command is
1444 * stored here; for suspended coroutines it
1445 * holds the nesting numLevels at yield. */
1446 int nargs; /* Number of args required for resuming this
1447 * coroutine; -2 means "0 or 1" (default), -1
1451 typedef struct ExecEnv {
1452 ExecStack *execStackPtr; /* Points to the first item in the evaluation
1453 * stack on the heap. */
1454 Tcl_Obj *constants[2]; /* Pointers to constant "0" and "1" objs. */
1455 struct Tcl_Interp *interp;
1456 struct NRE_callback *callbackPtr;
1457 /* Top callback in NRE's stack. */
1458 struct CoroutineData *corPtr;
1462 #define COR_IS_SUSPENDED(corPtr) \
1463 ((corPtr)->stackLevel == NULL)
1466 * The definitions for the LiteralTable and LiteralEntry structures. Each
1467 * interpreter contains a LiteralTable. It is used to reduce the storage
1468 * needed for all the Tcl objects that hold the literals of scripts compiled
1469 * by the interpreter. A literal's object is shared by all the ByteCodes that
1470 * refer to the literal. Each distinct literal has one LiteralEntry entry in
1471 * the LiteralTable. A literal table is a specialized hash table that is
1472 * indexed by the literal's string representation, which may contain null
1475 * Note that we reduce the space needed for literals by sharing literal
1476 * objects both within a ByteCode (each ByteCode contains a local
1477 * LiteralTable) and across all an interpreter's ByteCodes (with the
1478 * interpreter's global LiteralTable).
1481 typedef struct LiteralEntry {
1482 struct LiteralEntry *nextPtr;
1483 /* Points to next entry in this hash bucket or
1484 * NULL if end of chain. */
1485 Tcl_Obj *objPtr; /* Points to Tcl object that holds the
1486 * literal's bytes and length. */
1487 int refCount; /* If in an interpreter's global literal
1488 * table, the number of ByteCode structures
1489 * that share the literal object; the literal
1490 * entry can be freed when refCount drops to
1491 * 0. If in a local literal table, -1. */
1492 Namespace *nsPtr; /* Namespace in which this literal is used. We
1493 * try to avoid sharing literal non-FQ command
1494 * names among different namespaces to reduce
1498 typedef struct LiteralTable {
1499 LiteralEntry **buckets; /* Pointer to bucket array. Each element
1500 * points to first entry in bucket's hash
1501 * chain, or NULL. */
1502 LiteralEntry *staticBuckets[TCL_SMALL_HASH_TABLE];
1503 /* Bucket array used for small tables to avoid
1504 * mallocs and frees. */
1505 int numBuckets; /* Total number of buckets allocated at
1507 int numEntries; /* Total number of entries present in
1509 int rebuildSize; /* Enlarge table when numEntries gets to be
1511 int mask; /* Mask value used in hashing function. */
1515 * The following structure defines for each Tcl interpreter various
1516 * statistics-related information about the bytecode compiler and
1517 * interpreter's operation in that interpreter.
1520 #ifdef TCL_COMPILE_STATS
1521 typedef struct ByteCodeStats {
1522 long numExecutions; /* Number of ByteCodes executed. */
1523 long numCompilations; /* Number of ByteCodes created. */
1524 long numByteCodesFreed; /* Number of ByteCodes destroyed. */
1525 long instructionCount[256]; /* Number of times each instruction was
1528 double totalSrcBytes; /* Total source bytes ever compiled. */
1529 double totalByteCodeBytes; /* Total bytes for all ByteCodes. */
1530 double currentSrcBytes; /* Src bytes for all current ByteCodes. */
1531 double currentByteCodeBytes;/* Code bytes in all current ByteCodes. */
1533 long srcCount[32]; /* Source size distribution: # of srcs of
1534 * size [2**(n-1)..2**n), n in [0..32). */
1535 long byteCodeCount[32]; /* ByteCode size distribution. */
1536 long lifetimeCount[32]; /* ByteCode lifetime distribution (ms). */
1538 double currentInstBytes; /* Instruction bytes-current ByteCodes. */
1539 double currentLitBytes; /* Current literal bytes. */
1540 double currentExceptBytes; /* Current exception table bytes. */
1541 double currentAuxBytes; /* Current auxiliary information bytes. */
1542 double currentCmdMapBytes; /* Current src<->code map bytes. */
1544 long numLiteralsCreated; /* Total literal objects ever compiled. */
1545 double totalLitStringBytes; /* Total string bytes in all literals. */
1546 double currentLitStringBytes;
1547 /* String bytes in current literals. */
1548 long literalCount[32]; /* Distribution of literal string sizes. */
1550 #endif /* TCL_COMPILE_STATS */
1553 * Structure used in implementation of those core ensembles which are
1554 * partially compiled. Used as an array of these, with a terminating field
1555 * whose 'name' is NULL.
1559 const char *name; /* The name of the subcommand. */
1560 Tcl_ObjCmdProc *proc; /* The implementation of the subcommand. */
1561 CompileProc *compileProc; /* The compiler for the subcommand. */
1562 Tcl_ObjCmdProc *nreProc; /* NRE implementation of this command. */
1563 ClientData clientData; /* Any clientData to give the command. */
1564 int unsafe; /* Whether this command is to be hidden by
1565 * default in a safe interpreter. */
1569 *----------------------------------------------------------------
1570 * Data structures related to commands.
1571 *----------------------------------------------------------------
1575 * An imported command is created in an namespace when it imports a "real"
1576 * command from another namespace. An imported command has a Command structure
1577 * that points (via its ClientData value) to the "real" Command structure in
1578 * the source namespace's command table. The real command records all the
1579 * imported commands that refer to it in a list of ImportRef structures so
1580 * that they can be deleted when the real command is deleted.
1583 typedef struct ImportRef {
1584 struct Command *importedCmdPtr;
1585 /* Points to the imported command created in
1586 * an importing namespace; this command
1587 * redirects its invocations to the "real"
1589 struct ImportRef *nextPtr; /* Next element on the linked list of imported
1590 * commands that refer to the "real" command.
1591 * The real command deletes these imported
1592 * commands on this list when it is
1597 * Data structure used as the ClientData of imported commands: commands
1598 * created in an namespace when it imports a "real" command from another
1602 typedef struct ImportedCmdData {
1603 struct Command *realCmdPtr; /* "Real" command that this imported command
1605 struct Command *selfPtr; /* Pointer to this imported command. Needed
1606 * only when deleting it in order to remove it
1607 * from the real command's linked list of
1608 * imported commands that refer to it. */
1612 * A Command structure exists for each command in a namespace. The Tcl_Command
1613 * opaque type actually refers to these structures.
1616 typedef struct Command {
1617 Tcl_HashEntry *hPtr; /* Pointer to the hash table entry that refers
1618 * to this command. The hash table is either a
1619 * namespace's command table or an
1620 * interpreter's hidden command table. This
1621 * pointer is used to get a command's name
1622 * from its Tcl_Command handle. NULL means
1623 * that the hash table entry has been removed
1624 * already (this can happen if deleteProc
1625 * causes the command to be deleted or
1627 Namespace *nsPtr; /* Points to the namespace containing this
1629 int refCount; /* 1 if in command hashtable plus 1 for each
1630 * reference from a CmdName Tcl object
1631 * representing a command's name in a ByteCode
1632 * instruction sequence. This structure can be
1633 * freed when refCount becomes zero. */
1634 int cmdEpoch; /* Incremented to invalidate any references
1635 * that point to this command when it is
1636 * renamed, deleted, hidden, or exposed. */
1637 CompileProc *compileProc; /* Procedure called to compile command. NULL
1638 * if no compile proc exists for command. */
1639 Tcl_ObjCmdProc *objProc; /* Object-based command procedure. */
1640 ClientData objClientData; /* Arbitrary value passed to object proc. */
1641 Tcl_CmdProc *proc; /* String-based command procedure. */
1642 ClientData clientData; /* Arbitrary value passed to string proc. */
1643 Tcl_CmdDeleteProc *deleteProc;
1644 /* Procedure invoked when deleting command to,
1645 * e.g., free all client data. */
1646 ClientData deleteData; /* Arbitrary value passed to deleteProc. */
1647 int flags; /* Miscellaneous bits of information about
1648 * command. See below for definitions. */
1649 ImportRef *importRefPtr; /* List of each imported Command created in
1650 * another namespace when this command is
1651 * imported. These imported commands redirect
1652 * invocations back to this command. The list
1653 * is used to remove all those imported
1654 * commands when deleting this "real"
1656 CommandTrace *tracePtr; /* First in list of all traces set for this
1658 Tcl_ObjCmdProc *nreProc; /* NRE implementation of this command. */
1662 * Flag bits for commands.
1664 * CMD_IS_DELETED - Means that the command is in the process of
1665 * being deleted (its deleteProc is currently
1666 * executing). Other attempts to delete the
1667 * command should be ignored.
1668 * CMD_TRACE_ACTIVE - 1 means that trace processing is currently
1669 * underway for a rename/delete change. See the
1670 * two flags below for which is currently being
1672 * CMD_HAS_EXEC_TRACES - 1 means that this command has at least one
1673 * execution trace (as opposed to simple
1674 * delete/rename traces) in its tracePtr list.
1675 * CMD_COMPILES_EXPANDED - 1 means that this command has a compiler that
1676 * can handle expansion (provided it is not the
1678 * TCL_TRACE_RENAME - A rename trace is in progress. Further
1679 * recursive renames will not be traced.
1680 * TCL_TRACE_DELETE - A delete trace is in progress. Further
1681 * recursive deletes will not be traced.
1682 * (these last two flags are defined in tcl.h)
1685 #define CMD_IS_DELETED 0x01
1686 #define CMD_TRACE_ACTIVE 0x02
1687 #define CMD_HAS_EXEC_TRACES 0x04
1688 #define CMD_COMPILES_EXPANDED 0x08
1689 #define CMD_REDEF_IN_PROGRESS 0x10
1690 #define CMD_VIA_RESOLVER 0x20
1691 #define CMD_DEAD 0x40
1695 *----------------------------------------------------------------
1696 * Data structures related to name resolution procedures.
1697 *----------------------------------------------------------------
1701 * The interpreter keeps a linked list of name resolution schemes. The scheme
1702 * for a namespace is consulted first, followed by the list of schemes in an
1703 * interpreter, followed by the default name resolution in Tcl. Schemes are
1704 * added/removed from the interpreter's list by calling Tcl_AddInterpResolver
1705 * and Tcl_RemoveInterpResolver.
1708 typedef struct ResolverScheme {
1709 char *name; /* Name identifying this scheme. */
1710 Tcl_ResolveCmdProc *cmdResProc;
1711 /* Procedure handling command name
1713 Tcl_ResolveVarProc *varResProc;
1714 /* Procedure handling variable name resolution
1715 * for variables that can only be handled at
1717 Tcl_ResolveCompiledVarProc *compiledVarResProc;
1718 /* Procedure handling variable name resolution
1719 * at compile time. */
1721 struct ResolverScheme *nextPtr;
1722 /* Pointer to next record in linked list. */
1726 * Forward declaration of the TIP#143 limit handler structure.
1729 typedef struct LimitHandler LimitHandler;
1733 * Values for the selection mode, i.e the package require preferences.
1736 enum PkgPreferOptions {
1737 PKG_PREFER_LATEST, PKG_PREFER_STABLE
1741 *----------------------------------------------------------------
1742 * This structure shadows the first few fields of the memory cache for the
1743 * allocator defined in tclThreadAlloc.c; it has to be kept in sync with the
1745 * Some macros require knowledge of some fields in the struct in order to
1746 * avoid hitting the TSD unnecessarily. In order to facilitate this, a pointer
1747 * to the relevant fields is kept in the allocCache field in struct Interp.
1748 *----------------------------------------------------------------
1751 typedef struct AllocCache {
1752 struct Cache *nextPtr; /* Linked list of cache entries. */
1753 Tcl_ThreadId owner; /* Which thread's cache is this? */
1754 Tcl_Obj *firstObjPtr; /* List of free objects for thread. */
1755 int numObjects; /* Number of objects for thread. */
1759 *----------------------------------------------------------------
1760 * This structure defines an interpreter, which is a collection of commands
1761 * plus other state information related to interpreting commands, such as
1762 * variable storage. Primary responsibility for this data structure is in
1763 * tclBasic.c, but almost every Tcl source file uses something in here.
1764 *----------------------------------------------------------------
1767 typedef struct Interp {
1769 * Note: the first three fields must match exactly the fields in a
1770 * Tcl_Interp struct (see tcl.h). If you change one, be sure to change the
1773 * The interpreter's result is held in both the string and the
1774 * objResultPtr fields. These fields hold, respectively, the result's
1775 * string or object value. The interpreter's result is always in the
1776 * result field if that is non-empty, otherwise it is in objResultPtr.
1777 * The two fields are kept consistent unless some C code sets
1778 * interp->result directly. Programs should not access result and
1779 * objResultPtr directly; instead, they should always get and set the
1780 * result using procedures such as Tcl_SetObjResult, Tcl_GetObjResult, and
1781 * Tcl_GetStringResult. See the SetResult man page for details.
1784 char *result; /* If the last command returned a string
1785 * result, this points to it. Should not be
1786 * accessed directly; see comment above. */
1787 Tcl_FreeProc *freeProc; /* Zero means a string result is statically
1788 * allocated. TCL_DYNAMIC means string result
1789 * was allocated with ckalloc and should be
1790 * freed with ckfree. Other values give
1791 * address of procedure to invoke to free the
1792 * string result. Tcl_Eval must free it before
1793 * executing next command. */
1794 int errorLine; /* When TCL_ERROR is returned, this gives the
1795 * line number in the command where the error
1796 * occurred (1 means first line). */
1797 const struct TclStubs *stubTable;
1798 /* Pointer to the exported Tcl stub table. On
1799 * previous versions of Tcl this is a pointer
1800 * to the objResultPtr or a pointer to a
1801 * buckets array in a hash table. We therefore
1802 * have to do some careful checking before we
1805 TclHandle handle; /* Handle used to keep track of when this
1806 * interp is deleted. */
1808 Namespace *globalNsPtr; /* The interpreter's global namespace. */
1809 Tcl_HashTable *hiddenCmdTablePtr;
1810 /* Hash table used by tclBasic.c to keep track
1811 * of hidden commands on a per-interp
1813 ClientData interpInfo; /* Information used by tclInterp.c to keep
1814 * track of parent/child interps on a
1815 * per-interp basis. */
1817 void (*optimizer)(void *envPtr);
1818 Tcl_HashTable unused2; /* No longer used (was mathFuncTable). The
1819 * unused space in interp was repurposed for
1820 * pluggable bytecode optimizers. The core
1821 * contains one optimizer, which can be
1822 * selectively overridden by extensions. */
1826 * Information related to procedures and variables. See tclProc.c and
1827 * tclVar.c for usage.
1830 int numLevels; /* Keeps track of how many nested calls to
1831 * Tcl_Eval are in progress for this
1832 * interpreter. It's used to delay deletion of
1833 * the table until all Tcl_Eval invocations
1835 int maxNestingDepth; /* If numLevels exceeds this value then Tcl
1836 * assumes that infinite recursion has
1837 * occurred and it generates an error. */
1838 CallFrame *framePtr; /* Points to top-most in stack of all nested
1839 * procedure invocations. */
1840 CallFrame *varFramePtr; /* Points to the call frame whose variables
1841 * are currently in use (same as framePtr
1842 * unless an "uplevel" command is
1844 ActiveVarTrace *activeVarTracePtr;
1845 /* First in list of active traces for interp,
1846 * or NULL if no active traces. */
1847 int returnCode; /* [return -code] parameter. */
1848 CallFrame *rootFramePtr; /* Global frame pointer for this
1850 Namespace *lookupNsPtr; /* Namespace to use ONLY on the next
1851 * TCL_EVAL_INVOKE call to Tcl_EvalObjv. */
1854 * Information used by Tcl_AppendResult to keep track of partial results.
1855 * See Tcl_AppendResult code for details.
1858 char *appendResult; /* Storage space for results generated by
1859 * Tcl_AppendResult. Ckalloc-ed. NULL means
1860 * not yet allocated. */
1861 int appendAvl; /* Total amount of space available at
1863 int appendUsed; /* Number of non-null bytes currently stored
1864 * at partialResult. */
1867 * Information about packages. Used only in tclPkg.c.
1870 Tcl_HashTable packageTable; /* Describes all of the packages loaded in or
1871 * available to this interpreter. Keys are
1872 * package names, values are (Package *)
1874 char *packageUnknown; /* Command to invoke during "package require"
1875 * commands for packages that aren't described
1876 * in packageTable. Ckalloc'ed, may be
1879 * Miscellaneous information:
1882 int cmdCount; /* Total number of times a command procedure
1883 * has been called for this interpreter. */
1884 int evalFlags; /* Flags to control next call to Tcl_Eval.
1885 * Normally zero, but may be set before
1886 * calling Tcl_Eval. See below for valid
1888 int unused1; /* No longer used (was termOffset) */
1889 LiteralTable literalTable; /* Contains LiteralEntry's describing all Tcl
1890 * objects holding literals of scripts
1891 * compiled by the interpreter. Indexed by the
1892 * string representations of literals. Used to
1893 * avoid creating duplicate objects. */
1894 int compileEpoch; /* Holds the current "compilation epoch" for
1895 * this interpreter. This is incremented to
1896 * invalidate existing ByteCodes when, e.g., a
1897 * command with a compile procedure is
1899 Proc *compiledProcPtr; /* If a procedure is being compiled, a pointer
1900 * to its Proc structure; otherwise, this is
1901 * NULL. Set by ObjInterpProc in tclProc.c and
1902 * used by tclCompile.c to process local
1903 * variables appropriately. */
1904 ResolverScheme *resolverPtr;
1905 /* Linked list of name resolution schemes
1906 * added to this interpreter. Schemes are
1907 * added and removed by calling
1908 * Tcl_AddInterpResolvers and
1909 * Tcl_RemoveInterpResolver respectively. */
1910 Tcl_Obj *scriptFile; /* NULL means there is no nested source
1911 * command active; otherwise this points to
1912 * pathPtr of the file being sourced. */
1913 int flags; /* Various flag bits. See below. */
1914 long randSeed; /* Seed used for rand() function. */
1915 Trace *tracePtr; /* List of traces for this interpreter. */
1916 Tcl_HashTable *assocData; /* Hash table for associating data with this
1917 * interpreter. Cleaned up when this
1918 * interpreter is deleted. */
1919 struct ExecEnv *execEnvPtr; /* Execution environment for Tcl bytecode
1920 * execution. Contains a pointer to the Tcl
1921 * evaluation stack. */
1922 Tcl_Obj *emptyObjPtr; /* Points to an object holding an empty
1923 * string. Returned by Tcl_ObjSetVar2 when
1924 * variable traces change a variable in a
1926 char resultSpace[TCL_RESULT_SIZE+1];
1927 /* Static space holding small results. */
1928 Tcl_Obj *objResultPtr; /* If the last command returned an object
1929 * result, this points to it. Should not be
1930 * accessed directly; see comment above. */
1931 Tcl_ThreadId threadId; /* ID of thread that owns the interpreter. */
1933 ActiveCommandTrace *activeCmdTracePtr;
1934 /* First in list of active command traces for
1935 * interp, or NULL if no active traces. */
1936 ActiveInterpTrace *activeInterpTracePtr;
1937 /* First in list of active traces for interp,
1938 * or NULL if no active traces. */
1940 int tracesForbiddingInline; /* Count of traces (in the list headed by
1941 * tracePtr) that forbid inline bytecode
1945 * Fields used to manage extensible return options (TIP 90).
1948 Tcl_Obj *returnOpts; /* A dictionary holding the options to the
1949 * last [return] command. */
1951 Tcl_Obj *errorInfo; /* errorInfo value (now as a Tcl_Obj). */
1952 Tcl_Obj *eiVar; /* cached ref to ::errorInfo variable. */
1953 Tcl_Obj *errorCode; /* errorCode value (now as a Tcl_Obj). */
1954 Tcl_Obj *ecVar; /* cached ref to ::errorInfo variable. */
1955 int returnLevel; /* [return -level] parameter. */
1958 * Resource limiting framework support (TIP#143).
1962 int active; /* Flag values defining which limits have been
1964 int granularityTicker; /* Counter used to determine how often to
1965 * check the limits. */
1966 int exceeded; /* Which limits have been exceeded, described
1967 * as flag values the same as the 'active'
1970 int cmdCount; /* Limit for how many commands to execute in
1971 * the interpreter. */
1972 LimitHandler *cmdHandlers;
1973 /* Handlers to execute when the limit is
1975 int cmdGranularity; /* Mod factor used to determine how often to
1976 * evaluate the limit check. */
1978 Tcl_Time time; /* Time limit for execution within the
1980 LimitHandler *timeHandlers;
1981 /* Handlers to execute when the limit is
1983 int timeGranularity; /* Mod factor used to determine how often to
1984 * evaluate the limit check. */
1985 Tcl_TimerToken timeEvent;
1986 /* Handle for a timer callback that will occur
1987 * when the time-limit is exceeded. */
1989 Tcl_HashTable callbacks;/* Mapping from (interp,type) pair to data
1990 * used to install a limit handler callback to
1991 * run in _this_ interp when the limit is
1996 * Information for improved default error generation from ensembles
2001 Tcl_Obj *const *sourceObjs;
2002 /* What arguments were actually input into the
2003 * *root* ensemble command? (Nested ensembles
2004 * don't rewrite this.) NULL if we're not
2005 * processing an ensemble. */
2006 int numRemovedObjs; /* How many arguments have been stripped off
2007 * because of ensemble processing. */
2008 int numInsertedObjs; /* How many of the current arguments were
2009 * inserted by an ensemble. */
2013 * TIP #219: Global info for the I/O system.
2016 Tcl_Obj *chanMsg; /* Error message set by channel drivers, for
2017 * the propagation of arbitrary Tcl errors.
2018 * This information, if present (chanMsg not
2019 * NULL), takes precedence over a POSIX error
2020 * code returned by a channel operation. */
2023 * Source code origin information (TIP #280).
2026 CmdFrame *cmdFramePtr; /* Points to the command frame containing the
2027 * location information for the current
2029 const CmdFrame *invokeCmdFramePtr;
2030 /* Points to the command frame which is the
2031 * invoking context of the bytecode compiler.
2032 * NULL when the byte code compiler is not
2034 int invokeWord; /* Index of the word in the command which
2035 * is getting compiled. */
2036 Tcl_HashTable *linePBodyPtr;/* This table remembers for each statically
2037 * defined procedure the location information
2038 * for its body. It is keyed by the address of
2039 * the Proc structure for a procedure. The
2040 * values are "struct CmdFrame*". */
2041 Tcl_HashTable *lineBCPtr; /* This table remembers for each ByteCode
2042 * object the location information for its
2043 * body. It is keyed by the address of the
2044 * Proc structure for a procedure. The values
2045 * are "struct ExtCmdLoc*". (See
2047 Tcl_HashTable *lineLABCPtr;
2048 Tcl_HashTable *lineLAPtr; /* This table remembers for each argument of a
2049 * command on the execution stack the index of
2050 * the argument in the command, and the
2051 * location data of the command. It is keyed
2052 * by the address of the Tcl_Obj containing
2053 * the argument. The values are "struct
2054 * CFWord*" (See tclBasic.c). This allows
2055 * commands like uplevel, eval, etc. to find
2056 * location information for their arguments,
2057 * if they are a proper literal argument to an
2058 * invoking command. Alt view: An index to the
2059 * CmdFrame stack keyed by command argument
2061 ContLineLoc *scriptCLLocPtr;/* This table points to the location data for
2062 * invisible continuation lines in the script,
2063 * if any. This pointer is set by the function
2064 * TclEvalObjEx() in file "tclBasic.c", and
2065 * used by function ...() in the same file.
2066 * It does for the eval/direct path of script
2067 * execution what CompileEnv.clLoc does for
2068 * the bytecode compiler.
2071 * TIP #268. The currently active selection mode, i.e. the package require
2075 int packagePrefer; /* Current package selection mode. */
2078 * Hashtables for variable traces and searches.
2081 Tcl_HashTable varTraces; /* Hashtable holding the start of a variable's
2082 * active trace list; varPtr is the key. */
2083 Tcl_HashTable varSearches; /* Hashtable holding the start of a variable's
2084 * active searches list; varPtr is the key. */
2086 * The thread-specific data ekeko: cache pointers or values that
2087 * (a) do not change during the thread's lifetime
2088 * (b) require access to TSD to determine at runtime
2089 * (c) are accessed very often (e.g., at each command call)
2091 * Note that these are the same for all interps in the same thread. They
2092 * just have to be initialised for the thread's parent interp, children
2093 * inherit the value.
2095 * They are used by the macros defined below.
2098 AllocCache *allocCache;
2099 void *pendingObjDataPtr; /* Pointer to the Cache and PendingObjData
2100 * structs for this interp's thread; see
2101 * tclObj.c and tclThreadAlloc.c */
2102 int *asyncReadyPtr; /* Pointer to the asyncReady indicator for
2103 * this interp's thread; see tclAsync.c */
2105 * The pointer to the object system root ekeko. c.f. TIP #257.
2107 void *objectFoundation; /* Pointer to the Foundation structure of the
2108 * object system, which contains things like
2109 * references to key namespaces. See
2110 * tclOOInt.h and tclOO.c for real definition
2113 struct NRE_callback *deferredCallbacks;
2114 /* Callbacks that are set previous to a call
2115 * to some Eval function but that actually
2116 * belong to the command that is about to be
2117 * called - i.e., they should be run *before*
2118 * any tailcall is invoked. */
2121 * TIP #285, Script cancellation support.
2124 Tcl_AsyncHandler asyncCancel;
2125 /* Async handler token for Tcl_CancelEval. */
2126 Tcl_Obj *asyncCancelMsg; /* Error message set by async cancel handler
2127 * for the propagation of arbitrary Tcl
2128 * errors. This information, if present
2129 * (asyncCancelMsg not NULL), takes precedence
2130 * over the default error messages returned by
2131 * a script cancellation operation. */
2134 * TIP #348 IMPLEMENTATION - Substituted error stack
2136 Tcl_Obj *errorStack; /* [info errorstack] value (as a Tcl_Obj). */
2137 Tcl_Obj *upLiteral; /* "UP" literal for [info errorstack] */
2138 Tcl_Obj *callLiteral; /* "CALL" literal for [info errorstack] */
2139 Tcl_Obj *innerLiteral; /* "INNER" literal for [info errorstack] */
2140 Tcl_Obj *innerContext; /* cached list for fast reallocation */
2141 int resetErrorStack; /* controls cleaning up of ::errorStack */
2143 #ifdef TCL_COMPILE_STATS
2145 * Statistical information about the bytecode compiler and interpreter's
2146 * operation. This should be the last field of Interp.
2149 ByteCodeStats stats; /* Holds compilation and execution statistics
2150 * for this interpreter. */
2151 #endif /* TCL_COMPILE_STATS */
2155 * Macros that use the TSD-ekeko.
2158 #define TclAsyncReady(iPtr) \
2159 *((iPtr)->asyncReadyPtr)
2162 * Macros for script cancellation support (TIP #285).
2165 #define TclCanceled(iPtr) \
2166 (((iPtr)->flags & CANCELED) || ((iPtr)->flags & TCL_CANCEL_UNWIND))
2168 #define TclSetCancelFlags(iPtr, cancelFlags) \
2169 (iPtr)->flags |= CANCELED; \
2170 if ((cancelFlags) & TCL_CANCEL_UNWIND) { \
2171 (iPtr)->flags |= TCL_CANCEL_UNWIND; \
2174 #define TclUnsetCancelFlags(iPtr) \
2175 (iPtr)->flags &= (~(CANCELED | TCL_CANCEL_UNWIND))
2178 * Macros for splicing into and out of doubly linked lists. They assume
2179 * existence of struct items 'prevPtr' and 'nextPtr'.
2181 * a = element to add or remove.
2184 * TclSpliceIn adds to the head of the list.
2187 #define TclSpliceIn(a,b) \
2188 (a)->nextPtr = (b); \
2189 if ((b) != NULL) { \
2190 (b)->prevPtr = (a); \
2192 (a)->prevPtr = NULL, (b) = (a);
2194 #define TclSpliceOut(a,b) \
2195 if ((a)->prevPtr != NULL) { \
2196 (a)->prevPtr->nextPtr = (a)->nextPtr; \
2198 (b) = (a)->nextPtr; \
2200 if ((a)->nextPtr != NULL) { \
2201 (a)->nextPtr->prevPtr = (a)->prevPtr; \
2205 * EvalFlag bits for Interp structures:
2207 * TCL_ALLOW_EXCEPTIONS 1 means it's OK for the script to terminate with a
2208 * code other than TCL_OK or TCL_ERROR; 0 means codes
2209 * other than these should be turned into errors.
2212 #define TCL_ALLOW_EXCEPTIONS 0x04
2213 #define TCL_EVAL_FILE 0x02
2214 #define TCL_EVAL_SOURCE_IN_FRAME 0x10
2215 #define TCL_EVAL_NORESOLVE 0x20
2216 #define TCL_EVAL_DISCARD_RESULT 0x40
2219 * Flag bits for Interp structures:
2221 * DELETED: Non-zero means the interpreter has been deleted:
2222 * don't process any more commands for it, and destroy
2223 * the structure as soon as all nested invocations of
2224 * Tcl_Eval are done.
2225 * ERR_ALREADY_LOGGED: Non-zero means information has already been logged in
2226 * iPtr->errorInfo for the current Tcl_Eval instance, so
2227 * Tcl_Eval needn't log it (used to implement the "error
2228 * message log" command).
2229 * DONT_COMPILE_CMDS_INLINE: Non-zero means that the bytecode compiler should
2230 * not compile any commands into an inline sequence of
2231 * instructions. This is set 1, for example, when command
2232 * traces are requested.
2233 * RAND_SEED_INITIALIZED: Non-zero means that the randSeed value of the interp
2234 * has not be initialized. This is set 1 when we first
2235 * use the rand() or srand() functions.
2236 * SAFE_INTERP: Non zero means that the current interp is a safe
2237 * interp (i.e. it has only the safe commands installed,
2238 * less privilege than a regular interp).
2239 * INTERP_DEBUG_FRAME: Used for switching on various extra interpreter
2240 * debug/info mechanisms (e.g. info frame eval/uplevel
2241 * tracing) which are performance intensive.
2242 * INTERP_TRACE_IN_PROGRESS: Non-zero means that an interp trace is currently
2243 * active; so no further trace callbacks should be
2245 * INTERP_ALTERNATE_WRONG_ARGS: Used for listing second and subsequent forms
2246 * of the wrong-num-args string in Tcl_WrongNumArgs.
2247 * Makes it append instead of replacing and uses
2248 * different intermediate text.
2249 * CANCELED: Non-zero means that the script in progress should be
2250 * canceled as soon as possible. This can be checked by
2251 * extensions (and the core itself) by calling
2252 * Tcl_Canceled and checking if TCL_ERROR is returned.
2253 * This is a one-shot flag that is reset immediately upon
2254 * being detected; however, if the TCL_CANCEL_UNWIND flag
2255 * is set Tcl_Canceled will continue to report that the
2256 * script in progress has been canceled thereby allowing
2257 * the evaluation stack for the interp to be fully
2260 * WARNING: For the sake of some extensions that have made use of former
2261 * internal values, do not re-use the flag values 2 (formerly ERR_IN_PROGRESS)
2262 * or 8 (formerly ERROR_CODE_SET).
2266 #define ERR_ALREADY_LOGGED 4
2267 #define INTERP_DEBUG_FRAME 0x10
2268 #define DONT_COMPILE_CMDS_INLINE 0x20
2269 #define RAND_SEED_INITIALIZED 0x40
2270 #define SAFE_INTERP 0x80
2271 #define INTERP_TRACE_IN_PROGRESS 0x200
2272 #define INTERP_ALTERNATE_WRONG_ARGS 0x400
2273 #define ERR_LEGACY_COPY 0x800
2274 #define CANCELED 0x1000
2277 * Maximum number of levels of nesting permitted in Tcl commands (used to
2278 * catch infinite recursion).
2281 #define MAX_NESTING_DEPTH 1000
2284 * The macro below is used to modify a "char" value (e.g. by casting it to an
2285 * unsigned character) so that it can be used safely with macros such as
2289 #define UCHAR(c) ((unsigned char) (c))
2292 * This macro is used to properly align the memory allocated by Tcl, giving
2293 * the same alignment as the native malloc.
2296 #if defined(__APPLE__)
2297 #define TCL_ALLOCALIGN 16
2299 #define TCL_ALLOCALIGN (2*sizeof(void *))
2303 * This macro is used to determine the offset needed to safely allocate any
2304 * data structure in memory. Given a starting offset or size, it "rounds up"
2305 * or "aligns" the offset to the next 8-byte boundary so that any data
2306 * structure can be placed at the resulting offset without fear of an
2309 * WARNING!! DO NOT USE THIS MACRO TO ALIGN POINTERS: it will produce the
2310 * wrong result on platforms that allocate addresses that are divisible by 4
2311 * or 2. Only use it for offsets or sizes.
2313 * This macro is only used by tclCompile.c in the core (Bug 926445). It
2314 * however not be made file static, as extensions that touch bytecodes
2315 * (notably tbcload) require it.
2318 #define TCL_ALIGN(x) (((int)(x) + 7) & ~7)
2321 * The following enum values are used to specify the runtime platform setting
2322 * of the tclPlatform variable.
2326 TCL_PLATFORM_UNIX = 0, /* Any Unix-like OS. */
2327 TCL_PLATFORM_WINDOWS = 2 /* Any Microsoft Windows OS. */
2331 * The following enum values are used to indicate the translation of a Tcl
2332 * channel. Declared here so that each platform can define
2333 * TCL_PLATFORM_TRANSLATION to the native translation on that platform.
2336 typedef enum TclEolTranslation {
2337 TCL_TRANSLATE_AUTO, /* Eol == \r, \n and \r\n. */
2338 TCL_TRANSLATE_CR, /* Eol == \r. */
2339 TCL_TRANSLATE_LF, /* Eol == \n. */
2340 TCL_TRANSLATE_CRLF /* Eol == \r\n. */
2341 } TclEolTranslation;
2344 * Flags for TclInvoke:
2346 * TCL_INVOKE_HIDDEN Invoke a hidden command; if not set, invokes
2347 * an exposed command.
2348 * TCL_INVOKE_NO_UNKNOWN If set, "unknown" is not invoked if the
2349 * command to be invoked is not found. Only has
2350 * an effect if invoking an exposed command,
2351 * i.e. if TCL_INVOKE_HIDDEN is not also set.
2352 * TCL_INVOKE_NO_TRACEBACK Does not record traceback information if the
2353 * invoked command returns an error. Used if the
2354 * caller plans on recording its own traceback
2358 #define TCL_INVOKE_HIDDEN (1<<0)
2359 #define TCL_INVOKE_NO_UNKNOWN (1<<1)
2360 #define TCL_INVOKE_NO_TRACEBACK (1<<2)
2363 * The structure used as the internal representation of Tcl list objects. This
2364 * struct is grown (reallocated and copied) as necessary to hold all the
2365 * list's element pointers. The struct might contain more slots than currently
2366 * used to hold all element pointers. This is done to make append operations
2370 typedef struct List {
2372 int maxElemCount; /* Total number of element array slots. */
2373 int elemCount; /* Current number of list elements. */
2374 int canonicalFlag; /* Set if the string representation was
2375 * derived from the list representation. May
2376 * be ignored if there is no string rep at
2378 Tcl_Obj *elements; /* First list element; the struct is grown to
2379 * accommodate all elements. */
2383 (1 + (int)(((size_t)UINT_MAX - sizeof(List))/sizeof(Tcl_Obj *)))
2384 #define LIST_SIZE(numElems) \
2385 (unsigned)(sizeof(List) + (((numElems) - 1) * sizeof(Tcl_Obj *)))
2388 * Macro used to get the elements of a list object.
2391 #define ListRepPtr(listPtr) \
2392 ((List *) (listPtr)->internalRep.twoPtrValue.ptr1)
2394 /* Not used any more */
2395 #define ListSetIntRep(objPtr, listRepPtr) \
2396 (objPtr)->internalRep.twoPtrValue.ptr1 = (void *)(listRepPtr), \
2397 (objPtr)->internalRep.twoPtrValue.ptr2 = NULL, \
2398 (listRepPtr)->refCount++, \
2399 (objPtr)->typePtr = &tclListType
2401 #define ListObjGetElements(listPtr, objc, objv) \
2402 ((objv) = &(ListRepPtr(listPtr)->elements), \
2403 (objc) = ListRepPtr(listPtr)->elemCount)
2405 #define ListObjLength(listPtr, len) \
2406 ((len) = ListRepPtr(listPtr)->elemCount)
2408 #define ListObjIsCanonical(listPtr) \
2409 (((listPtr)->bytes == NULL) || ListRepPtr(listPtr)->canonicalFlag)
2411 #define TclListObjGetElements(interp, listPtr, objcPtr, objvPtr) \
2412 (((listPtr)->typePtr == &tclListType) \
2413 ? ((ListObjGetElements((listPtr), *(objcPtr), *(objvPtr))), TCL_OK)\
2414 : Tcl_ListObjGetElements((interp), (listPtr), (objcPtr), (objvPtr)))
2416 #define TclListObjLength(interp, listPtr, lenPtr) \
2417 (((listPtr)->typePtr == &tclListType) \
2418 ? ((ListObjLength((listPtr), *(lenPtr))), TCL_OK)\
2419 : Tcl_ListObjLength((interp), (listPtr), (lenPtr)))
2421 #define TclListObjIsCanonical(listPtr) \
2422 (((listPtr)->typePtr == &tclListType) ? ListObjIsCanonical((listPtr)) : 0)
2425 * Modes for collecting (or not) in the implementations of TclNRForeachCmd,
2426 * TclNRLmapCmd and their compilations.
2429 #define TCL_EACH_KEEP_NONE 0 /* Discard iteration result like [foreach] */
2430 #define TCL_EACH_COLLECT 1 /* Collect iteration result like [lmap] */
2433 * Macros providing a faster path to integers: Tcl_GetLongFromObj,
2434 * Tcl_GetIntFromObj and TclGetIntForIndex.
2436 * WARNING: these macros eval their args more than once.
2439 #define TclGetLongFromObj(interp, objPtr, longPtr) \
2440 (((objPtr)->typePtr == &tclIntType) \
2441 ? ((*(longPtr) = (objPtr)->internalRep.longValue), TCL_OK) \
2442 : Tcl_GetLongFromObj((interp), (objPtr), (longPtr)))
2444 #if (LONG_MAX == INT_MAX)
2445 #define TclGetIntFromObj(interp, objPtr, intPtr) \
2446 (((objPtr)->typePtr == &tclIntType) \
2447 ? ((*(intPtr) = (objPtr)->internalRep.longValue), TCL_OK) \
2448 : Tcl_GetIntFromObj((interp), (objPtr), (intPtr)))
2449 #define TclGetIntForIndexM(interp, objPtr, endValue, idxPtr) \
2450 (((objPtr)->typePtr == &tclIntType) \
2451 ? ((*(idxPtr) = (objPtr)->internalRep.longValue), TCL_OK) \
2452 : TclGetIntForIndex((interp), (objPtr), (endValue), (idxPtr)))
2454 #define TclGetIntFromObj(interp, objPtr, intPtr) \
2455 (((objPtr)->typePtr == &tclIntType \
2456 && (objPtr)->internalRep.longValue >= -(Tcl_WideInt)(UINT_MAX) \
2457 && (objPtr)->internalRep.longValue <= (Tcl_WideInt)(UINT_MAX)) \
2458 ? ((*(intPtr) = (objPtr)->internalRep.longValue), TCL_OK) \
2459 : Tcl_GetIntFromObj((interp), (objPtr), (intPtr)))
2460 #define TclGetIntForIndexM(interp, objPtr, endValue, idxPtr) \
2461 (((objPtr)->typePtr == &tclIntType \
2462 && (objPtr)->internalRep.longValue >= INT_MIN \
2463 && (objPtr)->internalRep.longValue <= INT_MAX) \
2464 ? ((*(idxPtr) = (objPtr)->internalRep.longValue), TCL_OK) \
2465 : TclGetIntForIndex((interp), (objPtr), (endValue), (idxPtr)))
2469 * Macro used to save a function call for common uses of
2470 * Tcl_GetWideIntFromObj(). The ANSI C "prototype" is:
2472 * MODULE_SCOPE int TclGetWideIntFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
2473 * Tcl_WideInt *wideIntPtr);
2476 #ifdef TCL_WIDE_INT_IS_LONG
2477 #define TclGetWideIntFromObj(interp, objPtr, wideIntPtr) \
2478 (((objPtr)->typePtr == &tclIntType) \
2479 ? (*(wideIntPtr) = (Tcl_WideInt) \
2480 ((objPtr)->internalRep.longValue), TCL_OK) : \
2481 Tcl_GetWideIntFromObj((interp), (objPtr), (wideIntPtr)))
2482 #else /* !TCL_WIDE_INT_IS_LONG */
2483 #define TclGetWideIntFromObj(interp, objPtr, wideIntPtr) \
2484 (((objPtr)->typePtr == &tclWideIntType) \
2485 ? (*(wideIntPtr) = (objPtr)->internalRep.wideValue, TCL_OK) : \
2486 ((objPtr)->typePtr == &tclIntType) \
2487 ? (*(wideIntPtr) = (Tcl_WideInt) \
2488 ((objPtr)->internalRep.longValue), TCL_OK) : \
2489 Tcl_GetWideIntFromObj((interp), (objPtr), (wideIntPtr)))
2490 #endif /* TCL_WIDE_INT_IS_LONG */
2493 * Flag values for TclTraceDictPath().
2495 * DICT_PATH_READ indicates that all entries on the path must exist but no
2496 * updates will be needed.
2498 * DICT_PATH_UPDATE indicates that we are going to be doing an update at the
2499 * tip of the path, so duplication of shared objects should be done along the
2502 * DICT_PATH_EXISTS indicates that we are performing an existence test and a
2503 * lookup failure should therefore not be an error. If (and only if) this flag
2504 * is set, TclTraceDictPath() will return the special value
2505 * DICT_PATH_NON_EXISTENT if the path is not traceable.
2507 * DICT_PATH_CREATE (which also requires the DICT_PATH_UPDATE bit to be set)
2508 * indicates that we are to create non-existent dictionaries on the path.
2511 #define DICT_PATH_READ 0
2512 #define DICT_PATH_UPDATE 1
2513 #define DICT_PATH_EXISTS 2
2514 #define DICT_PATH_CREATE 5
2516 #define DICT_PATH_NON_EXISTENT ((Tcl_Obj *) (void *) 1)
2519 *----------------------------------------------------------------
2520 * Data structures related to the filesystem internals
2521 *----------------------------------------------------------------
2525 * The version_2 filesystem is private to Tcl. As and when these changes have
2526 * been thoroughly tested and investigated a new public filesystem interface
2527 * will be released. The aim is more versatile virtual filesystem interfaces,
2528 * more efficiency in 'path' manipulation and usage, and cleaner filesystem
2532 #define TCL_FILESYSTEM_VERSION_2 ((Tcl_FSVersion) 0x2)
2533 typedef ClientData (TclFSGetCwdProc2)(ClientData clientData);
2534 typedef int (Tcl_FSLoadFileProc2) (Tcl_Interp *interp, Tcl_Obj *pathPtr,
2535 Tcl_LoadHandle *handlePtr, Tcl_FSUnloadFileProc **unloadProcPtr, int flags);
2538 * The following types are used for getting and storing platform-specific file
2539 * attributes in tclFCmd.c and the various platform-versions of that file.
2540 * This is done to have as much common code as possible in the file attributes
2541 * code. For more information about the callbacks, see TclFileAttrsCmd in
2545 typedef int (TclGetFileAttrProc)(Tcl_Interp *interp, int objIndex,
2546 Tcl_Obj *fileName, Tcl_Obj **attrObjPtrPtr);
2547 typedef int (TclSetFileAttrProc)(Tcl_Interp *interp, int objIndex,
2548 Tcl_Obj *fileName, Tcl_Obj *attrObjPtr);
2550 typedef struct TclFileAttrProcs {
2551 TclGetFileAttrProc *getProc;/* The procedure for getting attrs. */
2552 TclSetFileAttrProc *setProc;/* The procedure for setting attrs. */
2556 * Opaque handle used in pipeline routines to encapsulate platform-dependent
2560 typedef struct TclFile_ *TclFile;
2563 * The "globParameters" argument of the function TclGlob is an or'ed
2564 * combination of the following values:
2567 #define TCL_GLOBMODE_NO_COMPLAIN 1
2568 #define TCL_GLOBMODE_JOIN 2
2569 #define TCL_GLOBMODE_DIR 4
2570 #define TCL_GLOBMODE_TAILS 8
2572 typedef enum Tcl_PathPart {
2580 *----------------------------------------------------------------
2581 * Data structures related to obsolete filesystem hooks
2582 *----------------------------------------------------------------
2585 typedef int (TclStatProc_)(const char *path, struct stat *buf);
2586 typedef int (TclAccessProc_)(const char *path, int mode);
2587 typedef Tcl_Channel (TclOpenFileChannelProc_)(Tcl_Interp *interp,
2588 const char *fileName, const char *modeString, int permissions);
2591 *----------------------------------------------------------------
2592 * Data structures related to procedures
2593 *----------------------------------------------------------------
2596 typedef Tcl_CmdProc *TclCmdProcType;
2597 typedef Tcl_ObjCmdProc *TclObjCmdProcType;
2600 *----------------------------------------------------------------
2601 * Data structures for process-global values.
2602 *----------------------------------------------------------------
2605 typedef void (TclInitProcessGlobalValueProc)(char **valuePtr, int *lengthPtr,
2606 Tcl_Encoding *encodingPtr);
2609 * A ProcessGlobalValue struct exists for each internal value in Tcl that is
2610 * to be shared among several threads. Each thread sees a (Tcl_Obj) copy of
2611 * the value, and the gobal value is kept as a counted string, with epoch and
2612 * mutex control. Each ProcessGlobalValue struct should be a static variable in
2616 typedef struct ProcessGlobalValue {
2617 int epoch; /* Epoch counter to detect changes in the
2619 int numBytes; /* Length of the global string. */
2620 char *value; /* The global string value. */
2621 Tcl_Encoding encoding; /* system encoding when global string was
2623 TclInitProcessGlobalValueProc *proc;
2624 /* A procedure to initialize the global string
2625 * copy when a "get" request comes in before
2626 * any "set" request has been received. */
2627 Tcl_Mutex mutex; /* Enforce orderly access from multiple
2629 Tcl_ThreadDataKey key; /* Key for per-thread data holding the
2630 * (Tcl_Obj) copy for each thread. */
2631 } ProcessGlobalValue;
2634 *----------------------------------------------------------------------
2635 * Flags for TclParseNumber
2636 *----------------------------------------------------------------------
2639 #define TCL_PARSE_DECIMAL_ONLY 1
2640 /* Leading zero doesn't denote octal or
2642 #define TCL_PARSE_OCTAL_ONLY 2
2643 /* Parse octal even without prefix. */
2644 #define TCL_PARSE_HEXADECIMAL_ONLY 4
2645 /* Parse hexadecimal even without prefix. */
2646 #define TCL_PARSE_INTEGER_ONLY 8
2647 /* Disable floating point parsing. */
2648 #define TCL_PARSE_SCAN_PREFIXES 16
2649 /* Use [scan] rules dealing with 0?
2651 #define TCL_PARSE_NO_WHITESPACE 32
2652 /* Reject leading/trailing whitespace. */
2653 #define TCL_PARSE_BINARY_ONLY 64
2654 /* Parse binary even without prefix. */
2657 *----------------------------------------------------------------------
2658 * Type values TclGetNumberFromObj
2659 *----------------------------------------------------------------------
2662 #define TCL_NUMBER_LONG 1
2663 #define TCL_NUMBER_WIDE 2
2664 #define TCL_NUMBER_BIG 3
2665 #define TCL_NUMBER_DOUBLE 4
2666 #define TCL_NUMBER_NAN 5
2669 *----------------------------------------------------------------
2670 * Variables shared among Tcl modules but not used by the outside world.
2671 *----------------------------------------------------------------
2674 MODULE_SCOPE char *tclNativeExecutableName;
2675 MODULE_SCOPE int tclFindExecutableSearchDone;
2676 MODULE_SCOPE char *tclMemDumpFileName;
2677 MODULE_SCOPE TclPlatformType tclPlatform;
2678 MODULE_SCOPE Tcl_NotifierProcs tclNotifierHooks;
2680 MODULE_SCOPE Tcl_Encoding tclIdentityEncoding;
2683 * TIP #233 (Virtualized Time)
2684 * Data for the time hooks, if any.
2687 MODULE_SCOPE Tcl_GetTimeProc *tclGetTimeProcPtr;
2688 MODULE_SCOPE Tcl_ScaleTimeProc *tclScaleTimeProcPtr;
2689 MODULE_SCOPE ClientData tclTimeClientData;
2692 * Variables denoting the Tcl object types defined in the core.
2695 MODULE_SCOPE const Tcl_ObjType tclBignumType;
2696 MODULE_SCOPE const Tcl_ObjType tclBooleanType;
2697 MODULE_SCOPE const Tcl_ObjType tclByteArrayType;
2698 MODULE_SCOPE const Tcl_ObjType tclByteCodeType;
2699 MODULE_SCOPE const Tcl_ObjType tclDoubleType;
2700 MODULE_SCOPE const Tcl_ObjType tclEndOffsetType;
2701 MODULE_SCOPE const Tcl_ObjType tclIntType;
2702 MODULE_SCOPE const Tcl_ObjType tclListType;
2703 MODULE_SCOPE const Tcl_ObjType tclDictType;
2704 MODULE_SCOPE const Tcl_ObjType tclProcBodyType;
2705 MODULE_SCOPE const Tcl_ObjType tclStringType;
2706 MODULE_SCOPE const Tcl_ObjType tclArraySearchType;
2707 MODULE_SCOPE const Tcl_ObjType tclEnsembleCmdType;
2708 #ifndef TCL_WIDE_INT_IS_LONG
2709 MODULE_SCOPE const Tcl_ObjType tclWideIntType;
2711 MODULE_SCOPE const Tcl_ObjType tclRegexpType;
2712 MODULE_SCOPE Tcl_ObjType tclCmdNameType;
2715 * Variables denoting the hash key types defined in the core.
2718 MODULE_SCOPE const Tcl_HashKeyType tclArrayHashKeyType;
2719 MODULE_SCOPE const Tcl_HashKeyType tclOneWordHashKeyType;
2720 MODULE_SCOPE const Tcl_HashKeyType tclStringHashKeyType;
2721 MODULE_SCOPE const Tcl_HashKeyType tclObjHashKeyType;
2724 * The head of the list of free Tcl objects, and the total number of Tcl
2725 * objects ever allocated and freed.
2728 MODULE_SCOPE Tcl_Obj * tclFreeObjList;
2730 #ifdef TCL_COMPILE_STATS
2731 MODULE_SCOPE long tclObjsAlloced;
2732 MODULE_SCOPE long tclObjsFreed;
2733 #define TCL_MAX_SHARED_OBJ_STATS 5
2734 MODULE_SCOPE long tclObjsShared[TCL_MAX_SHARED_OBJ_STATS];
2735 #endif /* TCL_COMPILE_STATS */
2738 * Pointer to a heap-allocated string of length zero that the Tcl core uses as
2739 * the value of an empty string representation for an object. This value is
2740 * shared by all new objects allocated by Tcl_NewObj.
2743 MODULE_SCOPE char * tclEmptyStringRep;
2744 MODULE_SCOPE char tclEmptyString;
2746 enum CheckEmptyStringResult {
2747 TCL_EMPTYSTRING_UNKNOWN = -1, TCL_EMPTYSTRING_NO, TCL_EMPTYSTRING_YES
2751 *----------------------------------------------------------------
2752 * Procedures shared among Tcl modules but not used by the outside world,
2753 * introduced by/for NRE.
2754 *----------------------------------------------------------------
2757 MODULE_SCOPE Tcl_ObjCmdProc TclNRApplyObjCmd;
2758 MODULE_SCOPE Tcl_ObjCmdProc TclNREvalObjCmd;
2759 MODULE_SCOPE Tcl_ObjCmdProc TclNRCatchObjCmd;
2760 MODULE_SCOPE Tcl_ObjCmdProc TclNRExprObjCmd;
2761 MODULE_SCOPE Tcl_ObjCmdProc TclNRForObjCmd;
2762 MODULE_SCOPE Tcl_ObjCmdProc TclNRForeachCmd;
2763 MODULE_SCOPE Tcl_ObjCmdProc TclNRIfObjCmd;
2764 MODULE_SCOPE Tcl_ObjCmdProc TclNRLmapCmd;
2765 MODULE_SCOPE Tcl_ObjCmdProc TclNRPackageObjCmd;
2766 MODULE_SCOPE Tcl_ObjCmdProc TclNRSourceObjCmd;
2767 MODULE_SCOPE Tcl_ObjCmdProc TclNRSubstObjCmd;
2768 MODULE_SCOPE Tcl_ObjCmdProc TclNRSwitchObjCmd;
2769 MODULE_SCOPE Tcl_ObjCmdProc TclNRTryObjCmd;
2770 MODULE_SCOPE Tcl_ObjCmdProc TclNRUplevelObjCmd;
2771 MODULE_SCOPE Tcl_ObjCmdProc TclNRWhileObjCmd;
2773 MODULE_SCOPE Tcl_NRPostProc TclNRForIterCallback;
2774 MODULE_SCOPE Tcl_NRPostProc TclNRCoroutineActivateCallback;
2775 MODULE_SCOPE Tcl_ObjCmdProc TclNRTailcallObjCmd;
2776 MODULE_SCOPE Tcl_NRPostProc TclNRTailcallEval;
2777 MODULE_SCOPE Tcl_ObjCmdProc TclNRCoroutineObjCmd;
2778 MODULE_SCOPE Tcl_ObjCmdProc TclNRYieldObjCmd;
2779 MODULE_SCOPE Tcl_ObjCmdProc TclNRYieldmObjCmd;
2780 MODULE_SCOPE Tcl_ObjCmdProc TclNRYieldToObjCmd;
2781 MODULE_SCOPE Tcl_ObjCmdProc TclNRInvoke;
2782 MODULE_SCOPE Tcl_NRPostProc TclNRReleaseValues;
2784 MODULE_SCOPE void TclSetTailcall(Tcl_Interp *interp, Tcl_Obj *tailcallPtr);
2785 MODULE_SCOPE void TclPushTailcallPoint(Tcl_Interp *interp);
2787 /* These two can be considered for the public api */
2788 MODULE_SCOPE void TclMarkTailcall(Tcl_Interp *interp);
2789 MODULE_SCOPE void TclSkipTailcall(Tcl_Interp *interp);
2792 * This structure holds the data for the various iteration callbacks used to
2793 * NRE the 'for' and 'while' commands. We need a separate structure because we
2794 * have more than the 4 client data entries we can provide directly thorugh
2795 * the callback API. It is the 'word' information which puts us over the
2796 * limit. It is needed because the loop body is argument 4 of 'for' and
2797 * argument 2 of 'while'. Not providing the correct index confuses the #280
2798 * code. We TclSmallAlloc/Free this.
2801 typedef struct ForIterData {
2802 Tcl_Obj *cond; /* Loop condition expression. */
2803 Tcl_Obj *body; /* Loop body. */
2804 Tcl_Obj *next; /* Loop step script, NULL for 'while'. */
2805 const char *msg; /* Error message part. */
2806 int word; /* Index of the body script in the command */
2809 /* TIP #357 - Structure doing the bookkeeping of handles for Tcl_LoadFile
2810 * and Tcl_FindSymbol. This structure corresponds to an opaque
2811 * typedef in tcl.h */
2813 typedef void* TclFindSymbolProc(Tcl_Interp* interp, Tcl_LoadHandle loadHandle,
2814 const char* symbol);
2815 struct Tcl_LoadHandle_ {
2816 ClientData clientData; /* Client data is the load handle in the
2817 * native filesystem if a module was loaded
2818 * there, or an opaque pointer to a structure
2819 * for further bookkeeping on load-from-VFS
2820 * and load-from-memory */
2821 TclFindSymbolProc* findSymbolProcPtr;
2822 /* Procedure that resolves symbols in a
2824 Tcl_FSUnloadFileProc* unloadFileProcPtr;
2825 /* Procedure that unloads a loaded module */
2828 /* Flags for conversion of doubles to digit strings */
2830 #define TCL_DD_SHORTEST 0x4
2831 /* Use the shortest possible string */
2832 #define TCL_DD_STEELE 0x5
2833 /* Use the original Steele&White algorithm */
2834 #define TCL_DD_E_FORMAT 0x2
2835 /* Use a fixed-length string of digits,
2836 * suitable for E format*/
2837 #define TCL_DD_F_FORMAT 0x3
2838 /* Use a fixed number of digits after the
2839 * decimal point, suitable for F format */
2841 #define TCL_DD_SHORTEN_FLAG 0x4
2842 /* Allow return of a shorter digit string
2843 * if it converts losslessly */
2844 #define TCL_DD_NO_QUICK 0x8
2845 /* Debug flag: forbid quick FP conversion */
2847 #define TCL_DD_CONVERSION_TYPE_MASK 0x3
2848 /* Mask to isolate the conversion type */
2849 #define TCL_DD_STEELE0 0x1
2850 /* 'Steele&White' after masking */
2851 #define TCL_DD_SHORTEST0 0x0
2852 /* 'Shortest possible' after masking */
2855 *----------------------------------------------------------------
2856 * Procedures shared among Tcl modules but not used by the outside world:
2857 *----------------------------------------------------------------
2860 MODULE_SCOPE void TclAppendBytesToByteArray(Tcl_Obj *objPtr,
2861 const unsigned char *bytes, int len);
2862 MODULE_SCOPE int TclNREvalCmd(Tcl_Interp *interp, Tcl_Obj *objPtr,
2864 MODULE_SCOPE void TclAdvanceContinuations(int *line, int **next,
2866 MODULE_SCOPE void TclAdvanceLines(int *line, const char *start,
2868 MODULE_SCOPE void TclArgumentEnter(Tcl_Interp *interp,
2869 Tcl_Obj *objv[], int objc, CmdFrame *cf);
2870 MODULE_SCOPE void TclArgumentRelease(Tcl_Interp *interp,
2871 Tcl_Obj *objv[], int objc);
2872 MODULE_SCOPE void TclArgumentBCEnter(Tcl_Interp *interp,
2873 Tcl_Obj *objv[], int objc,
2874 void *codePtr, CmdFrame *cfPtr, int cmd, int pc);
2875 MODULE_SCOPE void TclArgumentBCRelease(Tcl_Interp *interp,
2877 MODULE_SCOPE void TclArgumentGet(Tcl_Interp *interp, Tcl_Obj *obj,
2878 CmdFrame **cfPtrPtr, int *wordPtr);
2879 MODULE_SCOPE double TclBignumToDouble(const mp_int *bignum);
2880 MODULE_SCOPE int TclByteArrayMatch(const unsigned char *string,
2881 int strLen, const unsigned char *pattern,
2882 int ptnLen, int flags);
2883 MODULE_SCOPE double TclCeil(const mp_int *a);
2884 MODULE_SCOPE void TclChannelPreserve(Tcl_Channel chan);
2885 MODULE_SCOPE void TclChannelRelease(Tcl_Channel chan);
2886 MODULE_SCOPE int TclCheckArrayTraces(Tcl_Interp *interp, Var *varPtr,
2887 Var *arrayPtr, Tcl_Obj *name, int index);
2888 MODULE_SCOPE int TclCheckBadOctal(Tcl_Interp *interp,
2890 MODULE_SCOPE int TclCheckEmptyString(Tcl_Obj *objPtr);
2891 MODULE_SCOPE int TclChanCaughtErrorBypass(Tcl_Interp *interp,
2893 MODULE_SCOPE Tcl_ObjCmdProc TclChannelNamesCmd;
2894 MODULE_SCOPE Tcl_NRPostProc TclClearRootEnsemble;
2895 MODULE_SCOPE ContLineLoc *TclContinuationsEnter(Tcl_Obj *objPtr, int num,
2897 MODULE_SCOPE void TclContinuationsEnterDerived(Tcl_Obj *objPtr,
2898 int start, int *clNext);
2899 MODULE_SCOPE ContLineLoc *TclContinuationsGet(Tcl_Obj *objPtr);
2900 MODULE_SCOPE void TclContinuationsCopy(Tcl_Obj *objPtr,
2901 Tcl_Obj *originObjPtr);
2902 MODULE_SCOPE int TclConvertElement(const char *src, int length,
2903 char *dst, int flags);
2904 MODULE_SCOPE Tcl_Command TclCreateObjCommandInNs (
2906 const char *cmdName,
2907 Tcl_Namespace *nsPtr,
2908 Tcl_ObjCmdProc *proc,
2909 ClientData clientData,
2910 Tcl_CmdDeleteProc *deleteProc);
2911 MODULE_SCOPE Tcl_Command TclCreateEnsembleInNs(
2914 Tcl_Namespace *nameNamespacePtr,
2915 Tcl_Namespace *ensembleNamespacePtr,
2917 MODULE_SCOPE void TclDeleteNamespaceVars(Namespace *nsPtr);
2918 MODULE_SCOPE int TclFindDictElement(Tcl_Interp *interp,
2919 const char *dict, int dictLength,
2920 const char **elementPtr, const char **nextPtr,
2921 int *sizePtr, int *literalPtr);
2922 /* TIP #280 - Modified token based evulation, with line information. */
2923 MODULE_SCOPE int TclEvalEx(Tcl_Interp *interp, const char *script,
2924 int numBytes, int flags, int line,
2925 int *clNextOuter, const char *outerScript);
2926 MODULE_SCOPE Tcl_ObjCmdProc TclFileAttrsCmd;
2927 MODULE_SCOPE Tcl_ObjCmdProc TclFileCopyCmd;
2928 MODULE_SCOPE Tcl_ObjCmdProc TclFileDeleteCmd;
2929 MODULE_SCOPE Tcl_ObjCmdProc TclFileLinkCmd;
2930 MODULE_SCOPE Tcl_ObjCmdProc TclFileMakeDirsCmd;
2931 MODULE_SCOPE Tcl_ObjCmdProc TclFileReadLinkCmd;
2932 MODULE_SCOPE Tcl_ObjCmdProc TclFileRenameCmd;
2933 MODULE_SCOPE Tcl_ObjCmdProc TclFileTemporaryCmd;
2934 MODULE_SCOPE void TclCreateLateExitHandler(Tcl_ExitProc *proc,
2935 ClientData clientData);
2936 MODULE_SCOPE void TclDeleteLateExitHandler(Tcl_ExitProc *proc,
2937 ClientData clientData);
2938 MODULE_SCOPE char * TclDStringAppendObj(Tcl_DString *dsPtr,
2940 MODULE_SCOPE char * TclDStringAppendDString(Tcl_DString *dsPtr,
2941 Tcl_DString *toAppendPtr);
2942 MODULE_SCOPE Tcl_Obj * TclDStringToObj(Tcl_DString *dsPtr);
2943 MODULE_SCOPE Tcl_Obj *const * TclFetchEnsembleRoot(Tcl_Interp *interp,
2944 Tcl_Obj *const *objv, int objc, int *objcPtr);
2945 MODULE_SCOPE Tcl_Obj *const *TclEnsembleGetRewriteValues(Tcl_Interp *interp);
2946 MODULE_SCOPE Tcl_Namespace *TclEnsureNamespace(Tcl_Interp *interp,
2947 Tcl_Namespace *namespacePtr);
2949 MODULE_SCOPE void TclFinalizeAllocSubsystem(void);
2950 MODULE_SCOPE void TclFinalizeAsync(void);
2951 MODULE_SCOPE void TclFinalizeDoubleConversion(void);
2952 MODULE_SCOPE void TclFinalizeEncodingSubsystem(void);
2953 MODULE_SCOPE void TclFinalizeEnvironment(void);
2954 MODULE_SCOPE void TclFinalizeEvaluation(void);
2955 MODULE_SCOPE void TclFinalizeExecution(void);
2956 MODULE_SCOPE void TclFinalizeIOSubsystem(void);
2957 MODULE_SCOPE void TclFinalizeFilesystem(void);
2958 MODULE_SCOPE void TclResetFilesystem(void);
2959 MODULE_SCOPE void TclFinalizeLoad(void);
2960 MODULE_SCOPE void TclFinalizeLock(void);
2961 MODULE_SCOPE void TclFinalizeMemorySubsystem(void);
2962 MODULE_SCOPE void TclFinalizeNotifier(void);
2963 MODULE_SCOPE void TclFinalizeObjects(void);
2964 MODULE_SCOPE void TclFinalizePreserve(void);
2965 MODULE_SCOPE void TclFinalizeSynchronization(void);
2966 MODULE_SCOPE void TclFinalizeThreadAlloc(void);
2967 MODULE_SCOPE void TclFinalizeThreadAllocThread(void);
2968 MODULE_SCOPE void TclFinalizeThreadData(int quick);
2969 MODULE_SCOPE void TclFinalizeThreadObjects(void);
2970 MODULE_SCOPE double TclFloor(const mp_int *a);
2971 MODULE_SCOPE void TclFormatNaN(double value, char *buffer);
2972 MODULE_SCOPE int TclFSFileAttrIndex(Tcl_Obj *pathPtr,
2973 const char *attributeName, int *indexPtr);
2974 MODULE_SCOPE Tcl_Command TclNRCreateCommandInNs (
2976 const char *cmdName,
2977 Tcl_Namespace *nsPtr,
2978 Tcl_ObjCmdProc *proc,
2979 Tcl_ObjCmdProc *nreProc,
2980 ClientData clientData,
2981 Tcl_CmdDeleteProc *deleteProc);
2983 MODULE_SCOPE int TclNREvalFile(Tcl_Interp *interp, Tcl_Obj *pathPtr,
2984 const char *encodingName);
2985 MODULE_SCOPE void TclFSUnloadTempFile(Tcl_LoadHandle loadHandle);
2986 MODULE_SCOPE int * TclGetAsyncReadyPtr(void);
2987 MODULE_SCOPE Tcl_Obj * TclGetBgErrorHandler(Tcl_Interp *interp);
2988 MODULE_SCOPE int TclGetChannelFromObj(Tcl_Interp *interp,
2989 Tcl_Obj *objPtr, Tcl_Channel *chanPtr,
2990 int *modePtr, int flags);
2991 MODULE_SCOPE CmdFrame * TclGetCmdFrameForProcedure(Proc *procPtr);
2992 MODULE_SCOPE int TclGetCompletionCodeFromObj(Tcl_Interp *interp,
2993 Tcl_Obj *value, int *code);
2994 MODULE_SCOPE int TclGetNumberFromObj(Tcl_Interp *interp,
2995 Tcl_Obj *objPtr, ClientData *clientDataPtr,
2997 MODULE_SCOPE int TclGetOpenModeEx(Tcl_Interp *interp,
2998 const char *modeString, int *seekFlagPtr,
3000 MODULE_SCOPE Tcl_Obj * TclGetProcessGlobalValue(ProcessGlobalValue *pgvPtr);
3001 MODULE_SCOPE Tcl_Obj * TclGetSourceFromFrame(CmdFrame *cfPtr, int objc,
3002 Tcl_Obj *const objv[]);
3003 MODULE_SCOPE char * TclGetStringStorage(Tcl_Obj *objPtr,
3004 unsigned int *sizePtr);
3005 MODULE_SCOPE int TclGlob(Tcl_Interp *interp, char *pattern,
3006 Tcl_Obj *unquotedPrefix, int globFlags,
3007 Tcl_GlobTypeData *types);
3008 MODULE_SCOPE int TclIncrObj(Tcl_Interp *interp, Tcl_Obj *valuePtr,
3010 MODULE_SCOPE Tcl_Obj * TclIncrObjVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
3011 Tcl_Obj *part2Ptr, Tcl_Obj *incrPtr, int flags);
3012 MODULE_SCOPE int TclInfoExistsCmd(ClientData dummy, Tcl_Interp *interp,
3013 int objc, Tcl_Obj *const objv[]);
3014 MODULE_SCOPE int TclInfoCoroutineCmd(ClientData dummy, Tcl_Interp *interp,
3015 int objc, Tcl_Obj *const objv[]);
3016 MODULE_SCOPE Tcl_Obj * TclInfoFrame(Tcl_Interp *interp, CmdFrame *framePtr);
3017 MODULE_SCOPE int TclInfoGlobalsCmd(ClientData dummy, Tcl_Interp *interp,
3018 int objc, Tcl_Obj *const objv[]);
3019 MODULE_SCOPE int TclInfoLocalsCmd(ClientData dummy, Tcl_Interp *interp,
3020 int objc, Tcl_Obj *const objv[]);
3021 MODULE_SCOPE int TclInfoVarsCmd(ClientData dummy, Tcl_Interp *interp,
3022 int objc, Tcl_Obj *const objv[]);
3023 MODULE_SCOPE void TclInitAlloc(void);
3024 MODULE_SCOPE void TclInitDbCkalloc(void);
3025 MODULE_SCOPE void TclInitDoubleConversion(void);
3026 MODULE_SCOPE void TclInitEmbeddedConfigurationInformation(
3027 Tcl_Interp *interp);
3028 MODULE_SCOPE void TclInitEncodingSubsystem(void);
3029 MODULE_SCOPE void TclInitIOSubsystem(void);
3030 MODULE_SCOPE void TclInitLimitSupport(Tcl_Interp *interp);
3031 MODULE_SCOPE void TclInitNamespaceSubsystem(void);
3032 MODULE_SCOPE void TclInitNotifier(void);
3033 MODULE_SCOPE void TclInitObjSubsystem(void);
3034 MODULE_SCOPE void TclInitSubsystems(void);
3035 MODULE_SCOPE int TclInterpReady(Tcl_Interp *interp);
3036 MODULE_SCOPE int TclIsBareword(int byte);
3037 MODULE_SCOPE Tcl_Obj * TclJoinPath(int elements, Tcl_Obj * const objv[],
3039 MODULE_SCOPE int TclJoinThread(Tcl_ThreadId id, int *result);
3040 MODULE_SCOPE void TclLimitRemoveAllHandlers(Tcl_Interp *interp);
3041 MODULE_SCOPE Tcl_Obj * TclLindexList(Tcl_Interp *interp,
3042 Tcl_Obj *listPtr, Tcl_Obj *argPtr);
3043 MODULE_SCOPE Tcl_Obj * TclLindexFlat(Tcl_Interp *interp, Tcl_Obj *listPtr,
3044 int indexCount, Tcl_Obj *const indexArray[]);
3046 MODULE_SCOPE void TclListLines(Tcl_Obj *listObj, int line, int n,
3047 int *lines, Tcl_Obj *const *elems);
3048 MODULE_SCOPE Tcl_Obj * TclListObjCopy(Tcl_Interp *interp, Tcl_Obj *listPtr);
3049 MODULE_SCOPE Tcl_Obj * TclLsetList(Tcl_Interp *interp, Tcl_Obj *listPtr,
3050 Tcl_Obj *indexPtr, Tcl_Obj *valuePtr);
3051 MODULE_SCOPE Tcl_Obj * TclLsetFlat(Tcl_Interp *interp, Tcl_Obj *listPtr,
3052 int indexCount, Tcl_Obj *const indexArray[],
3054 MODULE_SCOPE Tcl_Command TclMakeEnsemble(Tcl_Interp *interp, const char *name,
3055 const EnsembleImplMap map[]);
3056 MODULE_SCOPE int TclMaxListLength(const char *bytes, int numBytes,
3057 const char **endPtr);
3058 MODULE_SCOPE int TclMergeReturnOptions(Tcl_Interp *interp, int objc,
3059 Tcl_Obj *const objv[], Tcl_Obj **optionsPtrPtr,
3060 int *codePtr, int *levelPtr);
3061 MODULE_SCOPE Tcl_Obj * TclNoErrorStack(Tcl_Interp *interp, Tcl_Obj *options);
3062 MODULE_SCOPE int TclNokia770Doubles(void);
3063 MODULE_SCOPE void TclNsDecrRefCount(Namespace *nsPtr);
3064 MODULE_SCOPE void TclNsDecrRefCount(Namespace *nsPtr);
3065 MODULE_SCOPE int TclNamespaceDeleted(Namespace *nsPtr);
3066 MODULE_SCOPE void TclObjVarErrMsg(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
3067 Tcl_Obj *part2Ptr, const char *operation,
3068 const char *reason, int index);
3069 MODULE_SCOPE int TclObjInvokeNamespace(Tcl_Interp *interp,
3070 int objc, Tcl_Obj *const objv[],
3071 Tcl_Namespace *nsPtr, int flags);
3072 MODULE_SCOPE int TclObjUnsetVar2(Tcl_Interp *interp,
3073 Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, int flags);
3074 MODULE_SCOPE int TclParseBackslash(const char *src,
3075 int numBytes, int *readPtr, char *dst);
3076 MODULE_SCOPE int TclParseNumber(Tcl_Interp *interp, Tcl_Obj *objPtr,
3077 const char *expected, const char *bytes,
3078 int numBytes, const char **endPtrPtr, int flags);
3079 MODULE_SCOPE void TclParseInit(Tcl_Interp *interp, const char *string,
3080 int numBytes, Tcl_Parse *parsePtr);
3081 MODULE_SCOPE int TclParseAllWhiteSpace(const char *src, int numBytes);
3082 MODULE_SCOPE int TclProcessReturn(Tcl_Interp *interp,
3083 int code, int level, Tcl_Obj *returnOpts);
3084 MODULE_SCOPE int TclpObjLstat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf);
3085 MODULE_SCOPE Tcl_Obj * TclpTempFileName(void);
3086 MODULE_SCOPE Tcl_Obj * TclpTempFileNameForLibrary(Tcl_Interp *interp, Tcl_Obj* pathPtr);
3087 MODULE_SCOPE Tcl_Obj * TclNewFSPathObj(Tcl_Obj *dirPtr, const char *addStrRep,
3089 MODULE_SCOPE int TclpDeleteFile(const void *path);
3090 MODULE_SCOPE void TclpFinalizeCondition(Tcl_Condition *condPtr);
3091 MODULE_SCOPE void TclpFinalizeMutex(Tcl_Mutex *mutexPtr);
3092 MODULE_SCOPE void TclpFinalizePipes(void);
3093 MODULE_SCOPE void TclpFinalizeSockets(void);
3094 MODULE_SCOPE int TclCreateSocketAddress(Tcl_Interp *interp,
3095 struct addrinfo **addrlist,
3096 const char *host, int port, int willBind,
3097 const char **errorMsgPtr);
3098 MODULE_SCOPE int TclpThreadCreate(Tcl_ThreadId *idPtr,
3099 Tcl_ThreadCreateProc *proc, ClientData clientData,
3100 int stackSize, int flags);
3101 MODULE_SCOPE int TclpFindVariable(const char *name, int *lengthPtr);
3102 MODULE_SCOPE void TclpInitLibraryPath(char **valuePtr,
3103 int *lengthPtr, Tcl_Encoding *encodingPtr);
3104 MODULE_SCOPE void TclpInitLock(void);
3105 MODULE_SCOPE void TclpInitPlatform(void);
3106 MODULE_SCOPE void TclpInitUnlock(void);
3107 MODULE_SCOPE Tcl_Obj * TclpObjListVolumes(void);
3108 MODULE_SCOPE void TclpGlobalLock(void);
3109 MODULE_SCOPE void TclpGlobalUnlock(void);
3110 MODULE_SCOPE int TclpMatchFiles(Tcl_Interp *interp, char *separators,
3111 Tcl_DString *dirPtr, char *pattern, char *tail);
3112 MODULE_SCOPE int TclpObjNormalizePath(Tcl_Interp *interp,
3113 Tcl_Obj *pathPtr, int nextCheckpoint);
3114 MODULE_SCOPE void TclpNativeJoinPath(Tcl_Obj *prefix, const char *joining);
3115 MODULE_SCOPE Tcl_Obj * TclpNativeSplitPath(Tcl_Obj *pathPtr, int *lenPtr);
3116 MODULE_SCOPE Tcl_PathType TclpGetNativePathType(Tcl_Obj *pathPtr,
3117 int *driveNameLengthPtr, Tcl_Obj **driveNameRef);
3118 MODULE_SCOPE int TclCrossFilesystemCopy(Tcl_Interp *interp,
3119 Tcl_Obj *source, Tcl_Obj *target);
3120 MODULE_SCOPE int TclpMatchInDirectory(Tcl_Interp *interp,
3121 Tcl_Obj *resultPtr, Tcl_Obj *pathPtr,
3122 const char *pattern, Tcl_GlobTypeData *types);
3123 MODULE_SCOPE ClientData TclpGetNativeCwd(ClientData clientData);
3124 MODULE_SCOPE Tcl_FSDupInternalRepProc TclNativeDupInternalRep;
3125 MODULE_SCOPE Tcl_Obj * TclpObjLink(Tcl_Obj *pathPtr, Tcl_Obj *toPtr,
3127 MODULE_SCOPE int TclpObjChdir(Tcl_Obj *pathPtr);
3128 MODULE_SCOPE Tcl_Channel TclpOpenTemporaryFile(Tcl_Obj *dirObj,
3129 Tcl_Obj *basenameObj, Tcl_Obj *extensionObj,
3130 Tcl_Obj *resultingNameObj);
3131 MODULE_SCOPE Tcl_Obj * TclPathPart(Tcl_Interp *interp, Tcl_Obj *pathPtr,
3132 Tcl_PathPart portion);
3133 MODULE_SCOPE char * TclpReadlink(const char *fileName,
3134 Tcl_DString *linkPtr);
3135 MODULE_SCOPE void TclpSetVariables(Tcl_Interp *interp);
3136 MODULE_SCOPE void * TclThreadStorageKeyGet(Tcl_ThreadDataKey *keyPtr);
3137 MODULE_SCOPE void TclThreadStorageKeySet(Tcl_ThreadDataKey *keyPtr,
3139 MODULE_SCOPE void TclpThreadExit(int status);
3140 MODULE_SCOPE void TclRememberCondition(Tcl_Condition *mutex);
3141 MODULE_SCOPE void TclRememberJoinableThread(Tcl_ThreadId id);
3142 MODULE_SCOPE void TclRememberMutex(Tcl_Mutex *mutex);
3143 MODULE_SCOPE void TclRemoveScriptLimitCallbacks(Tcl_Interp *interp);
3144 MODULE_SCOPE int TclReToGlob(Tcl_Interp *interp, const char *reStr,
3145 int reStrLen, Tcl_DString *dsPtr, int *flagsPtr,
3146 int *quantifiersFoundPtr);
3147 MODULE_SCOPE int TclScanElement(const char *string, int length,
3149 MODULE_SCOPE void TclSetBgErrorHandler(Tcl_Interp *interp,
3150 Tcl_Obj *cmdPrefix);
3151 MODULE_SCOPE void TclSetBignumInternalRep(Tcl_Obj *objPtr,
3152 mp_int *bignumValue);
3153 MODULE_SCOPE int TclSetBooleanFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
3154 MODULE_SCOPE void TclSetCmdNameObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
3156 MODULE_SCOPE void TclSetDuplicateObj(Tcl_Obj *dupPtr, Tcl_Obj *objPtr);
3157 MODULE_SCOPE void TclSetProcessGlobalValue(ProcessGlobalValue *pgvPtr,
3158 Tcl_Obj *newValue, Tcl_Encoding encoding);
3159 MODULE_SCOPE void TclSignalExitThread(Tcl_ThreadId id, int result);
3160 MODULE_SCOPE void TclSpellFix(Tcl_Interp *interp,
3161 Tcl_Obj *const *objv, int objc, int subIdx,
3162 Tcl_Obj *bad, Tcl_Obj *fix);
3163 MODULE_SCOPE void * TclStackRealloc(Tcl_Interp *interp, void *ptr,
3166 typedef int (*memCmpFn_t)(const void*, const void*, size_t);
3167 MODULE_SCOPE int TclStringCmp (Tcl_Obj *value1Ptr, Tcl_Obj *value2Ptr,
3168 int checkEq, int nocase, int reqlength);
3169 MODULE_SCOPE int TclStringCmpOpts (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[],
3170 int *nocase, int *reqlength);
3171 MODULE_SCOPE int TclStringMatch(const char *str, int strLen,
3172 const char *pattern, int ptnLen, int flags);
3173 MODULE_SCOPE int TclStringMatchObj(Tcl_Obj *stringObj,
3174 Tcl_Obj *patternObj, int flags);
3175 MODULE_SCOPE Tcl_Obj * TclStringReverse(Tcl_Obj *objPtr);
3176 MODULE_SCOPE void TclSubstCompile(Tcl_Interp *interp, const char *bytes,
3177 int numBytes, int flags, int line,
3178 struct CompileEnv *envPtr);
3179 MODULE_SCOPE int TclSubstOptions(Tcl_Interp *interp, int numOpts,
3180 Tcl_Obj *const opts[], int *flagPtr);
3181 MODULE_SCOPE void TclSubstParse(Tcl_Interp *interp, const char *bytes,
3182 int numBytes, int flags, Tcl_Parse *parsePtr,
3183 Tcl_InterpState *statePtr);
3184 MODULE_SCOPE int TclSubstTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr,
3185 int count, int *tokensLeftPtr, int line,
3186 int *clNextOuter, const char *outerScript);
3187 MODULE_SCOPE int TclTrim(const char *bytes, int numBytes,
3188 const char *trim, int numTrim, int *trimRight);
3189 MODULE_SCOPE int TclTrimLeft(const char *bytes, int numBytes,
3190 const char *trim, int numTrim);
3191 MODULE_SCOPE int TclTrimRight(const char *bytes, int numBytes,
3192 const char *trim, int numTrim);
3193 MODULE_SCOPE int TclUtfCasecmp(const char *cs, const char *ct);
3194 MODULE_SCOPE int TclUtfToUCS4(const char *, int *);
3195 MODULE_SCOPE int TclUCS4ToUtf(int, char *);
3196 MODULE_SCOPE int TclUCS4ToLower(int ch);
3197 #if TCL_UTF_MAX == 4
3198 MODULE_SCOPE int TclGetUCS4(Tcl_Obj *, int);
3199 MODULE_SCOPE int TclUniCharToUCS4(const Tcl_UniChar *, int *);
3201 # define TclGetUCS4 Tcl_GetUniChar
3202 # define TclUniCharToUCS4(src, ptr) (*ptr = *(src),1)
3206 * Bytes F0-F4 are start-bytes for 4-byte sequences.
3207 * Byte 0xED can be the start-byte of an upper surrogate. In that case,
3208 * TclUtfToUCS4() might read the lower surrogate following it too.
3210 # define TclUCS4Complete(src, length) (((unsigned)(UCHAR(*(src)) - 0xF0) < 5) \
3211 ? ((length) >= 4) : (UCHAR(*(src)) == 0xED) ? ((length) >= 6) : Tcl_UtfCharComplete((src), (length)))
3212 MODULE_SCOPE Tcl_Obj * TclpNativeToNormalized(ClientData clientData);
3213 MODULE_SCOPE Tcl_Obj * TclpFilesystemPathType(Tcl_Obj *pathPtr);
3214 MODULE_SCOPE int TclpDlopen(Tcl_Interp *interp, Tcl_Obj *pathPtr,
3215 Tcl_LoadHandle *loadHandle,
3216 Tcl_FSUnloadFileProc **unloadProcPtr, int flags);
3217 MODULE_SCOPE int TclpUtime(Tcl_Obj *pathPtr, struct utimbuf *tval);
3218 #ifdef TCL_LOAD_FROM_MEMORY
3219 MODULE_SCOPE void * TclpLoadMemoryGetBuffer(Tcl_Interp *interp, int size);
3220 MODULE_SCOPE int TclpLoadMemory(Tcl_Interp *interp, void *buffer,
3221 int size, int codeSize, Tcl_LoadHandle *loadHandle,
3222 Tcl_FSUnloadFileProc **unloadProcPtr, int flags);
3224 MODULE_SCOPE void TclInitThreadStorage(void);
3225 MODULE_SCOPE void TclFinalizeThreadDataThread(void);
3226 MODULE_SCOPE void TclFinalizeThreadStorage(void);
3228 /* TclWideMUInt -- wide integer used for measurement calculations: */
3229 #if (!defined(_WIN32) || !defined(_MSC_VER) || (_MSC_VER >= 1400))
3230 # define TclWideMUInt Tcl_WideUInt
3232 /* older MSVS may not allow conversions between unsigned __int64 and double) */
3233 # define TclWideMUInt Tcl_WideInt
3235 #ifdef TCL_WIDE_CLICKS
3236 MODULE_SCOPE Tcl_WideInt TclpGetWideClicks(void);
3237 MODULE_SCOPE double TclpWideClicksToNanoseconds(Tcl_WideInt clicks);
3238 MODULE_SCOPE double TclpWideClickInMicrosec(void);
3241 # define TCL_WIDE_CLICKS 1
3242 MODULE_SCOPE Tcl_WideInt TclpGetWideClicks(void);
3243 MODULE_SCOPE double TclpWideClickInMicrosec(void);
3244 # define TclpWideClicksToNanoseconds(clicks) \
3245 ((double)(clicks) * TclpWideClickInMicrosec() * 1000)
3248 MODULE_SCOPE Tcl_WideInt TclpGetMicroseconds(void);
3250 MODULE_SCOPE int TclZlibInit(Tcl_Interp *interp);
3251 MODULE_SCOPE void * TclpThreadCreateKey(void);
3252 MODULE_SCOPE void TclpThreadDeleteKey(void *keyPtr);
3253 MODULE_SCOPE void TclpThreadSetGlobalTSD(void *tsdKeyPtr, void *ptr);
3254 MODULE_SCOPE void * TclpThreadGetGlobalTSD(void *tsdKeyPtr);
3256 MODULE_SCOPE void TclErrorStackResetIf(Tcl_Interp *interp, const char *msg, int length);
3259 * Many parsing tasks need a common definition of whitespace.
3260 * Use this routine and macro to achieve that and place
3261 * optimization (fragile on changes) in one place.
3264 MODULE_SCOPE int TclIsSpaceProc(int byte);
3265 # define TclIsSpaceProcM(byte) \
3266 (((byte) > 0x20) ? 0 : TclIsSpaceProc(byte))
3269 *----------------------------------------------------------------
3270 * Command procedures in the generic core:
3271 *----------------------------------------------------------------
3274 MODULE_SCOPE int Tcl_AfterObjCmd(ClientData clientData,
3275 Tcl_Interp *interp, int objc,
3276 Tcl_Obj *const objv[]);
3277 MODULE_SCOPE int Tcl_AppendObjCmd(ClientData clientData,
3278 Tcl_Interp *interp, int objc,
3279 Tcl_Obj *const objv[]);
3280 MODULE_SCOPE int Tcl_ApplyObjCmd(ClientData clientData,
3281 Tcl_Interp *interp, int objc,
3282 Tcl_Obj *const objv[]);
3283 MODULE_SCOPE Tcl_Command TclInitArrayCmd(Tcl_Interp *interp);
3284 MODULE_SCOPE Tcl_Command TclInitBinaryCmd(Tcl_Interp *interp);
3285 MODULE_SCOPE int Tcl_BreakObjCmd(ClientData clientData,
3286 Tcl_Interp *interp, int objc,
3287 Tcl_Obj *const objv[]);
3288 MODULE_SCOPE int Tcl_CaseObjCmd(ClientData clientData,
3289 Tcl_Interp *interp, int objc,
3290 Tcl_Obj *const objv[]);
3291 MODULE_SCOPE int Tcl_CatchObjCmd(ClientData clientData,
3292 Tcl_Interp *interp, int objc,
3293 Tcl_Obj *const objv[]);
3294 MODULE_SCOPE int Tcl_CdObjCmd(ClientData clientData,
3295 Tcl_Interp *interp, int objc,
3296 Tcl_Obj *const objv[]);
3297 MODULE_SCOPE Tcl_Command TclInitChanCmd(Tcl_Interp *interp);
3298 MODULE_SCOPE int TclChanCreateObjCmd(ClientData clientData,
3299 Tcl_Interp *interp, int objc,
3300 Tcl_Obj *const objv[]);
3301 MODULE_SCOPE int TclChanPostEventObjCmd(ClientData clientData,
3302 Tcl_Interp *interp, int objc,
3303 Tcl_Obj *const objv[]);
3304 MODULE_SCOPE int TclChanPopObjCmd(ClientData clientData,
3305 Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
3306 MODULE_SCOPE int TclChanPushObjCmd(ClientData clientData,
3307 Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
3308 MODULE_SCOPE void TclClockInit(Tcl_Interp *interp);
3309 MODULE_SCOPE int TclClockOldscanObjCmd(
3310 ClientData clientData, Tcl_Interp *interp,
3311 int objc, Tcl_Obj *const objv[]);
3312 MODULE_SCOPE int Tcl_CloseObjCmd(ClientData clientData,
3313 Tcl_Interp *interp, int objc,
3314 Tcl_Obj *const objv[]);
3315 MODULE_SCOPE int Tcl_ConcatObjCmd(ClientData clientData,
3316 Tcl_Interp *interp, int objc,
3317 Tcl_Obj *const objv[]);
3318 MODULE_SCOPE int Tcl_ContinueObjCmd(ClientData clientData,
3319 Tcl_Interp *interp, int objc,
3320 Tcl_Obj *const objv[]);
3321 MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
3322 Tcl_Time *timePtr, Tcl_TimerProc *proc,
3323 ClientData clientData);
3324 MODULE_SCOPE int TclDefaultBgErrorHandlerObjCmd(
3325 ClientData clientData, Tcl_Interp *interp,
3326 int objc, Tcl_Obj *const objv[]);
3327 MODULE_SCOPE Tcl_Command TclInitDictCmd(Tcl_Interp *interp);
3328 MODULE_SCOPE int TclDictWithFinish(Tcl_Interp *interp, Var *varPtr,
3329 Var *arrayPtr, Tcl_Obj *part1Ptr,
3330 Tcl_Obj *part2Ptr, int index, int pathc,
3331 Tcl_Obj *const pathv[], Tcl_Obj *keysPtr);
3332 MODULE_SCOPE Tcl_Obj * TclDictWithInit(Tcl_Interp *interp, Tcl_Obj *dictPtr,
3333 int pathc, Tcl_Obj *const pathv[]);
3334 MODULE_SCOPE int Tcl_DisassembleObjCmd(ClientData clientData,
3335 Tcl_Interp *interp, int objc,
3336 Tcl_Obj *const objv[]);
3338 /* Assemble command function */
3339 MODULE_SCOPE int Tcl_AssembleObjCmd(ClientData clientData,
3340 Tcl_Interp *interp, int objc,
3341 Tcl_Obj *const objv[]);
3342 MODULE_SCOPE int TclNRAssembleObjCmd(ClientData clientData,
3343 Tcl_Interp *interp, int objc,
3344 Tcl_Obj *const objv[]);
3345 MODULE_SCOPE Tcl_Command TclInitEncodingCmd(Tcl_Interp *interp);
3346 MODULE_SCOPE int TclMakeEncodingCommandSafe(Tcl_Interp *interp);
3347 MODULE_SCOPE int Tcl_EofObjCmd(ClientData clientData,
3348 Tcl_Interp *interp, int objc,
3349 Tcl_Obj *const objv[]);
3350 MODULE_SCOPE int Tcl_ErrorObjCmd(ClientData clientData,
3351 Tcl_Interp *interp, int objc,
3352 Tcl_Obj *const objv[]);
3353 MODULE_SCOPE int Tcl_EvalObjCmd(ClientData clientData,
3354 Tcl_Interp *interp, int objc,
3355 Tcl_Obj *const objv[]);
3356 MODULE_SCOPE int Tcl_ExecObjCmd(ClientData clientData,
3357 Tcl_Interp *interp, int objc,
3358 Tcl_Obj *const objv[]);
3359 MODULE_SCOPE int Tcl_ExitObjCmd(ClientData clientData,
3360 Tcl_Interp *interp, int objc,
3361 Tcl_Obj *const objv[]);
3362 MODULE_SCOPE int Tcl_ExprObjCmd(ClientData clientData,
3363 Tcl_Interp *interp, int objc,
3364 Tcl_Obj *const objv[]);
3365 MODULE_SCOPE int Tcl_FblockedObjCmd(ClientData clientData,
3366 Tcl_Interp *interp, int objc,
3367 Tcl_Obj *const objv[]);
3368 MODULE_SCOPE int Tcl_FconfigureObjCmd(
3369 ClientData clientData, Tcl_Interp *interp,
3370 int objc, Tcl_Obj *const objv[]);
3371 MODULE_SCOPE int Tcl_FcopyObjCmd(ClientData dummy,
3372 Tcl_Interp *interp, int objc,
3373 Tcl_Obj *const objv[]);
3374 MODULE_SCOPE Tcl_Command TclInitFileCmd(Tcl_Interp *interp);
3375 MODULE_SCOPE int TclMakeFileCommandSafe(Tcl_Interp *interp);
3376 MODULE_SCOPE int Tcl_FileEventObjCmd(ClientData clientData,
3377 Tcl_Interp *interp, int objc,
3378 Tcl_Obj *const objv[]);
3379 MODULE_SCOPE int Tcl_FlushObjCmd(ClientData clientData,
3380 Tcl_Interp *interp, int objc,
3381 Tcl_Obj *const objv[]);
3382 MODULE_SCOPE int Tcl_ForObjCmd(ClientData clientData,
3383 Tcl_Interp *interp, int objc,
3384 Tcl_Obj *const objv[]);
3385 MODULE_SCOPE int Tcl_ForeachObjCmd(ClientData clientData,
3386 Tcl_Interp *interp, int objc,
3387 Tcl_Obj *const objv[]);
3388 MODULE_SCOPE int Tcl_FormatObjCmd(ClientData dummy,
3389 Tcl_Interp *interp, int objc,
3390 Tcl_Obj *const objv[]);
3391 MODULE_SCOPE int Tcl_GetsObjCmd(ClientData clientData,
3392 Tcl_Interp *interp, int objc,
3393 Tcl_Obj *const objv[]);
3394 MODULE_SCOPE int Tcl_GlobalObjCmd(ClientData clientData,
3395 Tcl_Interp *interp, int objc,
3396 Tcl_Obj *const objv[]);
3397 MODULE_SCOPE int Tcl_GlobObjCmd(ClientData clientData,
3398 Tcl_Interp *interp, int objc,
3399 Tcl_Obj *const objv[]);
3400 MODULE_SCOPE int Tcl_IfObjCmd(ClientData clientData,
3401 Tcl_Interp *interp, int objc,
3402 Tcl_Obj *const objv[]);
3403 MODULE_SCOPE int Tcl_IncrObjCmd(ClientData clientData,
3404 Tcl_Interp *interp, int objc,
3405 Tcl_Obj *const objv[]);
3406 MODULE_SCOPE Tcl_Command TclInitInfoCmd(Tcl_Interp *interp);
3407 MODULE_SCOPE int Tcl_InterpObjCmd(ClientData clientData,
3408 Tcl_Interp *interp, int argc,
3409 Tcl_Obj *const objv[]);
3410 MODULE_SCOPE int Tcl_JoinObjCmd(ClientData clientData,
3411 Tcl_Interp *interp, int objc,
3412 Tcl_Obj *const objv[]);
3413 MODULE_SCOPE int Tcl_LappendObjCmd(ClientData clientData,
3414 Tcl_Interp *interp, int objc,
3415 Tcl_Obj *const objv[]);
3416 MODULE_SCOPE int Tcl_LassignObjCmd(ClientData clientData,
3417 Tcl_Interp *interp, int objc,
3418 Tcl_Obj *const objv[]);
3419 MODULE_SCOPE int Tcl_LindexObjCmd(ClientData clientData,
3420 Tcl_Interp *interp, int objc,
3421 Tcl_Obj *const objv[]);
3422 MODULE_SCOPE int Tcl_LinsertObjCmd(ClientData clientData,
3423 Tcl_Interp *interp, int objc,
3424 Tcl_Obj *const objv[]);
3425 MODULE_SCOPE int Tcl_LlengthObjCmd(ClientData clientData,
3426 Tcl_Interp *interp, int objc,
3427 Tcl_Obj *const objv[]);
3428 MODULE_SCOPE int Tcl_ListObjCmd(ClientData clientData,
3429 Tcl_Interp *interp, int objc,
3430 Tcl_Obj *const objv[]);
3431 MODULE_SCOPE int Tcl_LmapObjCmd(ClientData clientData,
3432 Tcl_Interp *interp, int objc,
3433 Tcl_Obj *const objv[]);
3434 MODULE_SCOPE int Tcl_LoadObjCmd(ClientData clientData,
3435 Tcl_Interp *interp, int objc,
3436 Tcl_Obj *const objv[]);
3437 MODULE_SCOPE int Tcl_LrangeObjCmd(ClientData clientData,
3438 Tcl_Interp *interp, int objc,
3439 Tcl_Obj *const objv[]);
3440 MODULE_SCOPE int Tcl_LrepeatObjCmd(ClientData clientData,
3441 Tcl_Interp *interp, int objc,
3442 Tcl_Obj *const objv[]);
3443 MODULE_SCOPE int Tcl_LreplaceObjCmd(ClientData clientData,
3444 Tcl_Interp *interp, int objc,
3445 Tcl_Obj *const objv[]);
3446 MODULE_SCOPE int Tcl_LreverseObjCmd(ClientData clientData,
3447 Tcl_Interp *interp, int objc,
3448 Tcl_Obj *const objv[]);
3449 MODULE_SCOPE int Tcl_LsearchObjCmd(ClientData clientData,
3450 Tcl_Interp *interp, int objc,
3451 Tcl_Obj *const objv[]);
3452 MODULE_SCOPE int Tcl_LsetObjCmd(ClientData clientData,
3453 Tcl_Interp *interp, int objc,
3454 Tcl_Obj *const objv[]);
3455 MODULE_SCOPE int Tcl_LsortObjCmd(ClientData clientData,
3456 Tcl_Interp *interp, int objc,
3457 Tcl_Obj *const objv[]);
3458 MODULE_SCOPE Tcl_Command TclInitNamespaceCmd(Tcl_Interp *interp);
3459 MODULE_SCOPE int TclNamespaceEnsembleCmd(ClientData dummy,
3460 Tcl_Interp *interp, int objc,
3461 Tcl_Obj *const objv[]);
3462 MODULE_SCOPE int Tcl_OpenObjCmd(ClientData clientData,
3463 Tcl_Interp *interp, int objc,
3464 Tcl_Obj *const objv[]);
3465 MODULE_SCOPE int Tcl_PackageObjCmd(ClientData clientData,
3466 Tcl_Interp *interp, int objc,
3467 Tcl_Obj *const objv[]);
3468 MODULE_SCOPE int Tcl_PidObjCmd(ClientData clientData,
3469 Tcl_Interp *interp, int objc,
3470 Tcl_Obj *const objv[]);
3471 MODULE_SCOPE Tcl_Command TclInitPrefixCmd(Tcl_Interp *interp);
3472 MODULE_SCOPE int Tcl_PutsObjCmd(ClientData clientData,
3473 Tcl_Interp *interp, int objc,
3474 Tcl_Obj *const objv[]);
3475 MODULE_SCOPE int Tcl_PwdObjCmd(ClientData clientData,
3476 Tcl_Interp *interp, int objc,
3477 Tcl_Obj *const objv[]);
3478 MODULE_SCOPE int Tcl_ReadObjCmd(ClientData clientData,
3479 Tcl_Interp *interp, int objc,
3480 Tcl_Obj *const objv[]);
3481 MODULE_SCOPE int Tcl_RegexpObjCmd(ClientData clientData,
3482 Tcl_Interp *interp, int objc,
3483 Tcl_Obj *const objv[]);
3484 MODULE_SCOPE int Tcl_RegsubObjCmd(ClientData clientData,
3485 Tcl_Interp *interp, int objc,
3486 Tcl_Obj *const objv[]);
3487 MODULE_SCOPE int Tcl_RenameObjCmd(ClientData clientData,
3488 Tcl_Interp *interp, int objc,
3489 Tcl_Obj *const objv[]);
3490 MODULE_SCOPE int Tcl_RepresentationCmd(ClientData clientData,
3491 Tcl_Interp *interp, int objc,
3492 Tcl_Obj *const objv[]);
3493 MODULE_SCOPE int Tcl_ReturnObjCmd(ClientData clientData,
3494 Tcl_Interp *interp, int objc,
3495 Tcl_Obj *const objv[]);
3496 MODULE_SCOPE int Tcl_ScanObjCmd(ClientData clientData,
3497 Tcl_Interp *interp, int objc,
3498 Tcl_Obj *const objv[]);
3499 MODULE_SCOPE int Tcl_SeekObjCmd(ClientData clientData,
3500 Tcl_Interp *interp, int objc,
3501 Tcl_Obj *const objv[]);
3502 MODULE_SCOPE int Tcl_SetObjCmd(ClientData clientData,
3503 Tcl_Interp *interp, int objc,
3504 Tcl_Obj *const objv[]);
3505 MODULE_SCOPE int Tcl_SplitObjCmd(ClientData clientData,
3506 Tcl_Interp *interp, int objc,
3507 Tcl_Obj *const objv[]);
3508 MODULE_SCOPE int Tcl_SocketObjCmd(ClientData clientData,
3509 Tcl_Interp *interp, int objc,
3510 Tcl_Obj *const objv[]);
3511 MODULE_SCOPE int Tcl_SourceObjCmd(ClientData clientData,
3512 Tcl_Interp *interp, int objc,
3513 Tcl_Obj *const objv[]);
3514 MODULE_SCOPE Tcl_Command TclInitStringCmd(Tcl_Interp *interp);
3515 MODULE_SCOPE int Tcl_SubstObjCmd(ClientData clientData,
3516 Tcl_Interp *interp, int objc,
3517 Tcl_Obj *const objv[]);
3518 MODULE_SCOPE int Tcl_SwitchObjCmd(ClientData clientData,
3519 Tcl_Interp *interp, int objc,
3520 Tcl_Obj *const objv[]);
3521 MODULE_SCOPE int Tcl_TellObjCmd(ClientData clientData,
3522 Tcl_Interp *interp, int objc,
3523 Tcl_Obj *const objv[]);
3524 MODULE_SCOPE int Tcl_ThrowObjCmd(ClientData dummy, Tcl_Interp *interp,
3525 int objc, Tcl_Obj *const objv[]);
3526 MODULE_SCOPE int Tcl_TimeObjCmd(ClientData clientData,
3527 Tcl_Interp *interp, int objc,
3528 Tcl_Obj *const objv[]);
3529 MODULE_SCOPE int Tcl_TimeRateObjCmd(ClientData clientData,
3530 Tcl_Interp *interp, int objc,
3531 Tcl_Obj *const objv[]);
3532 MODULE_SCOPE int Tcl_TraceObjCmd(ClientData clientData,
3533 Tcl_Interp *interp, int objc,
3534 Tcl_Obj *const objv[]);
3535 MODULE_SCOPE int Tcl_TryObjCmd(ClientData clientData,
3536 Tcl_Interp *interp, int objc,
3537 Tcl_Obj *const objv[]);
3538 MODULE_SCOPE int Tcl_UnloadObjCmd(ClientData clientData,
3539 Tcl_Interp *interp, int objc,
3540 Tcl_Obj *const objv[]);
3541 MODULE_SCOPE int Tcl_UnsetObjCmd(ClientData clientData,
3542 Tcl_Interp *interp, int objc,
3543 Tcl_Obj *const objv[]);
3544 MODULE_SCOPE int Tcl_UpdateObjCmd(ClientData clientData,
3545 Tcl_Interp *interp, int objc,
3546 Tcl_Obj *const objv[]);
3547 MODULE_SCOPE int Tcl_UplevelObjCmd(ClientData clientData,
3548 Tcl_Interp *interp, int objc,
3549 Tcl_Obj *const objv[]);
3550 MODULE_SCOPE int Tcl_UpvarObjCmd(ClientData clientData,
3551 Tcl_Interp *interp, int objc,
3552 Tcl_Obj *const objv[]);
3553 MODULE_SCOPE int Tcl_VariableObjCmd(ClientData clientData,
3554 Tcl_Interp *interp, int objc,
3555 Tcl_Obj *const objv[]);
3556 MODULE_SCOPE int Tcl_VwaitObjCmd(ClientData clientData,
3557 Tcl_Interp *interp, int objc,
3558 Tcl_Obj *const objv[]);
3559 MODULE_SCOPE int Tcl_WhileObjCmd(ClientData clientData,
3560 Tcl_Interp *interp, int objc,
3561 Tcl_Obj *const objv[]);
3564 *----------------------------------------------------------------
3565 * Compilation procedures for commands in the generic core:
3566 *----------------------------------------------------------------
3569 MODULE_SCOPE int TclCompileAppendCmd(Tcl_Interp *interp,
3570 Tcl_Parse *parsePtr, Command *cmdPtr,
3571 struct CompileEnv *envPtr);
3572 MODULE_SCOPE int TclCompileArrayExistsCmd(Tcl_Interp *interp,
3573 Tcl_Parse *parsePtr, Command *cmdPtr,
3574 struct CompileEnv *envPtr);
3575 MODULE_SCOPE int TclCompileArraySetCmd(Tcl_Interp *interp,
3576 Tcl_Parse *parsePtr, Command *cmdPtr,
3577 struct CompileEnv *envPtr);
3578 MODULE_SCOPE int TclCompileArrayUnsetCmd(Tcl_Interp *interp,
3579 Tcl_Parse *parsePtr, Command *cmdPtr,
3580 struct CompileEnv *envPtr);
3581 MODULE_SCOPE int TclCompileBreakCmd(Tcl_Interp *interp,
3582 Tcl_Parse *parsePtr, Command *cmdPtr,
3583 struct CompileEnv *envPtr);
3584 MODULE_SCOPE int TclCompileCatchCmd(Tcl_Interp *interp,
3585 Tcl_Parse *parsePtr, Command *cmdPtr,
3586 struct CompileEnv *envPtr);
3587 MODULE_SCOPE int TclCompileClockClicksCmd(Tcl_Interp *interp,
3588 Tcl_Parse *parsePtr, Command *cmdPtr,
3589 struct CompileEnv *envPtr);
3590 MODULE_SCOPE int TclCompileClockReadingCmd(Tcl_Interp *interp,
3591 Tcl_Parse *parsePtr, Command *cmdPtr,
3592 struct CompileEnv *envPtr);
3593 MODULE_SCOPE int TclCompileConcatCmd(Tcl_Interp *interp,
3594 Tcl_Parse *parsePtr, Command *cmdPtr,
3595 struct CompileEnv *envPtr);
3596 MODULE_SCOPE int TclCompileContinueCmd(Tcl_Interp *interp,
3597 Tcl_Parse *parsePtr, Command *cmdPtr,
3598 struct CompileEnv *envPtr);
3599 MODULE_SCOPE int TclCompileDictAppendCmd(Tcl_Interp *interp,
3600 Tcl_Parse *parsePtr, Command *cmdPtr,
3601 struct CompileEnv *envPtr);
3602 MODULE_SCOPE int TclCompileDictCreateCmd(Tcl_Interp *interp,
3603 Tcl_Parse *parsePtr, Command *cmdPtr,
3604 struct CompileEnv *envPtr);
3605 MODULE_SCOPE int TclCompileDictExistsCmd(Tcl_Interp *interp,
3606 Tcl_Parse *parsePtr, Command *cmdPtr,
3607 struct CompileEnv *envPtr);
3608 MODULE_SCOPE int TclCompileDictForCmd(Tcl_Interp *interp,
3609 Tcl_Parse *parsePtr, Command *cmdPtr,
3610 struct CompileEnv *envPtr);
3611 MODULE_SCOPE int TclCompileDictGetCmd(Tcl_Interp *interp,
3612 Tcl_Parse *parsePtr, Command *cmdPtr,
3613 struct CompileEnv *envPtr);
3614 MODULE_SCOPE int TclCompileDictIncrCmd(Tcl_Interp *interp,
3615 Tcl_Parse *parsePtr, Command *cmdPtr,
3616 struct CompileEnv *envPtr);
3617 MODULE_SCOPE int TclCompileDictLappendCmd(Tcl_Interp *interp,
3618 Tcl_Parse *parsePtr, Command *cmdPtr,
3619 struct CompileEnv *envPtr);
3620 MODULE_SCOPE int TclCompileDictMapCmd(Tcl_Interp *interp,
3621 Tcl_Parse *parsePtr, Command *cmdPtr,
3622 struct CompileEnv *envPtr);
3623 MODULE_SCOPE int TclCompileDictMergeCmd(Tcl_Interp *interp,
3624 Tcl_Parse *parsePtr, Command *cmdPtr,
3625 struct CompileEnv *envPtr);
3626 MODULE_SCOPE int TclCompileDictSetCmd(Tcl_Interp *interp,
3627 Tcl_Parse *parsePtr, Command *cmdPtr,
3628 struct CompileEnv *envPtr);
3629 MODULE_SCOPE int TclCompileDictUnsetCmd(Tcl_Interp *interp,
3630 Tcl_Parse *parsePtr, Command *cmdPtr,
3631 struct CompileEnv *envPtr);
3632 MODULE_SCOPE int TclCompileDictUpdateCmd(Tcl_Interp *interp,
3633 Tcl_Parse *parsePtr, Command *cmdPtr,
3634 struct CompileEnv *envPtr);
3635 MODULE_SCOPE int TclCompileDictWithCmd(Tcl_Interp *interp,
3636 Tcl_Parse *parsePtr, Command *cmdPtr,
3637 struct CompileEnv *envPtr);
3638 MODULE_SCOPE int TclCompileEnsemble(Tcl_Interp *interp,
3639 Tcl_Parse *parsePtr, Command *cmdPtr,
3640 struct CompileEnv *envPtr);
3641 MODULE_SCOPE int TclCompileErrorCmd(Tcl_Interp *interp,
3642 Tcl_Parse *parsePtr, Command *cmdPtr,
3643 struct CompileEnv *envPtr);
3644 MODULE_SCOPE int TclCompileExprCmd(Tcl_Interp *interp,
3645 Tcl_Parse *parsePtr, Command *cmdPtr,
3646 struct CompileEnv *envPtr);
3647 MODULE_SCOPE int TclCompileForCmd(Tcl_Interp *interp,
3648 Tcl_Parse *parsePtr, Command *cmdPtr,
3649 struct CompileEnv *envPtr);
3650 MODULE_SCOPE int TclCompileForeachCmd(Tcl_Interp *interp,
3651 Tcl_Parse *parsePtr, Command *cmdPtr,
3652 struct CompileEnv *envPtr);
3653 MODULE_SCOPE int TclCompileFormatCmd(Tcl_Interp *interp,
3654 Tcl_Parse *parsePtr, Command *cmdPtr,
3655 struct CompileEnv *envPtr);
3656 MODULE_SCOPE int TclCompileGlobalCmd(Tcl_Interp *interp,
3657 Tcl_Parse *parsePtr, Command *cmdPtr,
3658 struct CompileEnv *envPtr);
3659 MODULE_SCOPE int TclCompileIfCmd(Tcl_Interp *interp,
3660 Tcl_Parse *parsePtr, Command *cmdPtr,
3661 struct CompileEnv *envPtr);
3662 MODULE_SCOPE int TclCompileInfoCommandsCmd(Tcl_Interp *interp,
3663 Tcl_Parse *parsePtr, Command *cmdPtr,
3664 struct CompileEnv *envPtr);
3665 MODULE_SCOPE int TclCompileInfoCoroutineCmd(Tcl_Interp *interp,
3666 Tcl_Parse *parsePtr, Command *cmdPtr,
3667 struct CompileEnv *envPtr);
3668 MODULE_SCOPE int TclCompileInfoExistsCmd(Tcl_Interp *interp,
3669 Tcl_Parse *parsePtr, Command *cmdPtr,
3670 struct CompileEnv *envPtr);
3671 MODULE_SCOPE int TclCompileInfoLevelCmd(Tcl_Interp *interp,
3672 Tcl_Parse *parsePtr, Command *cmdPtr,
3673 struct CompileEnv *envPtr);
3674 MODULE_SCOPE int TclCompileInfoObjectClassCmd(Tcl_Interp *interp,
3675 Tcl_Parse *parsePtr, Command *cmdPtr,
3676 struct CompileEnv *envPtr);
3677 MODULE_SCOPE int TclCompileInfoObjectIsACmd(Tcl_Interp *interp,
3678 Tcl_Parse *parsePtr, Command *cmdPtr,
3679 struct CompileEnv *envPtr);
3680 MODULE_SCOPE int TclCompileInfoObjectNamespaceCmd(Tcl_Interp *interp,
3681 Tcl_Parse *parsePtr, Command *cmdPtr,
3682 struct CompileEnv *envPtr);
3683 MODULE_SCOPE int TclCompileIncrCmd(Tcl_Interp *interp,
3684 Tcl_Parse *parsePtr, Command *cmdPtr,
3685 struct CompileEnv *envPtr);
3686 MODULE_SCOPE int TclCompileLappendCmd(Tcl_Interp *interp,
3687 Tcl_Parse *parsePtr, Command *cmdPtr,
3688 struct CompileEnv *envPtr);
3689 MODULE_SCOPE int TclCompileLassignCmd(Tcl_Interp *interp,
3690 Tcl_Parse *parsePtr, Command *cmdPtr,
3691 struct CompileEnv *envPtr);
3692 MODULE_SCOPE int TclCompileLindexCmd(Tcl_Interp *interp,
3693 Tcl_Parse *parsePtr, Command *cmdPtr,
3694 struct CompileEnv *envPtr);
3695 MODULE_SCOPE int TclCompileLinsertCmd(Tcl_Interp *interp,
3696 Tcl_Parse *parsePtr, Command *cmdPtr,
3697 struct CompileEnv *envPtr);
3698 MODULE_SCOPE int TclCompileListCmd(Tcl_Interp *interp,
3699 Tcl_Parse *parsePtr, Command *cmdPtr,
3700 struct CompileEnv *envPtr);
3701 MODULE_SCOPE int TclCompileLlengthCmd(Tcl_Interp *interp,
3702 Tcl_Parse *parsePtr, Command *cmdPtr,
3703 struct CompileEnv *envPtr);
3704 MODULE_SCOPE int TclCompileLmapCmd(Tcl_Interp *interp,
3705 Tcl_Parse *parsePtr, Command *cmdPtr,
3706 struct CompileEnv *envPtr);
3707 MODULE_SCOPE int TclCompileLrangeCmd(Tcl_Interp *interp,
3708 Tcl_Parse *parsePtr, Command *cmdPtr,
3709 struct CompileEnv *envPtr);
3710 MODULE_SCOPE int TclCompileLreplaceCmd(Tcl_Interp *interp,
3711 Tcl_Parse *parsePtr, Command *cmdPtr,
3712 struct CompileEnv *envPtr);
3713 MODULE_SCOPE int TclCompileLsetCmd(Tcl_Interp *interp,
3714 Tcl_Parse *parsePtr, Command *cmdPtr,
3715 struct CompileEnv *envPtr);
3716 MODULE_SCOPE int TclCompileNamespaceCodeCmd(Tcl_Interp *interp,
3717 Tcl_Parse *parsePtr, Command *cmdPtr,
3718 struct CompileEnv *envPtr);
3719 MODULE_SCOPE int TclCompileNamespaceCurrentCmd(Tcl_Interp *interp,
3720 Tcl_Parse *parsePtr, Command *cmdPtr,
3721 struct CompileEnv *envPtr);
3722 MODULE_SCOPE int TclCompileNamespaceOriginCmd(Tcl_Interp *interp,
3723 Tcl_Parse *parsePtr, Command *cmdPtr,
3724 struct CompileEnv *envPtr);
3725 MODULE_SCOPE int TclCompileNamespaceQualifiersCmd(Tcl_Interp *interp,
3726 Tcl_Parse *parsePtr, Command *cmdPtr,
3727 struct CompileEnv *envPtr);
3728 MODULE_SCOPE int TclCompileNamespaceTailCmd(Tcl_Interp *interp,
3729 Tcl_Parse *parsePtr, Command *cmdPtr,
3730 struct CompileEnv *envPtr);
3731 MODULE_SCOPE int TclCompileNamespaceUpvarCmd(Tcl_Interp *interp,
3732 Tcl_Parse *parsePtr, Command *cmdPtr,
3733 struct CompileEnv *envPtr);
3734 MODULE_SCOPE int TclCompileNamespaceWhichCmd(Tcl_Interp *interp,
3735 Tcl_Parse *parsePtr, Command *cmdPtr,
3736 struct CompileEnv *envPtr);
3737 MODULE_SCOPE int TclCompileNoOp(Tcl_Interp *interp,
3738 Tcl_Parse *parsePtr, Command *cmdPtr,
3739 struct CompileEnv *envPtr);
3740 MODULE_SCOPE int TclCompileObjectNextCmd(Tcl_Interp *interp,
3741 Tcl_Parse *parsePtr, Command *cmdPtr,
3742 struct CompileEnv *envPtr);
3743 MODULE_SCOPE int TclCompileObjectNextToCmd(Tcl_Interp *interp,
3744 Tcl_Parse *parsePtr, Command *cmdPtr,
3745 struct CompileEnv *envPtr);
3746 MODULE_SCOPE int TclCompileObjectSelfCmd(Tcl_Interp *interp,
3747 Tcl_Parse *parsePtr, Command *cmdPtr,
3748 struct CompileEnv *envPtr);
3749 MODULE_SCOPE int TclCompileRegexpCmd(Tcl_Interp *interp,
3750 Tcl_Parse *parsePtr, Command *cmdPtr,
3751 struct CompileEnv *envPtr);
3752 MODULE_SCOPE int TclCompileRegsubCmd(Tcl_Interp *interp,
3753 Tcl_Parse *parsePtr, Command *cmdPtr,
3754 struct CompileEnv *envPtr);
3755 MODULE_SCOPE int TclCompileReturnCmd(Tcl_Interp *interp,
3756 Tcl_Parse *parsePtr, Command *cmdPtr,
3757 struct CompileEnv *envPtr);
3758 MODULE_SCOPE int TclCompileSetCmd(Tcl_Interp *interp,
3759 Tcl_Parse *parsePtr, Command *cmdPtr,
3760 struct CompileEnv *envPtr);
3761 MODULE_SCOPE int TclCompileStringCatCmd(Tcl_Interp *interp,
3762 Tcl_Parse *parsePtr, Command *cmdPtr,
3763 struct CompileEnv *envPtr);
3764 MODULE_SCOPE int TclCompileStringCmpCmd(Tcl_Interp *interp,
3765 Tcl_Parse *parsePtr, Command *cmdPtr,
3766 struct CompileEnv *envPtr);
3767 MODULE_SCOPE int TclCompileStringEqualCmd(Tcl_Interp *interp,
3768 Tcl_Parse *parsePtr, Command *cmdPtr,
3769 struct CompileEnv *envPtr);
3770 MODULE_SCOPE int TclCompileStringFirstCmd(Tcl_Interp *interp,
3771 Tcl_Parse *parsePtr, Command *cmdPtr,
3772 struct CompileEnv *envPtr);
3773 MODULE_SCOPE int TclCompileStringIndexCmd(Tcl_Interp *interp,
3774 Tcl_Parse *parsePtr, Command *cmdPtr,
3775 struct CompileEnv *envPtr);
3776 MODULE_SCOPE int TclCompileStringIsCmd(Tcl_Interp *interp,
3777 Tcl_Parse *parsePtr, Command *cmdPtr,
3778 struct CompileEnv *envPtr);
3779 MODULE_SCOPE int TclCompileStringLastCmd(Tcl_Interp *interp,
3780 Tcl_Parse *parsePtr, Command *cmdPtr,
3781 struct CompileEnv *envPtr);
3782 MODULE_SCOPE int TclCompileStringLenCmd(Tcl_Interp *interp,
3783 Tcl_Parse *parsePtr, Command *cmdPtr,
3784 struct CompileEnv *envPtr);
3785 MODULE_SCOPE int TclCompileStringMapCmd(Tcl_Interp *interp,
3786 Tcl_Parse *parsePtr, Command *cmdPtr,
3787 struct CompileEnv *envPtr);
3788 MODULE_SCOPE int TclCompileStringMatchCmd(Tcl_Interp *interp,
3789 Tcl_Parse *parsePtr, Command *cmdPtr,
3790 struct CompileEnv *envPtr);
3791 MODULE_SCOPE int TclCompileStringRangeCmd(Tcl_Interp *interp,
3792 Tcl_Parse *parsePtr, Command *cmdPtr,
3793 struct CompileEnv *envPtr);
3794 MODULE_SCOPE int TclCompileStringReplaceCmd(Tcl_Interp *interp,
3795 Tcl_Parse *parsePtr, Command *cmdPtr,
3796 struct CompileEnv *envPtr);
3797 MODULE_SCOPE int TclCompileStringToLowerCmd(Tcl_Interp *interp,
3798 Tcl_Parse *parsePtr, Command *cmdPtr,
3799 struct CompileEnv *envPtr);
3800 MODULE_SCOPE int TclCompileStringToTitleCmd(Tcl_Interp *interp,
3801 Tcl_Parse *parsePtr, Command *cmdPtr,
3802 struct CompileEnv *envPtr);
3803 MODULE_SCOPE int TclCompileStringToUpperCmd(Tcl_Interp *interp,
3804 Tcl_Parse *parsePtr, Command *cmdPtr,
3805 struct CompileEnv *envPtr);
3806 MODULE_SCOPE int TclCompileStringTrimCmd(Tcl_Interp *interp,
3807 Tcl_Parse *parsePtr, Command *cmdPtr,
3808 struct CompileEnv *envPtr);
3809 MODULE_SCOPE int TclCompileStringTrimLCmd(Tcl_Interp *interp,
3810 Tcl_Parse *parsePtr, Command *cmdPtr,
3811 struct CompileEnv *envPtr);
3812 MODULE_SCOPE int TclCompileStringTrimRCmd(Tcl_Interp *interp,
3813 Tcl_Parse *parsePtr, Command *cmdPtr,
3814 struct CompileEnv *envPtr);
3815 MODULE_SCOPE int TclCompileSubstCmd(Tcl_Interp *interp,
3816 Tcl_Parse *parsePtr, Command *cmdPtr,
3817 struct CompileEnv *envPtr);
3818 MODULE_SCOPE int TclCompileSwitchCmd(Tcl_Interp *interp,
3819 Tcl_Parse *parsePtr, Command *cmdPtr,
3820 struct CompileEnv *envPtr);
3821 MODULE_SCOPE int TclCompileTailcallCmd(Tcl_Interp *interp,
3822 Tcl_Parse *parsePtr, Command *cmdPtr,
3823 struct CompileEnv *envPtr);
3824 MODULE_SCOPE int TclCompileThrowCmd(Tcl_Interp *interp,
3825 Tcl_Parse *parsePtr, Command *cmdPtr,
3826 struct CompileEnv *envPtr);
3827 MODULE_SCOPE int TclCompileTryCmd(Tcl_Interp *interp,
3828 Tcl_Parse *parsePtr, Command *cmdPtr,
3829 struct CompileEnv *envPtr);
3830 MODULE_SCOPE int TclCompileUnsetCmd(Tcl_Interp *interp,
3831 Tcl_Parse *parsePtr, Command *cmdPtr,
3832 struct CompileEnv *envPtr);
3833 MODULE_SCOPE int TclCompileUpvarCmd(Tcl_Interp *interp,
3834 Tcl_Parse *parsePtr, Command *cmdPtr,
3835 struct CompileEnv *envPtr);
3836 MODULE_SCOPE int TclCompileVariableCmd(Tcl_Interp *interp,
3837 Tcl_Parse *parsePtr, Command *cmdPtr,
3838 struct CompileEnv *envPtr);
3839 MODULE_SCOPE int TclCompileWhileCmd(Tcl_Interp *interp,
3840 Tcl_Parse *parsePtr, Command *cmdPtr,
3841 struct CompileEnv *envPtr);
3842 MODULE_SCOPE int TclCompileYieldCmd(Tcl_Interp *interp,
3843 Tcl_Parse *parsePtr, Command *cmdPtr,
3844 struct CompileEnv *envPtr);
3845 MODULE_SCOPE int TclCompileYieldToCmd(Tcl_Interp *interp,
3846 Tcl_Parse *parsePtr, Command *cmdPtr,
3847 struct CompileEnv *envPtr);
3848 MODULE_SCOPE int TclCompileBasic0ArgCmd(Tcl_Interp *interp,
3849 Tcl_Parse *parsePtr, Command *cmdPtr,
3850 struct CompileEnv *envPtr);
3851 MODULE_SCOPE int TclCompileBasic1ArgCmd(Tcl_Interp *interp,
3852 Tcl_Parse *parsePtr, Command *cmdPtr,
3853 struct CompileEnv *envPtr);
3854 MODULE_SCOPE int TclCompileBasic2ArgCmd(Tcl_Interp *interp,
3855 Tcl_Parse *parsePtr, Command *cmdPtr,
3856 struct CompileEnv *envPtr);
3857 MODULE_SCOPE int TclCompileBasic3ArgCmd(Tcl_Interp *interp,
3858 Tcl_Parse *parsePtr, Command *cmdPtr,
3859 struct CompileEnv *envPtr);
3860 MODULE_SCOPE int TclCompileBasic0Or1ArgCmd(Tcl_Interp *interp,
3861 Tcl_Parse *parsePtr, Command *cmdPtr,
3862 struct CompileEnv *envPtr);
3863 MODULE_SCOPE int TclCompileBasic1Or2ArgCmd(Tcl_Interp *interp,
3864 Tcl_Parse *parsePtr, Command *cmdPtr,
3865 struct CompileEnv *envPtr);
3866 MODULE_SCOPE int TclCompileBasic2Or3ArgCmd(Tcl_Interp *interp,
3867 Tcl_Parse *parsePtr, Command *cmdPtr,
3868 struct CompileEnv *envPtr);
3869 MODULE_SCOPE int TclCompileBasic0To2ArgCmd(Tcl_Interp *interp,
3870 Tcl_Parse *parsePtr, Command *cmdPtr,
3871 struct CompileEnv *envPtr);
3872 MODULE_SCOPE int TclCompileBasic1To3ArgCmd(Tcl_Interp *interp,
3873 Tcl_Parse *parsePtr, Command *cmdPtr,
3874 struct CompileEnv *envPtr);
3875 MODULE_SCOPE int TclCompileBasicMin0ArgCmd(Tcl_Interp *interp,
3876 Tcl_Parse *parsePtr, Command *cmdPtr,
3877 struct CompileEnv *envPtr);
3878 MODULE_SCOPE int TclCompileBasicMin1ArgCmd(Tcl_Interp *interp,
3879 Tcl_Parse *parsePtr, Command *cmdPtr,
3880 struct CompileEnv *envPtr);
3881 MODULE_SCOPE int TclCompileBasicMin2ArgCmd(Tcl_Interp *interp,
3882 Tcl_Parse *parsePtr, Command *cmdPtr,
3883 struct CompileEnv *envPtr);
3885 MODULE_SCOPE int TclInvertOpCmd(ClientData clientData,
3886 Tcl_Interp *interp, int objc,
3887 Tcl_Obj *const objv[]);
3888 MODULE_SCOPE int TclCompileInvertOpCmd(Tcl_Interp *interp,
3889 Tcl_Parse *parsePtr, Command *cmdPtr,
3890 struct CompileEnv *envPtr);
3891 MODULE_SCOPE int TclNotOpCmd(ClientData clientData,
3892 Tcl_Interp *interp, int objc,
3893 Tcl_Obj *const objv[]);
3894 MODULE_SCOPE int TclCompileNotOpCmd(Tcl_Interp *interp,
3895 Tcl_Parse *parsePtr, Command *cmdPtr,
3896 struct CompileEnv *envPtr);
3897 MODULE_SCOPE int TclAddOpCmd(ClientData clientData,
3898 Tcl_Interp *interp, int objc,
3899 Tcl_Obj *const objv[]);
3900 MODULE_SCOPE int TclCompileAddOpCmd(Tcl_Interp *interp,
3901 Tcl_Parse *parsePtr, Command *cmdPtr,
3902 struct CompileEnv *envPtr);
3903 MODULE_SCOPE int TclMulOpCmd(ClientData clientData,
3904 Tcl_Interp *interp, int objc,
3905 Tcl_Obj *const objv[]);
3906 MODULE_SCOPE int TclCompileMulOpCmd(Tcl_Interp *interp,
3907 Tcl_Parse *parsePtr, Command *cmdPtr,
3908 struct CompileEnv *envPtr);
3909 MODULE_SCOPE int TclAndOpCmd(ClientData clientData,
3910 Tcl_Interp *interp, int objc,
3911 Tcl_Obj *const objv[]);
3912 MODULE_SCOPE int TclCompileAndOpCmd(Tcl_Interp *interp,
3913 Tcl_Parse *parsePtr, Command *cmdPtr,
3914 struct CompileEnv *envPtr);
3915 MODULE_SCOPE int TclOrOpCmd(ClientData clientData,
3916 Tcl_Interp *interp, int objc,
3917 Tcl_Obj *const objv[]);
3918 MODULE_SCOPE int TclCompileOrOpCmd(Tcl_Interp *interp,
3919 Tcl_Parse *parsePtr, Command *cmdPtr,
3920 struct CompileEnv *envPtr);
3921 MODULE_SCOPE int TclXorOpCmd(ClientData clientData,
3922 Tcl_Interp *interp, int objc,
3923 Tcl_Obj *const objv[]);
3924 MODULE_SCOPE int TclCompileXorOpCmd(Tcl_Interp *interp,
3925 Tcl_Parse *parsePtr, Command *cmdPtr,
3926 struct CompileEnv *envPtr);
3927 MODULE_SCOPE int TclPowOpCmd(ClientData clientData,
3928 Tcl_Interp *interp, int objc,
3929 Tcl_Obj *const objv[]);
3930 MODULE_SCOPE int TclCompilePowOpCmd(Tcl_Interp *interp,
3931 Tcl_Parse *parsePtr, Command *cmdPtr,
3932 struct CompileEnv *envPtr);
3933 MODULE_SCOPE int TclLshiftOpCmd(ClientData clientData,
3934 Tcl_Interp *interp, int objc,
3935 Tcl_Obj *const objv[]);
3936 MODULE_SCOPE int TclCompileLshiftOpCmd(Tcl_Interp *interp,
3937 Tcl_Parse *parsePtr, Command *cmdPtr,
3938 struct CompileEnv *envPtr);
3939 MODULE_SCOPE int TclRshiftOpCmd(ClientData clientData,
3940 Tcl_Interp *interp, int objc,
3941 Tcl_Obj *const objv[]);
3942 MODULE_SCOPE int TclCompileRshiftOpCmd(Tcl_Interp *interp,
3943 Tcl_Parse *parsePtr, Command *cmdPtr,
3944 struct CompileEnv *envPtr);
3945 MODULE_SCOPE int TclModOpCmd(ClientData clientData,
3946 Tcl_Interp *interp, int objc,
3947 Tcl_Obj *const objv[]);
3948 MODULE_SCOPE int TclCompileModOpCmd(Tcl_Interp *interp,
3949 Tcl_Parse *parsePtr, Command *cmdPtr,
3950 struct CompileEnv *envPtr);
3951 MODULE_SCOPE int TclNeqOpCmd(ClientData clientData,
3952 Tcl_Interp *interp, int objc,
3953 Tcl_Obj *const objv[]);
3954 MODULE_SCOPE int TclCompileNeqOpCmd(Tcl_Interp *interp,
3955 Tcl_Parse *parsePtr, Command *cmdPtr,
3956 struct CompileEnv *envPtr);
3957 MODULE_SCOPE int TclStrneqOpCmd(ClientData clientData,
3958 Tcl_Interp *interp, int objc,
3959 Tcl_Obj *const objv[]);
3960 MODULE_SCOPE int TclCompileStrneqOpCmd(Tcl_Interp *interp,
3961 Tcl_Parse *parsePtr, Command *cmdPtr,
3962 struct CompileEnv *envPtr);
3963 MODULE_SCOPE int TclInOpCmd(ClientData clientData,
3964 Tcl_Interp *interp, int objc,
3965 Tcl_Obj *const objv[]);
3966 MODULE_SCOPE int TclCompileInOpCmd(Tcl_Interp *interp,
3967 Tcl_Parse *parsePtr, Command *cmdPtr,
3968 struct CompileEnv *envPtr);
3969 MODULE_SCOPE int TclNiOpCmd(ClientData clientData,
3970 Tcl_Interp *interp, int objc,
3971 Tcl_Obj *const objv[]);
3972 MODULE_SCOPE int TclCompileNiOpCmd(Tcl_Interp *interp,
3973 Tcl_Parse *parsePtr, Command *cmdPtr,
3974 struct CompileEnv *envPtr);
3975 MODULE_SCOPE int TclMinusOpCmd(ClientData clientData,
3976 Tcl_Interp *interp, int objc,
3977 Tcl_Obj *const objv[]);
3978 MODULE_SCOPE int TclCompileMinusOpCmd(Tcl_Interp *interp,
3979 Tcl_Parse *parsePtr, Command *cmdPtr,
3980 struct CompileEnv *envPtr);
3981 MODULE_SCOPE int TclDivOpCmd(ClientData clientData,
3982 Tcl_Interp *interp, int objc,
3983 Tcl_Obj *const objv[]);
3984 MODULE_SCOPE int TclCompileDivOpCmd(Tcl_Interp *interp,
3985 Tcl_Parse *parsePtr, Command *cmdPtr,
3986 struct CompileEnv *envPtr);
3987 MODULE_SCOPE int TclCompileLessOpCmd(Tcl_Interp *interp,
3988 Tcl_Parse *parsePtr, Command *cmdPtr,
3989 struct CompileEnv *envPtr);
3990 MODULE_SCOPE int TclCompileLeqOpCmd(Tcl_Interp *interp,
3991 Tcl_Parse *parsePtr, Command *cmdPtr,
3992 struct CompileEnv *envPtr);
3993 MODULE_SCOPE int TclCompileGreaterOpCmd(Tcl_Interp *interp,
3994 Tcl_Parse *parsePtr, Command *cmdPtr,
3995 struct CompileEnv *envPtr);
3996 MODULE_SCOPE int TclCompileGeqOpCmd(Tcl_Interp *interp,
3997 Tcl_Parse *parsePtr, Command *cmdPtr,
3998 struct CompileEnv *envPtr);
3999 MODULE_SCOPE int TclCompileEqOpCmd(Tcl_Interp *interp,
4000 Tcl_Parse *parsePtr, Command *cmdPtr,
4001 struct CompileEnv *envPtr);
4002 MODULE_SCOPE int TclCompileStreqOpCmd(Tcl_Interp *interp,
4003 Tcl_Parse *parsePtr, Command *cmdPtr,
4004 struct CompileEnv *envPtr);
4006 MODULE_SCOPE int TclCompileAssembleCmd(Tcl_Interp *interp,
4007 Tcl_Parse *parsePtr, Command *cmdPtr,
4008 struct CompileEnv *envPtr);
4011 * Functions defined in generic/tclVar.c and currently exported only for use
4012 * by the bytecode compiler and engine. Some of these could later be placed in
4013 * the public interface.
4016 MODULE_SCOPE Var * TclObjLookupVarEx(Tcl_Interp * interp,
4017 Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, int flags,
4018 const char *msg, const int createPart1,
4019 const int createPart2, Var **arrayPtrPtr);
4020 MODULE_SCOPE Var * TclLookupArrayElement(Tcl_Interp *interp,
4021 Tcl_Obj *arrayNamePtr, Tcl_Obj *elNamePtr,
4022 const int flags, const char *msg,
4023 const int createPart1, const int createPart2,
4024 Var *arrayPtr, int index);
4025 MODULE_SCOPE Tcl_Obj * TclPtrGetVarIdx(Tcl_Interp *interp,
4026 Var *varPtr, Var *arrayPtr, Tcl_Obj *part1Ptr,
4027 Tcl_Obj *part2Ptr, const int flags, int index);
4028 MODULE_SCOPE Tcl_Obj * TclPtrSetVarIdx(Tcl_Interp *interp,
4029 Var *varPtr, Var *arrayPtr, Tcl_Obj *part1Ptr,
4030 Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr,
4031 const int flags, int index);
4032 MODULE_SCOPE Tcl_Obj * TclPtrIncrObjVarIdx(Tcl_Interp *interp,
4033 Var *varPtr, Var *arrayPtr, Tcl_Obj *part1Ptr,
4034 Tcl_Obj *part2Ptr, Tcl_Obj *incrPtr,
4035 const int flags, int index);
4036 MODULE_SCOPE int TclPtrObjMakeUpvarIdx(Tcl_Interp *interp,
4037 Var *otherPtr, Tcl_Obj *myNamePtr, int myFlags,
4039 MODULE_SCOPE int TclPtrUnsetVarIdx(Tcl_Interp *interp, Var *varPtr,
4040 Var *arrayPtr, Tcl_Obj *part1Ptr,
4041 Tcl_Obj *part2Ptr, const int flags,
4043 MODULE_SCOPE void TclInvalidateNsPath(Namespace *nsPtr);
4044 MODULE_SCOPE void TclFindArrayPtrElements(Var *arrayPtr,
4045 Tcl_HashTable *tablePtr);
4048 * The new extended interface to the variable traces.
4051 MODULE_SCOPE int TclObjCallVarTraces(Interp *iPtr, Var *arrayPtr,
4052 Var *varPtr, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr,
4053 int flags, int leaveErrMsg, int index);
4056 * So tclObj.c and tclDictObj.c can share these implementations.
4059 MODULE_SCOPE int TclCompareObjKeys(void *keyPtr, Tcl_HashEntry *hPtr);
4060 MODULE_SCOPE void TclFreeObjEntry(Tcl_HashEntry *hPtr);
4061 MODULE_SCOPE unsigned TclHashObjKey(Tcl_HashTable *tablePtr, void *keyPtr);
4063 MODULE_SCOPE int TclFullFinalizationRequested(void);
4066 * Utility routines for encoding index values as integers. Used by both
4067 * some of the command compilers and by [lsort] and [lsearch].
4070 MODULE_SCOPE int TclIndexEncode(Tcl_Interp *interp, Tcl_Obj *objPtr,
4071 int before, int after, int *indexPtr);
4072 MODULE_SCOPE int TclIndexDecode(int encoded, int endValue);
4074 MODULE_SCOPE void TclBN_s_mp_reverse(unsigned char *s, size_t len);
4076 /* Constants used in index value encoding routines. */
4077 #define TCL_INDEX_END (-2)
4078 #define TCL_INDEX_BEFORE (-1)
4079 #define TCL_INDEX_START (0)
4080 #define TCL_INDEX_AFTER (INT_MAX)
4083 *----------------------------------------------------------------
4084 * Macros used by the Tcl core to create and release Tcl objects.
4085 * TclNewObj(objPtr) creates a new object denoting an empty string.
4086 * TclDecrRefCount(objPtr) decrements the object's reference count, and frees
4087 * the object if its reference count is zero. These macros are inline versions
4088 * of Tcl_NewObj() and Tcl_DecrRefCount(). Notice that the names differ in not
4089 * having a "_" after the "Tcl". Notice also that these macros reference their
4090 * argument more than once, so you should avoid calling them with an
4091 * expression that is expensive to compute or has side effects. The ANSI C
4092 * "prototypes" for these macros are:
4094 * MODULE_SCOPE void TclNewObj(Tcl_Obj *objPtr);
4095 * MODULE_SCOPE void TclDecrRefCount(Tcl_Obj *objPtr);
4097 * These macros are defined in terms of two macros that depend on memory
4098 * allocator in use: TclAllocObjStorage, TclFreeObjStorage. They are defined
4100 *----------------------------------------------------------------
4104 * DTrace object allocation probe macros.
4108 #ifndef _TCLDTRACE_H
4109 #include "tclDTrace.h"
4111 #define TCL_DTRACE_OBJ_CREATE(objPtr) TCL_OBJ_CREATE(objPtr)
4112 #define TCL_DTRACE_OBJ_FREE(objPtr) TCL_OBJ_FREE(objPtr)
4113 #else /* USE_DTRACE */
4114 #define TCL_DTRACE_OBJ_CREATE(objPtr) {}
4115 #define TCL_DTRACE_OBJ_FREE(objPtr) {}
4116 #endif /* USE_DTRACE */
4118 #ifdef TCL_COMPILE_STATS
4119 # define TclIncrObjsAllocated() \
4121 # define TclIncrObjsFreed() \
4124 # define TclIncrObjsAllocated()
4125 # define TclIncrObjsFreed()
4126 #endif /* TCL_COMPILE_STATS */
4128 # define TclAllocObjStorage(objPtr) \
4129 TclAllocObjStorageEx(NULL, (objPtr))
4131 # define TclFreeObjStorage(objPtr) \
4132 TclFreeObjStorageEx(NULL, (objPtr))
4134 #ifndef TCL_MEM_DEBUG
4135 # define TclNewObj(objPtr) \
4136 TclIncrObjsAllocated(); \
4137 TclAllocObjStorage(objPtr); \
4138 (objPtr)->refCount = 0; \
4139 (objPtr)->bytes = tclEmptyStringRep; \
4140 (objPtr)->length = 0; \
4141 (objPtr)->typePtr = NULL; \
4142 TCL_DTRACE_OBJ_CREATE(objPtr)
4145 * Invalidate the string rep first so we can use the bytes value for our
4146 * pointer chain, and signal an obj deletion (as opposed to shimmering) with
4148 * Use empty 'if ; else' to handle use in unbraced outer if/else conditions.
4151 # define TclDecrRefCount(objPtr) \
4152 if ((objPtr)->refCount-- > 1) ; else { \
4153 if (!(objPtr)->typePtr || !(objPtr)->typePtr->freeIntRepProc) { \
4154 TCL_DTRACE_OBJ_FREE(objPtr); \
4155 if ((objPtr)->bytes \
4156 && ((objPtr)->bytes != tclEmptyStringRep)) { \
4157 ckfree((char *) (objPtr)->bytes); \
4159 (objPtr)->length = -1; \
4160 TclFreeObjStorage(objPtr); \
4161 TclIncrObjsFreed(); \
4163 TclFreeObj(objPtr); \
4170 * The PURIFY mode is like the regular mode, but instead of doing block
4171 * Tcl_Obj allocation and keeping a freed list for efficiency, it always
4172 * allocates and frees a single Tcl_Obj so that tools like Purify can better
4173 * track memory leaks.
4176 # define TclAllocObjStorageEx(interp, objPtr) \
4177 (objPtr) = (Tcl_Obj *) ckalloc(sizeof(Tcl_Obj))
4179 # define TclFreeObjStorageEx(interp, objPtr) \
4180 ckfree((char *) (objPtr))
4182 #undef USE_THREAD_ALLOC
4184 #elif defined(TCL_THREADS) && defined(USE_THREAD_ALLOC)
4187 * The TCL_THREADS mode is like the regular mode but allocates Tcl_Obj's from
4188 * per-thread caches.
4191 MODULE_SCOPE Tcl_Obj * TclThreadAllocObj(void);
4192 MODULE_SCOPE void TclThreadFreeObj(Tcl_Obj *);
4193 MODULE_SCOPE Tcl_Mutex *TclpNewAllocMutex(void);
4194 MODULE_SCOPE void TclFreeAllocCache(void *);
4195 MODULE_SCOPE void * TclpGetAllocCache(void);
4196 MODULE_SCOPE void TclpSetAllocCache(void *);
4197 MODULE_SCOPE void TclpFreeAllocMutex(Tcl_Mutex *mutex);
4198 MODULE_SCOPE void TclpFreeAllocCache(void *);
4201 * These macros need to be kept in sync with the code of TclThreadAllocObj()
4202 * and TclThreadFreeObj().
4204 * Note that the optimiser should resolve the case (interp==NULL) at compile
4208 # define ALLOC_NOBJHIGH 1200
4210 # define TclAllocObjStorageEx(interp, objPtr) \
4212 AllocCache *cachePtr; \
4213 if (((interp) == NULL) || \
4214 ((cachePtr = ((Interp *)(interp))->allocCache), \
4215 (cachePtr->numObjects == 0))) { \
4216 (objPtr) = TclThreadAllocObj(); \
4218 (objPtr) = cachePtr->firstObjPtr; \
4219 cachePtr->firstObjPtr = (Tcl_Obj *)(objPtr)->internalRep.twoPtrValue.ptr1; \
4220 --cachePtr->numObjects; \
4224 # define TclFreeObjStorageEx(interp, objPtr) \
4226 AllocCache *cachePtr; \
4227 if (((interp) == NULL) || \
4228 ((cachePtr = ((Interp *)(interp))->allocCache), \
4229 ((cachePtr->numObjects == 0) || \
4230 (cachePtr->numObjects >= ALLOC_NOBJHIGH)))) { \
4231 TclThreadFreeObj(objPtr); \
4233 (objPtr)->internalRep.twoPtrValue.ptr1 = cachePtr->firstObjPtr; \
4234 cachePtr->firstObjPtr = objPtr; \
4235 ++cachePtr->numObjects; \
4239 #else /* not PURIFY or USE_THREAD_ALLOC */
4241 #if defined(USE_TCLALLOC) && USE_TCLALLOC
4242 MODULE_SCOPE void TclFinalizeAllocSubsystem();
4243 MODULE_SCOPE void TclInitAlloc();
4245 # define USE_TCLALLOC 0
4249 /* declared in tclObj.c */
4250 MODULE_SCOPE Tcl_Mutex tclObjMutex;
4253 # define TclAllocObjStorageEx(interp, objPtr) \
4255 Tcl_MutexLock(&tclObjMutex); \
4256 if (tclFreeObjList == NULL) { \
4257 TclAllocateFreeObjects(); \
4259 (objPtr) = tclFreeObjList; \
4260 tclFreeObjList = (Tcl_Obj *) \
4261 tclFreeObjList->internalRep.twoPtrValue.ptr1; \
4262 Tcl_MutexUnlock(&tclObjMutex); \
4265 # define TclFreeObjStorageEx(interp, objPtr) \
4267 Tcl_MutexLock(&tclObjMutex); \
4268 (objPtr)->internalRep.twoPtrValue.ptr1 = (void *) tclFreeObjList; \
4269 tclFreeObjList = (objPtr); \
4270 Tcl_MutexUnlock(&tclObjMutex); \
4274 #else /* TCL_MEM_DEBUG */
4275 MODULE_SCOPE void TclDbInitNewObj(Tcl_Obj *objPtr, const char *file,
4278 # define TclDbNewObj(objPtr, file, line) \
4280 TclIncrObjsAllocated(); \
4281 (objPtr) = (Tcl_Obj *) \
4282 Tcl_DbCkalloc(sizeof(Tcl_Obj), (file), (line)); \
4283 TclDbInitNewObj((objPtr), (file), (line)); \
4284 TCL_DTRACE_OBJ_CREATE(objPtr); \
4287 # define TclNewObj(objPtr) \
4288 TclDbNewObj(objPtr, __FILE__, __LINE__);
4290 # define TclDecrRefCount(objPtr) \
4291 Tcl_DbDecrRefCount(objPtr, __FILE__, __LINE__)
4293 # define TclNewListObjDirect(objc, objv) \
4294 TclDbNewListObjDirect(objc, objv, __FILE__, __LINE__)
4296 #undef USE_THREAD_ALLOC
4297 #endif /* TCL_MEM_DEBUG */
4300 *----------------------------------------------------------------
4301 * Macro used by the Tcl core to set a Tcl_Obj's string representation to a
4302 * copy of the "len" bytes starting at "bytePtr". This code works even if the
4303 * byte array contains NULLs as long as the length is correct. Because "len"
4304 * is referenced multiple times, it should be as simple an expression as
4305 * possible. The ANSI C "prototype" for this macro is:
4307 * MODULE_SCOPE void TclInitStringRep(Tcl_Obj *objPtr, char *bytePtr, int len);
4309 * This macro should only be called on an unshared objPtr where
4310 * objPtr->typePtr->freeIntRepProc == NULL
4311 *----------------------------------------------------------------
4314 #define TclInitStringRep(objPtr, bytePtr, len) \
4316 (objPtr)->bytes = tclEmptyStringRep; \
4317 (objPtr)->length = 0; \
4319 (objPtr)->bytes = (char *) ckalloc((len) + 1); \
4320 memcpy((objPtr)->bytes, (bytePtr), (len)); \
4321 (objPtr)->bytes[len] = '\0'; \
4322 (objPtr)->length = (len); \
4326 *----------------------------------------------------------------
4327 * Macro used by the Tcl core to get the string representation's byte array
4328 * pointer from a Tcl_Obj. This is an inline version of Tcl_GetString(). The
4329 * macro's expression result is the string rep's byte pointer which might be
4330 * NULL. The bytes referenced by this pointer must not be modified by the
4331 * caller. The ANSI C "prototype" for this macro is:
4333 * MODULE_SCOPE char * TclGetString(Tcl_Obj *objPtr);
4334 *----------------------------------------------------------------
4337 #define TclGetString(objPtr) \
4338 ((objPtr)->bytes? (objPtr)->bytes : Tcl_GetString((objPtr)))
4340 #define TclGetStringFromObj(objPtr, lenPtr) \
4342 ? (*(lenPtr) = (objPtr)->length, (objPtr)->bytes) \
4343 : Tcl_GetStringFromObj((objPtr), (lenPtr)))
4346 *----------------------------------------------------------------
4347 * Macro used by the Tcl core to clean out an object's internal
4348 * representation. Does not actually reset the rep's bytes. The ANSI C
4349 * "prototype" for this macro is:
4351 * MODULE_SCOPE void TclFreeIntRep(Tcl_Obj *objPtr);
4352 *----------------------------------------------------------------
4355 #define TclFreeIntRep(objPtr) \
4356 if ((objPtr)->typePtr != NULL) { \
4357 if ((objPtr)->typePtr->freeIntRepProc != NULL) { \
4358 (objPtr)->typePtr->freeIntRepProc(objPtr); \
4360 (objPtr)->typePtr = NULL; \
4364 *----------------------------------------------------------------
4365 * Macro used by the Tcl core to clean out an object's string representation.
4366 * The ANSI C "prototype" for this macro is:
4368 * MODULE_SCOPE void TclInvalidateStringRep(Tcl_Obj *objPtr);
4369 *----------------------------------------------------------------
4372 #define TclInvalidateStringRep(objPtr) \
4374 Tcl_Obj *_isobjPtr = (Tcl_Obj *)(objPtr); \
4375 if (_isobjPtr->bytes != NULL) { \
4376 if (_isobjPtr->bytes != tclEmptyStringRep) { \
4377 ckfree((char *)_isobjPtr->bytes); \
4379 _isobjPtr->bytes = NULL; \
4383 #define TclHasStringRep(objPtr) \
4384 ((objPtr)->bytes != NULL)
4387 *----------------------------------------------------------------
4388 * Macros used by the Tcl core to grow Tcl_Token arrays. They use the same
4389 * growth algorithm as used in tclStringObj.c for growing strings. The ANSI C
4390 * "prototype" for this macro is:
4392 * MODULE_SCOPE void TclGrowTokenArray(Tcl_Token *tokenPtr, int used,
4393 * int available, int append,
4394 * Tcl_Token *staticPtr);
4395 * MODULE_SCOPE void TclGrowParseTokenArray(Tcl_Parse *parsePtr,
4397 *----------------------------------------------------------------
4400 /* General tuning for minimum growth in Tcl growth algorithms */
4401 #ifndef TCL_MIN_GROWTH
4402 # ifdef TCL_GROWTH_MIN_ALLOC
4403 /* Support for any legacy tuners */
4404 # define TCL_MIN_GROWTH TCL_GROWTH_MIN_ALLOC
4406 # define TCL_MIN_GROWTH 1024
4410 /* Token growth tuning, default to the general value. */
4411 #ifndef TCL_MIN_TOKEN_GROWTH
4412 #define TCL_MIN_TOKEN_GROWTH TCL_MIN_GROWTH/sizeof(Tcl_Token)
4415 #define TCL_MAX_TOKENS (int)(UINT_MAX / sizeof(Tcl_Token))
4416 #define TclGrowTokenArray(tokenPtr, used, available, append, staticPtr) \
4418 int _needed = (used) + (append); \
4419 if (_needed > TCL_MAX_TOKENS) { \
4420 Tcl_Panic("max # of tokens for a Tcl parse (%d) exceeded", \
4423 if (_needed > (available)) { \
4424 int allocated = 2 * _needed; \
4425 Tcl_Token *oldPtr = (tokenPtr); \
4426 Tcl_Token *newPtr; \
4427 if (oldPtr == (staticPtr)) { \
4430 if (allocated > TCL_MAX_TOKENS) { \
4431 allocated = TCL_MAX_TOKENS; \
4433 newPtr = (Tcl_Token *) attemptckrealloc((char *) oldPtr, \
4434 (unsigned int) (allocated * sizeof(Tcl_Token))); \
4435 if (newPtr == NULL) { \
4436 allocated = _needed + (append) + TCL_MIN_TOKEN_GROWTH; \
4437 if (allocated > TCL_MAX_TOKENS) { \
4438 allocated = TCL_MAX_TOKENS; \
4440 newPtr = (Tcl_Token *) ckrealloc((char *) oldPtr, \
4441 (unsigned int) (allocated * sizeof(Tcl_Token))); \
4443 (available) = allocated; \
4444 if (oldPtr == NULL) { \
4445 memcpy(newPtr, staticPtr, \
4446 (size_t) ((used) * sizeof(Tcl_Token))); \
4448 (tokenPtr) = newPtr; \
4452 #define TclGrowParseTokenArray(parsePtr, append) \
4453 TclGrowTokenArray((parsePtr)->tokenPtr, (parsePtr)->numTokens, \
4454 (parsePtr)->tokensAvailable, (append), \
4455 (parsePtr)->staticTokens)
4458 *----------------------------------------------------------------
4459 * Macro used by the Tcl core get a unicode char from a utf string. It checks
4460 * to see if we have a one-byte utf char before calling the real
4461 * Tcl_UtfToUniChar, as this will save a lot of time for primarily ASCII
4462 * string handling. The macro's expression result is 1 for the 1-byte case or
4463 * the result of Tcl_UtfToUniChar. The ANSI C "prototype" for this macro is:
4465 * MODULE_SCOPE int TclUtfToUniChar(const char *string, Tcl_UniChar *ch);
4466 *----------------------------------------------------------------
4469 #define TclUtfToUniChar(str, chPtr) \
4470 (((UCHAR(*(str))) < 0x80) ? \
4471 ((*(chPtr) = UCHAR(*(str))), 1) \
4472 : Tcl_UtfToUniChar(str, chPtr))
4475 *----------------------------------------------------------------
4476 * Macro counterpart of the Tcl_NumUtfChars() function. To be used in speed-
4477 * -sensitive points where it pays to avoid a function call in the common case
4478 * of counting along a string of all one-byte characters. The ANSI C
4479 * "prototype" for this macro is:
4481 * MODULE_SCOPE void TclNumUtfChars(int numChars, const char *bytes,
4483 *----------------------------------------------------------------
4486 #define TclNumUtfChars(numChars, bytes, numBytes) \
4488 int _count, _i = (numBytes); \
4489 unsigned char *_str = (unsigned char *) (bytes); \
4490 while (_i && (*_str < 0xC0)) { _i--; _str++; } \
4491 _count = (numBytes) - _i; \
4493 _count += Tcl_NumUtfChars((bytes) + _count, _i); \
4495 (numChars) = _count; \
4498 #define TclUtfPrev(src, start) \
4499 (((src) < (start)+2) ? (start) : \
4500 (UCHAR(*((src) - 1))) < 0x80 ? (src)-1 : \
4501 Tcl_UtfPrev(src, start))
4504 *----------------------------------------------------------------
4505 * Macro that encapsulates the logic that determines when it is safe to
4506 * interpret a string as a byte array directly. In summary, the object must be
4507 * a byte array and must not have a string representation (as the operations
4508 * that it is used in are defined on strings, not byte arrays). Theoretically
4509 * it is possible to also be efficient in the case where the object's bytes
4510 * field is filled by generation from the byte array (c.f. list canonicality)
4511 * but we don't do that at the moment since this is purely about efficiency.
4512 * The ANSI C "prototype" for this macro is:
4514 * MODULE_SCOPE int TclIsPureByteArray(Tcl_Obj *objPtr);
4515 *----------------------------------------------------------------
4518 #define TclIsPureByteArray(objPtr) \
4519 (((objPtr)->typePtr==&tclByteArrayType) && ((objPtr)->bytes==NULL))
4520 #define TclIsPureDict(objPtr) \
4521 (((objPtr)->bytes==NULL) && ((objPtr)->typePtr==&tclDictType))
4523 #define TclIsPureList(objPtr) \
4524 (((objPtr)->bytes==NULL) && ((objPtr)->typePtr==&tclListType))
4527 *----------------------------------------------------------------
4528 * Macro used by the Tcl core to compare Unicode strings. On big-endian
4529 * systems we can use the more efficient memcmp, but this would not be
4530 * lexically correct on little-endian systems. The ANSI C "prototype" for
4533 * MODULE_SCOPE int TclUniCharNcmp(const Tcl_UniChar *cs,
4534 * const Tcl_UniChar *ct, unsigned long n);
4535 *----------------------------------------------------------------
4538 #if defined(WORDS_BIGENDIAN) && (TCL_UTF_MAX != 4)
4539 # define TclUniCharNcmp(cs,ct,n) memcmp((cs),(ct),(n)*sizeof(Tcl_UniChar))
4540 #else /* !WORDS_BIGENDIAN */
4541 # define TclUniCharNcmp Tcl_UniCharNcmp
4542 #endif /* WORDS_BIGENDIAN */
4545 *----------------------------------------------------------------
4546 * Macro used by the Tcl core to increment a namespace's export epoch
4547 * counter. The ANSI C "prototype" for this macro is:
4549 * MODULE_SCOPE void TclInvalidateNsCmdLookup(Namespace *nsPtr);
4550 *----------------------------------------------------------------
4553 #define TclInvalidateNsCmdLookup(nsPtr) \
4554 if ((nsPtr)->numExportPatterns) { \
4555 (nsPtr)->exportLookupEpoch++; \
4557 if ((nsPtr)->commandPathLength) { \
4558 (nsPtr)->cmdRefEpoch++; \
4562 *----------------------------------------------------------------------
4564 * Core procedure added to libtommath for bignum manipulation.
4566 *----------------------------------------------------------------------
4569 MODULE_SCOPE Tcl_PackageInitProc TclTommath_Init;
4572 *----------------------------------------------------------------------
4574 * External (platform specific) initialization routine, these declarations
4575 * explicitly don't use EXTERN since this code does not get compiled into the
4578 *----------------------------------------------------------------------
4581 MODULE_SCOPE Tcl_PackageInitProc TclplatformtestInit;
4582 MODULE_SCOPE Tcl_PackageInitProc TclObjTest_Init;
4583 MODULE_SCOPE Tcl_PackageInitProc TclThread_Init;
4584 MODULE_SCOPE Tcl_PackageInitProc Procbodytest_Init;
4585 MODULE_SCOPE Tcl_PackageInitProc Procbodytest_SafeInit;
4588 *----------------------------------------------------------------
4589 * Macro used by the Tcl core to check whether a pattern has any characters
4590 * special to [string match]. The ANSI C "prototype" for this macro is:
4592 * MODULE_SCOPE int TclMatchIsTrivial(const char *pattern);
4593 *----------------------------------------------------------------
4596 #define TclMatchIsTrivial(pattern) \
4597 (strpbrk((pattern), "*[?\\") == NULL)
4600 *----------------------------------------------------------------
4601 * Macros used by the Tcl core to set a Tcl_Obj's numeric representation
4602 * avoiding the corresponding function calls in time critical parts of the
4603 * core. They should only be called on unshared objects. The ANSI C
4604 * "prototypes" for these macros are:
4606 * MODULE_SCOPE void TclSetIntObj(Tcl_Obj *objPtr, int intValue);
4607 * MODULE_SCOPE void TclSetLongObj(Tcl_Obj *objPtr, long longValue);
4608 * MODULE_SCOPE void TclSetBooleanObj(Tcl_Obj *objPtr, long boolValue);
4609 * MODULE_SCOPE void TclSetWideIntObj(Tcl_Obj *objPtr, Tcl_WideInt w);
4610 * MODULE_SCOPE void TclSetDoubleObj(Tcl_Obj *objPtr, double d);
4611 *----------------------------------------------------------------
4614 #define TclSetLongObj(objPtr, i) \
4616 TclInvalidateStringRep(objPtr); \
4617 TclFreeIntRep(objPtr); \
4618 (objPtr)->internalRep.longValue = (long)(i); \
4619 (objPtr)->typePtr = &tclIntType; \
4622 #define TclSetIntObj(objPtr, l) \
4623 TclSetLongObj(objPtr, l)
4626 * NOTE: There is to be no such thing as a "pure" boolean. Boolean values set
4627 * programmatically go straight to being "int" Tcl_Obj's, with value 0 or 1.
4628 * The only "boolean" Tcl_Obj's shall be those holding the cached boolean
4629 * value of strings like: "yes", "no", "true", "false", "on", "off".
4632 #define TclSetBooleanObj(objPtr, b) \
4633 TclSetLongObj(objPtr, (b)!=0);
4635 #ifndef TCL_WIDE_INT_IS_LONG
4636 #define TclSetWideIntObj(objPtr, w) \
4638 TclInvalidateStringRep(objPtr); \
4639 TclFreeIntRep(objPtr); \
4640 (objPtr)->internalRep.wideValue = (Tcl_WideInt)(w); \
4641 (objPtr)->typePtr = &tclWideIntType; \
4645 #define TclSetDoubleObj(objPtr, d) \
4647 TclInvalidateStringRep(objPtr); \
4648 TclFreeIntRep(objPtr); \
4649 (objPtr)->internalRep.doubleValue = (double)(d); \
4650 (objPtr)->typePtr = &tclDoubleType; \
4654 *----------------------------------------------------------------
4655 * Macros used by the Tcl core to create and initialise objects of standard
4656 * types, avoiding the corresponding function calls in time critical parts of
4657 * the core. The ANSI C "prototypes" for these macros are:
4659 * MODULE_SCOPE void TclNewIntObj(Tcl_Obj *objPtr, int i);
4660 * MODULE_SCOPE void TclNewLongObj(Tcl_Obj *objPtr, long l);
4661 * MODULE_SCOPE void TclNewBooleanObj(Tcl_Obj *objPtr, int b);
4662 * MODULE_SCOPE void TclNewWideObj(Tcl_Obj *objPtr, Tcl_WideInt w);
4663 * MODULE_SCOPE void TclNewDoubleObj(Tcl_Obj *objPtr, double d);
4664 * MODULE_SCOPE void TclNewStringObj(Tcl_Obj *objPtr, char *s, int len);
4665 * MODULE_SCOPE void TclNewLiteralStringObj(Tcl_Obj*objPtr, char*sLiteral);
4667 *----------------------------------------------------------------
4670 #ifndef TCL_MEM_DEBUG
4671 #define TclNewLongObj(objPtr, i) \
4673 TclIncrObjsAllocated(); \
4674 TclAllocObjStorage(objPtr); \
4675 (objPtr)->refCount = 0; \
4676 (objPtr)->bytes = NULL; \
4677 (objPtr)->internalRep.longValue = (long)(i); \
4678 (objPtr)->typePtr = &tclIntType; \
4679 TCL_DTRACE_OBJ_CREATE(objPtr); \
4682 #define TclNewIntObj(objPtr, l) \
4683 TclNewLongObj(objPtr, l)
4686 * NOTE: There is to be no such thing as a "pure" boolean.
4687 * See comment above TclSetBooleanObj macro above.
4689 #define TclNewBooleanObj(objPtr, b) \
4690 TclNewLongObj((objPtr), (b)!=0)
4692 #define TclNewDoubleObj(objPtr, d) \
4694 TclIncrObjsAllocated(); \
4695 TclAllocObjStorage(objPtr); \
4696 (objPtr)->refCount = 0; \
4697 (objPtr)->bytes = NULL; \
4698 (objPtr)->internalRep.doubleValue = (double)(d); \
4699 (objPtr)->typePtr = &tclDoubleType; \
4700 TCL_DTRACE_OBJ_CREATE(objPtr); \
4703 #define TclNewStringObj(objPtr, s, len) \
4705 TclIncrObjsAllocated(); \
4706 TclAllocObjStorage(objPtr); \
4707 (objPtr)->refCount = 0; \
4708 TclInitStringRep((objPtr), (s), (len)); \
4709 (objPtr)->typePtr = NULL; \
4710 TCL_DTRACE_OBJ_CREATE(objPtr); \
4713 #else /* TCL_MEM_DEBUG */
4714 #define TclNewIntObj(objPtr, i) \
4715 (objPtr) = Tcl_NewIntObj(i)
4717 #define TclNewLongObj(objPtr, l) \
4718 (objPtr) = Tcl_NewLongObj(l)
4720 #define TclNewBooleanObj(objPtr, b) \
4721 (objPtr) = Tcl_NewBooleanObj(b)
4723 #define TclNewDoubleObj(objPtr, d) \
4724 (objPtr) = Tcl_NewDoubleObj(d)
4726 #define TclNewStringObj(objPtr, s, len) \
4727 (objPtr) = Tcl_NewStringObj((s), (len))
4728 #endif /* TCL_MEM_DEBUG */
4731 * The sLiteral argument *must* be a string literal; the incantation with
4732 * sizeof(sLiteral "") will fail to compile otherwise.
4734 #define TclNewLiteralStringObj(objPtr, sLiteral) \
4735 TclNewStringObj((objPtr), (sLiteral), (int) (sizeof(sLiteral "") - 1))
4738 *----------------------------------------------------------------
4739 * Convenience macros for DStrings.
4740 * The ANSI C "prototypes" for these macros are:
4742 * MODULE_SCOPE char * TclDStringAppendLiteral(Tcl_DString *dsPtr,
4743 * const char *sLiteral);
4744 * MODULE_SCOPE void TclDStringClear(Tcl_DString *dsPtr);
4747 #define TclDStringAppendLiteral(dsPtr, sLiteral) \
4748 Tcl_DStringAppend((dsPtr), (sLiteral), (int) (sizeof(sLiteral "") - 1))
4749 #define TclDStringClear(dsPtr) \
4750 Tcl_DStringSetLength((dsPtr), 0)
4753 *----------------------------------------------------------------
4754 * Macros used by the Tcl core to test for some special double values.
4755 * The ANSI C "prototypes" for these macros are:
4757 * MODULE_SCOPE int TclIsInfinite(double d);
4758 * MODULE_SCOPE int TclIsNaN(double d);
4762 # define TclIsInfinite(d) (!(_finite((d))))
4763 # define TclIsNaN(d) (_isnan((d)))
4765 # define TclIsInfinite(d) ((d) > DBL_MAX || (d) < -DBL_MAX)
4767 # define TclIsNaN(d) ((d) != (d))
4769 # define TclIsNaN(d) (isnan(d))
4774 * ----------------------------------------------------------------------
4775 * Macro to use to find the offset of a field in a structure. Computes number
4776 * of bytes from beginning of structure to a given field.
4780 #define TclOffset(type, field) ((int) offsetof(type, field))
4782 #define TclOffset(type, field) ((int) ((char *) &((type *) 0)->field))
4786 *----------------------------------------------------------------
4787 * Inline version of Tcl_GetCurrentNamespace and Tcl_GetGlobalNamespace.
4790 #define TclGetCurrentNamespace(interp) \
4791 (Tcl_Namespace *) ((Interp *)(interp))->varFramePtr->nsPtr
4793 #define TclGetGlobalNamespace(interp) \
4794 (Tcl_Namespace *) ((Interp *)(interp))->globalNsPtr
4797 *----------------------------------------------------------------
4798 * Inline version of TclCleanupCommand; still need the function as it is in
4799 * the internal stubs, but the core can use the macro instead.
4802 #define TclCleanupCommandMacro(cmdPtr) \
4803 if ((cmdPtr)->refCount-- <= 1) { \
4804 ckfree((char *) (cmdPtr));\
4808 *----------------------------------------------------------------
4809 * Inline versions of Tcl_LimitReady() and Tcl_LimitExceeded to limit number
4810 * of calls out of the critical path. Note that this code isn't particularly
4811 * readable; the non-inline version (in tclInterp.c) is much easier to
4812 * understand. Note also that these macros takes different args (iPtr->limit)
4813 * to the non-inline version.
4816 #define TclLimitExceeded(limit) ((limit).exceeded != 0)
4818 #define TclLimitReady(limit) \
4819 (((limit).active == 0) ? 0 : \
4820 (++(limit).granularityTicker, \
4821 ((((limit).active & TCL_LIMIT_COMMANDS) && \
4822 (((limit).cmdGranularity == 1) || \
4823 ((limit).granularityTicker % (limit).cmdGranularity == 0))) \
4825 (((limit).active & TCL_LIMIT_TIME) && \
4826 (((limit).timeGranularity == 1) || \
4827 ((limit).granularityTicker % (limit).timeGranularity == 0)))\
4831 * Compile-time assertions: these produce a compile time error if the
4832 * expression is not known to be true at compile time. If the assertion is
4833 * known to be false, the compiler (or optimizer?) will error out with
4834 * "division by zero". If the assertion cannot be evaluated at compile time,
4835 * the compiler will error out with "non-static initializer".
4837 * Adapted with permission from
4838 * http://www.pixelbeat.org/programming/gcc/static_assert.html
4841 #define TCL_CT_ASSERT(e) \
4842 {enum { ct_assert_value = 1/(!!(e)) };}
4845 *----------------------------------------------------------------
4846 * Allocator for small structs (<=sizeof(Tcl_Obj)) using the Tcl_Obj pool.
4847 * Only checked at compile time.
4849 * ONLY USE FOR CONSTANT nBytes.
4851 * DO NOT LET THEM CROSS THREAD BOUNDARIES
4852 *----------------------------------------------------------------
4855 #define TclSmallAlloc(nbytes, memPtr) \
4856 TclSmallAllocEx(NULL, (nbytes), (memPtr))
4858 #define TclSmallFree(memPtr) \
4859 TclSmallFreeEx(NULL, (memPtr))
4861 #ifndef TCL_MEM_DEBUG
4862 #define TclSmallAllocEx(interp, nbytes, memPtr) \
4865 TCL_CT_ASSERT((nbytes)<=sizeof(Tcl_Obj)); \
4866 TclIncrObjsAllocated(); \
4867 TclAllocObjStorageEx((interp), (_objPtr)); \
4868 memPtr = (ClientData) (_objPtr); \
4871 #define TclSmallFreeEx(interp, memPtr) \
4873 TclFreeObjStorageEx((interp), (Tcl_Obj *) (memPtr)); \
4874 TclIncrObjsFreed(); \
4877 #else /* TCL_MEM_DEBUG */
4878 #define TclSmallAllocEx(interp, nbytes, memPtr) \
4881 TCL_CT_ASSERT((nbytes)<=sizeof(Tcl_Obj)); \
4882 TclNewObj(_objPtr); \
4883 memPtr = (ClientData) _objPtr; \
4886 #define TclSmallFreeEx(interp, memPtr) \
4888 Tcl_Obj *_objPtr = (Tcl_Obj *) memPtr; \
4889 _objPtr->bytes = NULL; \
4890 _objPtr->typePtr = NULL; \
4891 _objPtr->refCount = 1; \
4892 TclDecrRefCount(_objPtr); \
4894 #endif /* TCL_MEM_DEBUG */
4897 * Support for Clang Static Analyzer <http://clang-analyzer.llvm.org>
4900 #if defined(PURIFY) && defined(__clang__)
4901 #if __has_feature(attribute_analyzer_noreturn) && \
4902 !defined(Tcl_Panic) && defined(Tcl_Panic_TCL_DECLARED)
4903 void Tcl_Panic(const char *, ...) __attribute__((analyzer_noreturn));
4905 #if !defined(CLANG_ASSERT)
4907 #define CLANG_ASSERT(x) assert(x)
4909 #elif !defined(CLANG_ASSERT)
4910 #define CLANG_ASSERT(x)
4911 #endif /* PURIFY && __clang__ */
4914 *----------------------------------------------------------------
4915 * Parameters, structs and macros for the non-recursive engine (NRE)
4916 *----------------------------------------------------------------
4919 #define NRE_USE_SMALL_ALLOC 1 /* Only turn off for debugging purposes. */
4920 #ifndef NRE_ENABLE_ASSERTS
4921 #define NRE_ENABLE_ASSERTS 0
4925 * This is the main data struct for representing NR commands. It is designed
4926 * to fit in sizeof(Tcl_Obj) in order to exploit the fastest memory allocator
4930 typedef struct NRE_callback {
4931 Tcl_NRPostProc *procPtr;
4933 struct NRE_callback *nextPtr;
4936 #define TOP_CB(iPtr) (((Interp *)(iPtr))->execEnvPtr->callbackPtr)
4939 * Inline version of Tcl_NRAddCallback.
4942 #define TclNRAddCallback(interp,postProcPtr,data0,data1,data2,data3) \
4944 NRE_callback *_callbackPtr; \
4945 TCLNR_ALLOC((interp), (_callbackPtr)); \
4946 _callbackPtr->procPtr = (postProcPtr); \
4947 _callbackPtr->data[0] = (ClientData)(data0); \
4948 _callbackPtr->data[1] = (ClientData)(data1); \
4949 _callbackPtr->data[2] = (ClientData)(data2); \
4950 _callbackPtr->data[3] = (ClientData)(data3); \
4951 _callbackPtr->nextPtr = TOP_CB(interp); \
4952 TOP_CB(interp) = _callbackPtr; \
4955 #if NRE_USE_SMALL_ALLOC
4956 #define TCLNR_ALLOC(interp, ptr) \
4957 TclSmallAllocEx(interp, sizeof(NRE_callback), (ptr))
4958 #define TCLNR_FREE(interp, ptr) TclSmallFreeEx((interp), (ptr))
4960 #define TCLNR_ALLOC(interp, ptr) \
4961 (ptr = ((ClientData) ckalloc(sizeof(NRE_callback))))
4962 #define TCLNR_FREE(interp, ptr) ckfree((char *) (ptr))
4965 #if NRE_ENABLE_ASSERTS
4966 #define NRE_ASSERT(expr) assert((expr))
4968 #define NRE_ASSERT(expr)
4971 #include "tclIntDecls.h"
4972 #include "tclIntPlatDecls.h"
4973 #include "tclTomMathDecls.h"
4975 #if !defined(USE_TCL_STUBS) && !defined(TCL_MEM_DEBUG)
4976 #define Tcl_AttemptAlloc(size) TclpAlloc(size)
4977 #define Tcl_AttemptRealloc(ptr, size) TclpRealloc((ptr), (size))
4978 #define Tcl_Free(ptr) TclpFree(ptr)
4985 MODULE_SCOPE size_t TclEnvEpoch; /* Epoch of the tcl environment
4986 * (if changed with tcl-env). */
4988 #endif /* _TCLINT */
OSDN Git Service
