Parent Directory | Revision Log | Patch
to_be_filed/sf_code/esrgpcpj/shared/tcl_base/tclint.h revision 29 by dashley, Sat Oct 8 07:08:47 2016 UTC | projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclint.h revision 71 by dashley, Sat Nov 5 11:07:06 2016 UTC | |
---|---|---|
# | Line 1 | Line 1 |
/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tcl_base/tclint.h,v 1.1.1.1 2001/06/13 04:40:00 dtashley Exp $ */ | ||
/* | ||
* tclInt.h -- | ||
* | ||
* Declarations of things used internally by the Tcl interpreter. | ||
* | ||
* Copyright (c) 1987-1993 The Regents of the University of California. | ||
* Copyright (c) 1993-1997 Lucent Technologies. | ||
* Copyright (c) 1994-1998 Sun Microsystems, Inc. | ||
* Copyright (c) 1998-1999 by Scriptics Corporation. | ||
* | ||
* See the file "license.terms" for information on usage and redistribution | ||
* of this file, and for a DISCLAIMER OF ALL WARRANTIES. | ||
* | ||
* RCS: @(#) $Id: tclint.h,v 1.1.1.1 2001/06/13 04:40:00 dtashley Exp $ | ||
*/ | ||
#ifndef _TCLINT | ||
#define _TCLINT | ||
/* | ||
* Common include files needed by most of the Tcl source files are | ||
* included here, so that system-dependent personalizations for the | ||
* include files only have to be made in once place. This results | ||
* in a few extra includes, but greater modularity. The order of | ||
* the three groups of #includes is important. For example, stdio.h | ||
* is needed by tcl.h, and the _ANSI_ARGS_ declaration in tcl.h is | ||
* needed by stdlib.h in some configurations. | ||
*/ | ||
#include <stdio.h> | ||
#ifndef _TCL | ||
#include "tcl.h" | ||
#endif | ||
#include <ctype.h> | ||
#ifdef NO_LIMITS_H | ||
# include "../compat/limits.h" | ||
#else | ||
# include <limits.h> | ||
#endif | ||
#ifdef NO_STDLIB_H | ||
# include "../compat/stdlib.h" | ||
#else | ||
# include <stdlib.h> | ||
#endif | ||
#ifdef NO_STRING_H | ||
#include "../compat/string.h" | ||
#else | ||
#include <string.h> | ||
#endif | ||
#undef TCL_STORAGE_CLASS | ||
#ifdef BUILD_tcl | ||
# define TCL_STORAGE_CLASS DLLEXPORT | ||
#else | ||
# ifdef USE_TCL_STUBS | ||
# define TCL_STORAGE_CLASS | ||
# else | ||
# define TCL_STORAGE_CLASS DLLIMPORT | ||
# endif | ||
#endif | ||
/* | ||
* The following procedures allow namespaces to be customized to | ||
* support special name resolution rules for commands/variables. | ||
* | ||
*/ | ||
struct Tcl_ResolvedVarInfo; | ||
typedef Tcl_Var (Tcl_ResolveRuntimeVarProc) _ANSI_ARGS_(( | ||
Tcl_Interp* interp, struct Tcl_ResolvedVarInfo *vinfoPtr)); | ||
typedef void (Tcl_ResolveVarDeleteProc) _ANSI_ARGS_(( | ||
struct Tcl_ResolvedVarInfo *vinfoPtr)); | ||
/* | ||
* The following structure encapsulates the routines needed to resolve a | ||
* variable reference at runtime. Any variable specific state will typically | ||
* be appended to this structure. | ||
*/ | ||
typedef struct Tcl_ResolvedVarInfo { | ||
Tcl_ResolveRuntimeVarProc *fetchProc; | ||
Tcl_ResolveVarDeleteProc *deleteProc; | ||
} Tcl_ResolvedVarInfo; | ||
typedef int (Tcl_ResolveCompiledVarProc) _ANSI_ARGS_(( | ||
Tcl_Interp* interp, char* name, int length, | ||
Tcl_Namespace *context, Tcl_ResolvedVarInfo **rPtr)); | ||
typedef int (Tcl_ResolveVarProc) _ANSI_ARGS_(( | ||
Tcl_Interp* interp, char* name, Tcl_Namespace *context, | ||
int flags, Tcl_Var *rPtr)); | ||
typedef int (Tcl_ResolveCmdProc) _ANSI_ARGS_((Tcl_Interp* interp, | ||
char* name, Tcl_Namespace *context, int flags, | ||
Tcl_Command *rPtr)); | ||
typedef struct Tcl_ResolverInfo { | ||
Tcl_ResolveCmdProc *cmdResProc; /* Procedure handling command name | ||
* resolution. */ | ||
Tcl_ResolveVarProc *varResProc; /* Procedure handling variable name | ||
* resolution for variables that | ||
* can only be handled at runtime. */ | ||
Tcl_ResolveCompiledVarProc *compiledVarResProc; | ||
/* Procedure handling variable name | ||
* resolution at compile time. */ | ||
} Tcl_ResolverInfo; | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures related to namespaces. | ||
*---------------------------------------------------------------- | ||
*/ | ||
/* | ||
* The structure below defines a namespace. | ||
* Note: the first five fields must match exactly the fields in a | ||
* Tcl_Namespace structure (see tcl.h). If you change one, be sure to | ||
* change the other. | ||
*/ | ||
typedef struct Namespace { | ||
char *name; /* The namespace's simple (unqualified) | ||
* name. This contains no ::'s. The name of | ||
* the global namespace is "" although "::" | ||
* is an synonym. */ | ||
char *fullName; /* The namespace's fully qualified name. | ||
* This starts with ::. */ | ||
ClientData clientData; /* An arbitrary value associated with this | ||
* namespace. */ | ||
Tcl_NamespaceDeleteProc *deleteProc; | ||
/* Procedure invoked when deleting the | ||
* namespace to, e.g., free clientData. */ | ||
struct Namespace *parentPtr; /* Points to the namespace that contains | ||
* this one. NULL if this is the global | ||
* namespace. */ | ||
Tcl_HashTable childTable; /* Contains any child namespaces. Indexed | ||
* by strings; values have type | ||
* (Namespace *). */ | ||
long nsId; /* Unique id for the namespace. */ | ||
Tcl_Interp *interp; /* The interpreter containing this | ||
* namespace. */ | ||
int flags; /* OR-ed combination of the namespace | ||
* status flags NS_DYING and NS_DEAD | ||
* listed below. */ | ||
int activationCount; /* Number of "activations" or active call | ||
* frames for this namespace that are on | ||
* the Tcl call stack. The namespace won't | ||
* be freed until activationCount becomes | ||
* zero. */ | ||
int refCount; /* Count of references by namespaceName * | ||
* objects. The namespace can't be freed | ||
* until refCount becomes zero. */ | ||
Tcl_HashTable cmdTable; /* Contains all the commands currently | ||
* registered in the namespace. Indexed by | ||
* strings; values have type (Command *). | ||
* Commands imported by Tcl_Import have | ||
* Command structures that point (via an | ||
* ImportedCmdRef structure) to the | ||
* Command structure in the source | ||
* namespace's command table. */ | ||
Tcl_HashTable varTable; /* Contains all the (global) variables | ||
* currently in this namespace. Indexed | ||
* by strings; values have type (Var *). */ | ||
char **exportArrayPtr; /* Points to an array of string patterns | ||
* specifying which commands are exported. | ||
* A pattern may include "string match" | ||
* style wildcard characters to specify | ||
* multiple commands; however, no namespace | ||
* qualifiers are allowed. NULL if no | ||
* export patterns are registered. */ | ||
int numExportPatterns; /* Number of export patterns currently | ||
* registered using "namespace export". */ | ||
int maxExportPatterns; /* Mumber of export patterns for which | ||
* space is currently allocated. */ | ||
int cmdRefEpoch; /* Incremented if a newly added command | ||
* shadows a command for which this | ||
* namespace has already cached a Command * | ||
* pointer; this causes all its cached | ||
* Command* pointers to be invalidated. */ | ||
int resolverEpoch; /* Incremented whenever the name resolution | ||
* rules change for this namespace; this | ||
* invalidates all byte codes compiled in | ||
* the namespace, causing the code to be | ||
* recompiled under the new rules. */ | ||
Tcl_ResolveCmdProc *cmdResProc; | ||
/* If non-null, this procedure overrides | ||
* the usual command resolution mechanism | ||
* in Tcl. This procedure is invoked | ||
* within Tcl_FindCommand to resolve all | ||
* command references within the namespace. */ | ||
Tcl_ResolveVarProc *varResProc; | ||
/* If non-null, this procedure overrides | ||
* the usual variable resolution mechanism | ||
* in Tcl. This procedure is invoked | ||
* within Tcl_FindNamespaceVar to resolve all | ||
* variable references within the namespace | ||
* at runtime. */ | ||
Tcl_ResolveCompiledVarProc *compiledVarResProc; | ||
/* If non-null, this procedure overrides | ||
* the usual variable resolution mechanism | ||
* in Tcl. This procedure is invoked | ||
* within LookupCompiledLocal to resolve | ||
* variable references within the namespace | ||
* at compile time. */ | ||
} Namespace; | ||
/* | ||
* Flags used to represent the status of a namespace: | ||
* | ||
* NS_DYING - 1 means Tcl_DeleteNamespace has been called to delete the | ||
* namespace but there are still active call frames on the Tcl | ||
* stack that refer to the namespace. When the last call frame | ||
* referring to it has been popped, it's variables and command | ||
* will be destroyed and it will be marked "dead" (NS_DEAD). | ||
* The namespace can no longer be looked up by name. | ||
* NS_DEAD - 1 means Tcl_DeleteNamespace has been called to delete the | ||
* namespace and no call frames still refer to it. Its | ||
* variables and command have already been destroyed. This bit | ||
* allows the namespace resolution code to recognize that the | ||
* namespace is "deleted". When the last namespaceName object | ||
* in any byte code code unit that refers to the namespace has | ||
* been freed (i.e., when the namespace's refCount is 0), the | ||
* namespace's storage will be freed. | ||
*/ | ||
#define NS_DYING 0x01 | ||
#define NS_DEAD 0x02 | ||
/* | ||
* Flag passed to TclGetNamespaceForQualName to have it create all namespace | ||
* components of a namespace-qualified name that cannot be found. The new | ||
* namespaces are created within their specified parent. Note that this | ||
* flag's value must not conflict with the values of the flags | ||
* TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY, and FIND_ONLY_NS (defined in | ||
* tclNamesp.c). | ||
*/ | ||
#define CREATE_NS_IF_UNKNOWN 0x800 | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures related to variables. These are used primarily | ||
* in tclVar.c | ||
*---------------------------------------------------------------- | ||
*/ | ||
/* | ||
* The following structure defines a variable trace, which is used to | ||
* invoke a specific C procedure whenever certain operations are performed | ||
* on a variable. | ||
*/ | ||
typedef struct VarTrace { | ||
Tcl_VarTraceProc *traceProc;/* Procedure to call when operations given | ||
* by flags are performed on variable. */ | ||
ClientData clientData; /* Argument to pass to proc. */ | ||
int flags; /* What events the trace procedure is | ||
* interested in: OR-ed combination of | ||
* TCL_TRACE_READS, TCL_TRACE_WRITES, | ||
* TCL_TRACE_UNSETS and TCL_TRACE_ARRAY. */ | ||
struct VarTrace *nextPtr; /* Next in list of traces associated with | ||
* a particular variable. */ | ||
} VarTrace; | ||
/* | ||
* When a variable trace is active (i.e. its associated procedure is | ||
* executing), one of the following structures is linked into a list | ||
* associated with the variable's interpreter. The information in | ||
* the structure is needed in order for Tcl to behave reasonably | ||
* if traces are deleted while traces are active. | ||
*/ | ||
typedef struct ActiveVarTrace { | ||
struct Var *varPtr; /* Variable that's being traced. */ | ||
struct ActiveVarTrace *nextPtr; | ||
/* Next in list of all active variable | ||
* traces for the interpreter, or NULL | ||
* if no more. */ | ||
VarTrace *nextTracePtr; /* Next trace to check after current | ||
* trace procedure returns; if this | ||
* trace gets deleted, must update pointer | ||
* to avoid using free'd memory. */ | ||
} ActiveVarTrace; | ||
/* | ||
* The following structure describes an enumerative search in progress on | ||
* an array variable; this are invoked with options to the "array" | ||
* command. | ||
*/ | ||
typedef struct ArraySearch { | ||
int id; /* Integer id used to distinguish among | ||
* multiple concurrent searches for the | ||
* same array. */ | ||
struct Var *varPtr; /* Pointer to array variable that's being | ||
* searched. */ | ||
Tcl_HashSearch search; /* Info kept by the hash module about | ||
* progress through the array. */ | ||
Tcl_HashEntry *nextEntry; /* Non-null means this is the next element | ||
* to be enumerated (it's leftover from | ||
* the Tcl_FirstHashEntry call or from | ||
* an "array anymore" command). NULL | ||
* means must call Tcl_NextHashEntry | ||
* to get value to return. */ | ||
struct ArraySearch *nextPtr;/* Next in list of all active searches | ||
* for this variable, or NULL if this is | ||
* the last one. */ | ||
} ArraySearch; | ||
/* | ||
* The structure below defines a variable, which associates a string name | ||
* with a Tcl_Obj value. These structures are kept in procedure call frames | ||
* (for local variables recognized by the compiler) or in the heap (for | ||
* global variables and any variable not known to the compiler). For each | ||
* Var structure in the heap, a hash table entry holds the variable name and | ||
* a pointer to the Var structure. | ||
*/ | ||
typedef struct Var { | ||
union { | ||
Tcl_Obj *objPtr; /* The variable's object value. Used for | ||
* scalar variables and array elements. */ | ||
Tcl_HashTable *tablePtr;/* For array variables, this points to | ||
* information about the hash table used | ||
* to implement the associative array. | ||
* Points to malloc-ed data. */ | ||
struct Var *linkPtr; /* If this is a global variable being | ||
* referred to in a procedure, or a variable | ||
* created by "upvar", this field points to | ||
* the referenced variable's Var struct. */ | ||
} value; | ||
char *name; /* NULL if the variable is in a hashtable, | ||
* otherwise points to the variable's | ||
* name. It is used, e.g., by TclLookupVar | ||
* and "info locals". The storage for the | ||
* characters of the name is not owned by | ||
* the Var and must not be freed when | ||
* freeing the Var. */ | ||
Namespace *nsPtr; /* Points to the namespace that contains | ||
* this variable or NULL if the variable is | ||
* a local variable in a Tcl procedure. */ | ||
Tcl_HashEntry *hPtr; /* If variable is in a hashtable, either the | ||
* hash table entry that refers to this | ||
* variable or NULL if the variable has been | ||
* detached from its hash table (e.g. an | ||
* array is deleted, but some of its | ||
* elements are still referred to in | ||
* upvars). NULL if the variable is not in a | ||
* hashtable. This is used to delete an | ||
* variable from its hashtable if it is no | ||
* longer needed. */ | ||
int refCount; /* Counts number of active uses of this | ||
* variable, not including its entry in the | ||
* call frame or the hash table: 1 for each | ||
* additional variable whose linkPtr points | ||
* here, 1 for each nested trace active on | ||
* variable, and 1 if the variable is a | ||
* namespace variable. This record can't be | ||
* deleted until refCount becomes 0. */ | ||
VarTrace *tracePtr; /* First in list of all traces set for this | ||
* variable. */ | ||
ArraySearch *searchPtr; /* First in list of all searches active | ||
* for this variable, or NULL if none. */ | ||
int flags; /* Miscellaneous bits of information about | ||
* variable. See below for definitions. */ | ||
} Var; | ||
/* | ||
* Flag bits for variables. The first three (VAR_SCALAR, VAR_ARRAY, and | ||
* VAR_LINK) are mutually exclusive and give the "type" of the variable. | ||
* VAR_UNDEFINED is independent of the variable's type. | ||
* | ||
* VAR_SCALAR - 1 means this is a scalar variable and not | ||
* an array or link. The "objPtr" field points | ||
* to the variable's value, a Tcl object. | ||
* VAR_ARRAY - 1 means this is an array variable rather | ||
* than a scalar variable or link. The | ||
* "tablePtr" field points to the array's | ||
* hashtable for its elements. | ||
* VAR_LINK - 1 means this Var structure contains a | ||
* pointer to another Var structure that | ||
* either has the real value or is itself | ||
* another VAR_LINK pointer. Variables like | ||
* this come about through "upvar" and "global" | ||
* commands, or through references to variables | ||
* in enclosing namespaces. | ||
* VAR_UNDEFINED - 1 means that the variable is in the process | ||
* of being deleted. An undefined variable | ||
* logically does not exist and survives only | ||
* while it has a trace, or if it is a global | ||
* variable currently being used by some | ||
* procedure. | ||
* VAR_IN_HASHTABLE - 1 means this variable is in a hashtable and | ||
* the Var structure is malloced. 0 if it is | ||
* a local variable that was assigned a slot | ||
* in a procedure frame by the compiler so the | ||
* Var storage is part of the call frame. | ||
* VAR_TRACE_ACTIVE - 1 means that trace processing is currently | ||
* underway for a read or write access, so | ||
* new read or write accesses should not cause | ||
* trace procedures to be called and the | ||
* variable can't be deleted. | ||
* VAR_ARRAY_ELEMENT - 1 means that this variable is an array | ||
* element, so it is not legal for it to be | ||
* an array itself (the VAR_ARRAY flag had | ||
* better not be set). | ||
* VAR_NAMESPACE_VAR - 1 means that this variable was declared | ||
* as a namespace variable. This flag ensures | ||
* it persists until its namespace is | ||
* destroyed or until the variable is unset; | ||
* it will persist even if it has not been | ||
* initialized and is marked undefined. | ||
* The variable's refCount is incremented to | ||
* reflect the "reference" from its namespace. | ||
* | ||
* The following additional flags are used with the CompiledLocal type | ||
* defined below: | ||
* | ||
* VAR_ARGUMENT - 1 means that this variable holds a procedure | ||
* argument. | ||
* VAR_TEMPORARY - 1 if the local variable is an anonymous | ||
* temporary variable. Temporaries have a NULL | ||
* name. | ||
* VAR_RESOLVED - 1 if name resolution has been done for this | ||
* variable. | ||
*/ | ||
#define VAR_SCALAR 0x1 | ||
#define VAR_ARRAY 0x2 | ||
#define VAR_LINK 0x4 | ||
#define VAR_UNDEFINED 0x8 | ||
#define VAR_IN_HASHTABLE 0x10 | ||
#define VAR_TRACE_ACTIVE 0x20 | ||
#define VAR_ARRAY_ELEMENT 0x40 | ||
#define VAR_NAMESPACE_VAR 0x80 | ||
#define VAR_ARGUMENT 0x100 | ||
#define VAR_TEMPORARY 0x200 | ||
#define VAR_RESOLVED 0x400 | ||
/* | ||
* Macros to ensure that various flag bits are set properly for variables. | ||
* The ANSI C "prototypes" for these macros are: | ||
* | ||
* EXTERN void TclSetVarScalar _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN void TclSetVarArray _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN void TclSetVarLink _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN void TclSetVarArrayElement _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN void TclSetVarUndefined _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN void TclClearVarUndefined _ANSI_ARGS_((Var *varPtr)); | ||
*/ | ||
#define TclSetVarScalar(varPtr) \ | ||
(varPtr)->flags = ((varPtr)->flags & ~(VAR_ARRAY|VAR_LINK)) | VAR_SCALAR | ||
#define TclSetVarArray(varPtr) \ | ||
(varPtr)->flags = ((varPtr)->flags & ~(VAR_SCALAR|VAR_LINK)) | VAR_ARRAY | ||
#define TclSetVarLink(varPtr) \ | ||
(varPtr)->flags = ((varPtr)->flags & ~(VAR_SCALAR|VAR_ARRAY)) | VAR_LINK | ||
#define TclSetVarArrayElement(varPtr) \ | ||
(varPtr)->flags = ((varPtr)->flags & ~VAR_ARRAY) | VAR_ARRAY_ELEMENT | ||
#define TclSetVarUndefined(varPtr) \ | ||
(varPtr)->flags |= VAR_UNDEFINED | ||
#define TclClearVarUndefined(varPtr) \ | ||
(varPtr)->flags &= ~VAR_UNDEFINED | ||
/* | ||
* Macros to read various flag bits of variables. | ||
* The ANSI C "prototypes" for these macros are: | ||
* | ||
* EXTERN int TclIsVarScalar _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN int TclIsVarLink _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN int TclIsVarArray _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN int TclIsVarUndefined _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN int TclIsVarArrayElement _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN int TclIsVarTemporary _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN int TclIsVarArgument _ANSI_ARGS_((Var *varPtr)); | ||
* EXTERN int TclIsVarResolved _ANSI_ARGS_((Var *varPtr)); | ||
*/ | ||
#define TclIsVarScalar(varPtr) \ | ||
((varPtr)->flags & VAR_SCALAR) | ||
#define TclIsVarLink(varPtr) \ | ||
((varPtr)->flags & VAR_LINK) | ||
#define TclIsVarArray(varPtr) \ | ||
((varPtr)->flags & VAR_ARRAY) | ||
#define TclIsVarUndefined(varPtr) \ | ||
((varPtr)->flags & VAR_UNDEFINED) | ||
#define TclIsVarArrayElement(varPtr) \ | ||
((varPtr)->flags & VAR_ARRAY_ELEMENT) | ||
#define TclIsVarTemporary(varPtr) \ | ||
((varPtr)->flags & VAR_TEMPORARY) | ||
#define TclIsVarArgument(varPtr) \ | ||
((varPtr)->flags & VAR_ARGUMENT) | ||
#define TclIsVarResolved(varPtr) \ | ||
((varPtr)->flags & VAR_RESOLVED) | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures related to procedures. These are used primarily | ||
* in tclProc.c, tclCompile.c, and tclExecute.c. | ||
*---------------------------------------------------------------- | ||
*/ | ||
/* | ||
* Forward declaration to prevent an error when the forward reference to | ||
* Command is encountered in the Proc and ImportRef types declared below. | ||
*/ | ||
struct Command; | ||
/* | ||
* The variable-length structure below describes a local variable of a | ||
* procedure that was recognized by the compiler. These variables have a | ||
* name, an element in the array of compiler-assigned local variables in the | ||
* procedure's call frame, and various other items of information. If the | ||
* local variable is a formal argument, it may also have a default value. | ||
* The compiler can't recognize local variables whose names are | ||
* expressions (these names are only known at runtime when the expressions | ||
* are evaluated) or local variables that are created as a result of an | ||
* "upvar" or "uplevel" command. These other local variables are kept | ||
* separately in a hash table in the call frame. | ||
*/ | ||
typedef struct CompiledLocal { | ||
struct CompiledLocal *nextPtr; | ||
/* Next compiler-recognized local variable | ||
* for this procedure, or NULL if this is | ||
* the last local. */ | ||
int nameLength; /* The number of characters in local | ||
* variable's name. Used to speed up | ||
* variable lookups. */ | ||
int frameIndex; /* Index in the array of compiler-assigned | ||
* variables in the procedure call frame. */ | ||
int flags; /* Flag bits for the local variable. Same as | ||
* the flags for the Var structure above, | ||
* although only VAR_SCALAR, VAR_ARRAY, | ||
* VAR_LINK, VAR_ARGUMENT, VAR_TEMPORARY, and | ||
* VAR_RESOLVED make sense. */ | ||
Tcl_Obj *defValuePtr; /* Pointer to the default value of an | ||
* argument, if any. NULL if not an argument | ||
* or, if an argument, no default value. */ | ||
Tcl_ResolvedVarInfo *resolveInfo; | ||
/* Customized variable resolution info | ||
* supplied by the Tcl_ResolveCompiledVarProc | ||
* associated with a namespace. Each variable | ||
* is marked by a unique ClientData tag | ||
* during compilation, and that same tag | ||
* is used to find the variable at runtime. */ | ||
char name[4]; /* Name of the local variable starts here. | ||
* If the name is NULL, this will just be | ||
* '\0'. The actual size of this field will | ||
* be large enough to hold the name. MUST | ||
* BE THE LAST FIELD IN THE STRUCTURE! */ | ||
} CompiledLocal; | ||
/* | ||
* The structure below defines a command procedure, which consists of a | ||
* collection of Tcl commands plus information about arguments and other | ||
* local variables recognized at compile time. | ||
*/ | ||
typedef struct Proc { | ||
struct Interp *iPtr; /* Interpreter for which this command | ||
* is defined. */ | ||
int refCount; /* Reference count: 1 if still present | ||
* in command table plus 1 for each call | ||
* to the procedure that is currently | ||
* active. This structure can be freed | ||
* when refCount becomes zero. */ | ||
struct Command *cmdPtr; /* Points to the Command structure for | ||
* this procedure. This is used to get | ||
* the namespace in which to execute | ||
* the procedure. */ | ||
Tcl_Obj *bodyPtr; /* Points to the ByteCode object for | ||
* procedure's body command. */ | ||
int numArgs; /* Number of formal parameters. */ | ||
int numCompiledLocals; /* Count of local variables recognized by | ||
* the compiler including arguments and | ||
* temporaries. */ | ||
CompiledLocal *firstLocalPtr; /* Pointer to first of the procedure's | ||
* compiler-allocated local variables, or | ||
* NULL if none. The first numArgs entries | ||
* in this list describe the procedure's | ||
* formal arguments. */ | ||
CompiledLocal *lastLocalPtr; /* Pointer to the last allocated local | ||
* variable or NULL if none. This has | ||
* frame index (numCompiledLocals-1). */ | ||
} Proc; | ||
/* | ||
* The structure below defines a command trace. This is used to allow Tcl | ||
* clients to find out whenever a command is about to be executed. | ||
*/ | ||
typedef struct Trace { | ||
int level; /* Only trace commands at nesting level | ||
* less than or equal to this. */ | ||
Tcl_CmdTraceProc *proc; /* Procedure to call to trace command. */ | ||
ClientData clientData; /* Arbitrary value to pass to proc. */ | ||
struct Trace *nextPtr; /* Next in list of traces for this interp. */ | ||
} Trace; | ||
/* | ||
* The structure below defines an entry in the assocData hash table which | ||
* is associated with an interpreter. The entry contains a pointer to a | ||
* function to call when the interpreter is deleted, and a pointer to | ||
* a user-defined piece of data. | ||
*/ | ||
typedef struct AssocData { | ||
Tcl_InterpDeleteProc *proc; /* Proc to call when deleting. */ | ||
ClientData clientData; /* Value to pass to proc. */ | ||
} AssocData; | ||
/* | ||
* The structure below defines a call frame. A call frame defines a naming | ||
* context for a procedure call: its local naming scope (for local | ||
* variables) and its global naming scope (a namespace, perhaps the global | ||
* :: namespace). A call frame can also define the naming context for a | ||
* namespace eval or namespace inscope command: the namespace in which the | ||
* command's code should execute. The Tcl_CallFrame structures exist only | ||
* while procedures or namespace eval/inscope's are being executed, and | ||
* provide a kind of Tcl call stack. | ||
* | ||
* WARNING!! The structure definition must be kept consistent with the | ||
* Tcl_CallFrame structure in tcl.h. If you change one, change the other. | ||
*/ | ||
typedef struct CallFrame { | ||
Namespace *nsPtr; /* Points to the namespace used to resolve | ||
* commands and global variables. */ | ||
int isProcCallFrame; /* If nonzero, the frame was pushed to | ||
* execute a Tcl procedure and may have | ||
* local vars. If 0, the frame was pushed | ||
* to execute a namespace command and var | ||
* references are treated as references to | ||
* namespace vars; varTablePtr and | ||
* compiledLocals are ignored. */ | ||
int objc; /* This and objv below describe the | ||
* arguments for this procedure call. */ | ||
Tcl_Obj *CONST *objv; /* Array of argument objects. */ | ||
struct CallFrame *callerPtr; | ||
/* Value of interp->framePtr when this | ||
* procedure was invoked (i.e. next higher | ||
* in stack of all active procedures). */ | ||
struct CallFrame *callerVarPtr; | ||
/* Value of interp->varFramePtr when this | ||
* procedure was invoked (i.e. determines | ||
* variable scoping within caller). Same | ||
* as callerPtr unless an "uplevel" command | ||
* or something equivalent was active in | ||
* the caller). */ | ||
int level; /* Level of this procedure, for "uplevel" | ||
* purposes (i.e. corresponds to nesting of | ||
* callerVarPtr's, not callerPtr's). 1 for | ||
* outermost procedure, 0 for top-level. */ | ||
Proc *procPtr; /* Points to the structure defining the | ||
* called procedure. Used to get information | ||
* such as the number of compiled local | ||
* variables (local variables assigned | ||
* entries ["slots"] in the compiledLocals | ||
* array below). */ | ||
Tcl_HashTable *varTablePtr; /* Hash table containing local variables not | ||
* recognized by the compiler, or created at | ||
* execution time through, e.g., upvar. | ||
* Initially NULL and created if needed. */ | ||
int numCompiledLocals; /* Count of local variables recognized by | ||
* the compiler including arguments. */ | ||
Var* compiledLocals; /* Points to the array of local variables | ||
* recognized by the compiler. The compiler | ||
* emits code that refers to these variables | ||
* using an index into this array. */ | ||
} CallFrame; | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures and procedures related to TclHandles, which | ||
* are a very lightweight method of preserving enough information | ||
* to determine if an arbitrary malloc'd block has been deleted. | ||
*---------------------------------------------------------------- | ||
*/ | ||
typedef VOID **TclHandle; | ||
EXTERN TclHandle TclHandleCreate _ANSI_ARGS_((VOID *ptr)); | ||
EXTERN void TclHandleFree _ANSI_ARGS_((TclHandle handle)); | ||
EXTERN TclHandle TclHandlePreserve _ANSI_ARGS_((TclHandle handle)); | ||
EXTERN void TclHandleRelease _ANSI_ARGS_((TclHandle handle)); | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures related to history. These are used primarily | ||
* in tclHistory.c | ||
*---------------------------------------------------------------- | ||
*/ | ||
/* | ||
* The structure below defines one history event (a previously-executed | ||
* command that can be re-executed in whole or in part). | ||
*/ | ||
typedef struct { | ||
char *command; /* String containing previously-executed | ||
* command. */ | ||
int bytesAvl; /* Total # of bytes available at *event (not | ||
* all are necessarily in use now). */ | ||
} HistoryEvent; | ||
/* | ||
* The structure below defines a pending revision to the most recent | ||
* history event. Changes are linked together into a list and applied | ||
* during the next call to Tcl_RecordHistory. See the comments at the | ||
* beginning of tclHistory.c for information on revisions. | ||
*/ | ||
typedef struct HistoryRev { | ||
int firstIndex; /* Index of the first byte to replace in | ||
* current history event. */ | ||
int lastIndex; /* Index of last byte to replace in | ||
* current history event. */ | ||
int newSize; /* Number of bytes in newBytes. */ | ||
char *newBytes; /* Replacement for the range given by | ||
* firstIndex and lastIndex (malloced). */ | ||
struct HistoryRev *nextPtr; /* Next in chain of revisions to apply, or | ||
* NULL for end of list. */ | ||
} HistoryRev; | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures related to expressions. These are used only in | ||
* tclExpr.c. | ||
*---------------------------------------------------------------- | ||
*/ | ||
/* | ||
* The data structure below defines a math function (e.g. sin or hypot) | ||
* for use in Tcl expressions. | ||
*/ | ||
#define MAX_MATH_ARGS 5 | ||
typedef struct MathFunc { | ||
int builtinFuncIndex; /* If this is a builtin math function, its | ||
* index in the array of builtin functions. | ||
* (tclCompilation.h lists these indices.) | ||
* The value is -1 if this is a new function | ||
* defined by Tcl_CreateMathFunc. The value | ||
* is also -1 if a builtin function is | ||
* replaced by a Tcl_CreateMathFunc call. */ | ||
int numArgs; /* Number of arguments for function. */ | ||
Tcl_ValueType argTypes[MAX_MATH_ARGS]; | ||
/* Acceptable types for each argument. */ | ||
Tcl_MathProc *proc; /* Procedure that implements this function. | ||
* NULL if isBuiltinFunc is 1. */ | ||
ClientData clientData; /* Additional argument to pass to the | ||
* function when invoking it. NULL if | ||
* isBuiltinFunc is 1. */ | ||
} MathFunc; | ||
/* | ||
* These are a thin layer over TclpThreadKeyDataGet and TclpThreadKeyDataSet | ||
* when threads are used, or an emulation if there are no threads. These | ||
* are really internal and Tcl clients should use Tcl_GetThreadData. | ||
*/ | ||
EXTERN VOID *TclThreadDataKeyGet _ANSI_ARGS_((Tcl_ThreadDataKey *keyPtr)); | ||
EXTERN void TclThreadDataKeySet _ANSI_ARGS_((Tcl_ThreadDataKey *keyPtr, VOID *data)); | ||
/* | ||
* This is a convenience macro used to initialize a thread local storage ptr. | ||
*/ | ||
#define TCL_TSD_INIT(keyPtr) (ThreadSpecificData *)Tcl_GetThreadData((keyPtr), sizeof(ThreadSpecificData)) | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures related to bytecode compilation and execution. | ||
* These are used primarily in tclCompile.c, tclExecute.c, and | ||
* tclBasic.c. | ||
*---------------------------------------------------------------- | ||
*/ | ||
/* | ||
* Forward declaration to prevent errors when the forward references to | ||
* Tcl_Parse and CompileEnv are encountered in the procedure type | ||
* CompileProc declared below. | ||
*/ | ||
struct CompileEnv; | ||
/* | ||
* The type of procedures called by the Tcl bytecode compiler to compile | ||
* commands. Pointers to these procedures are kept in the Command structure | ||
* describing each command. When a CompileProc returns, the interpreter's | ||
* result is set to error information, if any. In addition, the CompileProc | ||
* returns an integer value, which is one of the following: | ||
* | ||
* TCL_OK Compilation completed normally. | ||
* TCL_ERROR Compilation failed because of an error; | ||
* the interpreter's result describes what went wrong. | ||
* TCL_OUT_LINE_COMPILE Compilation failed because, e.g., the command is | ||
* too complex for effective inline compilation. The | ||
* CompileProc believes the command is legal but | ||
* should be compiled "out of line" by emitting code | ||
* to invoke its command procedure at runtime. | ||
*/ | ||
#define TCL_OUT_LINE_COMPILE (TCL_CONTINUE + 1) | ||
typedef int (CompileProc) _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *compEnvPtr)); | ||
/* | ||
* The type of procedure called from the compilation hook point in | ||
* SetByteCodeFromAny. | ||
*/ | ||
typedef int (CompileHookProc) _ANSI_ARGS_((Tcl_Interp *interp, | ||
struct CompileEnv *compEnvPtr, ClientData clientData)); | ||
/* | ||
* The data structure defining the execution environment for ByteCode's. | ||
* There is one ExecEnv structure per Tcl interpreter. It holds the | ||
* evaluation stack that holds command operands and results. The stack grows | ||
* towards increasing addresses. The "stackTop" member is cached by | ||
* TclExecuteByteCode in a local variable: it must be set before calling | ||
* TclExecuteByteCode and will be restored by TclExecuteByteCode before it | ||
* returns. | ||
*/ | ||
typedef struct ExecEnv { | ||
Tcl_Obj **stackPtr; /* Points to the first item in the | ||
* evaluation stack on the heap. */ | ||
int stackTop; /* Index of current top of stack; -1 when | ||
* the stack is empty. */ | ||
int stackEnd; /* Index of last usable item in stack. */ | ||
} ExecEnv; | ||
/* | ||
* The definitions for the LiteralTable and LiteralEntry structures. Each | ||
* interpreter contains a LiteralTable. It is used to reduce the storage | ||
* needed for all the Tcl objects that hold the literals of scripts compiled | ||
* by the interpreter. A literal's object is shared by all the ByteCodes | ||
* that refer to the literal. Each distinct literal has one LiteralEntry | ||
* entry in the LiteralTable. A literal table is a specialized hash table | ||
* that is indexed by the literal's string representation, which may contain | ||
* null characters. | ||
* | ||
* Note that we reduce the space needed for literals by sharing literal | ||
* objects both within a ByteCode (each ByteCode contains a local | ||
* LiteralTable) and across all an interpreter's ByteCodes (with the | ||
* interpreter's global LiteralTable). | ||
*/ | ||
typedef struct LiteralEntry { | ||
struct LiteralEntry *nextPtr; /* Points to next entry in this | ||
* hash bucket or NULL if end of | ||
* chain. */ | ||
Tcl_Obj *objPtr; /* Points to Tcl object that | ||
* holds the literal's bytes and | ||
* length. */ | ||
int refCount; /* If in an interpreter's global | ||
* literal table, the number of | ||
* ByteCode structures that share | ||
* the literal object; the literal | ||
* entry can be freed when refCount | ||
* drops to 0. If in a local literal | ||
* table, -1. */ | ||
} LiteralEntry; | ||
typedef struct LiteralTable { | ||
LiteralEntry **buckets; /* Pointer to bucket array. Each | ||
* element points to first entry in | ||
* bucket's hash chain, or NULL. */ | ||
LiteralEntry *staticBuckets[TCL_SMALL_HASH_TABLE]; | ||
/* Bucket array used for small | ||
* tables to avoid mallocs and | ||
* frees. */ | ||
int numBuckets; /* Total number of buckets allocated | ||
* at **buckets. */ | ||
int numEntries; /* Total number of entries present | ||
* in table. */ | ||
int rebuildSize; /* Enlarge table when numEntries | ||
* gets to be this large. */ | ||
int mask; /* Mask value used in hashing | ||
* function. */ | ||
} LiteralTable; | ||
/* | ||
* The following structure defines for each Tcl interpreter various | ||
* statistics-related information about the bytecode compiler and | ||
* interpreter's operation in that interpreter. | ||
*/ | ||
#ifdef TCL_COMPILE_STATS | ||
typedef struct ByteCodeStats { | ||
long numExecutions; /* Number of ByteCodes executed. */ | ||
long numCompilations; /* Number of ByteCodes created. */ | ||
long numByteCodesFreed; /* Number of ByteCodes destroyed. */ | ||
long instructionCount[256]; /* Number of times each instruction was | ||
* executed. */ | ||
double totalSrcBytes; /* Total source bytes ever compiled. */ | ||
double totalByteCodeBytes; /* Total bytes for all ByteCodes. */ | ||
double currentSrcBytes; /* Src bytes for all current ByteCodes. */ | ||
double currentByteCodeBytes; /* Code bytes in all current ByteCodes. */ | ||
long srcCount[32]; /* Source size distribution: # of srcs of | ||
* size [2**(n-1)..2**n), n in [0..32). */ | ||
long byteCodeCount[32]; /* ByteCode size distribution. */ | ||
long lifetimeCount[32]; /* ByteCode lifetime distribution (ms). */ | ||
double currentInstBytes; /* Instruction bytes-current ByteCodes. */ | ||
double currentLitBytes; /* Current literal bytes. */ | ||
double currentExceptBytes; /* Current exception table bytes. */ | ||
double currentAuxBytes; /* Current auxiliary information bytes. */ | ||
double currentCmdMapBytes; /* Current src<->code map bytes. */ | ||
long numLiteralsCreated; /* Total literal objects ever compiled. */ | ||
double totalLitStringBytes; /* Total string bytes in all literals. */ | ||
double currentLitStringBytes; /* String bytes in current literals. */ | ||
long literalCount[32]; /* Distribution of literal string sizes. */ | ||
} ByteCodeStats; | ||
#endif /* TCL_COMPILE_STATS */ | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures related to commands. | ||
*---------------------------------------------------------------- | ||
*/ | ||
/* | ||
* An imported command is created in an namespace when it imports a "real" | ||
* command from another namespace. An imported command has a Command | ||
* structure that points (via its ClientData value) to the "real" Command | ||
* structure in the source namespace's command table. The real command | ||
* records all the imported commands that refer to it in a list of ImportRef | ||
* structures so that they can be deleted when the real command is deleted. */ | ||
typedef struct ImportRef { | ||
struct Command *importedCmdPtr; | ||
/* Points to the imported command created in | ||
* an importing namespace; this command | ||
* redirects its invocations to the "real" | ||
* command. */ | ||
struct ImportRef *nextPtr; /* Next element on the linked list of | ||
* imported commands that refer to the | ||
* "real" command. The real command deletes | ||
* these imported commands on this list when | ||
* it is deleted. */ | ||
} ImportRef; | ||
/* | ||
* Data structure used as the ClientData of imported commands: commands | ||
* created in an namespace when it imports a "real" command from another | ||
* namespace. | ||
*/ | ||
typedef struct ImportedCmdData { | ||
struct Command *realCmdPtr; /* "Real" command that this imported command | ||
* refers to. */ | ||
struct Command *selfPtr; /* Pointer to this imported command. Needed | ||
* only when deleting it in order to remove | ||
* it from the real command's linked list of | ||
* imported commands that refer to it. */ | ||
} ImportedCmdData; | ||
/* | ||
* A Command structure exists for each command in a namespace. The | ||
* Tcl_Command opaque type actually refers to these structures. | ||
*/ | ||
typedef struct Command { | ||
Tcl_HashEntry *hPtr; /* Pointer to the hash table entry that | ||
* refers to this command. The hash table is | ||
* either a namespace's command table or an | ||
* interpreter's hidden command table. This | ||
* pointer is used to get a command's name | ||
* from its Tcl_Command handle. NULL means | ||
* that the hash table entry has been | ||
* removed already (this can happen if | ||
* deleteProc causes the command to be | ||
* deleted or recreated). */ | ||
Namespace *nsPtr; /* Points to the namespace containing this | ||
* command. */ | ||
int refCount; /* 1 if in command hashtable plus 1 for each | ||
* reference from a CmdName Tcl object | ||
* representing a command's name in a | ||
* ByteCode instruction sequence. This | ||
* structure can be freed when refCount | ||
* becomes zero. */ | ||
int cmdEpoch; /* Incremented to invalidate any references | ||
* that point to this command when it is | ||
* renamed, deleted, hidden, or exposed. */ | ||
CompileProc *compileProc; /* Procedure called to compile command. NULL | ||
* if no compile proc exists for command. */ | ||
Tcl_ObjCmdProc *objProc; /* Object-based command procedure. */ | ||
ClientData objClientData; /* Arbitrary value passed to object proc. */ | ||
Tcl_CmdProc *proc; /* String-based command procedure. */ | ||
ClientData clientData; /* Arbitrary value passed to string proc. */ | ||
Tcl_CmdDeleteProc *deleteProc; | ||
/* Procedure invoked when deleting command | ||
* to, e.g., free all client data. */ | ||
ClientData deleteData; /* Arbitrary value passed to deleteProc. */ | ||
int deleted; /* Means that the command is in the process | ||
* of being deleted (its deleteProc is | ||
* currently executing). Other attempts to | ||
* delete the command should be ignored. */ | ||
ImportRef *importRefPtr; /* List of each imported Command created in | ||
* another namespace when this command is | ||
* imported. These imported commands | ||
* redirect invocations back to this | ||
* command. The list is used to remove all | ||
* those imported commands when deleting | ||
* this "real" command. */ | ||
} Command; | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures related to name resolution procedures. | ||
*---------------------------------------------------------------- | ||
*/ | ||
/* | ||
* The interpreter keeps a linked list of name resolution schemes. | ||
* The scheme for a namespace is consulted first, followed by the | ||
* list of schemes in an interpreter, followed by the default | ||
* name resolution in Tcl. Schemes are added/removed from the | ||
* interpreter's list by calling Tcl_AddInterpResolver and | ||
* Tcl_RemoveInterpResolver. | ||
*/ | ||
typedef struct ResolverScheme { | ||
char *name; /* Name identifying this scheme. */ | ||
Tcl_ResolveCmdProc *cmdResProc; | ||
/* Procedure handling command name | ||
* resolution. */ | ||
Tcl_ResolveVarProc *varResProc; | ||
/* Procedure handling variable name | ||
* resolution for variables that | ||
* can only be handled at runtime. */ | ||
Tcl_ResolveCompiledVarProc *compiledVarResProc; | ||
/* Procedure handling variable name | ||
* resolution at compile time. */ | ||
struct ResolverScheme *nextPtr; | ||
/* Pointer to next record in linked list. */ | ||
} ResolverScheme; | ||
/* | ||
*---------------------------------------------------------------- | ||
* This structure defines an interpreter, which is a collection of | ||
* commands plus other state information related to interpreting | ||
* commands, such as variable storage. Primary responsibility for | ||
* this data structure is in tclBasic.c, but almost every Tcl | ||
* source file uses something in here. | ||
*---------------------------------------------------------------- | ||
*/ | ||
typedef struct Interp { | ||
/* | ||
* Note: the first three fields must match exactly the fields in | ||
* a Tcl_Interp struct (see tcl.h). If you change one, be sure to | ||
* change the other. | ||
* | ||
* The interpreter's result is held in both the string and the | ||
* objResultPtr fields. These fields hold, respectively, the result's | ||
* string or object value. The interpreter's result is always in the | ||
* result field if that is non-empty, otherwise it is in objResultPtr. | ||
* The two fields are kept consistent unless some C code sets | ||
* interp->result directly. Programs should not access result and | ||
* objResultPtr directly; instead, they should always get and set the | ||
* result using procedures such as Tcl_SetObjResult, Tcl_GetObjResult, | ||
* and Tcl_GetStringResult. See the SetResult man page for details. | ||
*/ | ||
char *result; /* If the last command returned a string | ||
* result, this points to it. Should not be | ||
* accessed directly; see comment above. */ | ||
Tcl_FreeProc *freeProc; /* Zero means a string result is statically | ||
* allocated. TCL_DYNAMIC means string | ||
* result was allocated with ckalloc and | ||
* should be freed with ckfree. Other values | ||
* give address of procedure to invoke to | ||
* free the string result. Tcl_Eval must | ||
* free it before executing next command. */ | ||
int errorLine; /* When TCL_ERROR is returned, this gives | ||
* the line number in the command where the | ||
* error occurred (1 means first line). */ | ||
struct TclStubs *stubTable; | ||
/* Pointer to the exported Tcl stub table. | ||
* On previous versions of Tcl this is a | ||
* pointer to the objResultPtr or a pointer | ||
* to a buckets array in a hash table. We | ||
* therefore have to do some careful checking | ||
* before we can use this. */ | ||
TclHandle handle; /* Handle used to keep track of when this | ||
* interp is deleted. */ | ||
Namespace *globalNsPtr; /* The interpreter's global namespace. */ | ||
Tcl_HashTable *hiddenCmdTablePtr; | ||
/* Hash table used by tclBasic.c to keep | ||
* track of hidden commands on a per-interp | ||
* basis. */ | ||
ClientData interpInfo; /* Information used by tclInterp.c to keep | ||
* track of master/slave interps on | ||
* a per-interp basis. */ | ||
Tcl_HashTable mathFuncTable;/* Contains all the math functions currently | ||
* defined for the interpreter. Indexed by | ||
* strings (function names); values have | ||
* type (MathFunc *). */ | ||
/* | ||
* Information related to procedures and variables. See tclProc.c | ||
* and tclvar.c for usage. | ||
*/ | ||
int numLevels; /* Keeps track of how many nested calls to | ||
* Tcl_Eval are in progress for this | ||
* interpreter. It's used to delay deletion | ||
* of the table until all Tcl_Eval | ||
* invocations are completed. */ | ||
int maxNestingDepth; /* If numLevels exceeds this value then Tcl | ||
* assumes that infinite recursion has | ||
* occurred and it generates an error. */ | ||
CallFrame *framePtr; /* Points to top-most in stack of all nested | ||
* procedure invocations. NULL means there | ||
* are no active procedures. */ | ||
CallFrame *varFramePtr; /* Points to the call frame whose variables | ||
* are currently in use (same as framePtr | ||
* unless an "uplevel" command is | ||
* executing). NULL means no procedure is | ||
* active or "uplevel 0" is executing. */ | ||
ActiveVarTrace *activeTracePtr; | ||
/* First in list of active traces for | ||
* interp, or NULL if no active traces. */ | ||
int returnCode; /* Completion code to return if current | ||
* procedure exits with TCL_RETURN code. */ | ||
char *errorInfo; /* Value to store in errorInfo if returnCode | ||
* is TCL_ERROR. Malloc'ed, may be NULL */ | ||
char *errorCode; /* Value to store in errorCode if returnCode | ||
* is TCL_ERROR. Malloc'ed, may be NULL */ | ||
/* | ||
* Information used by Tcl_AppendResult to keep track of partial | ||
* results. See Tcl_AppendResult code for details. | ||
*/ | ||
char *appendResult; /* Storage space for results generated | ||
* by Tcl_AppendResult. Malloc-ed. NULL | ||
* means not yet allocated. */ | ||
int appendAvl; /* Total amount of space available at | ||
* partialResult. */ | ||
int appendUsed; /* Number of non-null bytes currently | ||
* stored at partialResult. */ | ||
/* | ||
* Information about packages. Used only in tclPkg.c. | ||
*/ | ||
Tcl_HashTable packageTable; /* Describes all of the packages loaded | ||
* in or available to this interpreter. | ||
* Keys are package names, values are | ||
* (Package *) pointers. */ | ||
char *packageUnknown; /* Command to invoke during "package | ||
* require" commands for packages that | ||
* aren't described in packageTable. | ||
* Malloc'ed, may be NULL. */ | ||
/* | ||
* Miscellaneous information: | ||
*/ | ||
int cmdCount; /* Total number of times a command procedure | ||
* has been called for this interpreter. */ | ||
int evalFlags; /* Flags to control next call to Tcl_Eval. | ||
* Normally zero, but may be set before | ||
* calling Tcl_Eval. See below for valid | ||
* values. */ | ||
int termOffset; /* Offset of character just after last one | ||
* compiled or executed by Tcl_EvalObj. */ | ||
LiteralTable literalTable; /* Contains LiteralEntry's describing all | ||
* Tcl objects holding literals of scripts | ||
* compiled by the interpreter. Indexed by | ||
* the string representations of literals. | ||
* Used to avoid creating duplicate | ||
* objects. */ | ||
int compileEpoch; /* Holds the current "compilation epoch" | ||
* for this interpreter. This is | ||
* incremented to invalidate existing | ||
* ByteCodes when, e.g., a command with a | ||
* compile procedure is redefined. */ | ||
Proc *compiledProcPtr; /* If a procedure is being compiled, a | ||
* pointer to its Proc structure; otherwise, | ||
* this is NULL. Set by ObjInterpProc in | ||
* tclProc.c and used by tclCompile.c to | ||
* process local variables appropriately. */ | ||
ResolverScheme *resolverPtr; | ||
/* Linked list of name resolution schemes | ||
* added to this interpreter. Schemes | ||
* are added/removed by calling | ||
* Tcl_AddInterpResolvers and | ||
* Tcl_RemoveInterpResolver. */ | ||
char *scriptFile; /* NULL means there is no nested source | ||
* command active; otherwise this points to | ||
* the name of the file being sourced (it's | ||
* not malloc-ed: it points to an argument | ||
* to Tcl_EvalFile. */ | ||
int flags; /* Various flag bits. See below. */ | ||
long randSeed; /* Seed used for rand() function. */ | ||
Trace *tracePtr; /* List of traces for this interpreter. */ | ||
Tcl_HashTable *assocData; /* Hash table for associating data with | ||
* this interpreter. Cleaned up when | ||
* this interpreter is deleted. */ | ||
struct ExecEnv *execEnvPtr; /* Execution environment for Tcl bytecode | ||
* execution. Contains a pointer to the | ||
* Tcl evaluation stack. */ | ||
Tcl_Obj *emptyObjPtr; /* Points to an object holding an empty | ||
* string. Returned by Tcl_ObjSetVar2 when | ||
* variable traces change a variable in a | ||
* gross way. */ | ||
char resultSpace[TCL_RESULT_SIZE+1]; | ||
/* Static space holding small results. */ | ||
Tcl_Obj *objResultPtr; /* If the last command returned an object | ||
* result, this points to it. Should not be | ||
* accessed directly; see comment above. */ | ||
Tcl_ThreadId threadId; /* ID of thread that owns the interpreter */ | ||
/* | ||
* Statistical information about the bytecode compiler and interpreter's | ||
* operation. | ||
*/ | ||
#ifdef TCL_COMPILE_STATS | ||
ByteCodeStats stats; /* Holds compilation and execution | ||
* statistics for this interpreter. */ | ||
#endif /* TCL_COMPILE_STATS */ | ||
} Interp; | ||
/* | ||
* EvalFlag bits for Interp structures: | ||
* | ||
* TCL_BRACKET_TERM 1 means that the current script is terminated by | ||
* a close bracket rather than the end of the string. | ||
* TCL_ALLOW_EXCEPTIONS 1 means it's OK for the script to terminate with | ||
* a code other than TCL_OK or TCL_ERROR; 0 means | ||
* codes other than these should be turned into errors. | ||
*/ | ||
#define TCL_BRACKET_TERM 1 | ||
#define TCL_ALLOW_EXCEPTIONS 4 | ||
/* | ||
* Flag bits for Interp structures: | ||
* | ||
* DELETED: Non-zero means the interpreter has been deleted: | ||
* don't process any more commands for it, and destroy | ||
* the structure as soon as all nested invocations of | ||
* Tcl_Eval are done. | ||
* ERR_IN_PROGRESS: Non-zero means an error unwind is already in | ||
* progress. Zero means a command proc has been | ||
* invoked since last error occured. | ||
* ERR_ALREADY_LOGGED: Non-zero means information has already been logged | ||
* in $errorInfo for the current Tcl_Eval instance, | ||
* so Tcl_Eval needn't log it (used to implement the | ||
* "error message log" command). | ||
* ERROR_CODE_SET: Non-zero means that Tcl_SetErrorCode has been | ||
* called to record information for the current | ||
* error. Zero means Tcl_Eval must clear the | ||
* errorCode variable if an error is returned. | ||
* EXPR_INITIALIZED: Non-zero means initialization specific to | ||
* expressions has been carried out. | ||
* DONT_COMPILE_CMDS_INLINE: Non-zero means that the bytecode compiler | ||
* should not compile any commands into an inline | ||
* sequence of instructions. This is set 1, for | ||
* example, when command traces are requested. | ||
* RAND_SEED_INITIALIZED: Non-zero means that the randSeed value of the | ||
* interp has not be initialized. This is set 1 | ||
* when we first use the rand() or srand() functions. | ||
* SAFE_INTERP: Non zero means that the current interp is a | ||
* safe interp (ie it has only the safe commands | ||
* installed, less priviledge than a regular interp). | ||
* USE_EVAL_DIRECT: Non-zero means don't use the compiler or byte-code | ||
* interpreter; instead, have Tcl_EvalObj call | ||
* Tcl_EvalEx. Used primarily for testing the | ||
* new parser. | ||
*/ | ||
#define DELETED 1 | ||
#define ERR_IN_PROGRESS 2 | ||
#define ERR_ALREADY_LOGGED 4 | ||
#define ERROR_CODE_SET 8 | ||
#define EXPR_INITIALIZED 0x10 | ||
#define DONT_COMPILE_CMDS_INLINE 0x20 | ||
#define RAND_SEED_INITIALIZED 0x40 | ||
#define SAFE_INTERP 0x80 | ||
#define USE_EVAL_DIRECT 0x100 | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures related to command parsing. These are used in | ||
* tclParse.c and its clients. | ||
*---------------------------------------------------------------- | ||
*/ | ||
/* | ||
* The following data structure is used by various parsing procedures | ||
* to hold information about where to store the results of parsing | ||
* (e.g. the substituted contents of a quoted argument, or the result | ||
* of a nested command). At any given time, the space available | ||
* for output is fixed, but a procedure may be called to expand the | ||
* space available if the current space runs out. | ||
*/ | ||
typedef struct ParseValue { | ||
char *buffer; /* Address of first character in | ||
* output buffer. */ | ||
char *next; /* Place to store next character in | ||
* output buffer. */ | ||
char *end; /* Address of the last usable character | ||
* in the buffer. */ | ||
void (*expandProc) _ANSI_ARGS_((struct ParseValue *pvPtr, int needed)); | ||
/* Procedure to call when space runs out; | ||
* it will make more space. */ | ||
ClientData clientData; /* Arbitrary information for use of | ||
* expandProc. */ | ||
} ParseValue; | ||
/* | ||
* Maximum number of levels of nesting permitted in Tcl commands (used | ||
* to catch infinite recursion). | ||
*/ | ||
#define MAX_NESTING_DEPTH 1000 | ||
/* | ||
* The macro below is used to modify a "char" value (e.g. by casting | ||
* it to an unsigned character) so that it can be used safely with | ||
* macros such as isspace. | ||
*/ | ||
#define UCHAR(c) ((unsigned char) (c)) | ||
/* | ||
* This macro is used to determine the offset needed to safely allocate any | ||
* data structure in memory. Given a starting offset or size, it "rounds up" | ||
* or "aligns" the offset to the next 8-byte boundary so that any data | ||
* structure can be placed at the resulting offset without fear of an | ||
* alignment error. | ||
* | ||
* WARNING!! DO NOT USE THIS MACRO TO ALIGN POINTERS: it will produce | ||
* the wrong result on platforms that allocate addresses that are divisible | ||
* by 4 or 2. Only use it for offsets or sizes. | ||
*/ | ||
#define TCL_ALIGN(x) (((int)(x) + 7) & ~7) | ||
/* | ||
* The following macros are used to specify the runtime platform | ||
* setting of the tclPlatform variable. | ||
*/ | ||
typedef enum { | ||
TCL_PLATFORM_UNIX, /* Any Unix-like OS. */ | ||
TCL_PLATFORM_MAC, /* MacOS. */ | ||
TCL_PLATFORM_WINDOWS /* Any Microsoft Windows OS. */ | ||
} TclPlatformType; | ||
/* | ||
* Flags for TclInvoke: | ||
* | ||
* TCL_INVOKE_HIDDEN Invoke a hidden command; if not set, | ||
* invokes an exposed command. | ||
* TCL_INVOKE_NO_UNKNOWN If set, "unknown" is not invoked if | ||
* the command to be invoked is not found. | ||
* Only has an effect if invoking an exposed | ||
* command, i.e. if TCL_INVOKE_HIDDEN is not | ||
* also set. | ||
* TCL_INVOKE_NO_TRACEBACK Does not record traceback information if | ||
* the invoked command returns an error. Used | ||
* if the caller plans on recording its own | ||
* traceback information. | ||
*/ | ||
#define TCL_INVOKE_HIDDEN (1<<0) | ||
#define TCL_INVOKE_NO_UNKNOWN (1<<1) | ||
#define TCL_INVOKE_NO_TRACEBACK (1<<2) | ||
/* | ||
* The structure used as the internal representation of Tcl list | ||
* objects. This is an array of pointers to the element objects. This array | ||
* is grown (reallocated and copied) as necessary to hold all the list's | ||
* element pointers. The array might contain more slots than currently used | ||
* to hold all element pointers. This is done to make append operations | ||
* faster. | ||
*/ | ||
typedef struct List { | ||
int maxElemCount; /* Total number of element array slots. */ | ||
int elemCount; /* Current number of list elements. */ | ||
Tcl_Obj **elements; /* Array of pointers to element objects. */ | ||
} List; | ||
/* | ||
* The following types are used for getting and storing platform-specific | ||
* file attributes in tclFCmd.c and the various platform-versions of | ||
* that file. This is done to have as much common code as possible | ||
* in the file attributes code. For more information about the callbacks, | ||
* see TclFileAttrsCmd in tclFCmd.c. | ||
*/ | ||
typedef int (TclGetFileAttrProc) _ANSI_ARGS_((Tcl_Interp *interp, | ||
int objIndex, CONST char *fileName, Tcl_Obj **attrObjPtrPtr)); | ||
typedef int (TclSetFileAttrProc) _ANSI_ARGS_((Tcl_Interp *interp, | ||
int objIndex, CONST char *fileName, Tcl_Obj *attrObjPtr)); | ||
typedef struct TclFileAttrProcs { | ||
TclGetFileAttrProc *getProc; /* The procedure for getting attrs. */ | ||
TclSetFileAttrProc *setProc; /* The procedure for setting attrs. */ | ||
} TclFileAttrProcs; | ||
/* | ||
* Opaque handle used in pipeline routines to encapsulate platform-dependent | ||
* state. | ||
*/ | ||
typedef struct TclFile_ *TclFile; | ||
/* | ||
*---------------------------------------------------------------- | ||
* Data structures related to hooking 'TclStat(...)' and | ||
* 'TclAccess(...)'. | ||
*---------------------------------------------------------------- | ||
*/ | ||
typedef int (TclStatProc_) _ANSI_ARGS_((CONST char *path, struct stat *buf)); | ||
typedef int (TclAccessProc_) _ANSI_ARGS_((CONST char *path, int mode)); | ||
typedef Tcl_Channel (TclOpenFileChannelProc_) _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *fileName, char *modeString, | ||
int permissions)); | ||
typedef int (*TclCmdProcType) _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int argc, char *argv[])); | ||
typedef int (*TclObjCmdProcType) _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, struct Tcl_Obj * CONST objv[])); | ||
/* | ||
* Opaque names for platform specific types. | ||
*/ | ||
typedef struct TclpTime_t_ *TclpTime_t; | ||
/* | ||
* The following structure is used to pass glob type data amongst | ||
* the various glob routines and TclpMatchFilesTypes. Currently | ||
* most of the fields are ignored. However they will be used in | ||
* a future release to implement glob's ability to find files | ||
* of particular types/permissions/etc only. | ||
*/ | ||
typedef struct GlobTypeData { | ||
/* Corresponds to bcdpfls as in 'find -t' */ | ||
int type; | ||
/* Corresponds to file permissions */ | ||
int perm; | ||
/* Acceptable mac type */ | ||
Tcl_Obj* macType; | ||
/* Acceptable mac creator */ | ||
Tcl_Obj* macCreator; | ||
} GlobTypeData; | ||
/* | ||
* type and permission definitions for glob command | ||
*/ | ||
#define TCL_GLOB_TYPE_BLOCK (1<<0) | ||
#define TCL_GLOB_TYPE_CHAR (1<<1) | ||
#define TCL_GLOB_TYPE_DIR (1<<2) | ||
#define TCL_GLOB_TYPE_PIPE (1<<3) | ||
#define TCL_GLOB_TYPE_FILE (1<<4) | ||
#define TCL_GLOB_TYPE_LINK (1<<5) | ||
#define TCL_GLOB_TYPE_SOCK (1<<6) | ||
#define TCL_GLOB_PERM_RONLY (1<<0) | ||
#define TCL_GLOB_PERM_HIDDEN (1<<1) | ||
#define TCL_GLOB_PERM_R (1<<2) | ||
#define TCL_GLOB_PERM_W (1<<3) | ||
#define TCL_GLOB_PERM_X (1<<4) | ||
/* | ||
*---------------------------------------------------------------- | ||
* Variables shared among Tcl modules but not used by the outside world. | ||
*---------------------------------------------------------------- | ||
*/ | ||
extern Tcl_Time tclBlockTime; | ||
extern int tclBlockTimeSet; | ||
extern char * tclExecutableName; | ||
extern char * tclNativeExecutableName; | ||
extern char * tclDefaultEncodingDir; | ||
extern Tcl_ChannelType tclFileChannelType; | ||
extern char * tclMemDumpFileName; | ||
extern TclPlatformType tclPlatform; | ||
extern char * tclpFileAttrStrings[]; | ||
extern CONST TclFileAttrProcs tclpFileAttrProcs[]; | ||
/* | ||
* Variables denoting the Tcl object types defined in the core. | ||
*/ | ||
extern Tcl_ObjType tclBooleanType; | ||
extern Tcl_ObjType tclByteArrayType; | ||
extern Tcl_ObjType tclByteCodeType; | ||
extern Tcl_ObjType tclDoubleType; | ||
extern Tcl_ObjType tclIntType; | ||
extern Tcl_ObjType tclListType; | ||
extern Tcl_ObjType tclProcBodyType; | ||
extern Tcl_ObjType tclStringType; | ||
/* | ||
* The head of the list of free Tcl objects, and the total number of Tcl | ||
* objects ever allocated and freed. | ||
*/ | ||
extern Tcl_Obj * tclFreeObjList; | ||
#ifdef TCL_COMPILE_STATS | ||
extern long tclObjsAlloced; | ||
extern long tclObjsFreed; | ||
#endif /* TCL_COMPILE_STATS */ | ||
/* | ||
* Pointer to a heap-allocated string of length zero that the Tcl core uses | ||
* as the value of an empty string representation for an object. This value | ||
* is shared by all new objects allocated by Tcl_NewObj. | ||
*/ | ||
extern char * tclEmptyStringRep; | ||
/* | ||
*---------------------------------------------------------------- | ||
* Procedures shared among Tcl modules but not used by the outside | ||
* world: | ||
*---------------------------------------------------------------- | ||
*/ | ||
EXTERN int TclAccess _ANSI_ARGS_((CONST char *path, | ||
int mode)); | ||
EXTERN int TclAccessDeleteProc _ANSI_ARGS_((TclAccessProc_ *proc)); | ||
EXTERN int TclAccessInsertProc _ANSI_ARGS_((TclAccessProc_ *proc)); | ||
EXTERN void TclAllocateFreeObjects _ANSI_ARGS_((void)); | ||
EXTERN int TclArraySet _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Obj *arrayNameObj, Tcl_Obj *arrayElemObj)); | ||
EXTERN int TclCheckBadOctal _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *value)); | ||
EXTERN int TclCleanupChildren _ANSI_ARGS_((Tcl_Interp *interp, | ||
int numPids, Tcl_Pid *pidPtr, | ||
Tcl_Channel errorChan)); | ||
EXTERN void TclCleanupCommand _ANSI_ARGS_((Command *cmdPtr)); | ||
EXTERN int TclCopyChannel _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Channel inChan, Tcl_Channel outChan, | ||
int toRead, Tcl_Obj *cmdPtr)); | ||
/* | ||
* TclCreatePipeline unofficially exported for use by BLT. | ||
*/ | ||
EXTERN int TclCreatePipeline _ANSI_ARGS_((Tcl_Interp *interp, | ||
int argc, char **argv, Tcl_Pid **pidArrayPtr, | ||
TclFile *inPipePtr, TclFile *outPipePtr, | ||
TclFile *errFilePtr)); | ||
EXTERN int TclCreateProc _ANSI_ARGS_((Tcl_Interp *interp, | ||
Namespace *nsPtr, char *procName, | ||
Tcl_Obj *argsPtr, Tcl_Obj *bodyPtr, | ||
Proc **procPtrPtr)); | ||
EXTERN void TclDeleteCompiledLocalVars _ANSI_ARGS_(( | ||
Interp *iPtr, CallFrame *framePtr)); | ||
EXTERN void TclDeleteVars _ANSI_ARGS_((Interp *iPtr, | ||
Tcl_HashTable *tablePtr)); | ||
EXTERN int TclDoGlob _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *separators, Tcl_DString *headPtr, | ||
char *tail, GlobTypeData *types)); | ||
EXTERN void TclDumpMemoryInfo _ANSI_ARGS_((FILE *outFile)); | ||
EXTERN void TclExpandTokenArray _ANSI_ARGS_(( | ||
Tcl_Parse *parsePtr)); | ||
EXTERN void TclExprFloatError _ANSI_ARGS_((Tcl_Interp *interp, | ||
double value)); | ||
EXTERN int TclFileAttrsCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int TclFileCopyCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
int argc, char **argv)) ; | ||
EXTERN int TclFileDeleteCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
int argc, char **argv)); | ||
EXTERN int TclFileMakeDirsCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
int argc, char **argv)) ; | ||
EXTERN int TclFileRenameCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
int argc, char **argv)) ; | ||
EXTERN void TclFinalizeAllocSubsystem _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeCompExecEnv _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeCompilation _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeEncodingSubsystem _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeEnvironment _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeExecution _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeIOSubsystem _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeLoad _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeMemorySubsystem _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeNotifier _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeSynchronization _ANSI_ARGS_((void)); | ||
EXTERN void TclFinalizeThreadData _ANSI_ARGS_((void)); | ||
EXTERN void TclFindEncodings _ANSI_ARGS_((CONST char *argv0)); | ||
EXTERN Proc * TclFindProc _ANSI_ARGS_((Interp *iPtr, | ||
char *procName)); | ||
EXTERN int TclFormatInt _ANSI_ARGS_((char *buffer, long n)); | ||
EXTERN void TclFreePackageInfo _ANSI_ARGS_((Interp *iPtr)); | ||
EXTERN int TclGetDate _ANSI_ARGS_((char *p, | ||
unsigned long now, long zone, | ||
unsigned long *timePtr)); | ||
EXTERN Tcl_Obj * TclGetElementOfIndexedArray _ANSI_ARGS_(( | ||
Tcl_Interp *interp, int localIndex, | ||
Tcl_Obj *elemPtr, int leaveErrorMsg)); | ||
EXTERN char * TclGetExtension _ANSI_ARGS_((char *name)); | ||
EXTERN int TclGetFrame _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *string, CallFrame **framePtrPtr)); | ||
EXTERN TclCmdProcType TclGetInterpProc _ANSI_ARGS_((void)); | ||
EXTERN int TclGetIntForIndex _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Obj *objPtr, int endValue, int *indexPtr)); | ||
EXTERN Tcl_Obj * TclGetIndexedScalar _ANSI_ARGS_((Tcl_Interp *interp, | ||
int localIndex, int leaveErrorMsg)); | ||
EXTERN int TclGetLong _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *string, long *longPtr)); | ||
EXTERN int TclGetLoadedPackages _ANSI_ARGS_(( | ||
Tcl_Interp *interp, char *targetName)); | ||
EXTERN int TclGetNamespaceForQualName _ANSI_ARGS_(( | ||
Tcl_Interp *interp, char *qualName, | ||
Namespace *cxtNsPtr, int flags, | ||
Namespace **nsPtrPtr, Namespace **altNsPtrPtr, | ||
Namespace **actualCxtPtrPtr, | ||
char **simpleNamePtr)); | ||
EXTERN TclObjCmdProcType TclGetObjInterpProc _ANSI_ARGS_((void)); | ||
EXTERN int TclGetOpenMode _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *string, int *seekFlagPtr)); | ||
EXTERN Tcl_Command TclGetOriginalCommand _ANSI_ARGS_(( | ||
Tcl_Command command)); | ||
EXTERN int TclGlob _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *pattern, char *unquotedPrefix, | ||
int globFlags, GlobTypeData* types)); | ||
EXTERN int TclGlobalInvoke _ANSI_ARGS_((Tcl_Interp *interp, | ||
int argc, char **argv, int flags)); | ||
EXTERN int TclGuessPackageName _ANSI_ARGS_((char *fileName, | ||
Tcl_DString *bufPtr)); | ||
EXTERN int TclHideUnsafeCommands _ANSI_ARGS_(( | ||
Tcl_Interp *interp)); | ||
EXTERN int TclInExit _ANSI_ARGS_((void)); | ||
EXTERN Tcl_Obj * TclIncrElementOfIndexedArray _ANSI_ARGS_(( | ||
Tcl_Interp *interp, int localIndex, | ||
Tcl_Obj *elemPtr, long incrAmount)); | ||
EXTERN Tcl_Obj * TclIncrIndexedScalar _ANSI_ARGS_(( | ||
Tcl_Interp *interp, int localIndex, | ||
long incrAmount)); | ||
EXTERN Tcl_Obj * TclIncrVar2 _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, | ||
long incrAmount, int flags)); | ||
EXTERN void TclInitAlloc _ANSI_ARGS_((void)); | ||
EXTERN void TclInitCompiledLocals _ANSI_ARGS_(( | ||
Tcl_Interp *interp, CallFrame *framePtr, | ||
Namespace *nsPtr)); | ||
EXTERN void TclInitDbCkalloc _ANSI_ARGS_((void)); | ||
EXTERN void TclInitEncodingSubsystem _ANSI_ARGS_((void)); | ||
EXTERN void TclInitIOSubsystem _ANSI_ARGS_((void)); | ||
EXTERN void TclInitNamespaceSubsystem _ANSI_ARGS_((void)); | ||
EXTERN void TclInitNotifier _ANSI_ARGS_((void)); | ||
EXTERN void TclInitObjSubsystem _ANSI_ARGS_((void)); | ||
EXTERN void TclInitSubsystems _ANSI_ARGS_((CONST char *argv0)); | ||
EXTERN int TclInvoke _ANSI_ARGS_((Tcl_Interp *interp, | ||
int argc, char **argv, int flags)); | ||
EXTERN int TclInvokeObjectCommand _ANSI_ARGS_(( | ||
ClientData clientData, Tcl_Interp *interp, | ||
int argc, char **argv)); | ||
EXTERN int TclInvokeStringCommand _ANSI_ARGS_(( | ||
ClientData clientData, Tcl_Interp *interp, | ||
int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int TclIsLocalScalar _ANSI_ARGS_((CONST char *src, | ||
int len)); | ||
EXTERN Proc * TclIsProc _ANSI_ARGS_((Command *cmdPtr)); | ||
EXTERN Var * TclLookupVar _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *part1, char *part2, int flags, char *msg, | ||
int createPart1, int createPart2, | ||
Var **arrayPtrPtr)); | ||
EXTERN int TclMathInProgress _ANSI_ARGS_((void)); | ||
EXTERN int TclNeedSpace _ANSI_ARGS_((char *start, char *end)); | ||
EXTERN Tcl_Obj * TclNewProcBodyObj _ANSI_ARGS_((Proc *procPtr)); | ||
EXTERN int TclObjCommandComplete _ANSI_ARGS_((Tcl_Obj *cmdPtr)); | ||
EXTERN int TclObjInterpProc _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, | ||
Tcl_Obj *CONST objv[])); | ||
EXTERN int TclObjInvoke _ANSI_ARGS_((Tcl_Interp *interp, | ||
int objc, Tcl_Obj *CONST objv[], int flags)); | ||
EXTERN int TclObjInvokeGlobal _ANSI_ARGS_((Tcl_Interp *interp, | ||
int objc, Tcl_Obj *CONST objv[], int flags)); | ||
EXTERN int TclOpenFileChannelDeleteProc _ANSI_ARGS_(( | ||
TclOpenFileChannelProc_ *proc)); | ||
EXTERN int TclOpenFileChannelInsertProc _ANSI_ARGS_(( | ||
TclOpenFileChannelProc_ *proc)); | ||
EXTERN int TclpAccess _ANSI_ARGS_((CONST char *filename, | ||
int mode)); | ||
EXTERN char * TclpAlloc _ANSI_ARGS_((unsigned int size)); | ||
EXTERN int TclpCheckStackSpace _ANSI_ARGS_((void)); | ||
EXTERN int TclpCopyFile _ANSI_ARGS_((CONST char *source, | ||
CONST char *dest)); | ||
EXTERN int TclpCopyDirectory _ANSI_ARGS_((CONST char *source, | ||
CONST char *dest, Tcl_DString *errorPtr)); | ||
EXTERN int TclpCreateDirectory _ANSI_ARGS_((CONST char *path)); | ||
EXTERN int TclpDeleteFile _ANSI_ARGS_((CONST char *path)); | ||
EXTERN void TclpExit _ANSI_ARGS_((int status)); | ||
EXTERN void TclpFinalizeCondition _ANSI_ARGS_(( | ||
Tcl_Condition *condPtr)); | ||
EXTERN void TclpFinalizeMutex _ANSI_ARGS_((Tcl_Mutex *mutexPtr)); | ||
EXTERN void TclpFinalizeThreadData _ANSI_ARGS_(( | ||
Tcl_ThreadDataKey *keyPtr)); | ||
EXTERN void TclpFinalizeThreadDataKey _ANSI_ARGS_(( | ||
Tcl_ThreadDataKey *keyPtr)); | ||
EXTERN char * TclpFindExecutable _ANSI_ARGS_(( | ||
CONST char *argv0)); | ||
EXTERN int TclpFindVariable _ANSI_ARGS_((CONST char *name, | ||
int *lengthPtr)); | ||
EXTERN void TclpFree _ANSI_ARGS_((char *ptr)); | ||
EXTERN unsigned long TclpGetClicks _ANSI_ARGS_((void)); | ||
EXTERN Tcl_Channel TclpGetDefaultStdChannel _ANSI_ARGS_((int type)); | ||
EXTERN unsigned long TclpGetSeconds _ANSI_ARGS_((void)); | ||
EXTERN void TclpGetTime _ANSI_ARGS_((Tcl_Time *time)); | ||
EXTERN int TclpGetTimeZone _ANSI_ARGS_((unsigned long time)); | ||
EXTERN char * TclpGetUserHome _ANSI_ARGS_((CONST char *name, | ||
Tcl_DString *bufferPtr)); | ||
EXTERN int TclpHasSockets _ANSI_ARGS_((Tcl_Interp *interp)); | ||
EXTERN void TclpInitLibraryPath _ANSI_ARGS_((CONST char *argv0)); | ||
EXTERN void TclpInitLock _ANSI_ARGS_((void)); | ||
EXTERN void TclpInitPlatform _ANSI_ARGS_((void)); | ||
EXTERN void TclpInitUnlock _ANSI_ARGS_((void)); | ||
EXTERN int TclpListVolumes _ANSI_ARGS_((Tcl_Interp *interp)); | ||
EXTERN void TclpMasterLock _ANSI_ARGS_((void)); | ||
EXTERN void TclpMasterUnlock _ANSI_ARGS_((void)); | ||
EXTERN int TclpMatchFiles _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *separators, Tcl_DString *dirPtr, | ||
char *pattern, char *tail)); | ||
EXTERN Tcl_Channel TclpOpenFileChannel _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *fileName, char *modeString, | ||
int permissions)); | ||
EXTERN char * TclpReadlink _ANSI_ARGS_((CONST char *fileName, | ||
Tcl_DString *linkPtr)); | ||
EXTERN char * TclpRealloc _ANSI_ARGS_((char *ptr, | ||
unsigned int size)); | ||
EXTERN void TclpReleaseFile _ANSI_ARGS_((TclFile file)); | ||
EXTERN int TclpRemoveDirectory _ANSI_ARGS_((CONST char *path, | ||
int recursive, Tcl_DString *errorPtr)); | ||
EXTERN int TclpRenameFile _ANSI_ARGS_((CONST char *source, | ||
CONST char *dest)); | ||
EXTERN void TclpSetInitialEncodings _ANSI_ARGS_((void)); | ||
EXTERN void TclpSetVariables _ANSI_ARGS_((Tcl_Interp *interp)); | ||
EXTERN VOID * TclpSysAlloc _ANSI_ARGS_((long size, int isBin)); | ||
EXTERN void TclpSysFree _ANSI_ARGS_((VOID *ptr)); | ||
EXTERN VOID * TclpSysRealloc _ANSI_ARGS_((VOID *cp, | ||
unsigned int size)); | ||
EXTERN void TclpUnloadFile _ANSI_ARGS_((ClientData clientData)); | ||
EXTERN char * TclPrecTraceProc _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, char *name1, char *name2, | ||
int flags)); | ||
EXTERN int TclPreventAliasLoop _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Interp *cmdInterp, Tcl_Command cmd)); | ||
EXTERN void TclProcCleanupProc _ANSI_ARGS_((Proc *procPtr)); | ||
EXTERN int TclProcCompileProc _ANSI_ARGS_((Tcl_Interp *interp, | ||
Proc *procPtr, Tcl_Obj *bodyPtr, Namespace *nsPtr, | ||
CONST char *description, CONST char *procName)); | ||
EXTERN void TclProcDeleteProc _ANSI_ARGS_((ClientData clientData)); | ||
EXTERN int TclProcInterpProc _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int argc, char **argv)); | ||
EXTERN VOID * TclpThreadDataKeyGet _ANSI_ARGS_(( | ||
Tcl_ThreadDataKey *keyPtr)); | ||
EXTERN void TclpThreadDataKeyInit _ANSI_ARGS_(( | ||
Tcl_ThreadDataKey *keyPtr)); | ||
EXTERN void TclpThreadDataKeySet _ANSI_ARGS_(( | ||
Tcl_ThreadDataKey *keyPtr, VOID *data)); | ||
EXTERN void TclpThreadExit _ANSI_ARGS_((int status)); | ||
EXTERN void TclRememberCondition _ANSI_ARGS_((Tcl_Condition *mutex)); | ||
EXTERN void TclRememberDataKey _ANSI_ARGS_((Tcl_ThreadDataKey *mutex)); | ||
EXTERN void TclRememberMutex _ANSI_ARGS_((Tcl_Mutex *mutex)); | ||
EXTERN int TclRenameCommand _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *oldName, char *newName)) ; | ||
EXTERN void TclResetShadowedCmdRefs _ANSI_ARGS_(( | ||
Tcl_Interp *interp, Command *newCmdPtr)); | ||
EXTERN int TclServiceIdle _ANSI_ARGS_((void)); | ||
EXTERN Tcl_Obj * TclSetElementOfIndexedArray _ANSI_ARGS_(( | ||
Tcl_Interp *interp, int localIndex, | ||
Tcl_Obj *elemPtr, Tcl_Obj *objPtr, | ||
int leaveErrorMsg)); | ||
EXTERN Tcl_Obj * TclSetIndexedScalar _ANSI_ARGS_((Tcl_Interp *interp, | ||
int localIndex, Tcl_Obj *objPtr, | ||
int leaveErrorMsg)); | ||
EXTERN char * TclSetPreInitScript _ANSI_ARGS_((char *string)); | ||
EXTERN void TclSetupEnv _ANSI_ARGS_((Tcl_Interp *interp)); | ||
EXTERN int TclSockGetPort _ANSI_ARGS_((Tcl_Interp *interp, | ||
char *string, char *proto, int *portPtr)); | ||
EXTERN int TclSockMinimumBuffers _ANSI_ARGS_((int sock, | ||
int size)); | ||
EXTERN int TclStat _ANSI_ARGS_((CONST char *path, | ||
struct stat *buf)); | ||
EXTERN int TclStatDeleteProc _ANSI_ARGS_((TclStatProc_ *proc)); | ||
EXTERN int TclStatInsertProc _ANSI_ARGS_((TclStatProc_ *proc)); | ||
EXTERN void TclTeardownNamespace _ANSI_ARGS_((Namespace *nsPtr)); | ||
EXTERN void TclTransferResult _ANSI_ARGS_((Tcl_Interp *sourceInterp, | ||
int result, Tcl_Interp *targetInterp)); | ||
EXTERN int TclUpdateReturnInfo _ANSI_ARGS_((Interp *iPtr)); | ||
/* | ||
*---------------------------------------------------------------- | ||
* Command procedures in the generic core: | ||
*---------------------------------------------------------------- | ||
*/ | ||
EXTERN int Tcl_AfterObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_AppendObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ArrayObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_BinaryObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_BreakObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_CaseObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_CatchObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_CdObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ClockObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_CloseObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ConcatObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ContinueObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_EncodingObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_EofObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ErrorObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_EvalObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ExecObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ExitObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ExprObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_FblockedObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_FconfigureObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_FcopyObjCmd _ANSI_ARGS_((ClientData dummy, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_FileObjCmd _ANSI_ARGS_((ClientData dummy, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_FileEventObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_FlushObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ForObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ForeachObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_FormatObjCmd _ANSI_ARGS_((ClientData dummy, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_GetsObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_GlobalObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_GlobObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_IfObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_IncrObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_InfoObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_InterpObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int argc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_JoinObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_LappendObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_LindexObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_LinsertObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_LlengthObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ListObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_LoadObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_LrangeObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_LreplaceObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_LsearchObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_LsortObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_NamespaceObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_OpenObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_PackageObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_PidObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_PutsObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_PwdObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ReadObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_RegexpObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_RegsubObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_RenameObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ReturnObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ScanObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_SeekObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_SetObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_SplitObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_SocketObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_SourceObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_StringObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_SubstObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_SwitchObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_TellObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_TimeObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_TraceObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_UnsetObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_UpdateObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_UplevelObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_UpvarObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_VariableObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_VwaitObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_WhileObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
/* | ||
*---------------------------------------------------------------- | ||
* Command procedures found only in the Mac version of the core: | ||
*---------------------------------------------------------------- | ||
*/ | ||
#ifdef MAC_TCL | ||
EXTERN int Tcl_EchoCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int argc, char **argv)); | ||
EXTERN int Tcl_LsObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_BeepObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_MacSourceObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
EXTERN int Tcl_ResourceObjCmd _ANSI_ARGS_((ClientData clientData, | ||
Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); | ||
#endif | ||
/* | ||
*---------------------------------------------------------------- | ||
* Compilation procedures for commands in the generic core: | ||
*---------------------------------------------------------------- | ||
*/ | ||
EXTERN int TclCompileBreakCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *envPtr)); | ||
EXTERN int TclCompileCatchCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *envPtr)); | ||
EXTERN int TclCompileContinueCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *envPtr)); | ||
EXTERN int TclCompileExprCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *envPtr)); | ||
EXTERN int TclCompileForCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *envPtr)); | ||
EXTERN int TclCompileForeachCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *envPtr)); | ||
EXTERN int TclCompileIfCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *envPtr)); | ||
EXTERN int TclCompileIncrCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *envPtr)); | ||
EXTERN int TclCompileSetCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *envPtr)); | ||
EXTERN int TclCompileWhileCmd _ANSI_ARGS_((Tcl_Interp *interp, | ||
Tcl_Parse *parsePtr, struct CompileEnv *envPtr)); | ||
/* | ||
*---------------------------------------------------------------- | ||
* Macros used by the Tcl core to create and release Tcl objects. | ||
* TclNewObj(objPtr) creates a new object denoting an empty string. | ||
* TclDecrRefCount(objPtr) decrements the object's reference count, | ||
* and frees the object if its reference count is zero. | ||
* These macros are inline versions of Tcl_NewObj() and | ||
* Tcl_DecrRefCount(). Notice that the names differ in not having | ||
* a "_" after the "Tcl". Notice also that these macros reference | ||
* their argument more than once, so you should avoid calling them | ||
* with an expression that is expensive to compute or has | ||
* side effects. The ANSI C "prototypes" for these macros are: | ||
* | ||
* EXTERN void TclNewObj _ANSI_ARGS_((Tcl_Obj *objPtr)); | ||
* EXTERN void TclDecrRefCount _ANSI_ARGS_((Tcl_Obj *objPtr)); | ||
*---------------------------------------------------------------- | ||
*/ | ||
#ifdef TCL_COMPILE_STATS | ||
# define TclIncrObjsAllocated() \ | ||
tclObjsAlloced++ | ||
# define TclIncrObjsFreed() \ | ||
tclObjsFreed++ | ||
#else | ||
# define TclIncrObjsAllocated() | ||
# define TclIncrObjsFreed() | ||
#endif /* TCL_COMPILE_STATS */ | ||
#ifdef TCL_MEM_DEBUG | ||
# define TclNewObj(objPtr) \ | ||
(objPtr) = (Tcl_Obj *) \ | ||
Tcl_DbCkalloc(sizeof(Tcl_Obj), __FILE__, __LINE__); \ | ||
(objPtr)->refCount = 0; \ | ||
(objPtr)->bytes = tclEmptyStringRep; \ | ||
(objPtr)->length = 0; \ | ||
(objPtr)->typePtr = NULL; \ | ||
TclIncrObjsAllocated() | ||
# define TclDbNewObj(objPtr, file, line) \ | ||
(objPtr) = (Tcl_Obj *) Tcl_DbCkalloc(sizeof(Tcl_Obj), (file), (line)); \ | ||
(objPtr)->refCount = 0; \ | ||
(objPtr)->bytes = tclEmptyStringRep; \ | ||
(objPtr)->length = 0; \ | ||
(objPtr)->typePtr = NULL; \ | ||
TclIncrObjsAllocated() | ||
# define TclDecrRefCount(objPtr) \ | ||
if (--(objPtr)->refCount <= 0) { \ | ||
if ((objPtr)->refCount < -1) \ | ||
panic("Reference count for %lx was negative: %s line %d", \ | ||
(objPtr), __FILE__, __LINE__); \ | ||
if (((objPtr)->bytes != NULL) \ | ||
&& ((objPtr)->bytes != tclEmptyStringRep)) { \ | ||
ckfree((char *) (objPtr)->bytes); \ | ||
} \ | ||
if (((objPtr)->typePtr != NULL) \ | ||
&& ((objPtr)->typePtr->freeIntRepProc != NULL)) { \ | ||
(objPtr)->typePtr->freeIntRepProc(objPtr); \ | ||
} \ | ||
ckfree((char *) (objPtr)); \ | ||
TclIncrObjsFreed(); \ | ||
} | ||
#else /* not TCL_MEM_DEBUG */ | ||
#ifdef TCL_THREADS | ||
extern Tcl_Mutex tclObjMutex; | ||
#endif | ||
# define TclNewObj(objPtr) \ | ||
Tcl_MutexLock(&tclObjMutex); \ | ||
if (tclFreeObjList == NULL) { \ | ||
TclAllocateFreeObjects(); \ | ||
} \ | ||
(objPtr) = tclFreeObjList; \ | ||
tclFreeObjList = (Tcl_Obj *) \ | ||
tclFreeObjList->internalRep.otherValuePtr; \ | ||
(objPtr)->refCount = 0; \ | ||
(objPtr)->bytes = tclEmptyStringRep; \ | ||
(objPtr)->length = 0; \ | ||
(objPtr)->typePtr = NULL; \ | ||
TclIncrObjsAllocated(); \ | ||
Tcl_MutexUnlock(&tclObjMutex) | ||
# define TclDecrRefCount(objPtr) \ | ||
if (--(objPtr)->refCount <= 0) { \ | ||
if (((objPtr)->bytes != NULL) \ | ||
&& ((objPtr)->bytes != tclEmptyStringRep)) { \ | ||
ckfree((char *) (objPtr)->bytes); \ | ||
} \ | ||
if (((objPtr)->typePtr != NULL) \ | ||
&& ((objPtr)->typePtr->freeIntRepProc != NULL)) { \ | ||
(objPtr)->typePtr->freeIntRepProc(objPtr); \ | ||
} \ | ||
Tcl_MutexLock(&tclObjMutex); \ | ||
(objPtr)->internalRep.otherValuePtr = (VOID *) tclFreeObjList; \ | ||
tclFreeObjList = (objPtr); \ | ||
TclIncrObjsFreed(); \ | ||
Tcl_MutexUnlock(&tclObjMutex); \ | ||
} | ||
#endif /* TCL_MEM_DEBUG */ | ||
/* | ||
*---------------------------------------------------------------- | ||
* Macro used by the Tcl core to set a Tcl_Obj's string representation | ||
* to a copy of the "len" bytes starting at "bytePtr". This code | ||
* works even if the byte array contains NULLs as long as the length | ||
* is correct. Because "len" is referenced multiple times, it should | ||
* be as simple an expression as possible. The ANSI C "prototype" for | ||
* this macro is: | ||
* | ||
* EXTERN void TclInitStringRep _ANSI_ARGS_((Tcl_Obj *objPtr, | ||
* char *bytePtr, int len)); | ||
*---------------------------------------------------------------- | ||
*/ | ||
#define TclInitStringRep(objPtr, bytePtr, len) \ | ||
if ((len) == 0) { \ | ||
(objPtr)->bytes = tclEmptyStringRep; \ | ||
(objPtr)->length = 0; \ | ||
} else { \ | ||
(objPtr)->bytes = (char *) ckalloc((unsigned) ((len) + 1)); \ | ||
memcpy((VOID *) (objPtr)->bytes, (VOID *) (bytePtr), \ | ||
(unsigned) (len)); \ | ||
(objPtr)->bytes[len] = '\0'; \ | ||
(objPtr)->length = (len); \ | ||
} | ||
/* | ||
*---------------------------------------------------------------- | ||
* Macro used by the Tcl core to get the string representation's | ||
* byte array pointer from a Tcl_Obj. This is an inline version | ||
* of Tcl_GetString(). The macro's expression result is the string | ||
* rep's byte pointer which might be NULL. The bytes referenced by | ||
* this pointer must not be modified by the caller. | ||
* The ANSI C "prototype" for this macro is: | ||
* | ||
* EXTERN char * TclGetString _ANSI_ARGS_((Tcl_Obj *objPtr)); | ||
*---------------------------------------------------------------- | ||
*/ | ||
#define TclGetString(objPtr) \ | ||
((objPtr)->bytes? (objPtr)->bytes : Tcl_GetString((objPtr))) | ||
#include "tclIntDecls.h" | ||
# undef TCL_STORAGE_CLASS | ||
# define TCL_STORAGE_CLASS DLLIMPORT | ||
#endif /* _TCLINT */ | ||
/* $History: tclint.h $ | ||
* | ||
* ***************** Version 1 ***************** | ||
* User: Dtashley Date: 1/02/01 Time: 1:29a | ||
* Created in $/IjuScripter, IjuConsole/Source/Tcl Base | ||
* Initial check-in. | ||
*/ | ||
/* End of TCLINT.H */ | ||
1 | /* $Header$ */ | |
2 | /* | |
3 | * tclInt.h -- | |
4 | * | |
5 | * Declarations of things used internally by the Tcl interpreter. | |
6 | * | |
7 | * Copyright (c) 1987-1993 The Regents of the University of California. | |
8 | * Copyright (c) 1993-1997 Lucent Technologies. | |
9 | * Copyright (c) 1994-1998 Sun Microsystems, Inc. | |
10 | * Copyright (c) 1998-1999 by Scriptics Corporation. | |
11 | * | |
12 | * See the file "license.terms" for information on usage and redistribution | |
13 | * of this file, and for a DISCLAIMER OF ALL WARRANTIES. | |
14 | * | |
15 | * RCS: @(#) $Id: tclint.h,v 1.1.1.1 2001/06/13 04:40:00 dtashley Exp $ | |
16 | */ | |
17 | ||
18 | #ifndef _TCLINT | |
19 | #define _TCLINT | |
20 | ||
21 | /* | |
22 | * Common include files needed by most of the Tcl source files are | |
23 | * included here, so that system-dependent personalizations for the | |
24 | * include files only have to be made in once place. This results | |
25 | * in a few extra includes, but greater modularity. The order of | |
26 | * the three groups of #includes is important. For example, stdio.h | |
27 | * is needed by tcl.h, and the _ANSI_ARGS_ declaration in tcl.h is | |
28 | * needed by stdlib.h in some configurations. | |
29 | */ | |
30 | ||
31 | #include <stdio.h> | |
32 | ||
33 | #ifndef _TCL | |
34 | #include "tcl.h" | |
35 | #endif | |
36 | ||
37 | #include <ctype.h> | |
38 | #ifdef NO_LIMITS_H | |
39 | # include "../compat/limits.h" | |
40 | #else | |
41 | # include <limits.h> | |
42 | #endif | |
43 | #ifdef NO_STDLIB_H | |
44 | # include "../compat/stdlib.h" | |
45 | #else | |
46 | # include <stdlib.h> | |
47 | #endif | |
48 | #ifdef NO_STRING_H | |
49 | #include "../compat/string.h" | |
50 | #else | |
51 | #include <string.h> | |
52 | #endif | |
53 | ||
54 | #undef TCL_STORAGE_CLASS | |
55 | #ifdef BUILD_tcl | |
56 | # define TCL_STORAGE_CLASS DLLEXPORT | |
57 | #else | |
58 | # ifdef USE_TCL_STUBS | |
59 | # define TCL_STORAGE_CLASS | |
60 | # else | |
61 | # define TCL_STORAGE_CLASS DLLIMPORT | |
62 | # endif | |
63 | #endif | |
64 | ||
65 | /* | |
66 | * The following procedures allow namespaces to be customized to | |
67 | * support special name resolution rules for commands/variables. | |
68 | * | |
69 | */ | |
70 | ||
71 | struct Tcl_ResolvedVarInfo; | |
72 | ||
73 | typedef Tcl_Var (Tcl_ResolveRuntimeVarProc) _ANSI_ARGS_(( | |
74 | Tcl_Interp* interp, struct Tcl_ResolvedVarInfo *vinfoPtr)); | |
75 | ||
76 | typedef void (Tcl_ResolveVarDeleteProc) _ANSI_ARGS_(( | |
77 | struct Tcl_ResolvedVarInfo *vinfoPtr)); | |
78 | ||
79 | /* | |
80 | * The following structure encapsulates the routines needed to resolve a | |
81 | * variable reference at runtime. Any variable specific state will typically | |
82 | * be appended to this structure. | |
83 | */ | |
84 | ||
85 | ||
86 | typedef struct Tcl_ResolvedVarInfo { | |
87 | Tcl_ResolveRuntimeVarProc *fetchProc; | |
88 | Tcl_ResolveVarDeleteProc *deleteProc; | |
89 | } Tcl_ResolvedVarInfo; | |
90 | ||
91 | ||
92 | ||
93 | typedef int (Tcl_ResolveCompiledVarProc) _ANSI_ARGS_(( | |
94 | Tcl_Interp* interp, char* name, int length, | |
95 | Tcl_Namespace *context, Tcl_ResolvedVarInfo **rPtr)); | |
96 | ||
97 | typedef int (Tcl_ResolveVarProc) _ANSI_ARGS_(( | |
98 | Tcl_Interp* interp, char* name, Tcl_Namespace *context, | |
99 | int flags, Tcl_Var *rPtr)); | |
100 | ||
101 | typedef int (Tcl_ResolveCmdProc) _ANSI_ARGS_((Tcl_Interp* interp, | |
102 | char* name, Tcl_Namespace *context, int flags, | |
103 | Tcl_Command *rPtr)); | |
104 | ||
105 | typedef struct Tcl_ResolverInfo { | |
106 | Tcl_ResolveCmdProc *cmdResProc; /* Procedure handling command name | |
107 | * resolution. */ | |
108 | Tcl_ResolveVarProc *varResProc; /* Procedure handling variable name | |
109 | * resolution for variables that | |
110 | * can only be handled at runtime. */ | |
111 | Tcl_ResolveCompiledVarProc *compiledVarResProc; | |
112 | /* Procedure handling variable name | |
113 | * resolution at compile time. */ | |
114 | } Tcl_ResolverInfo; | |
115 | ||
116 | /* | |
117 | *---------------------------------------------------------------- | |
118 | * Data structures related to namespaces. | |
119 | *---------------------------------------------------------------- | |
120 | */ | |
121 | ||
122 | /* | |
123 | * The structure below defines a namespace. | |
124 | * Note: the first five fields must match exactly the fields in a | |
125 | * Tcl_Namespace structure (see tcl.h). If you change one, be sure to | |
126 | * change the other. | |
127 | */ | |
128 | ||
129 | typedef struct Namespace { | |
130 | char *name; /* The namespace's simple (unqualified) | |
131 | * name. This contains no ::'s. The name of | |
132 | * the global namespace is "" although "::" | |
133 | * is an synonym. */ | |
134 | char *fullName; /* The namespace's fully qualified name. | |
135 | * This starts with ::. */ | |
136 | ClientData clientData; /* An arbitrary value associated with this | |
137 | * namespace. */ | |
138 | Tcl_NamespaceDeleteProc *deleteProc; | |
139 | /* Procedure invoked when deleting the | |
140 | * namespace to, e.g., free clientData. */ | |
141 | struct Namespace *parentPtr; /* Points to the namespace that contains | |
142 | * this one. NULL if this is the global | |
143 | * namespace. */ | |
144 | Tcl_HashTable childTable; /* Contains any child namespaces. Indexed | |
145 | * by strings; values have type | |
146 | * (Namespace *). */ | |
147 | long nsId; /* Unique id for the namespace. */ | |
148 | Tcl_Interp *interp; /* The interpreter containing this | |
149 | * namespace. */ | |
150 | int flags; /* OR-ed combination of the namespace | |
151 | * status flags NS_DYING and NS_DEAD | |
152 | * listed below. */ | |
153 | int activationCount; /* Number of "activations" or active call | |
154 | * frames for this namespace that are on | |
155 | * the Tcl call stack. The namespace won't | |
156 | * be freed until activationCount becomes | |
157 | * zero. */ | |
158 | int refCount; /* Count of references by namespaceName * | |
159 | * objects. The namespace can't be freed | |
160 | * until refCount becomes zero. */ | |
161 | Tcl_HashTable cmdTable; /* Contains all the commands currently | |
162 | * registered in the namespace. Indexed by | |
163 | * strings; values have type (Command *). | |
164 | * Commands imported by Tcl_Import have | |
165 | * Command structures that point (via an | |
166 | * ImportedCmdRef structure) to the | |
167 | * Command structure in the source | |
168 | * namespace's command table. */ | |
169 | Tcl_HashTable varTable; /* Contains all the (global) variables | |
170 | * currently in this namespace. Indexed | |
171 | * by strings; values have type (Var *). */ | |
172 | char **exportArrayPtr; /* Points to an array of string patterns | |
173 | * specifying which commands are exported. | |
174 | * A pattern may include "string match" | |
175 | * style wildcard characters to specify | |
176 | * multiple commands; however, no namespace | |
177 | * qualifiers are allowed. NULL if no | |
178 | * export patterns are registered. */ | |
179 | int numExportPatterns; /* Number of export patterns currently | |
180 | * registered using "namespace export". */ | |
181 | int maxExportPatterns; /* Mumber of export patterns for which | |
182 | * space is currently allocated. */ | |
183 | int cmdRefEpoch; /* Incremented if a newly added command | |
184 | * shadows a command for which this | |
185 | * namespace has already cached a Command * | |
186 | * pointer; this causes all its cached | |
187 | * Command* pointers to be invalidated. */ | |
188 | int resolverEpoch; /* Incremented whenever the name resolution | |
189 | * rules change for this namespace; this | |
190 | * invalidates all byte codes compiled in | |
191 | * the namespace, causing the code to be | |
192 | * recompiled under the new rules. */ | |
193 | Tcl_ResolveCmdProc *cmdResProc; | |
194 | /* If non-null, this procedure overrides | |
195 | * the usual command resolution mechanism | |
196 | * in Tcl. This procedure is invoked | |
197 | * within Tcl_FindCommand to resolve all | |
198 | * command references within the namespace. */ | |
199 | Tcl_ResolveVarProc *varResProc; | |
200 | /* If non-null, this procedure overrides | |
201 | * the usual variable resolution mechanism | |
202 | * in Tcl. This procedure is invoked | |
203 | * within Tcl_FindNamespaceVar to resolve all | |
204 | * variable references within the namespace | |
205 | * at runtime. */ | |
206 | Tcl_ResolveCompiledVarProc *compiledVarResProc; | |
207 | /* If non-null, this procedure overrides | |
208 | * the usual variable resolution mechanism | |
209 | * in Tcl. This procedure is invoked | |
210 | * within LookupCompiledLocal to resolve | |
211 | * variable references within the namespace | |
212 | * at compile time. */ | |
213 | } Namespace; | |
214 | ||
215 | /* | |
216 | * Flags used to represent the status of a namespace: | |
217 | * | |
218 | * NS_DYING - 1 means Tcl_DeleteNamespace has been called to delete the | |
219 | * namespace but there are still active call frames on the Tcl | |
220 | * stack that refer to the namespace. When the last call frame | |
221 | * referring to it has been popped, it's variables and command | |
222 | * will be destroyed and it will be marked "dead" (NS_DEAD). | |
223 | * The namespace can no longer be looked up by name. | |
224 | * NS_DEAD - 1 means Tcl_DeleteNamespace has been called to delete the | |
225 | * namespace and no call frames still refer to it. Its | |
226 | * variables and command have already been destroyed. This bit | |
227 | * allows the namespace resolution code to recognize that the | |
228 | * namespace is "deleted". When the last namespaceName object | |
229 | * in any byte code code unit that refers to the namespace has | |
230 | * been freed (i.e., when the namespace's refCount is 0), the | |
231 | * namespace's storage will be freed. | |
232 | */ | |
233 | ||
234 | #define NS_DYING 0x01 | |
235 | #define NS_DEAD 0x02 | |
236 | ||
237 | /* | |
238 | * Flag passed to TclGetNamespaceForQualName to have it create all namespace | |
239 | * components of a namespace-qualified name that cannot be found. The new | |
240 | * namespaces are created within their specified parent. Note that this | |
241 | * flag's value must not conflict with the values of the flags | |
242 | * TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY, and FIND_ONLY_NS (defined in | |
243 | * tclNamesp.c). | |
244 | */ | |
245 | ||
246 | #define CREATE_NS_IF_UNKNOWN 0x800 | |
247 | ||
248 | /* | |
249 | *---------------------------------------------------------------- | |
250 | * Data structures related to variables. These are used primarily | |
251 | * in tclVar.c | |
252 | *---------------------------------------------------------------- | |
253 | */ | |
254 | ||
255 | /* | |
256 | * The following structure defines a variable trace, which is used to | |
257 | * invoke a specific C procedure whenever certain operations are performed | |
258 | * on a variable. | |
259 | */ | |
260 | ||
261 | typedef struct VarTrace { | |
262 | Tcl_VarTraceProc *traceProc;/* Procedure to call when operations given | |
263 | * by flags are performed on variable. */ | |
264 | ClientData clientData; /* Argument to pass to proc. */ | |
265 | int flags; /* What events the trace procedure is | |
266 | * interested in: OR-ed combination of | |
267 | * TCL_TRACE_READS, TCL_TRACE_WRITES, | |
268 | * TCL_TRACE_UNSETS and TCL_TRACE_ARRAY. */ | |
269 | struct VarTrace *nextPtr; /* Next in list of traces associated with | |
270 | * a particular variable. */ | |
271 | } VarTrace; | |
272 | ||
273 | /* | |
274 | * When a variable trace is active (i.e. its associated procedure is | |
275 | * executing), one of the following structures is linked into a list | |
276 | * associated with the variable's interpreter. The information in | |
277 | * the structure is needed in order for Tcl to behave reasonably | |
278 | * if traces are deleted while traces are active. | |
279 | */ | |
280 | ||
281 | typedef struct ActiveVarTrace { | |
282 | struct Var *varPtr; /* Variable that's being traced. */ | |
283 | struct ActiveVarTrace *nextPtr; | |
284 | /* Next in list of all active variable | |
285 | * traces for the interpreter, or NULL | |
286 | * if no more. */ | |
287 | VarTrace *nextTracePtr; /* Next trace to check after current | |
288 | * trace procedure returns; if this | |
289 | * trace gets deleted, must update pointer | |
290 | * to avoid using free'd memory. */ | |
291 | } ActiveVarTrace; | |
292 | ||
293 | /* | |
294 | * The following structure describes an enumerative search in progress on | |
295 | * an array variable; this are invoked with options to the "array" | |
296 | * command. | |
297 | */ | |
298 | ||
299 | typedef struct ArraySearch { | |
300 | int id; /* Integer id used to distinguish among | |
301 | * multiple concurrent searches for the | |
302 | * same array. */ | |
303 | struct Var *varPtr; /* Pointer to array variable that's being | |
304 | * searched. */ | |
305 | Tcl_HashSearch search; /* Info kept by the hash module about | |
306 | * progress through the array. */ | |
307 | Tcl_HashEntry *nextEntry; /* Non-null means this is the next element | |
308 | * to be enumerated (it's leftover from | |
309 | * the Tcl_FirstHashEntry call or from | |
310 | * an "array anymore" command). NULL | |
311 | * means must call Tcl_NextHashEntry | |
312 | * to get value to return. */ | |
313 | struct ArraySearch *nextPtr;/* Next in list of all active searches | |
314 | * for this variable, or NULL if this is | |
315 | * the last one. */ | |
316 | } ArraySearch; | |
317 | ||
318 | /* | |
319 | * The structure below defines a variable, which associates a string name | |
320 | * with a Tcl_Obj value. These structures are kept in procedure call frames | |
321 | * (for local variables recognized by the compiler) or in the heap (for | |
322 | * global variables and any variable not known to the compiler). For each | |
323 | * Var structure in the heap, a hash table entry holds the variable name and | |
324 | * a pointer to the Var structure. | |
325 | */ | |
326 | ||
327 | typedef struct Var { | |
328 | union { | |
329 | Tcl_Obj *objPtr; /* The variable's object value. Used for | |
330 | * scalar variables and array elements. */ | |
331 | Tcl_HashTable *tablePtr;/* For array variables, this points to | |
332 | * information about the hash table used | |
333 | * to implement the associative array. | |
334 | * Points to malloc-ed data. */ | |
335 | struct Var *linkPtr; /* If this is a global variable being | |
336 | * referred to in a procedure, or a variable | |
337 | * created by "upvar", this field points to | |
338 | * the referenced variable's Var struct. */ | |
339 | } value; | |
340 | char *name; /* NULL if the variable is in a hashtable, | |
341 | * otherwise points to the variable's | |
342 | * name. It is used, e.g., by TclLookupVar | |
343 | * and "info locals". The storage for the | |
344 | * characters of the name is not owned by | |
345 | * the Var and must not be freed when | |
346 | * freeing the Var. */ | |
347 | Namespace *nsPtr; /* Points to the namespace that contains | |
348 | * this variable or NULL if the variable is | |
349 | * a local variable in a Tcl procedure. */ | |
350 | Tcl_HashEntry *hPtr; /* If variable is in a hashtable, either the | |
351 | * hash table entry that refers to this | |
352 | * variable or NULL if the variable has been | |
353 | * detached from its hash table (e.g. an | |
354 | * array is deleted, but some of its | |
355 | * elements are still referred to in | |
356 | * upvars). NULL if the variable is not in a | |
357 | * hashtable. This is used to delete an | |
358 | * variable from its hashtable if it is no | |
359 | * longer needed. */ | |
360 | int refCount; /* Counts number of active uses of this | |
361 | * variable, not including its entry in the | |
362 | * call frame or the hash table: 1 for each | |
363 | * additional variable whose linkPtr points | |
364 | * here, 1 for each nested trace active on | |
365 | * variable, and 1 if the variable is a | |
366 | * namespace variable. This record can't be | |
367 | * deleted until refCount becomes 0. */ | |
368 | VarTrace *tracePtr; /* First in list of all traces set for this | |
369 | * variable. */ | |
370 | ArraySearch *searchPtr; /* First in list of all searches active | |
371 | * for this variable, or NULL if none. */ | |
372 | int flags; /* Miscellaneous bits of information about | |
373 | * variable. See below for definitions. */ | |
374 | } Var; | |
375 | ||
376 | /* | |
377 | * Flag bits for variables. The first three (VAR_SCALAR, VAR_ARRAY, and | |
378 | * VAR_LINK) are mutually exclusive and give the "type" of the variable. | |
379 | * VAR_UNDEFINED is independent of the variable's type. | |
380 | * | |
381 | * VAR_SCALAR - 1 means this is a scalar variable and not | |
382 | * an array or link. The "objPtr" field points | |
383 | * to the variable's value, a Tcl object. | |
384 | * VAR_ARRAY - 1 means this is an array variable rather | |
385 | * than a scalar variable or link. The | |
386 | * "tablePtr" field points to the array's | |
387 | * hashtable for its elements. | |
388 | * VAR_LINK - 1 means this Var structure contains a | |
389 | * pointer to another Var structure that | |
390 | * either has the real value or is itself | |
391 | * another VAR_LINK pointer. Variables like | |
392 | * this come about through "upvar" and "global" | |
393 | * commands, or through references to variables | |
394 | * in enclosing namespaces. | |
395 | * VAR_UNDEFINED - 1 means that the variable is in the process | |
396 | * of being deleted. An undefined variable | |
397 | * logically does not exist and survives only | |
398 | * while it has a trace, or if it is a global | |
399 | * variable currently being used by some | |
400 | * procedure. | |
401 | * VAR_IN_HASHTABLE - 1 means this variable is in a hashtable and | |
402 | * the Var structure is malloced. 0 if it is | |
403 | * a local variable that was assigned a slot | |
404 | * in a procedure frame by the compiler so the | |
405 | * Var storage is part of the call frame. | |
406 | * VAR_TRACE_ACTIVE - 1 means that trace processing is currently | |
407 | * underway for a read or write access, so | |
408 | * new read or write accesses should not cause | |
409 | * trace procedures to be called and the | |
410 | * variable can't be deleted. | |
411 | * VAR_ARRAY_ELEMENT - 1 means that this variable is an array | |
412 | * element, so it is not legal for it to be | |
413 | * an array itself (the VAR_ARRAY flag had | |
414 | * better not be set). | |
415 | * VAR_NAMESPACE_VAR - 1 means that this variable was declared | |
416 | * as a namespace variable. This flag ensures | |
417 | * it persists until its namespace is | |
418 | * destroyed or until the variable is unset; | |
419 | * it will persist even if it has not been | |
420 | * initialized and is marked undefined. | |
421 | * The variable's refCount is incremented to | |
422 | * reflect the "reference" from its namespace. | |
423 | * | |
424 | * The following additional flags are used with the CompiledLocal type | |
425 | * defined below: | |
426 | * | |
427 | * VAR_ARGUMENT - 1 means that this variable holds a procedure | |
428 | * argument. | |
429 | * VAR_TEMPORARY - 1 if the local variable is an anonymous | |
430 | * temporary variable. Temporaries have a NULL | |
431 | * name. | |
432 | * VAR_RESOLVED - 1 if name resolution has been done for this | |
433 | * variable. | |
434 | */ | |
435 | ||
436 | #define VAR_SCALAR 0x1 | |
437 | #define VAR_ARRAY 0x2 | |
438 | #define VAR_LINK 0x4 | |
439 | #define VAR_UNDEFINED 0x8 | |
440 | #define VAR_IN_HASHTABLE 0x10 | |
441 | #define VAR_TRACE_ACTIVE 0x20 | |
442 | #define VAR_ARRAY_ELEMENT 0x40 | |
443 | #define VAR_NAMESPACE_VAR 0x80 | |
444 | ||
445 | #define VAR_ARGUMENT 0x100 | |
446 | #define VAR_TEMPORARY 0x200 | |
447 | #define VAR_RESOLVED 0x400 | |
448 | ||
449 | /* | |
450 | * Macros to ensure that various flag bits are set properly for variables. | |
451 | * The ANSI C "prototypes" for these macros are: | |
452 | * | |
453 | * EXTERN void TclSetVarScalar _ANSI_ARGS_((Var *varPtr)); | |
454 | * EXTERN void TclSetVarArray _ANSI_ARGS_((Var *varPtr)); | |
455 | * EXTERN void TclSetVarLink _ANSI_ARGS_((Var *varPtr)); | |
456 | * EXTERN void TclSetVarArrayElement _ANSI_ARGS_((Var *varPtr)); | |
457 | * EXTERN void TclSetVarUndefined _ANSI_ARGS_((Var *varPtr)); | |
458 | * EXTERN void TclClearVarUndefined _ANSI_ARGS_((Var *varPtr)); | |
459 | */ | |
460 | ||
461 | #define TclSetVarScalar(varPtr) \ | |
462 | (varPtr)->flags = ((varPtr)->flags & ~(VAR_ARRAY|VAR_LINK)) | VAR_SCALAR | |
463 | ||
464 | #define TclSetVarArray(varPtr) \ | |
465 | (varPtr)->flags = ((varPtr)->flags & ~(VAR_SCALAR|VAR_LINK)) | VAR_ARRAY | |
466 | ||
467 | #define TclSetVarLink(varPtr) \ | |
468 | (varPtr)->flags = ((varPtr)->flags & ~(VAR_SCALAR|VAR_ARRAY)) | VAR_LINK | |
469 | ||
470 | #define TclSetVarArrayElement(varPtr) \ | |
471 | (varPtr)->flags = ((varPtr)->flags & ~VAR_ARRAY) | VAR_ARRAY_ELEMENT | |
472 | ||
473 | #define TclSetVarUndefined(varPtr) \ | |
474 | (varPtr)->flags |= VAR_UNDEFINED | |
475 | ||
476 | #define TclClearVarUndefined(varPtr) \ | |
477 | (varPtr)->flags &= ~VAR_UNDEFINED | |
478 | ||
479 | /* | |
480 | * Macros to read various flag bits of variables. | |
481 | * The ANSI C "prototypes" for these macros are: | |
482 | * | |
483 | * EXTERN int TclIsVarScalar _ANSI_ARGS_((Var *varPtr)); | |
484 | * EXTERN int TclIsVarLink _ANSI_ARGS_((Var *varPtr)); | |
485 | * EXTERN int TclIsVarArray _ANSI_ARGS_((Var *varPtr)); | |
486 | * EXTERN int TclIsVarUndefined _ANSI_ARGS_((Var *varPtr)); | |
487 | * EXTERN int TclIsVarArrayElement _ANSI_ARGS_((Var *varPtr)); | |
488 | * EXTERN int TclIsVarTemporary _ANSI_ARGS_((Var *varPtr)); | |
489 | * EXTERN int TclIsVarArgument _ANSI_ARGS_((Var *varPtr)); | |
490 | * EXTERN int TclIsVarResolved _ANSI_ARGS_((Var *varPtr)); | |
491 | */ | |
492 | ||
493 | #define TclIsVarScalar(varPtr) \ | |
494 | ((varPtr)->flags & VAR_SCALAR) | |
495 | ||
496 | #define TclIsVarLink(varPtr) \ | |
497 | ((varPtr)->flags & VAR_LINK) | |
498 | ||
499 | #define TclIsVarArray(varPtr) \ | |
500 | ((varPtr)->flags & VAR_ARRAY) | |
501 | ||
502 | #define TclIsVarUndefined(varPtr) \ | |
503 | ((varPtr)->flags & VAR_UNDEFINED) | |
504 | ||
505 | #define TclIsVarArrayElement(varPtr) \ | |
506 | ((varPtr)->flags & VAR_ARRAY_ELEMENT) | |
507 | ||
508 | #define TclIsVarTemporary(varPtr) \ | |
509 | ((varPtr)->flags & VAR_TEMPORARY) | |
510 | ||
511 | #define TclIsVarArgument(varPtr) \ | |
512 | ((varPtr)->flags & VAR_ARGUMENT) | |
513 | ||
514 | #define TclIsVarResolved(varPtr) \ | |
515 | ((varPtr)->flags & VAR_RESOLVED) | |
516 | ||
517 | /* | |
518 | *---------------------------------------------------------------- | |
519 | * Data structures related to procedures. These are used primarily | |
520 | * in tclProc.c, tclCompile.c, and tclExecute.c. | |
521 | *---------------------------------------------------------------- | |
522 | */ | |
523 | ||
524 | /* | |
525 | * Forward declaration to prevent an error when the forward reference to | |
526 | * Command is encountered in the Proc and ImportRef types declared below. | |
527 | */ | |
528 | ||
529 | struct Command; | |
530 | ||
531 | /* | |
532 | * The variable-length structure below describes a local variable of a | |
533 | * procedure that was recognized by the compiler. These variables have a | |
534 | * name, an element in the array of compiler-assigned local variables in the | |
535 | * procedure's call frame, and various other items of information. If the | |
536 | * local variable is a formal argument, it may also have a default value. | |
537 | * The compiler can't recognize local variables whose names are | |
538 | * expressions (these names are only known at runtime when the expressions | |
539 | * are evaluated) or local variables that are created as a result of an | |
540 | * "upvar" or "uplevel" command. These other local variables are kept | |
541 | * separately in a hash table in the call frame. | |
542 | */ | |
543 | ||
544 | typedef struct CompiledLocal { | |
545 | struct CompiledLocal *nextPtr; | |
546 | /* Next compiler-recognized local variable | |
547 | * for this procedure, or NULL if this is | |
548 | * the last local. */ | |
549 | int nameLength; /* The number of characters in local | |
550 | * variable's name. Used to speed up | |
551 | * variable lookups. */ | |
552 | int frameIndex; /* Index in the array of compiler-assigned | |
553 | * variables in the procedure call frame. */ | |
554 | int flags; /* Flag bits for the local variable. Same as | |
555 | * the flags for the Var structure above, | |
556 | * although only VAR_SCALAR, VAR_ARRAY, | |
557 | * VAR_LINK, VAR_ARGUMENT, VAR_TEMPORARY, and | |
558 | * VAR_RESOLVED make sense. */ | |
559 | Tcl_Obj *defValuePtr; /* Pointer to the default value of an | |
560 | * argument, if any. NULL if not an argument | |
561 | * or, if an argument, no default value. */ | |
562 | Tcl_ResolvedVarInfo *resolveInfo; | |
563 | /* Customized variable resolution info | |
564 | * supplied by the Tcl_ResolveCompiledVarProc | |
565 | * associated with a namespace. Each variable | |
566 | * is marked by a unique ClientData tag | |
567 | * during compilation, and that same tag | |
568 | * is used to find the variable at runtime. */ | |
569 | char name[4]; /* Name of the local variable starts here. | |
570 | * If the name is NULL, this will just be | |
571 | * '\0'. The actual size of this field will | |
572 | * be large enough to hold the name. MUST | |
573 | * BE THE LAST FIELD IN THE STRUCTURE! */ | |
574 | } CompiledLocal; | |
575 | ||
576 | /* | |
577 | * The structure below defines a command procedure, which consists of a | |
578 | * collection of Tcl commands plus information about arguments and other | |
579 | * local variables recognized at compile time. | |
580 | */ | |
581 | ||
582 | typedef struct Proc { | |
583 | struct Interp *iPtr; /* Interpreter for which this command | |
584 | * is defined. */ | |
585 | int refCount; /* Reference count: 1 if still present | |
586 | * in command table plus 1 for each call | |
587 | * to the procedure that is currently | |
588 | * active. This structure can be freed | |
589 | * when refCount becomes zero. */ | |
590 | struct Command *cmdPtr; /* Points to the Command structure for | |
591 | * this procedure. This is used to get | |
592 | * the namespace in which to execute | |
593 | * the procedure. */ | |
594 | Tcl_Obj *bodyPtr; /* Points to the ByteCode object for | |
595 | * procedure's body command. */ | |
596 | int numArgs; /* Number of formal parameters. */ | |
597 | int numCompiledLocals; /* Count of local variables recognized by | |
598 | * the compiler including arguments and | |
599 | * temporaries. */ | |
600 | CompiledLocal *firstLocalPtr; /* Pointer to first of the procedure's | |
601 | * compiler-allocated local variables, or | |
602 | * NULL if none. The first numArgs entries | |
603 | * in this list describe the procedure's | |
604 | * formal arguments. */ | |
605 | CompiledLocal *lastLocalPtr; /* Pointer to the last allocated local | |
606 | * variable or NULL if none. This has | |
607 | * frame index (numCompiledLocals-1). */ | |
608 | } Proc; | |
609 | ||
610 | /* | |
611 | * The structure below defines a command trace. This is used to allow Tcl | |
612 | * clients to find out whenever a command is about to be executed. | |
613 | */ | |
614 | ||
615 | typedef struct Trace { | |
616 | int level; /* Only trace commands at nesting level | |
617 | * less than or equal to this. */ | |
618 | Tcl_CmdTraceProc *proc; /* Procedure to call to trace command. */ | |
619 | ClientData clientData; /* Arbitrary value to pass to proc. */ | |
620 | struct Trace *nextPtr; /* Next in list of traces for this interp. */ | |
621 | } Trace; | |
622 | ||
623 | /* | |
624 | * The structure below defines an entry in the assocData hash table which | |
625 | * is associated with an interpreter. The entry contains a pointer to a | |
626 | * function to call when the interpreter is deleted, and a pointer to | |
627 | * a user-defined piece of data. | |
628 | */ | |
629 | ||
630 | typedef struct AssocData { | |
631 | Tcl_InterpDeleteProc *proc; /* Proc to call when deleting. */ | |
632 | ClientData clientData; /* Value to pass to proc. */ | |
633 | } AssocData; | |
634 | ||
635 | /* | |
636 | * The structure below defines a call frame. A call frame defines a naming | |
637 | * context for a procedure call: its local naming scope (for local | |
638 | * variables) and its global naming scope (a namespace, perhaps the global | |
639 | * :: namespace). A call frame can also define the naming context for a | |
640 | * namespace eval or namespace inscope command: the namespace in which the | |
641 | * command's code should execute. The Tcl_CallFrame structures exist only | |
642 | * while procedures or namespace eval/inscope's are being executed, and | |
643 | * provide a kind of Tcl call stack. | |
644 | * | |
645 | * WARNING!! The structure definition must be kept consistent with the | |
646 | * Tcl_CallFrame structure in tcl.h. If you change one, change the other. | |
647 | */ | |
648 | ||
649 | typedef struct CallFrame { | |
650 | Namespace *nsPtr; /* Points to the namespace used to resolve | |
651 | * commands and global variables. */ | |
652 | int isProcCallFrame; /* If nonzero, the frame was pushed to | |
653 | * execute a Tcl procedure and may have | |
654 | * local vars. If 0, the frame was pushed | |
655 | * to execute a namespace command and var | |
656 | * references are treated as references to | |
657 | * namespace vars; varTablePtr and | |
658 | * compiledLocals are ignored. */ | |
659 | int objc; /* This and objv below describe the | |
660 | * arguments for this procedure call. */ | |
661 | Tcl_Obj *CONST *objv; /* Array of argument objects. */ | |
662 | struct CallFrame *callerPtr; | |
663 | /* Value of interp->framePtr when this | |
664 | * procedure was invoked (i.e. next higher | |
665 | * in stack of all active procedures). */ | |
666 | struct CallFrame *callerVarPtr; | |
667 | /* Value of interp->varFramePtr when this | |
668 | * procedure was invoked (i.e. determines | |
669 | * variable scoping within caller). Same | |
670 | * as callerPtr unless an "uplevel" command | |
671 | * or something equivalent was active in | |
672 | * the caller). */ | |
673 | int level; /* Level of this procedure, for "uplevel" | |
674 | * purposes (i.e. corresponds to nesting of | |
675 | * callerVarPtr's, not callerPtr's). 1 for | |
676 | * outermost procedure, 0 for top-level. */ | |
677 | Proc *procPtr; /* Points to the structure defining the | |
678 | * called procedure. Used to get information | |
679 | * such as the number of compiled local | |
680 | * variables (local variables assigned | |
681 | * entries ["slots"] in the compiledLocals | |
682 | * array below). */ | |
683 | Tcl_HashTable *varTablePtr; /* Hash table containing local variables not | |
684 | * recognized by the compiler, or created at | |
685 | * execution time through, e.g., upvar. | |
686 | * Initially NULL and created if needed. */ | |
687 | int numCompiledLocals; /* Count of local variables recognized by | |
688 | * the compiler including arguments. */ | |
689 | Var* compiledLocals; /* Points to the array of local variables | |
690 | * recognized by the compiler. The compiler | |
691 | * emits code that refers to these variables | |
692 | * using an index into this array. */ | |
693 | } CallFrame; | |
694 | ||
695 | /* | |
696 | *---------------------------------------------------------------- | |
697 | * Data structures and procedures related to TclHandles, which | |
698 | * are a very lightweight method of preserving enough information | |
699 | * to determine if an arbitrary malloc'd block has been deleted. | |
700 | *---------------------------------------------------------------- | |
701 | */ | |
702 | ||
703 | typedef VOID **TclHandle; | |
704 | ||
705 | EXTERN TclHandle TclHandleCreate _ANSI_ARGS_((VOID *ptr)); | |
706 | EXTERN void TclHandleFree _ANSI_ARGS_((TclHandle handle)); | |
707 | EXTERN TclHandle TclHandlePreserve _ANSI_ARGS_((TclHandle handle)); | |
708 | EXTERN void TclHandleRelease _ANSI_ARGS_((TclHandle handle)); | |
709 | ||
710 | /* | |
711 | *---------------------------------------------------------------- | |
712 | * Data structures related to history. These are used primarily | |
713 | * in tclHistory.c | |
714 | *---------------------------------------------------------------- | |
715 | */ | |
716 | ||
717 | /* | |
718 | * The structure below defines one history event (a previously-executed | |
719 | * command that can be re-executed in whole or in part). | |
720 | */ | |
721 | ||
722 | typedef struct { | |
723 | char *command; /* String containing previously-executed | |
724 | * command. */ | |
725 | int bytesAvl; /* Total # of bytes available at *event (not | |
726 | * all are necessarily in use now). */ | |
727 | } HistoryEvent; | |
728 | ||
729 | /* | |
730 | * The structure below defines a pending revision to the most recent | |
731 | * history event. Changes are linked together into a list and applied | |
732 | * during the next call to Tcl_RecordHistory. See the comments at the | |
733 | * beginning of tclHistory.c for information on revisions. | |
734 | */ | |
735 | ||
736 | typedef struct HistoryRev { | |
737 | int firstIndex; /* Index of the first byte to replace in | |
738 | * current history event. */ | |
739 | int lastIndex; /* Index of last byte to replace in | |
740 | * current history event. */ | |
741 | int newSize; /* Number of bytes in newBytes. */ | |
742 | char *newBytes; /* Replacement for the range given by | |
743 | * firstIndex and lastIndex (malloced). */ | |
744 | struct HistoryRev *nextPtr; /* Next in chain of revisions to apply, or | |
745 | * NULL for end of list. */ | |
746 | } HistoryRev; | |
747 | ||
748 | /* | |
749 | *---------------------------------------------------------------- | |
750 | * Data structures related to expressions. These are used only in | |
751 | * tclExpr.c. | |
752 | *---------------------------------------------------------------- | |
753 | */ | |
754 | ||
755 | /* | |
756 | * The data structure below defines a math function (e.g. sin or hypot) | |
757 | * for use in Tcl expressions. | |
758 | */ | |
759 | ||
760 | #define MAX_MATH_ARGS 5 | |
761 | typedef struct MathFunc { | |
762 | int builtinFuncIndex; /* If this is a builtin math function, its | |
763 | * index in the array of builtin functions. | |
764 | * (tclCompilation.h lists these indices.) | |
765 | * The value is -1 if this is a new function | |
766 | * defined by Tcl_CreateMathFunc. The value | |
767 | * is also -1 if a builtin function is | |
768 | * replaced by a Tcl_CreateMathFunc call. */ | |
769 | int numArgs; /* Number of arguments for function. */ | |
770 | Tcl_ValueType argTypes[MAX_MATH_ARGS]; | |
771 | /* Acceptable types for each argument. */ | |
772 | Tcl_MathProc *proc; /* Procedure that implements this function. | |
773 | * NULL if isBuiltinFunc is 1. */ | |
774 | ClientData clientData; /* Additional argument to pass to the | |
775 | * function when invoking it. NULL if | |
776 | * isBuiltinFunc is 1. */ | |
777 | } MathFunc; | |
778 | ||
779 | /* | |
780 | * These are a thin layer over TclpThreadKeyDataGet and TclpThreadKeyDataSet | |
781 | * when threads are used, or an emulation if there are no threads. These | |
782 | * are really internal and Tcl clients should use Tcl_GetThreadData. | |
783 | */ | |
784 | ||
785 | EXTERN VOID *TclThreadDataKeyGet _ANSI_ARGS_((Tcl_ThreadDataKey *keyPtr)); | |
786 | EXTERN void TclThreadDataKeySet _ANSI_ARGS_((Tcl_ThreadDataKey *keyPtr, VOID *data)); | |
787 | ||
788 | /* | |
789 | * This is a convenience macro used to initialize a thread local storage ptr. | |
790 | */ | |
791 | #define TCL_TSD_INIT(keyPtr) (ThreadSpecificData *)Tcl_GetThreadData((keyPtr), sizeof(ThreadSpecificData)) | |
792 | ||
793 | ||
794 | /* | |
795 | *---------------------------------------------------------------- | |
796 | * Data structures related to bytecode compilation and execution. | |
797 | * These are used primarily in tclCompile.c, tclExecute.c, and | |
798 | * tclBasic.c. | |
799 | *---------------------------------------------------------------- | |
800 | */ | |
801 | ||
802 | /* | |
803 | * Forward declaration to prevent errors when the forward references to | |
804 | * Tcl_Parse and CompileEnv are encountered in the procedure type | |
805 | * CompileProc declared below. | |
806 | */ | |
807 | ||
808 | struct CompileEnv; | |
809 | ||
810 | /* | |
811 | * The type of procedures called by the Tcl bytecode compiler to compile | |
812 | * commands. Pointers to these procedures are kept in the Command structure | |
813 | * describing each command. When a CompileProc returns, the interpreter's | |
814 | * result is set to error information, if any. In addition, the CompileProc | |
815 | * returns an integer value, which is one of the following: | |
816 | * | |
817 | * TCL_OK Compilation completed normally. | |
818 | * TCL_ERROR Compilation failed because of an error; | |
819 | * the interpreter's result describes what went wrong. | |
820 | * TCL_OUT_LINE_COMPILE Compilation failed because, e.g., the command is | |
821 | * too complex for effective inline compilation. The | |
822 | * CompileProc believes the command is legal but | |
823 | * should be compiled "out of line" by emitting code | |
824 | * to invoke its command procedure at runtime. | |
825 | */ | |
826 | ||
827 | #define TCL_OUT_LINE_COMPILE (TCL_CONTINUE + 1) | |
828 | ||
829 | typedef int (CompileProc) _ANSI_ARGS_((Tcl_Interp *interp, | |
830 | Tcl_Parse *parsePtr, struct CompileEnv *compEnvPtr)); | |
831 | ||
832 | /* | |
833 | * The type of procedure called from the compilation hook point in | |
834 | * SetByteCodeFromAny. | |
835 | */ | |
836 | ||
837 | typedef int (CompileHookProc) _ANSI_ARGS_((Tcl_Interp *interp, | |
838 | struct CompileEnv *compEnvPtr, ClientData clientData)); | |
839 | ||
840 | /* | |
841 | * The data structure defining the execution environment for ByteCode's. | |
842 | * There is one ExecEnv structure per Tcl interpreter. It holds the | |
843 | * evaluation stack that holds command operands and results. The stack grows | |
844 | * towards increasing addresses. The "stackTop" member is cached by | |
845 | * TclExecuteByteCode in a local variable: it must be set before calling | |
846 | * TclExecuteByteCode and will be restored by TclExecuteByteCode before it | |
847 | * returns. | |
848 | */ | |
849 | ||
850 | typedef struct ExecEnv { | |
851 | Tcl_Obj **stackPtr; /* Points to the first item in the | |
852 | * evaluation stack on the heap. */ | |
853 | int stackTop; /* Index of current top of stack; -1 when | |
854 | * the stack is empty. */ | |
855 | int stackEnd; /* Index of last usable item in stack. */ | |
856 | } ExecEnv; | |
857 | ||
858 | /* | |
859 | * The definitions for the LiteralTable and LiteralEntry structures. Each | |
860 | * interpreter contains a LiteralTable. It is used to reduce the storage | |
861 | * needed for all the Tcl objects that hold the literals of scripts compiled | |
862 | * by the interpreter. A literal's object is shared by all the ByteCodes | |
863 | * that refer to the literal. Each distinct literal has one LiteralEntry | |
864 | * entry in the LiteralTable. A literal table is a specialized hash table | |
865 | * that is indexed by the literal's string representation, which may contain | |
866 | * null characters. | |
867 | * | |
868 | * Note that we reduce the space needed for literals by sharing literal | |
869 | * objects both within a ByteCode (each ByteCode contains a local | |
870 | * LiteralTable) and across all an interpreter's ByteCodes (with the | |
871 | * interpreter's global LiteralTable). | |
872 | */ | |
873 | ||
874 | typedef struct LiteralEntry { | |
875 | struct LiteralEntry *nextPtr; /* Points to next entry in this | |
876 | * hash bucket or NULL if end of | |
877 | * chain. */ | |
878 | Tcl_Obj *objPtr; /* Points to Tcl object that | |
879 | * holds the literal's bytes and | |
880 | * length. */ | |
881 | int refCount; /* If in an interpreter's global | |
882 | * literal table, the number of | |
883 | * ByteCode structures that share | |
884 | * the literal object; the literal | |
885 | * entry can be freed when refCount | |
886 | * drops to 0. If in a local literal | |
887 | * table, -1. */ | |
888 | } LiteralEntry; | |
889 | ||
890 | typedef struct LiteralTable { | |
891 | LiteralEntry **buckets; /* Pointer to bucket array. Each | |
892 | * element points to first entry in | |
893 | * bucket's hash chain, or NULL. */ | |
894 | LiteralEntry *staticBuckets[TCL_SMALL_HASH_TABLE]; | |
895 | /* Bucket array used for small | |
896 | * tables to avoid mallocs and | |
897 | * frees. */ | |
898 | int numBuckets; /* Total number of buckets allocated | |
899 | * at **buckets. */ | |
900 | int numEntries; /* Total number of entries present | |
901 | * in table. */ | |
902 | int rebuildSize; /* Enlarge table when numEntries | |
903 | * gets to be this large. */ | |
904 | int mask; /* Mask value used in hashing | |
905 | * function. */ | |
906 | } LiteralTable; | |
907 | ||
908 | /* | |
909 | * The following structure defines for each Tcl interpreter various | |
910 | * statistics-related information about the bytecode compiler and | |
911 | * interpreter's operation in that interpreter. | |
912 | */ | |
913 | ||
914 | #ifdef TCL_COMPILE_STATS | |
915 | typedef struct ByteCodeStats { | |
916 | long numExecutions; /* Number of ByteCodes executed. */ | |
917 | long numCompilations; /* Number of ByteCodes created. */ | |
918 | long numByteCodesFreed; /* Number of ByteCodes destroyed. */ | |
919 | long instructionCount[256]; /* Number of times each instruction was | |
920 | * executed. */ | |
921 | ||
922 | double totalSrcBytes; /* Total source bytes ever compiled. */ | |
923 | double totalByteCodeBytes; /* Total bytes for all ByteCodes. */ | |
924 | double currentSrcBytes; /* Src bytes for all current ByteCodes. */ | |
925 | double currentByteCodeBytes; /* Code bytes in all current ByteCodes. */ | |
926 | ||
927 | long srcCount[32]; /* Source size distribution: # of srcs of | |
928 | * size [2**(n-1)..2**n), n in [0..32). */ | |
929 | long byteCodeCount[32]; /* ByteCode size distribution. */ | |
930 | long lifetimeCount[32]; /* ByteCode lifetime distribution (ms). */ | |
931 | ||
932 | double currentInstBytes; /* Instruction bytes-current ByteCodes. */ | |
933 | double currentLitBytes; /* Current literal bytes. */ | |
934 | double currentExceptBytes; /* Current exception table bytes. */ | |
935 | double currentAuxBytes; /* Current auxiliary information bytes. */ | |
936 | double currentCmdMapBytes; /* Current src<->code map bytes. */ | |
937 | ||
938 | long numLiteralsCreated; /* Total literal objects ever compiled. */ | |
939 | double totalLitStringBytes; /* Total string bytes in all literals. */ | |
940 | double currentLitStringBytes; /* String bytes in current literals. */ | |
941 | long literalCount[32]; /* Distribution of literal string sizes. */ | |
942 | } ByteCodeStats; | |
943 | #endif /* TCL_COMPILE_STATS */ | |
944 | ||
945 | /* | |
946 | *---------------------------------------------------------------- | |
947 | * Data structures related to commands. | |
948 | *---------------------------------------------------------------- | |
949 | */ | |
950 | ||
951 | /* | |
952 | * An imported command is created in an namespace when it imports a "real" | |
953 | * command from another namespace. An imported command has a Command | |
954 | * structure that points (via its ClientData value) to the "real" Command | |
955 | * structure in the source namespace's command table. The real command | |
956 | * records all the imported commands that refer to it in a list of ImportRef | |
957 | * structures so that they can be deleted when the real command is deleted. */ | |
958 | ||
959 | typedef struct ImportRef { | |
960 | struct Command *importedCmdPtr; | |
961 | /* Points to the imported command created in | |
962 | * an importing namespace; this command | |
963 | * redirects its invocations to the "real" | |
964 | * command. */ | |
965 | struct ImportRef *nextPtr; /* Next element on the linked list of | |
966 | * imported commands that refer to the | |
967 | * "real" command. The real command deletes | |
968 | * these imported commands on this list when | |
969 | * it is deleted. */ | |
970 | } ImportRef; | |
971 | ||
972 | /* | |
973 | * Data structure used as the ClientData of imported commands: commands | |
974 | * created in an namespace when it imports a "real" command from another | |
975 | * namespace. | |
976 | */ | |
977 | ||
978 | typedef struct ImportedCmdData { | |
979 | struct Command *realCmdPtr; /* "Real" command that this imported command | |
980 | * refers to. */ | |
981 | struct Command *selfPtr; /* Pointer to this imported command. Needed | |
982 | * only when deleting it in order to remove | |
983 | * it from the real command's linked list of | |
984 | * imported commands that refer to it. */ | |
985 | } ImportedCmdData; | |
986 | ||
987 | /* | |
988 | * A Command structure exists for each command in a namespace. The | |
989 | * Tcl_Command opaque type actually refers to these structures. | |
990 | */ | |
991 | ||
992 | typedef struct Command { | |
993 | Tcl_HashEntry *hPtr; /* Pointer to the hash table entry that | |
994 | * refers to this command. The hash table is | |
995 | * either a namespace's command table or an | |
996 | * interpreter's hidden command table. This | |
997 | * pointer is used to get a command's name | |
998 | * from its Tcl_Command handle. NULL means | |
999 | * that the hash table entry has been | |
1000 | * removed already (this can happen if | |
1001 | * deleteProc causes the command to be | |
1002 | * deleted or recreated). */ | |
1003 | Namespace *nsPtr; /* Points to the namespace containing this | |
1004 | * command. */ | |
1005 | int refCount; /* 1 if in command hashtable plus 1 for each | |
1006 | * reference from a CmdName Tcl object | |
1007 | * representing a command's name in a | |
1008 | * ByteCode instruction sequence. This | |
1009 | * structure can be freed when refCount | |
1010 | * becomes zero. */ | |
1011 | int cmdEpoch; /* Incremented to invalidate any references | |
1012 | * that point to this command when it is | |
1013 | * renamed, deleted, hidden, or exposed. */ | |
1014 | CompileProc *compileProc; /* Procedure called to compile command. NULL | |
1015 | * if no compile proc exists for command. */ | |
1016 | Tcl_ObjCmdProc *objProc; /* Object-based command procedure. */ | |
1017 | ClientData objClientData; /* Arbitrary value passed to object proc. */ | |
1018 | Tcl_CmdProc *proc; /* String-based command procedure. */ | |
1019 | ClientData clientData; /* Arbitrary value passed to string proc. */ | |
1020 | Tcl_CmdDeleteProc *deleteProc; | |
1021 | /* Procedure invoked when deleting command | |
1022 | * to, e.g., free all client data. */ | |
1023 | ClientData deleteData; /* Arbitrary value passed to deleteProc. */ | |
1024 | int deleted; /* Means that the command is in the process | |
1025 | * of being deleted (its deleteProc is | |
1026 | * currently executing). Other attempts to | |
1027 | * delete the command should be ignored. */ | |
1028 | ImportRef *importRefPtr; /* List of each imported Command created in | |
1029 | * another namespace when this command is | |
1030 | * imported. These imported commands | |
1031 | * redirect invocations back to this | |
1032 | * command. The list is used to remove all | |
1033 | * those imported commands when deleting | |
1034 | * this "real" command. */ | |
1035 | } Command; | |
1036 | ||
1037 | /* | |
1038 | *---------------------------------------------------------------- | |
1039 | * Data structures related to name resolution procedures. | |
1040 | *---------------------------------------------------------------- | |
1041 | */ | |
1042 | ||
1043 | /* | |
1044 | * The interpreter keeps a linked list of name resolution schemes. | |
1045 | * The scheme for a namespace is consulted first, followed by the | |
1046 | * list of schemes in an interpreter, followed by the default | |
1047 | * name resolution in Tcl. Schemes are added/removed from the | |
1048 | * interpreter's list by calling Tcl_AddInterpResolver and | |
1049 | * Tcl_RemoveInterpResolver. | |
1050 | */ | |
1051 | ||
1052 | typedef struct ResolverScheme { | |
1053 | char *name; /* Name identifying this scheme. */ | |
1054 | Tcl_ResolveCmdProc *cmdResProc; | |
1055 | /* Procedure handling command name | |
1056 | * resolution. */ | |
1057 | Tcl_ResolveVarProc *varResProc; | |
1058 | /* Procedure handling variable name | |
1059 | * resolution for variables that | |
1060 | * can only be handled at runtime. */ | |
1061 | Tcl_ResolveCompiledVarProc *compiledVarResProc; | |
1062 | /* Procedure handling variable name | |
1063 | * resolution at compile time. */ | |
1064 | ||
1065 | struct ResolverScheme *nextPtr; | |
1066 | /* Pointer to next record in linked list. */ | |
1067 | } ResolverScheme; | |
1068 | ||
1069 | /* | |
1070 | *---------------------------------------------------------------- | |
1071 | * This structure defines an interpreter, which is a collection of | |
1072 | * commands plus other state information related to interpreting | |
1073 | * commands, such as variable storage. Primary responsibility for | |
1074 | * this data structure is in tclBasic.c, but almost every Tcl | |
1075 | * source file uses something in here. | |
1076 | *---------------------------------------------------------------- | |
1077 | */ | |
1078 | ||
1079 | typedef struct Interp { | |
1080 | ||
1081 | /* | |
1082 | * Note: the first three fields must match exactly the fields in | |
1083 | * a Tcl_Interp struct (see tcl.h). If you change one, be sure to | |
1084 | * change the other. | |
1085 | * | |
1086 | * The interpreter's result is held in both the string and the | |
1087 | * objResultPtr fields. These fields hold, respectively, the result's | |
1088 | * string or object value. The interpreter's result is always in the | |
1089 | * result field if that is non-empty, otherwise it is in objResultPtr. | |
1090 | * The two fields are kept consistent unless some C code sets | |
1091 | * interp->result directly. Programs should not access result and | |
1092 | * objResultPtr directly; instead, they should always get and set the | |
1093 | * result using procedures such as Tcl_SetObjResult, Tcl_GetObjResult, | |
1094 | * and Tcl_GetStringResult. See the SetResult man page for details. | |
1095 | */ | |
1096 | ||
1097 | char *result; /* If the last command returned a string | |
1098 | * result, this points to it. Should not be | |
1099 | * accessed directly; see comment above. */ | |
1100 | Tcl_FreeProc *freeProc; /* Zero means a string result is statically | |
1101 | * allocated. TCL_DYNAMIC means string | |
1102 | * result was allocated with ckalloc and | |
1103 | * should be freed with ckfree. Other values | |
1104 | * give address of procedure to invoke to | |
1105 | * free the string result. Tcl_Eval must | |
1106 | * free it before executing next command. */ | |
1107 | int errorLine; /* When TCL_ERROR is returned, this gives | |
1108 | * the line number in the command where the | |
1109 | * error occurred (1 means first line). */ | |
1110 | struct TclStubs *stubTable; | |
1111 | /* Pointer to the exported Tcl stub table. | |
1112 | * On previous versions of Tcl this is a | |
1113 | * pointer to the objResultPtr or a pointer | |
1114 | * to a buckets array in a hash table. We | |
1115 | * therefore have to do some careful checking | |
1116 | * before we can use this. */ | |
1117 | ||
1118 | TclHandle handle; /* Handle used to keep track of when this | |
1119 | * interp is deleted. */ | |
1120 | ||
1121 | Namespace *globalNsPtr; /* The interpreter's global namespace. */ | |
1122 | Tcl_HashTable *hiddenCmdTablePtr; | |
1123 | /* Hash table used by tclBasic.c to keep | |
1124 | * track of hidden commands on a per-interp | |
1125 | * basis. */ | |
1126 | ClientData interpInfo; /* Information used by tclInterp.c to keep | |
1127 | * track of master/slave interps on | |
1128 | * a per-interp basis. */ | |
1129 | Tcl_HashTable mathFuncTable;/* Contains all the math functions currently | |
1130 | * defined for the interpreter. Indexed by | |
1131 | * strings (function names); values have | |
1132 | * type (MathFunc *). */ | |
1133 | ||
1134 | ||
1135 | ||
1136 | /* | |
1137 | * Information related to procedures and variables. See tclProc.c | |
1138 | * and tclvar.c for usage. | |
1139 | */ | |
1140 | ||
1141 | int numLevels; /* Keeps track of how many nested calls to | |
1142 | * Tcl_Eval are in progress for this | |
1143 | * interpreter. It's used to delay deletion | |
1144 | * of the table until all Tcl_Eval | |
1145 | * invocations are completed. */ | |
1146 | int maxNestingDepth; /* If numLevels exceeds this value then Tcl | |
1147 | * assumes that infinite recursion has | |
1148 | * occurred and it generates an error. */ | |
1149 | CallFrame *framePtr; /* Points to top-most in stack of all nested | |
1150 | * procedure invocations. NULL means there | |
1151 | * are no active procedures. */ | |
1152 | CallFrame *varFramePtr; /* Points to the call frame whose variables | |
1153 | * are currently in use (same as framePtr | |
1154 | * unless an "uplevel" command is | |
1155 | * executing). NULL means no procedure is | |
1156 | * active or "uplevel 0" is executing. */ | |
1157 | ActiveVarTrace *activeTracePtr; | |
1158 | /* First in list of active traces for | |
1159 | * interp, or NULL if no active traces. */ | |
1160 | int returnCode; /* Completion code to return if current | |
1161 | * procedure exits with TCL_RETURN code. */ | |
1162 | char *errorInfo; /* Value to store in errorInfo if returnCode | |
1163 | * is TCL_ERROR. Malloc'ed, may be NULL */ | |
1164 | char *errorCode; /* Value to store in errorCode if returnCode | |
1165 | * is TCL_ERROR. Malloc'ed, may be NULL */ | |
1166 | ||
1167 | /* | |
1168 | * Information used by Tcl_AppendResult to keep track of partial | |
1169 | * results. See Tcl_AppendResult code for details. | |
1170 | */ | |
1171 | ||
1172 | char *appendResult; /* Storage space for results generated | |
1173 | * by Tcl_AppendResult. Malloc-ed. NULL | |
1174 | * means not yet allocated. */ | |
1175 | int appendAvl; /* Total amount of space available at | |
1176 | * partialResult. */ | |
1177 | int appendUsed; /* Number of non-null bytes currently | |
1178 | * stored at partialResult. */ | |
1179 | ||
1180 | /* | |
1181 | * Information about packages. Used only in tclPkg.c. | |
1182 | */ | |
1183 | ||
1184 | Tcl_HashTable packageTable; /* Describes all of the packages loaded | |
1185 | * in or available to this interpreter. | |
1186 | * Keys are package names, values are | |
1187 | * (Package *) pointers. */ | |
1188 | char *packageUnknown; /* Command to invoke during "package | |
1189 | * require" commands for packages that | |
1190 | * aren't described in packageTable. | |
1191 | * Malloc'ed, may be NULL. */ | |
1192 | ||
1193 | /* | |
1194 | * Miscellaneous information: | |
1195 | */ | |
1196 | ||
1197 | int cmdCount; /* Total number of times a command procedure | |
1198 | * has been called for this interpreter. */ | |
1199 | int evalFlags; /* Flags to control next call to Tcl_Eval. | |
1200 | * Normally zero, but may be set before | |
1201 | * calling Tcl_Eval. See below for valid | |
1202 | * values. */ | |
1203 | int termOffset; /* Offset of character just after last one | |
1204 | * compiled or executed by Tcl_EvalObj. */ | |
1205 | LiteralTable literalTable; /* Contains LiteralEntry's describing all | |
1206 | * Tcl objects holding literals of scripts | |
1207 | * compiled by the interpreter. Indexed by | |
1208 | * the string representations of literals. | |
1209 | * Used to avoid creating duplicate | |
1210 | * objects. */ | |
1211 | int compileEpoch; /* Holds the current "compilation epoch" | |
1212 | * for this interpreter. This is | |
1213 | * incremented to invalidate existing | |
1214 | * ByteCodes when, e.g., a command with a | |
1215 | * compile procedure is redefined. */ | |
1216 | Proc *compiledProcPtr; /* If a procedure is being compiled, a | |
1217 | * pointer to its Proc structure; otherwise, | |
1218 | * this is NULL. Set by ObjInterpProc in | |
1219 | * tclProc.c and used by tclCompile.c to | |
1220 | * process local variables appropriately. */ | |
1221 | ResolverScheme *resolverPtr; | |
1222 | /* Linked list of name resolution schemes | |
1223 | * added to this interpreter. Schemes | |
1224 | * are added/removed by calling | |
1225 | * Tcl_AddInterpResolvers and | |
1226 | * Tcl_RemoveInterpResolver. */ | |
1227 | char *scriptFile; /* NULL means there is no nested source | |
1228 | * command active; otherwise this points to | |
1229 | * the name of the file being sourced (it's | |
1230 | * not malloc-ed: it points to an argument | |
1231 | * to Tcl_EvalFile. */ | |
1232 | int flags; /* Various flag bits. See below. */ | |
1233 | long randSeed; /* Seed used for rand() function. */ | |
1234 | Trace *tracePtr; /* List of traces for this interpreter. */ | |
1235 | Tcl_HashTable *assocData; /* Hash table for associating data with | |
1236 | * this interpreter. Cleaned up when | |
1237 | * this interpreter is deleted. */ | |
1238 | struct ExecEnv *execEnvPtr; /* Execution environment for Tcl bytecode | |
1239 | * execution. Contains a pointer to the | |
1240 | * Tcl evaluation stack. */ | |
1241 | Tcl_Obj *emptyObjPtr; /* Points to an object holding an empty | |
1242 | * string. Returned by Tcl_ObjSetVar2 when | |
1243 | * variable traces change a variable in a | |
1244 | * gross way. */ | |
1245 | char resultSpace[TCL_RESULT_SIZE+1]; | |
1246 | /* Static space holding small results. */ | |
1247 | Tcl_Obj *objResultPtr; /* If the last command returned an object | |
1248 | * result, this points to it. Should not be | |
1249 | * accessed directly; see comment above. */ | |
1250 | Tcl_ThreadId threadId; /* ID of thread that owns the interpreter */ | |
1251 | ||
1252 | /* | |
1253 | * Statistical information about the bytecode compiler and interpreter's | |
1254 | * operation. | |
1255 | */ | |
1256 | ||
1257 | #ifdef TCL_COMPILE_STATS | |
1258 | ByteCodeStats stats; /* Holds compilation and execution | |
1259 | * statistics for this interpreter. */ | |
1260 | #endif /* TCL_COMPILE_STATS */ | |
1261 | } Interp; | |
1262 | ||
1263 | /* | |
1264 | * EvalFlag bits for Interp structures: | |
1265 | * | |
1266 | * TCL_BRACKET_TERM 1 means that the current script is terminated by | |
1267 | * a close bracket rather than the end of the string. | |
1268 | * TCL_ALLOW_EXCEPTIONS 1 means it's OK for the script to terminate with | |
1269 | * a code other than TCL_OK or TCL_ERROR; 0 means | |
1270 | * codes other than these should be turned into errors. | |
1271 | */ | |
1272 | ||
1273 | #define TCL_BRACKET_TERM 1 | |
1274 | #define TCL_ALLOW_EXCEPTIONS 4 | |
1275 | ||
1276 | /* | |
1277 | * Flag bits for Interp structures: | |
1278 | * | |
1279 | * DELETED: Non-zero means the interpreter has been deleted: | |
1280 | * don't process any more commands for it, and destroy | |
1281 | * the structure as soon as all nested invocations of | |
1282 | * Tcl_Eval are done. | |
1283 | * ERR_IN_PROGRESS: Non-zero means an error unwind is already in | |
1284 | * progress. Zero means a command proc has been | |
1285 | * invoked since last error occured. | |
1286 | * ERR_ALREADY_LOGGED: Non-zero means information has already been logged | |
1287 | * in $errorInfo for the current Tcl_Eval instance, | |
1288 | * so Tcl_Eval needn't log it (used to implement the | |
1289 | * "error message log" command). | |
1290 | * ERROR_CODE_SET: Non-zero means that Tcl_SetErrorCode has been | |
1291 | * called to record information for the current | |
1292 | * error. Zero means Tcl_Eval must clear the | |
1293 | * errorCode variable if an error is returned. | |
1294 | * EXPR_INITIALIZED: Non-zero means initialization specific to | |
1295 | * expressions has been carried out. | |
1296 | * DONT_COMPILE_CMDS_INLINE: Non-zero means that the bytecode compiler | |
1297 | * should not compile any commands into an inline | |
1298 | * sequence of instructions. This is set 1, for | |
1299 | * example, when command traces are requested. | |
1300 | * RAND_SEED_INITIALIZED: Non-zero means that the randSeed value of the | |
1301 | * interp has not be initialized. This is set 1 | |
1302 | * when we first use the rand() or srand() functions. | |
1303 | * SAFE_INTERP: Non zero means that the current interp is a | |
1304 | * safe interp (ie it has only the safe commands | |
1305 | * installed, less priviledge than a regular interp). | |
1306 | * USE_EVAL_DIRECT: Non-zero means don't use the compiler or byte-code | |
1307 | * interpreter; instead, have Tcl_EvalObj call | |
1308 | * Tcl_EvalEx. Used primarily for testing the | |
1309 | * new parser. | |
1310 | */ | |
1311 | ||
1312 | #define DELETED 1 | |
1313 | #define ERR_IN_PROGRESS 2 | |
1314 | #define ERR_ALREADY_LOGGED 4 | |
1315 | #define ERROR_CODE_SET 8 | |
1316 | #define EXPR_INITIALIZED 0x10 | |
1317 | #define DONT_COMPILE_CMDS_INLINE 0x20 | |
1318 | #define RAND_SEED_INITIALIZED 0x40 | |
1319 | #define SAFE_INTERP 0x80 | |
1320 | #define USE_EVAL_DIRECT 0x100 | |
1321 | ||
1322 | /* | |
1323 | *---------------------------------------------------------------- | |
1324 | * Data structures related to command parsing. These are used in | |
1325 | * tclParse.c and its clients. | |
1326 | *---------------------------------------------------------------- | |
1327 | */ | |
1328 | ||
1329 | /* | |
1330 | * The following data structure is used by various parsing procedures | |
1331 | * to hold information about where to store the results of parsing | |
1332 | * (e.g. the substituted contents of a quoted argument, or the result | |
1333 | * of a nested command). At any given time, the space available | |
1334 | * for output is fixed, but a procedure may be called to expand the | |
1335 | * space available if the current space runs out. | |
1336 | */ | |
1337 | ||
1338 | typedef struct ParseValue { | |
1339 | char *buffer; /* Address of first character in | |
1340 | * output buffer. */ | |
1341 | char *next; /* Place to store next character in | |
1342 | * output buffer. */ | |
1343 | char *end; /* Address of the last usable character | |
1344 | * in the buffer. */ | |
1345 | void (*expandProc) _ANSI_ARGS_((struct ParseValue *pvPtr, int needed)); | |
1346 | /* Procedure to call when space runs out; | |
1347 | * it will make more space. */ | |
1348 | ClientData clientData; /* Arbitrary information for use of | |
1349 | * expandProc. */ | |
1350 | } ParseValue; | |
1351 | ||
1352 | ||
1353 | /* | |
1354 | * Maximum number of levels of nesting permitted in Tcl commands (used | |
1355 | * to catch infinite recursion). | |
1356 | */ | |
1357 | ||
1358 | #define MAX_NESTING_DEPTH 1000 | |
1359 | ||
1360 | /* | |
1361 | * The macro below is used to modify a "char" value (e.g. by casting | |
1362 | * it to an unsigned character) so that it can be used safely with | |
1363 | * macros such as isspace. | |
1364 | */ | |
1365 | ||
1366 | #define UCHAR(c) ((unsigned char) (c)) | |
1367 | ||
1368 | /* | |
1369 | * This macro is used to determine the offset needed to safely allocate any | |
1370 | * data structure in memory. Given a starting offset or size, it "rounds up" | |
1371 | * or "aligns" the offset to the next 8-byte boundary so that any data | |
1372 | * structure can be placed at the resulting offset without fear of an | |
1373 | * alignment error. | |
1374 | * | |
1375 | * WARNING!! DO NOT USE THIS MACRO TO ALIGN POINTERS: it will produce | |
1376 | * the wrong result on platforms that allocate addresses that are divisible | |
1377 | * by 4 or 2. Only use it for offsets or sizes. | |
1378 | */ | |
1379 | ||
1380 | #define TCL_ALIGN(x) (((int)(x) + 7) & ~7) | |
1381 | ||
1382 | /* | |
1383 | * The following macros are used to specify the runtime platform | |
1384 | * setting of the tclPlatform variable. | |
1385 | */ | |
1386 | ||
1387 | typedef enum { | |
1388 | TCL_PLATFORM_UNIX, /* Any Unix-like OS. */ | |
1389 | TCL_PLATFORM_MAC, /* MacOS. */ | |
1390 | TCL_PLATFORM_WINDOWS /* Any Microsoft Windows OS. */ | |
1391 | } TclPlatformType; | |
1392 | ||
1393 | /* | |
1394 | * Flags for TclInvoke: | |
1395 | * | |
1396 | * TCL_INVOKE_HIDDEN Invoke a hidden command; if not set, | |
1397 | * invokes an exposed command. | |
1398 | * TCL_INVOKE_NO_UNKNOWN If set, "unknown" is not invoked if | |
1399 | * the command to be invoked is not found. | |
1400 | * Only has an effect if invoking an exposed | |
1401 | * command, i.e. if TCL_INVOKE_HIDDEN is not | |
1402 | * also set. | |
1403 | * TCL_INVOKE_NO_TRACEBACK Does not record traceback information if | |
1404 | * the invoked command returns an error. Used | |
1405 | * if the caller plans on recording its own | |
1406 | * traceback information. | |
1407 | */ | |
1408 | ||
1409 | #define TCL_INVOKE_HIDDEN (1<<0) | |
1410 | #define TCL_INVOKE_NO_UNKNOWN (1<<1) | |
1411 | #define TCL_INVOKE_NO_TRACEBACK (1<<2) | |
1412 | ||
1413 | /* | |
1414 | * The structure used as the internal representation of Tcl list | |
1415 | * objects. This is an array of pointers to the element objects. This array | |
1416 | * is grown (reallocated and copied) as necessary to hold all the list's | |
1417 | * element pointers. The array might contain more slots than currently used | |
1418 | * to hold all element pointers. This is done to make append operations | |
1419 | * faster. | |
1420 | */ | |
1421 | ||
1422 | typedef struct List { | |
1423 | int maxElemCount; /* Total number of element array slots. */ | |
1424 | int elemCount; /* Current number of list elements. */ | |
1425 | Tcl_Obj **elements; /* Array of pointers to element objects. */ | |
1426 | } List; | |
1427 | ||
1428 | ||
1429 | /* | |
1430 | * The following types are used for getting and storing platform-specific | |
1431 | * file attributes in tclFCmd.c and the various platform-versions of | |
1432 | * that file. This is done to have as much common code as possible | |
1433 | * in the file attributes code. For more information about the callbacks, | |
1434 | * see TclFileAttrsCmd in tclFCmd.c. | |
1435 | */ | |
1436 | ||
1437 | typedef int (TclGetFileAttrProc) _ANSI_ARGS_((Tcl_Interp *interp, | |
1438 | int objIndex, CONST char *fileName, Tcl_Obj **attrObjPtrPtr)); | |
1439 | typedef int (TclSetFileAttrProc) _ANSI_ARGS_((Tcl_Interp *interp, | |
1440 | int objIndex, CONST char *fileName, Tcl_Obj *attrObjPtr)); | |
1441 | ||
1442 | typedef struct TclFileAttrProcs { | |
1443 | TclGetFileAttrProc *getProc; /* The procedure for getting attrs. */ | |
1444 | TclSetFileAttrProc *setProc; /* The procedure for setting attrs. */ | |
1445 | } TclFileAttrProcs; | |
1446 | ||
1447 | /* | |
1448 | * Opaque handle used in pipeline routines to encapsulate platform-dependent | |
1449 | * state. | |
1450 | */ | |
1451 | ||
1452 | typedef struct TclFile_ *TclFile; | |
1453 | ||
1454 | /* | |
1455 | *---------------------------------------------------------------- | |
1456 | * Data structures related to hooking 'TclStat(...)' and | |
1457 | * 'TclAccess(...)'. | |
1458 | *---------------------------------------------------------------- | |
1459 | */ | |
1460 | ||
1461 | typedef int (TclStatProc_) _ANSI_ARGS_((CONST char *path, struct stat *buf)); | |
1462 | typedef int (TclAccessProc_) _ANSI_ARGS_((CONST char *path, int mode)); | |
1463 | typedef Tcl_Channel (TclOpenFileChannelProc_) _ANSI_ARGS_((Tcl_Interp *interp, | |
1464 | char *fileName, char *modeString, | |
1465 | int permissions)); | |
1466 | ||
1467 | typedef int (*TclCmdProcType) _ANSI_ARGS_((ClientData clientData, | |
1468 | Tcl_Interp *interp, int argc, char *argv[])); | |
1469 | typedef int (*TclObjCmdProcType) _ANSI_ARGS_((ClientData clientData, | |
1470 | Tcl_Interp *interp, int objc, struct Tcl_Obj * CONST objv[])); | |
1471 | ||
1472 | /* | |
1473 | * Opaque names for platform specific types. | |
1474 | */ | |
1475 | ||
1476 | typedef struct TclpTime_t_ *TclpTime_t; | |
1477 | ||
1478 | /* | |
1479 | * The following structure is used to pass glob type data amongst | |
1480 | * the various glob routines and TclpMatchFilesTypes. Currently | |
1481 | * most of the fields are ignored. However they will be used in | |
1482 | * a future release to implement glob's ability to find files | |
1483 | * of particular types/permissions/etc only. | |
1484 | */ | |
1485 | typedef struct GlobTypeData { | |
1486 | /* Corresponds to bcdpfls as in 'find -t' */ | |
1487 | int type; | |
1488 | /* Corresponds to file permissions */ | |
1489 | int perm; | |
1490 | /* Acceptable mac type */ | |
1491 | Tcl_Obj* macType; | |
1492 | /* Acceptable mac creator */ | |
1493 | Tcl_Obj* macCreator; | |
1494 | } GlobTypeData; | |
1495 | ||
1496 | /* | |
1497 | * type and permission definitions for glob command | |
1498 | */ | |
1499 | #define TCL_GLOB_TYPE_BLOCK (1<<0) | |
1500 | #define TCL_GLOB_TYPE_CHAR (1<<1) | |
1501 | #define TCL_GLOB_TYPE_DIR (1<<2) | |
1502 | #define TCL_GLOB_TYPE_PIPE (1<<3) | |
1503 | #define TCL_GLOB_TYPE_FILE (1<<4) | |
1504 | #define TCL_GLOB_TYPE_LINK (1<<5) | |
1505 | #define TCL_GLOB_TYPE_SOCK (1<<6) | |
1506 | ||
1507 | #define TCL_GLOB_PERM_RONLY (1<<0) | |
1508 | #define TCL_GLOB_PERM_HIDDEN (1<<1) | |
1509 | #define TCL_GLOB_PERM_R (1<<2) | |
1510 | #define TCL_GLOB_PERM_W (1<<3) | |
1511 | #define TCL_GLOB_PERM_X (1<<4) | |
1512 | ||
1513 | /* | |
1514 | *---------------------------------------------------------------- | |
1515 | * Variables shared among Tcl modules but not used by the outside world. | |
1516 | *---------------------------------------------------------------- | |
1517 | */ | |
1518 | ||
1519 | extern Tcl_Time tclBlockTime; | |
1520 | extern int tclBlockTimeSet; | |
1521 | extern char * tclExecutableName; | |
1522 | extern char * tclNativeExecutableName; | |
1523 | extern char * tclDefaultEncodingDir; | |
1524 | extern Tcl_ChannelType tclFileChannelType; | |
1525 | extern char * tclMemDumpFileName; | |
1526 | extern TclPlatformType tclPlatform; | |
1527 | extern char * tclpFileAttrStrings[]; | |
1528 | extern CONST TclFileAttrProcs tclpFileAttrProcs[]; | |
1529 | ||
1530 | /* | |
1531 | * Variables denoting the Tcl object types defined in the core. | |
1532 | */ | |
1533 | ||
1534 | extern Tcl_ObjType tclBooleanType; | |
1535 | extern Tcl_ObjType tclByteArrayType; | |
1536 | extern Tcl_ObjType tclByteCodeType; | |
1537 | extern Tcl_ObjType tclDoubleType; | |
1538 | extern Tcl_ObjType tclIntType; | |
1539 | extern Tcl_ObjType tclListType; | |
1540 | extern Tcl_ObjType tclProcBodyType; | |
1541 | extern Tcl_ObjType tclStringType; | |
1542 | ||
1543 | /* | |
1544 | * The head of the list of free Tcl objects, and the total number of Tcl | |
1545 | * objects ever allocated and freed. | |
1546 | */ | |
1547 | ||
1548 | extern Tcl_Obj * tclFreeObjList; | |
1549 | ||
1550 | #ifdef TCL_COMPILE_STATS | |
1551 | extern long tclObjsAlloced; | |
1552 | extern long tclObjsFreed; | |
1553 | #endif /* TCL_COMPILE_STATS */ | |
1554 | ||
1555 | /* | |
1556 | * Pointer to a heap-allocated string of length zero that the Tcl core uses | |
1557 | * as the value of an empty string representation for an object. This value | |
1558 | * is shared by all new objects allocated by Tcl_NewObj. | |
1559 | */ | |
1560 | ||
1561 | extern char * tclEmptyStringRep; | |
1562 | ||
1563 | /* | |
1564 | *---------------------------------------------------------------- | |
1565 | * Procedures shared among Tcl modules but not used by the outside | |
1566 | * world: | |
1567 | *---------------------------------------------------------------- | |
1568 | */ | |
1569 | ||
1570 | EXTERN int TclAccess _ANSI_ARGS_((CONST char *path, | |
1571 | int mode)); | |
1572 | EXTERN int TclAccessDeleteProc _ANSI_ARGS_((TclAccessProc_ *proc)); | |
1573 | EXTERN int TclAccessInsertProc _ANSI_ARGS_((TclAccessProc_ *proc)); | |
1574 | EXTERN void TclAllocateFreeObjects _ANSI_ARGS_((void)); | |
1575 | EXTERN int TclArraySet _ANSI_ARGS_((Tcl_Interp *interp, | |
1576 | Tcl_Obj *arrayNameObj, Tcl_Obj *arrayElemObj)); | |
1577 | EXTERN int TclCheckBadOctal _ANSI_ARGS_((Tcl_Interp *interp, | |
1578 | char *value)); | |
1579 | EXTERN int TclCleanupChildren _ANSI_ARGS_((Tcl_Interp *interp, | |
1580 | int numPids, Tcl_Pid *pidPtr, | |
1581 | Tcl_Channel errorChan)); | |
1582 | EXTERN void TclCleanupCommand _ANSI_ARGS_((Command *cmdPtr)); | |
1583 | EXTERN int TclCopyChannel _ANSI_ARGS_((Tcl_Interp *interp, | |
1584 | Tcl_Channel inChan, Tcl_Channel outChan, | |
1585 | int toRead, Tcl_Obj *cmdPtr)); | |
1586 | /* | |
1587 | * TclCreatePipeline unofficially exported for use by BLT. | |
1588 | */ | |
1589 | EXTERN int TclCreatePipeline _ANSI_ARGS_((Tcl_Interp *interp, | |
1590 | int argc, char **argv, Tcl_Pid **pidArrayPtr, | |
1591 | TclFile *inPipePtr, TclFile *outPipePtr, | |
1592 | TclFile *errFilePtr)); | |
1593 | EXTERN int TclCreateProc _ANSI_ARGS_((Tcl_Interp *interp, | |
1594 | Namespace *nsPtr, char *procName, | |
1595 | Tcl_Obj *argsPtr, Tcl_Obj *bodyPtr, | |
1596 | Proc **procPtrPtr)); | |
1597 | EXTERN void TclDeleteCompiledLocalVars _ANSI_ARGS_(( | |
1598 | Interp *iPtr, CallFrame *framePtr)); | |
1599 | EXTERN void TclDeleteVars _ANSI_ARGS_((Interp *iPtr, | |
1600 | Tcl_HashTable *tablePtr)); | |
1601 | EXTERN int TclDoGlob _ANSI_ARGS_((Tcl_Interp *interp, | |
1602 | char *separators, Tcl_DString *headPtr, | |
1603 | char *tail, GlobTypeData *types)); | |
1604 | EXTERN void TclDumpMemoryInfo _ANSI_ARGS_((FILE *outFile)); | |
1605 | EXTERN void TclExpandTokenArray _ANSI_ARGS_(( | |
1606 | Tcl_Parse *parsePtr)); | |
1607 | EXTERN void TclExprFloatError _ANSI_ARGS_((Tcl_Interp *interp, | |
1608 | double value)); | |
1609 | EXTERN int TclFileAttrsCmd _ANSI_ARGS_((Tcl_Interp *interp, | |
1610 | int objc, Tcl_Obj *CONST objv[])); | |
1611 | EXTERN int TclFileCopyCmd _ANSI_ARGS_((Tcl_Interp *interp, | |
1612 | int argc, char **argv)) ; | |
1613 | EXTERN int TclFileDeleteCmd _ANSI_ARGS_((Tcl_Interp *interp, | |
1614 | int argc, char **argv)); | |
1615 | EXTERN int TclFileMakeDirsCmd _ANSI_ARGS_((Tcl_Interp *interp, | |
1616 | int argc, char **argv)) ; | |
1617 | EXTERN int TclFileRenameCmd _ANSI_ARGS_((Tcl_Interp *interp, | |
1618 | int argc, char **argv)) ; | |
1619 | EXTERN void TclFinalizeAllocSubsystem _ANSI_ARGS_((void)); | |
1620 | EXTERN void TclFinalizeCompExecEnv _ANSI_ARGS_((void)); | |
1621 | EXTERN void TclFinalizeCompilation _ANSI_ARGS_((void)); | |
1622 | EXTERN void TclFinalizeEncodingSubsystem _ANSI_ARGS_((void)); | |
1623 | EXTERN void TclFinalizeEnvironment _ANSI_ARGS_((void)); | |
1624 | EXTERN void TclFinalizeExecution _ANSI_ARGS_((void)); | |
1625 | EXTERN void TclFinalizeIOSubsystem _ANSI_ARGS_((void)); | |
1626 | EXTERN void TclFinalizeLoad _ANSI_ARGS_((void)); | |
1627 | EXTERN void TclFinalizeMemorySubsystem _ANSI_ARGS_((void)); | |
1628 | EXTERN void TclFinalizeNotifier _ANSI_ARGS_((void)); | |
1629 | EXTERN void TclFinalizeSynchronization _ANSI_ARGS_((void)); | |
1630 | EXTERN void TclFinalizeThreadData _ANSI_ARGS_((void)); | |
1631 | EXTERN void TclFindEncodings _ANSI_ARGS_((CONST char *argv0)); | |
1632 | EXTERN Proc * TclFindProc _ANSI_ARGS_((Interp *iPtr, | |
1633 | char *procName)); | |
1634 | EXTERN int TclFormatInt _ANSI_ARGS_((char *buffer, long n)); | |
1635 | EXTERN void TclFreePackageInfo _ANSI_ARGS_((Interp *iPtr)); | |
1636 | EXTERN int TclGetDate _ANSI_ARGS_((char *p, | |
1637 | unsigned long now, long zone, | |
1638 | unsigned long *timePtr)); | |
1639 | EXTERN Tcl_Obj * TclGetElementOfIndexedArray _ANSI_ARGS_(( | |
1640 | Tcl_Interp *interp, int localIndex, | |
1641 | Tcl_Obj *elemPtr, int leaveErrorMsg)); | |
1642 | EXTERN char * TclGetExtension _ANSI_ARGS_((char *name)); | |
1643 | EXTERN int TclGetFrame _ANSI_ARGS_((Tcl_Interp *interp, | |
1644 | char *string, CallFrame **framePtrPtr)); | |
1645 | EXTERN TclCmdProcType TclGetInterpProc _ANSI_ARGS_((void)); | |
1646 | EXTERN int TclGetIntForIndex _ANSI_ARGS_((Tcl_Interp *interp, | |
1647 | Tcl_Obj *objPtr, int endValue, int *indexPtr)); | |
1648 | EXTERN Tcl_Obj * TclGetIndexedScalar _ANSI_ARGS_((Tcl_Interp *interp, | |
1649 | int localIndex, int leaveErrorMsg)); | |
1650 | EXTERN int TclGetLong _ANSI_ARGS_((Tcl_Interp *interp, | |
1651 | char *string, long *longPtr)); | |
1652 | EXTERN int TclGetLoadedPackages _ANSI_ARGS_(( | |
1653 | Tcl_Interp *interp, char *targetName)); | |
1654 | EXTERN int TclGetNamespaceForQualName _ANSI_ARGS_(( | |
1655 | Tcl_Interp *interp, char *qualName, | |
1656 | Namespace *cxtNsPtr, int flags, | |
1657 | Namespace **nsPtrPtr, Namespace **altNsPtrPtr, | |
1658 | Namespace **actualCxtPtrPtr, | |
1659 | char **simpleNamePtr)); | |
1660 | EXTERN TclObjCmdProcType TclGetObjInterpProc _ANSI_ARGS_((void)); | |
1661 | EXTERN int TclGetOpenMode _ANSI_ARGS_((Tcl_Interp *interp, | |
1662 | char *string, int *seekFlagPtr)); | |
1663 | EXTERN Tcl_Command TclGetOriginalCommand _ANSI_ARGS_(( | |
1664 | Tcl_Command command)); | |
1665 | EXTERN int TclGlob _ANSI_ARGS_((Tcl_Interp *interp, | |
1666 | char *pattern, char *unquotedPrefix, | |
1667 | int globFlags, GlobTypeData* types)); | |
1668 | EXTERN int TclGlobalInvoke _ANSI_ARGS_((Tcl_Interp *interp, | |
1669 | int argc, char **argv, int flags)); | |
1670 | EXTERN int TclGuessPackageName _ANSI_ARGS_((char *fileName, | |
1671 | Tcl_DString *bufPtr)); | |
1672 | EXTERN int TclHideUnsafeCommands _ANSI_ARGS_(( | |
1673 | Tcl_Interp *interp)); | |
1674 | EXTERN int TclInExit _ANSI_ARGS_((void)); | |
1675 | EXTERN Tcl_Obj * TclIncrElementOfIndexedArray _ANSI_ARGS_(( | |
1676 | Tcl_Interp *interp, int localIndex, | |
1677 | Tcl_Obj *elemPtr, long incrAmount)); | |
1678 | EXTERN Tcl_Obj * TclIncrIndexedScalar _ANSI_ARGS_(( | |
1679 | Tcl_Interp *interp, int localIndex, | |
1680 | long incrAmount)); | |
1681 | EXTERN Tcl_Obj * TclIncrVar2 _ANSI_ARGS_((Tcl_Interp *interp, | |
1682 | Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, | |
1683 | long incrAmount, int flags)); | |
1684 | EXTERN void TclInitAlloc _ANSI_ARGS_((void)); | |
1685 | EXTERN void TclInitCompiledLocals _ANSI_ARGS_(( | |
1686 | Tcl_Interp *interp, CallFrame *framePtr, | |
1687 | Namespace *nsPtr)); | |
1688 | EXTERN void TclInitDbCkalloc _ANSI_ARGS_((void)); | |
1689 | EXTERN void TclInitEncodingSubsystem _ANSI_ARGS_((void)); | |
1690 | EXTERN void TclInitIOSubsystem _ANSI_ARGS_((void)); | |
1691 | EXTERN void TclInitNamespaceSubsystem _ANSI_ARGS_((void)); | |
1692 | EXTERN void TclInitNotifier _ANSI_ARGS_((void)); | |
1693 | EXTERN void TclInitObjSubsystem _ANSI_ARGS_((void)); | |
1694 | EXTERN void TclInitSubsystems _ANSI_ARGS_((CONST char *argv0)); | |
1695 | EXTERN int TclInvoke _ANSI_ARGS_((Tcl_Interp *interp, | |
1696 | int argc, char **argv, int flags)); | |
1697 | EXTERN int TclInvokeObjectCommand _ANSI_ARGS_(( | |
1698 | ClientData clientData, Tcl_Interp *interp, | |
1699 | int argc, char **argv)); | |
1700 | EXTERN int TclInvokeStringCommand _ANSI_ARGS_(( | |
1701 | ClientData clientData, Tcl_Interp *interp, | |
1702 | int objc, Tcl_Obj *CONST objv[])); | |
1703 | EXTERN int TclIsLocalScalar _ANSI_ARGS_((CONST char *src, | |
1704 | int len)); | |
1705 | EXTERN Proc * TclIsProc _ANSI_ARGS_((Command *cmdPtr)); | |
1706 | EXTERN Var * TclLookupVar _ANSI_ARGS_((Tcl_Interp *interp, | |
1707 | char *part1, char *part2, int flags, char *msg, | |
1708 | int createPart1, int createPart2, | |
1709 | Var **arrayPtrPtr)); | |
1710 | EXTERN int TclMathInProgress _ANSI_ARGS_((void)); | |
1711 | EXTERN int TclNeedSpace _ANSI_ARGS_((char *start, char *end)); | |
1712 | EXTERN Tcl_Obj * TclNewProcBodyObj _ANSI_ARGS_((Proc *procPtr)); | |
1713 | EXTERN int TclObjCommandComplete _ANSI_ARGS_((Tcl_Obj *cmdPtr)); | |
1714 | EXTERN int TclObjInterpProc _ANSI_ARGS_((ClientData clientData, | |
1715 | Tcl_Interp *interp, int objc, | |
1716 | Tcl_Obj *CONST objv[])); | |
1717 | EXTERN int TclObjInvoke _ANSI_ARGS_((Tcl_Interp *interp, | |
1718 | int objc, Tcl_Obj *CONST objv[], int flags)); | |
1719 | EXTERN int TclObjInvokeGlobal _ANSI_ARGS_((Tcl_Interp *interp, | |
1720 | int objc, Tcl_Obj *CONST objv[], int flags)); | |
1721 | EXTERN int TclOpenFileChannelDeleteProc _ANSI_ARGS_(( | |
1722 | TclOpenFileChannelProc_ *proc)); | |
1723 | EXTERN int TclOpenFileChannelInsertProc _ANSI_ARGS_(( | |
1724 | TclOpenFileChannelProc_ *proc)); | |
1725 | EXTERN int TclpAccess _ANSI_ARGS_((CONST char *filename, | |
1726 | int mode)); | |
1727 | EXTERN char * TclpAlloc _ANSI_ARGS_((unsigned int size)); | |
1728 | EXTERN int TclpCheckStackSpace _ANSI_ARGS_((void)); | |
1729 | EXTERN int TclpCopyFile _ANSI_ARGS_((CONST char *source, | |
1730 | CONST char *dest)); | |
1731 | EXTERN int TclpCopyDirectory _ANSI_ARGS_((CONST char *source, | |
1732 | CONST char *dest, Tcl_DString *errorPtr)); | |
1733 | EXTERN int TclpCreateDirectory _ANSI_ARGS_((CONST char *path)); | |
1734 | EXTERN int TclpDeleteFile _ANSI_ARGS_((CONST char *path)); | |
1735 | EXTERN void TclpExit _ANSI_ARGS_((int status)); | |
1736 | EXTERN void TclpFinalizeCondition _ANSI_ARGS_(( | |
1737 | Tcl_Condition *condPtr)); | |
1738 | EXTERN void TclpFinalizeMutex _ANSI_ARGS_((Tcl_Mutex *mutexPtr)); | |
1739 | EXTERN void TclpFinalizeThreadData _ANSI_ARGS_(( | |
1740 | Tcl_ThreadDataKey *keyPtr)); | |
1741 | EXTERN void TclpFinalizeThreadDataKey _ANSI_ARGS_(( | |
1742 | Tcl_ThreadDataKey *keyPtr)); | |
1743 | EXTERN char * TclpFindExecutable _ANSI_ARGS_(( | |
1744 | CONST char *argv0)); | |
1745 | EXTERN int TclpFindVariable _ANSI_ARGS_((CONST char *name, | |
1746 | int *lengthPtr)); | |
1747 | EXTERN void TclpFree _ANSI_ARGS_((char *ptr)); | |