summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--generic/tclInt.h2758
1 files changed, 1335 insertions, 1423 deletions
diff --git a/generic/tclInt.h b/generic/tclInt.h
index 1da1a43..04a8096 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -9,23 +9,22 @@
* Copyright (c) 1998-19/99 by Scriptics Corporation.
* Copyright (c) 2001, 2002 by Kevin B. Kenny. All rights reserved.
*
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * 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.246 2005/08/24 17:56:23 andreas_kupries Exp $
+ * RCS: @(#) $Id: tclInt.h,v 1.247 2005/08/26 14:43:28 dkf 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.
+ * 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.
*/
#ifdef HAVE_TCL_CONFIG_H
@@ -61,8 +60,8 @@ typedef int ptrdiff_t;
/*
* Ensure WORDS_BIGENDIAN is defined correcly:
- * Needs to happen here in addition to configure to work with
- * fat compiles on Darwin (i.e. ppc and i386 at the same time).
+ * Needs to happen here in addition to configure to work with fat compiles on
+ * Darwin (i.e. ppc and i386 at the same time).
*/
#ifdef HAVE_SYS_TYPES_H
@@ -73,22 +72,21 @@ typedef int ptrdiff_t;
#endif
#ifdef BYTE_ORDER
# ifdef BIG_ENDIAN
-# if BYTE_ORDER == BIG_ENDIAN
-# undef WORDS_BIGENDIAN
-# define WORDS_BIGENDIAN
-# endif
+# if BYTE_ORDER == BIG_ENDIAN
+# undef WORDS_BIGENDIAN
+# define WORDS_BIGENDIAN
+# endif
# endif
# ifdef LITTLE_ENDIAN
-# if BYTE_ORDER == LITTLE_ENDIAN
-# undef WORDS_BIGENDIAN
-# endif
+# if BYTE_ORDER == LITTLE_ENDIAN
+# undef WORDS_BIGENDIAN
+# endif
# endif
#endif
/*
- * Used to tag functions that are only to be visible within the module
- * being built and not outside it (where this is supported by the
- * linker).
+ * Used to tag functions that are only to be visible within the module being
+ * built and not outside it (where this is supported by the linker).
*/
#ifndef MODULE_SCOPE
@@ -100,45 +98,38 @@ typedef int ptrdiff_t;
#endif
/*
- * The following procedures allow namespaces to be customized to
- * support special name resolution rules for commands/variables.
- *
+ * 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 Tcl_Var (Tcl_ResolveRuntimeVarProc) (Tcl_Interp* interp,
+ struct Tcl_ResolvedVarInfo *vinfoPtr);
-typedef void (Tcl_ResolveVarDeleteProc) _ANSI_ARGS_((
- struct Tcl_ResolvedVarInfo *vinfoPtr));
+typedef void (Tcl_ResolveVarDeleteProc)(struct Tcl_ResolvedVarInfo *vinfoPtr);
/*
* The following structure encapsulates the routines needed to resolve a
- * variable reference at runtime. Any variable specific state will typically
+ * 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) (Tcl_Interp* interp,
+ CONST84 char* name, int length, Tcl_Namespace *context,
+ Tcl_ResolvedVarInfo **rPtr);
+typedef int (Tcl_ResolveVarProc) (Tcl_Interp* interp, CONST84 char* name,
+ Tcl_Namespace *context, int flags, Tcl_Var *rPtr);
-typedef int (Tcl_ResolveCompiledVarProc) _ANSI_ARGS_((
- Tcl_Interp* interp, CONST84 char* name, int length,
- Tcl_Namespace *context, Tcl_ResolvedVarInfo **rPtr));
-
-typedef int (Tcl_ResolveVarProc) _ANSI_ARGS_((
- Tcl_Interp* interp, CONST84 char* name, Tcl_Namespace *context,
- int flags, Tcl_Var *rPtr));
+typedef int (Tcl_ResolveCmdProc) (Tcl_Interp* interp, CONST84 char* name,
+ Tcl_Namespace *context, int flags, Tcl_Command *rPtr);
-typedef int (Tcl_ResolveCmdProc) _ANSI_ARGS_((Tcl_Interp* interp,
- CONST84 char* name, Tcl_Namespace *context, int flags,
- Tcl_Command *rPtr));
-
typedef struct Tcl_ResolverInfo {
Tcl_ResolveCmdProc *cmdResProc; /* Procedure handling command name
* resolution. */
@@ -162,96 +153,93 @@ typedef struct NamespacePathEntry NamespacePathEntry;
/*
* 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.
+ * 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 ::. */
+ 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
+ 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 *). */
+ 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 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. */
+ * 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. */
+ * 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 *). */
+ * 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. */
+ * 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 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 (a) the name resolution
- * rules change for this namespace or (b) a
- * newly added command shadows a command that
- * is compiled to bytecodes.
- * This invalidates all byte codes compiled
- * in the namespace, causing the code to be
+ * 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 (a) the name
+ * resolution rules change for this namespace
+ * or (b) a newly added command shadows a
+ * command that is compiled to bytecodes. 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. */
+ /* 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. */
+ /* 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. */
+ /* 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. */
int exportLookupEpoch; /* Incremented whenever a command is added to
* a namespace, removed from a namespace or
* the exports of a namespace are changed.
@@ -275,8 +263,8 @@ typedef struct Namespace {
struct NamespacePathEntry {
Namespace *nsPtr; /* What does this path entry point to? If it
- *is NULL, this path entry points is redundant
- * and should be skipped. */
+ * is NULL, this path entry points is
+ * redundant and should be skipped. */
Namespace *creatorNsPtr; /* Where does this path entry point from? This
* allows for efficient invalidation of
* references when the path entry's target
@@ -295,16 +283,16 @@ struct NamespacePathEntry {
* 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.
+ * 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 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.
+ * 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
+ * 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
@@ -324,171 +312,166 @@ struct NamespacePathEntry {
/*
*----------------------------------------------------------------
- * Data structures related to variables. These are used primarily
- * in tclVar.c
+ * 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.
+ * 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. */
+ 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
+ * 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. */
+ struct VarTrace *nextPtr; /* Next in list of traces associated with a
+ * particular variable. */
} VarTrace;
/*
- * The following structure defines a command trace, which is used to
- * invoke a specific C procedure whenever certain operations are performed
- * on a command.
+ * The following structure defines a command trace, which is used to invoke a
+ * specific C procedure whenever certain operations are performed on a
+ * command.
*/
typedef struct CommandTrace {
- Tcl_CommandTraceProc *traceProc;/* Procedure to call when operations given
- * by flags are performed on command. */
- ClientData clientData; /* Argument to pass to proc. */
- int flags; /* What events the trace procedure is
- * interested in: OR-ed combination of
- * TCL_TRACE_RENAME, TCL_TRACE_DELETE. */
- struct CommandTrace *nextPtr; /* Next in list of traces associated with
- * a particular command. */
- int refCount; /* Used to ensure this structure is
- * not deleted too early. Keeps track
- * of how many pieces of code have
- * a pointer to this structure. */
+ Tcl_CommandTraceProc *traceProc;
+ /* Procedure to call when operations given by
+ * flags are performed on command. */
+ ClientData clientData; /* Argument to pass to proc. */
+ int flags; /* What events the trace procedure is
+ * interested in: OR-ed combination of
+ * TCL_TRACE_RENAME, TCL_TRACE_DELETE. */
+ struct CommandTrace *nextPtr;
+ /* Next in list of traces associated with a
+ * particular command. */
+ int refCount; /* Used to ensure this structure is not
+ * deleted too early. Keeps track of how many
+ * pieces of code have a pointer to this
+ * structure. */
} CommandTrace;
/*
- * When a command trace is active (i.e. its associated procedure is
- * executing), one of the following structures is linked into a list
- * associated with the command's interpreter. The information in
- * the structure is needed in order for Tcl to behave reasonably
- * if traces are deleted while traces are active.
+ * When a command trace is active (i.e. its associated procedure is executing)
+ * one of the following structures is linked into a list associated with the
+ * command'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 ActiveCommandTrace {
struct Command *cmdPtr; /* Command that's being traced. */
struct ActiveCommandTrace *nextPtr;
- /* Next in list of all active command
- * traces for the interpreter, or NULL
- * if no more. */
- CommandTrace *nextTracePtr; /* Next trace to check after current
- * trace procedure returns; if this
- * trace gets deleted, must update pointer
- * to avoid using free'd memory. */
- int reverseScan; /* Boolean set true when traces
- * are scanning in reverse order. */
+ /* Next in list of all active command traces
+ * for the interpreter, or NULL if no more. */
+ CommandTrace *nextTracePtr; /* Next trace to check after current trace
+ * procedure returns; if this trace gets
+ * deleted, must update pointer to avoid using
+ * free'd memory. */
+ int reverseScan; /* Boolean set true when traces are scanning
+ * in reverse order. */
} ActiveCommandTrace;
/*
* 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.
+ * 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. */
+ /* 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.
+ * 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. */
+ * 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. */
+ 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.
+ * 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
+ 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. */
+ * information about the hash table used to
+ * implement the associative array. Points to
+ * ckalloc-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. */
+ * 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. */
+ * 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
+ * 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. */
+ 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;
@@ -496,56 +479,55 @@ typedef struct 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_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_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.
+ * 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.
+ * 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.
+ * 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:
+ * The following additional flags are used with the CompiledLocal type defined
+ * below:
*
* VAR_ARGUMENT - 1 means that this variable holds a procedure
- * argument.
+ * argument.
* VAR_TEMPORARY - 1 if the local variable is an anonymous
* temporary variable. Temporaries have a NULL
* name.
@@ -564,19 +546,19 @@ typedef struct Var {
#define VAR_ARGUMENT 0x100
#define VAR_TEMPORARY 0x200
-#define VAR_RESOLVED 0x400
-#define VAR_IS_ARGS 0x800
+#define VAR_RESOLVED 0x400
+#define VAR_IS_ARGS 0x800
/*
* Macros to ensure that various flag bits are set properly for variables.
* The ANSI C "prototypes" for these macros are:
*
- * MODULE_SCOPE void TclSetVarScalar _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE void TclSetVarArray _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE void TclSetVarLink _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE void TclSetVarArrayElement _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE void TclSetVarUndefined _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE void TclClearVarUndefined _ANSI_ARGS_((Var *varPtr));
+ * MODULE_SCOPE void TclSetVarScalar(Var *varPtr);
+ * MODULE_SCOPE void TclSetVarArray(Var *varPtr);
+ * MODULE_SCOPE void TclSetVarLink(Var *varPtr);
+ * MODULE_SCOPE void TclSetVarArrayElement(Var *varPtr);
+ * MODULE_SCOPE void TclSetVarUndefined(Var *varPtr);
+ * MODULE_SCOPE void TclClearVarUndefined(Var *varPtr);
*/
#define TclSetVarScalar(varPtr) \
@@ -613,16 +595,16 @@ typedef struct Var {
* Macros to read various flag bits of variables.
* The ANSI C "prototypes" for these macros are:
*
- * MODULE_SCOPE int TclIsVarScalar _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE int TclIsVarLink _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE int TclIsVarArray _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE int TclIsVarUndefined _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE int TclIsVarArrayElement _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE int TclIsVarTemporary _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE int TclIsVarArgument _ANSI_ARGS_((Var *varPtr));
- * MODULE_SCOPE int TclIsVarResolved _ANSI_ARGS_((Var *varPtr));
- */
-
+ * MODULE_SCOPE int TclIsVarScalar(Var *varPtr);
+ * MODULE_SCOPE int TclIsVarLink(Var *varPtr);
+ * MODULE_SCOPE int TclIsVarArray(Var *varPtr);
+ * MODULE_SCOPE int TclIsVarUndefined(Var *varPtr);
+ * MODULE_SCOPE int TclIsVarArrayElement(Var *varPtr);
+ * MODULE_SCOPE int TclIsVarTemporary(Var *varPtr);
+ * MODULE_SCOPE int TclIsVarArgument(Var *varPtr);
+ * MODULE_SCOPE int TclIsVarResolved(Var *varPtr);
+ */
+
#define TclIsVarScalar(varPtr) \
((varPtr)->flags & VAR_SCALAR)
@@ -643,10 +625,10 @@ typedef struct Var {
#define TclIsVarTemporary(varPtr) \
((varPtr)->flags & VAR_TEMPORARY)
-
+
#define TclIsVarArgument(varPtr) \
((varPtr)->flags & VAR_ARGUMENT)
-
+
#define TclIsVarResolved(varPtr) \
((varPtr)->flags & VAR_RESOLVED)
@@ -661,7 +643,7 @@ typedef struct Var {
*/
#define TclIsVarDirectReadable(varPtr) \
- (TclIsVarScalar(varPtr) \
+ (TclIsVarScalar(varPtr) \
&& !TclIsVarUndefined(varPtr) \
&& TclIsVarUntraced(varPtr))
@@ -674,8 +656,8 @@ typedef struct Var {
/*
*----------------------------------------------------------------
- * Data structures related to procedures. These are used primarily
- * in tclProc.c, tclCompile.c, and tclExecute.c.
+ * Data structures related to procedures. These are used primarily in
+ * tclProc.c, tclCompile.c, and tclExecute.c.
*----------------------------------------------------------------
*/
@@ -688,30 +670,30 @@ 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 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.
+ * 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. */
+ /* 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. */
+ * 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,
+ * 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
@@ -721,58 +703,59 @@ typedef struct CompiledLocal {
/* 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! */
+ * 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.
+ * 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). */
+ 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
+ * 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. */
+ int level; /* Only trace commands at nesting level less
+ * than or equal to this. */
Tcl_CmdObjTraceProc *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. */
@@ -783,63 +766,62 @@ typedef struct Trace {
} Trace;
/*
- * When an interpreter trace is active (i.e. its associated procedure
- * is executing), one of the following structures is linked into a list
- * associated with the interpreter. The information in the structure
- * is needed in order for Tcl to behave reasonably if traces are
- * deleted while traces are active.
+ * When an interpreter trace is active (i.e. its associated procedure is
+ * executing), one of the following structures is linked into a list
+ * associated with the 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 ActiveInterpTrace {
struct ActiveInterpTrace *nextPtr;
- /* Next in list of all active command
- * traces for the interpreter, or NULL
- * if no more. */
- Trace *nextTracePtr; /* Next trace to check after current
- * trace procedure returns; if this
- * trace gets deleted, must update pointer
- * to avoid using free'd memory. */
- int reverseScan; /* Boolean set true when traces
- * are scanning in reverse order. */
+ /* Next in list of all active command traces
+ * for the interpreter, or NULL if no more. */
+ Trace *nextTracePtr; /* Next trace to check after current trace
+ * procedure returns; if this trace gets
+ * deleted, must update pointer to avoid using
+ * free'd memory. */
+ int reverseScan; /* Boolean set true when traces are scanning
+ * in reverse order. */
} ActiveInterpTrace;
/*
- * Flag values designating types of execution traces.
- * See tclTrace.c for related flag values.
+ * Flag values designating types of execution traces. See tclTrace.c for
+ * related flag values.
*
- * TCL_TRACE_ENTER_EXEC - triggers enter/enterstep traces.
+ * TCL_TRACE_ENTER_EXEC - triggers enter/enterstep traces.
* - passed to Tcl_CreateObjTrace to set up
- * "enterstep" traces.
- * TCL_TRACE_LEAVE_EXEC - triggets leave/leavestep traces.
+ * "enterstep" traces.
+ * TCL_TRACE_LEAVE_EXEC - triggers leave/leavestep traces.
* - passed to Tcl_CreateObjTrace to set up
- * "leavestep" traces.
+ * "leavestep" traces.
*
*/
-#define TCL_TRACE_ENTER_EXEC 1
-#define TCL_TRACE_LEAVE_EXEC 2
+#define TCL_TRACE_ENTER_EXEC 1
+#define TCL_TRACE_LEAVE_EXEC 2
/*
- * 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.
+ * 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;
+} 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.
- *
+ * 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.
*/
@@ -854,36 +836,35 @@ typedef struct CallFrame {
* If FRAME_IS_PROC is set, the frame was
* pushed to execute a Tcl procedure and may
* have local vars. */
- int objc; /* This and objv below describe the
- * arguments for this procedure call. */
+ 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). */
+ * 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). */
+ * 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). */
+ 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. */
+ 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
@@ -894,9 +875,9 @@ typedef struct 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.
+ * 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.
*----------------------------------------------------------------
*/
@@ -904,14 +885,13 @@ typedef VOID **TclHandle;
/*
*----------------------------------------------------------------
- * Data structures related to expressions. These are used only in
- * tclExpr.c.
+ * 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.
+ * The data structure below defines a math function (e.g. sin or hypot) for
+ * use in Tcl expressions.
*/
#define MAX_MATH_ARGS 5
@@ -920,48 +900,48 @@ typedef struct MathFunc {
* 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. */
+ * 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. */
+ 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.
+ * when threads are used, or an emulation if there are no threads. These are
+ * really internal and Tcl clients should use Tcl_GetThreadData.
*/
-MODULE_SCOPE VOID * TclThreadDataKeyGet _ANSI_ARGS_((
- Tcl_ThreadDataKey *keyPtr));
-MODULE_SCOPE void TclThreadDataKeySet _ANSI_ARGS_((
- Tcl_ThreadDataKey *keyPtr, VOID *data));
+MODULE_SCOPE VOID * TclThreadDataKeyGet(Tcl_ThreadDataKey *keyPtr);
+MODULE_SCOPE void TclThreadDataKeySet(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))
+
+#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.
+ * 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.
+ * Tcl_Parse and CompileEnv are encountered in the procedure type CompileProc
+ * declared below.
*/
struct CompileEnv;
@@ -969,65 +949,63 @@ 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. The integer value returned by a CompileProc
- * must be one of the following:
+ * describing each command. The integer value returned by a CompileProc must
+ * be one of the following:
*
* TCL_OK Compilation completed normally.
- * TCL_ERROR Compilation could not be completed. This can
- * be just a judgment by the CompileProc that the
- * command is too complex to compile effectively,
- * or it can indicate that in the current state of
- * the interp, the command would raise an error.
- * The bytecode compiler will not do any error reporting
- * at compiler time. Error reporting is deferred
- * until the actual runtime, because by then changes
- * in the interp state may allow the command to be
- * successfully evaluated.
- * TCL_OUT_LINE_COMPILE A source-compatible alias for TCL_ERROR, kept
- * for the sake of old code only.
+ * TCL_ERROR Compilation could not be completed. This can be just a
+ * judgment by the CompileProc that the command is too
+ * complex to compile effectively, or it can indicate
+ * that in the current state of the interp, the command
+ * would raise an error. The bytecode compiler will not
+ * do any error reporting at compiler time. Error
+ * reporting is deferred until the actual runtime,
+ * because by then changes in the interp state may allow
+ * the command to be successfully evaluated.
+ * TCL_OUT_LINE_COMPILE A source-compatible alias for TCL_ERROR, kept for the
+ * sake of old code only.
*/
#define TCL_OUT_LINE_COMPILE TCL_ERROR
-typedef int (CompileProc) _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *compEnvPtr));
+typedef int (CompileProc) (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));
+typedef int (CompileHookProc) (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.
+ * 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. */
- Tcl_Obj **tosPtr; /* Points to current top of stack;
+ Tcl_Obj **stackPtr; /* Points to the first item in the evaluation
+ * stack on the heap. */
+ Tcl_Obj **tosPtr; /* Points to current top of stack;
* (stackPtr-1) when the stack is empty. */
Tcl_Obj **endPtr; /* Points to last usable item in stack. */
- Tcl_Obj *constants[2]; /* Pointers to constant "0" and "1" objs. */
+ Tcl_Obj *constants[2]; /* Pointers to constant "0" and "1" objs. */
} 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.
+ * 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
@@ -1036,42 +1014,36 @@ typedef struct ExecEnv {
*/
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. */
- Namespace *nsPtr; /* Namespace in which this literal is
- * used. We try to avoid sharing
- * literal non-FQ command names among
- * different namespaces to reduce
- * shimmering.*/
+ 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. */
+ Namespace *nsPtr; /* Namespace in which this literal is used. We
+ * try to avoid sharing literal non-FQ command
+ * names among different namespaces to reduce
+ * shimmering. */
} LiteralEntry;
typedef struct LiteralTable {
- LiteralEntry **buckets; /* Pointer to bucket array. Each
- * element points to first entry in
- * bucket's hash chain, or NULL. */
+ 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. */
+ /* 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;
/*
@@ -1082,32 +1054,33 @@ typedef struct LiteralTable {
#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. */
+ 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 */
@@ -1119,11 +1092,12 @@ typedef struct ByteCodeStats {
/*
* 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. */
+ * 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;
@@ -1131,11 +1105,11 @@ typedef struct ImportRef {
* 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. */
+ 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;
/*
@@ -1148,35 +1122,34 @@ 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
+ * 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.
+ * 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
+ 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). */
+ * 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. */
+ * 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. */
@@ -1187,42 +1160,43 @@ typedef struct Command {
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. */
+ /* Procedure invoked when deleting command to,
+ * e.g., free all client data. */
ClientData deleteData; /* Arbitrary value passed to deleteProc. */
int flags; /* Miscellaneous bits of information about
* command. See below for definitions. */
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. */
+ * 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. */
CommandTrace *tracePtr; /* First in list of all traces set for this
* command. */
} Command;
/*
- * Flag bits for commands.
+ * Flag bits for commands.
*
- * CMD_IS_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.
+ * CMD_IS_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.
* CMD_TRACE_ACTIVE - 1 means that trace processing is currently
- * underway for a rename/delete change.
- * See the two flags below for which is
- * currently being processed.
- * CMD_HAS_EXEC_TRACES - 1 means that this command has at least
- * one execution trace (as opposed to simple
+ * underway for a rename/delete change. See the
+ * two flags below for which is currently being
+ * processed.
+ * CMD_HAS_EXEC_TRACES - 1 means that this command has at least one
+ * execution trace (as opposed to simple
* delete/rename traces) in its tracePtr list.
* TCL_TRACE_RENAME - A rename trace is in progress. Further
* recursive renames will not be traced.
- * TCL_TRACE_DELETE - A delete trace is in progress. Further
+ * TCL_TRACE_DELETE - A delete trace is in progress. Further
* recursive deletes will not be traced.
* (these last two flags are defined in tcl.h)
*/
+
#define CMD_IS_DELETED 0x1
#define CMD_TRACE_ACTIVE 0x2
#define CMD_HAS_EXEC_TRACES 0x4
@@ -1234,12 +1208,11 @@ typedef struct Command {
*/
/*
- * 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.
+ * 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 {
@@ -1248,12 +1221,12 @@ typedef struct ResolverScheme {
/* Procedure handling command name
* resolution. */
Tcl_ResolveVarProc *varResProc;
- /* Procedure handling variable name
- * resolution for variables that
- * can only be handled at runtime. */
+ /* 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. */
+ /* Procedure handling variable name resolution
+ * at compile time. */
struct ResolverScheme *nextPtr;
/* Pointer to next record in linked list. */
@@ -1267,20 +1240,18 @@ typedef struct LimitHandler LimitHandler;
/*
*----------------------------------------------------------------
- * 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.
+ * 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.
+ * 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
@@ -1289,102 +1260,99 @@ typedef struct Interp {
* 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.
+ * 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. */
+ * 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
+ /* 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. */
+ * 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 *). */
-
-
+ * 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.
+ * 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. */
+ * 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. */
+ * 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. */
+ * unless an "uplevel" command is executing).
+ * NULL means no procedure is active or
+ * "uplevel 0" is executing. */
ActiveVarTrace *activeVarTracePtr;
- /* First in list of active traces for
- * interp, or NULL if no active traces. */
+ /* First in list of active traces for interp,
+ * or NULL if no active traces. */
int returnCode; /* [return -code] parameter */
char *unused3; /* No longer used (was errorInfo) */
char *unused4; /* No longer used (was errorCode) */
/*
- * Information used by Tcl_AppendResult to keep track of partial
- * results. See Tcl_AppendResult code for details.
+ * 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. */
+ char *appendResult; /* Storage space for results generated by
+ * Tcl_AppendResult. Ckalloc-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. */
+ int appendUsed; /* Number of non-null bytes currently stored
+ * at partialResult. */
/*
- * Information about packages. Used only in tclPkg.c.
+ * 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. */
+ 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. Ckalloc'ed, may be
+ * NULL. */
/*
* Miscellaneous information:
@@ -1394,43 +1362,42 @@ typedef struct Interp {
* 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
+ * calling Tcl_Eval. See below for valid
* values. */
int unused1; /* No longer used (was termOffset) */
- 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. */
+ 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
+ * added to this interpreter. Schemes are
+ * added and removed by calling
* Tcl_AddInterpResolvers and
- * Tcl_RemoveInterpResolver. */
+ * Tcl_RemoveInterpResolver respectively. */
Tcl_Obj *scriptFile; /* NULL means there is no nested source
- * command active; otherwise this points to
+ * command active; otherwise this points to
* pathPtr of the file being sourced. */
- int flags; /* Various flag bits. See below. */
+ 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. */
+ 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. */
+ * 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
@@ -1446,8 +1413,8 @@ typedef struct Interp {
/* First in list of active command traces for
* interp, or NULL if no active traces. */
ActiveInterpTrace *activeInterpTracePtr;
- /* First in list of active traces for
- * interp, or NULL if no active traces. */
+ /* First in list of active traces for interp,
+ * or NULL if no active traces. */
int tracesForbiddingInline; /* Count of traces (in the list headed by
* tracePtr) that forbid inline bytecode
@@ -1468,61 +1435,65 @@ typedef struct Interp {
*/
struct {
- int active; /* Flag values defining which limits have
- * been set. */
+ int active; /* Flag values defining which limits have been
+ * set. */
int granularityTicker; /* Counter used to determine how often to
* check the limits. */
int exceeded; /* Which limits have been exceeded, described
* as flag values the same as the 'active'
* field. */
- int cmdCount; /* Limit for how many commands to execute
- * in the interpreter. */
- LimitHandler *cmdHandlers; /* Handlers to execute when the limit
- * is reached. */
- int cmdGranularity; /* Mod factor used to determine how often
- * to evaluate the limit check. */
+ int cmdCount; /* Limit for how many commands to execute in
+ * the interpreter. */
+ LimitHandler *cmdHandlers;
+ /* Handlers to execute when the limit is
+ * reached. */
+ int cmdGranularity; /* Mod factor used to determine how often to
+ * evaluate the limit check. */
Tcl_Time time; /* Time limit for execution within the
* interpreter. */
- LimitHandler *timeHandlers; /* Handlers to execute when the limit
- * is reached. */
- int timeGranularity; /* Mod factor used to determine how often
- * to evaluate the limit check. */
- Tcl_TimerToken timeEvent; /* Handle for a timer callback that will
- * occur when the time-limit is exceeded. */
-
- Tcl_HashTable callbacks; /* Mapping from (interp,type) pair to data
- * used to install a limit handler callback
- * to run in _this_ interp when the limit
- * is exceeded. */
+ LimitHandler *timeHandlers;
+ /* Handlers to execute when the limit is
+ * reached. */
+ int timeGranularity; /* Mod factor used to determine how often to
+ * evaluate the limit check. */
+ Tcl_TimerToken timeEvent;
+ /* Handle for a timer callback that will occur
+ * when the time-limit is exceeded. */
+
+ Tcl_HashTable callbacks;/* Mapping from (interp,type) pair to data
+ * used to install a limit handler callback to
+ * run in _this_ interp when the limit is
+ * exceeded. */
} limit;
/*
- * Information for improved default error generation from
- * ensembles (TIP#112).
+ * Information for improved default error generation from ensembles
+ * (TIP#112).
*/
struct {
Tcl_Obj * CONST *sourceObjs;
- /* What arguments were actually input into
- * the *root* ensemble command? (Nested
- * ensembles don't rewrite this.) NULL if
- * we're not processing an ensemble. */
+ /* What arguments were actually input into the
+ * *root* ensemble command? (Nested ensembles
+ * don't rewrite this.) NULL if we're not
+ * processing an ensemble. */
int numRemovedObjs; /* How many arguments have been stripped off
* because of ensemble processing. */
int numInsertedObjs; /* How many of the current arguments were
* inserted by an ensemble. */
} ensembleRewrite;
- /* TIP #219 ... Global info for the I/O system ...
- * Error message set by channel drivers, for the propagation of
- * arbitrary Tcl errors. This information, if present (chanMsg not
- * NULL), takes precedence over a posix error code returned by a
- * channel operation.
+ /*
+ * TIP #219 ... Global info for the I/O system ...
*/
- Tcl_Obj* chanMsg;
+ Tcl_Obj* chanMsg; /* Error message set by channel drivers, for
+ * the propagation of arbitrary Tcl errors.
+ * This information, if present (chanMsg not
+ * NULL), takes precedence over a posix error
+ * code returned by a channel operation. */
/*
* Statistical information about the bytecode compiler and interpreter's
@@ -1530,25 +1501,25 @@ typedef struct Interp {
*/
#ifdef TCL_COMPILE_STATS
- ByteCodeStats stats; /* Holds compilation and execution
- * statistics for this interpreter. */
-#endif /* TCL_COMPILE_STATS */
+ ByteCodeStats stats; /* Holds compilation and execution statistics
+ * for this interpreter. */
+#endif /* TCL_COMPILE_STATS */
} Interp;
/*
- * General list of interpreters. Doubly linked for easier
- * removal of items deep in the list.
+ * General list of interpreters. Doubly linked for easier removal of items
+ * deep in the list.
*/
typedef struct InterpList {
- Interp* interpPtr;
- struct InterpList* prevPtr;
- struct InterpList* nextPtr;
+ Interp* interpPtr;
+ struct InterpList* prevPtr;
+ struct InterpList* nextPtr;
} InterpList;
/*
- * Macros for splicing into and out of doubly linked lists.
- * They assume existence of struct items 'prevPtr' and 'nextPtr'.
+ * Macros for splicing into and out of doubly linked lists. They assume
+ * existence of struct items 'prevPtr' and 'nextPtr'.
*
* a = element to add or remove.
* b = list head.
@@ -1556,30 +1527,32 @@ typedef struct InterpList {
* TclSpliceIn adds to the head of the list.
*/
-#define TclSpliceIn(a,b) \
- (a)->nextPtr = (b); \
- if ((b) != NULL) \
- (b)->prevPtr = (a); \
+#define TclSpliceIn(a,b) \
+ (a)->nextPtr = (b); \
+ if ((b) != NULL) { \
+ (b)->prevPtr = (a); \
+ } \
(a)->prevPtr = NULL, (b) = (a);
-#define TclSpliceOut(a,b) \
- if ((a)->prevPtr != NULL) \
- (a)->prevPtr->nextPtr = (a)->nextPtr; \
- else \
- (b) = (a)->nextPtr; \
- if ((a)->nextPtr != NULL) \
- (a)->nextPtr->prevPtr = (a)->prevPtr;
-
+#define TclSpliceOut(a,b) \
+ if ((a)->prevPtr != NULL) { \
+ (a)->prevPtr->nextPtr = (a)->nextPtr; \
+ } else { \
+ (b) = (a)->nextPtr; \
+ } \
+ if ((a)->nextPtr != NULL) { \
+ (a)->nextPtr->prevPtr = (a)->prevPtr; \
+ }
/*
* EvalFlag bits for Interp structures:
*
- * 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.
+ * 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_ALLOW_EXCEPTIONS 4
+#define TCL_ALLOW_EXCEPTIONS 4
/*
* Flag bits for Interp structures:
@@ -1588,20 +1561,20 @@ typedef struct InterpList {
* don't process any more commands for it, and destroy
* the structure as soon as all nested invocations of
* Tcl_Eval are done.
- * ERR_ALREADY_LOGGED: Non-zero means information has already been logged
- * in iPtr->errorInfo for the current Tcl_Eval instance,
- * so Tcl_Eval needn't log it (used to implement the
- * "error message log" command).
- * 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).
+ * ERR_ALREADY_LOGGED: Non-zero means information has already been logged in
+ * iPtr->errorInfo for the current Tcl_Eval instance, so
+ * Tcl_Eval needn't log it (used to implement the "error
+ * message log" command).
+ * 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 (i.e. it has only the safe commands installed,
+ * less priviledge than a regular interp).
* INTERP_TRACE_IN_PROGRESS: Non-zero means that an interp trace is currently
* active; so no further trace callbacks should be
* invoked.
@@ -1624,8 +1597,8 @@ typedef struct InterpList {
#define INTERP_ALTERNATE_WRONG_ARGS 0x400
/*
- * Maximum number of levels of nesting permitted in Tcl commands (used
- * to catch infinite recursion).
+ * Maximum number of levels of nesting permitted in Tcl commands (used to
+ * catch infinite recursion).
*/
#define MAX_NESTING_DEPTH 1000
@@ -1636,9 +1609,11 @@ typedef struct InterpList {
struct LimitHandler {
int flags; /* The state of this particular handler. */
- Tcl_LimitHandlerProc *handlerProc; /* The handler callback. */
+ Tcl_LimitHandlerProc *handlerProc;
+ /* The handler callback. */
ClientData clientData; /* Opaque argument to the handler callback. */
- Tcl_LimitHandlerDeleteProc *deleteProc; /* How to delete the clientData */
+ Tcl_LimitHandlerDeleteProc *deleteProc;
+ /* How to delete the clientData */
LimitHandler *prevPtr; /* Previous item in linked list of handlers */
LimitHandler *nextPtr; /* Next item in linked list of handlers */
};
@@ -1647,7 +1622,7 @@ struct LimitHandler {
* Values for the LimitHandler flags field.
* LIMIT_HANDLER_ACTIVE - Whether the handler is currently being
* processed; handlers are never to be entered reentrantly.
- * LIMIT_HANDLER_DELETED - Whether the handler has been deleted. This
+ * LIMIT_HANDLER_DELETED - Whether the handler has been deleted. This
* should not normally be observed because when a handler is
* deleted it is also spliced out of the list of handlers, but
* even so we will be careful.
@@ -1657,9 +1632,9 @@ struct LimitHandler {
#define LIMIT_HANDLER_DELETED 0x02
/*
- * 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.
+ * 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))
@@ -1671,9 +1646,9 @@ struct LimitHandler {
* 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.
+ * 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.
*
* This macro is only used by tclCompile.c in the core (Bug 926445). It
* however not be made file static, as extensions that touch bytecodes
@@ -1684,8 +1659,8 @@ struct LimitHandler {
/*
- * The following enum values are used to specify the runtime platform
- * setting of the tclPlatform variable.
+ * The following enum values are used to specify the runtime platform setting
+ * of the tclPlatform variable.
*/
typedef enum {
@@ -1694,9 +1669,9 @@ typedef enum {
} TclPlatformType;
/*
- * The following enum values are used to indicate the translation
- * of a Tcl channel. Declared here so that each platform can define
- * TCL_PLATFORM_TRANSLATION to the native translation on that platform
+ * The following enum values are used to indicate the translation of a Tcl
+ * channel. Declared here so that each platform can define
+ * TCL_PLATFORM_TRANSLATION to the native translation on that platform
*/
typedef enum TclEolTranslation {
@@ -1709,17 +1684,16 @@ typedef enum TclEolTranslation {
/*
* 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.
+ * 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)
@@ -1727,11 +1701,11 @@ typedef enum TclEolTranslation {
#define TCL_INVOKE_NO_TRACEBACK (1<<2)
/*
- * The structure used as the internal representation of Tcl list
- * objects. This struct is grown (reallocated and copied) as necessary to hold
- * all the list's element pointers. The struct might contain more slots than
- * currently used to hold all element pointers. This is done to make append
- * operations faster.
+ * The structure used as the internal representation of Tcl list objects. This
+ * struct is grown (reallocated and copied) as necessary to hold all the
+ * list's element pointers. The struct might contain more slots than currently
+ * used to hold all element pointers. This is done to make append operations
+ * faster.
*/
typedef struct List {
@@ -1750,7 +1724,7 @@ typedef struct List {
#define TclListObjGetElements(listPtr, objc, objv) \
{ \
List *listRepPtr = \
- (List *) (listPtr)->internalRep.twoPtrValue.ptr1;\
+ (List *) (listPtr)->internalRep.twoPtrValue.ptr1;\
(objc) = listRepPtr->elemCount;\
(objv) = &listRepPtr->elements;\
}
@@ -1758,29 +1732,28 @@ typedef struct List {
/*
* Flag values for TclTraceDictPath().
*
- * DICT_PATH_READ indicates that all entries on the path must exist
- * but no updates will be needed.
+ * DICT_PATH_READ indicates that all entries on the path must exist but no
+ * updates will be needed.
*
- * DICT_PATH_UPDATE indicates that we are going to be doing an update
- * at the tip of the path, so duplication of shared objects should be
- * done along the way.
+ * DICT_PATH_UPDATE indicates that we are going to be doing an update at the
+ * tip of the path, so duplication of shared objects should be done along the
+ * way.
*
- * DICT_PATH_EXISTS indicates that we are performing an existance test
- * and a lookup failure should therefore not be an error. If (and
- * only if) this flag is set, TclTraceDictPath() will return the special
- * value DICT_PATH_NON_EXISTENT if the path is not traceable.
+ * DICT_PATH_EXISTS indicates that we are performing an existance test and a
+ * lookup failure should therefore not be an error. If (and only if) this flag
+ * is set, TclTraceDictPath() will return the special value
+ * DICT_PATH_NON_EXISTENT if the path is not traceable.
*
- * DICT_PATH_CREATE (which also requires the DICT_PATH_UPDATE bit to
- * be set) indicates that we are to create non-existant dictionaries
- * on the path.
+ * DICT_PATH_CREATE (which also requires the DICT_PATH_UPDATE bit to be set)
+ * indicates that we are to create non-existant dictionaries on the path.
*/
-#define DICT_PATH_READ 0
-#define DICT_PATH_UPDATE 1
-#define DICT_PATH_EXISTS 2
-#define DICT_PATH_CREATE 5
+#define DICT_PATH_READ 0
+#define DICT_PATH_UPDATE 1
+#define DICT_PATH_EXISTS 2
+#define DICT_PATH_CREATE 5
-#define DICT_PATH_NON_EXISTENT ((Tcl_Obj *) (void *) 1)
+#define DICT_PATH_NON_EXISTENT ((Tcl_Obj *) (void *) 1)
/*
*----------------------------------------------------------------
@@ -1788,46 +1761,45 @@ typedef struct List {
*----------------------------------------------------------------
*/
-
-/*
- * The version_2 filesystem is private to Tcl. As and when these
- * changes have been thoroughly tested and investigated a new public
- * filesystem interface will be released. The aim is more versatile
- * virtual filesystem interfaces, more efficiency in 'path' manipulation
- * and usage, and cleaner filesystem code internally.
+/*
+ * The version_2 filesystem is private to Tcl. As and when these changes have
+ * been thoroughly tested and investigated a new public filesystem interface
+ * will be released. The aim is more versatile virtual filesystem interfaces,
+ * more efficiency in 'path' manipulation and usage, and cleaner filesystem
+ * code internally.
*/
#define TCL_FILESYSTEM_VERSION_2 ((Tcl_FSVersion) 0x2)
-typedef ClientData (TclFSGetCwdProc2) _ANSI_ARGS_((ClientData clientData));
+typedef ClientData (TclFSGetCwdProc2) (ClientData clientData);
/*
- * 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.
+ * 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, Tcl_Obj *fileName, Tcl_Obj **attrObjPtrPtr));
-typedef int (TclSetFileAttrProc) _ANSI_ARGS_((Tcl_Interp *interp,
- int objIndex, Tcl_Obj *fileName, Tcl_Obj *attrObjPtr));
+typedef int (TclGetFileAttrProc) (Tcl_Interp *interp, int objIndex,
+ Tcl_Obj *fileName, Tcl_Obj **attrObjPtrPtr);
+typedef int (TclSetFileAttrProc) (Tcl_Interp *interp, int objIndex,
+ Tcl_Obj *fileName, Tcl_Obj *attrObjPtr);
typedef struct TclFileAttrProcs {
- TclGetFileAttrProc *getProc; /* The procedure for getting attrs. */
- TclSetFileAttrProc *setProc; /* The procedure for setting attrs. */
+ 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.
+ * state.
*/
typedef struct TclFile_ *TclFile;
-
+
/*
- * The "globParameters" argument of the function TclGlob is an
- * or'ed combination of the following values:
+ * The "globParameters" argument of the function TclGlob is an or'ed
+ * combination of the following values:
*/
#define TCL_GLOBMODE_NO_COMPLAIN 1
@@ -1837,7 +1809,7 @@ typedef struct TclFile_ *TclFile;
typedef enum Tcl_PathPart {
TCL_PATH_DIRNAME,
- TCL_PATH_TAIL,
+ TCL_PATH_TAIL,
TCL_PATH_EXTENSION,
TCL_PATH_ROOT
} Tcl_PathPart;
@@ -1848,12 +1820,10 @@ typedef enum Tcl_PathPart {
*----------------------------------------------------------------
*/
-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,
- CONST char *fileName, CONST char *modeString,
- int permissions));
-
+typedef int (TclStatProc_) (CONST char *path, struct stat *buf);
+typedef int (TclAccessProc_) (CONST char *path, int mode);
+typedef Tcl_Channel (TclOpenFileChannelProc_) (Tcl_Interp *interp,
+ CONST char *fileName, CONST char *modeString, int permissions);
/*
*----------------------------------------------------------------
@@ -1870,32 +1840,32 @@ typedef Tcl_ObjCmdProc *TclObjCmdProcType;
*----------------------------------------------------------------
*/
-typedef void (TclInitProcessGlobalValueProc) _ANSI_ARGS_((char **valuePtr,
- int *lengthPtr, Tcl_Encoding *encodingPtr));
+typedef void (TclInitProcessGlobalValueProc) (char **valuePtr, int *lengthPtr,
+ Tcl_Encoding *encodingPtr);
/*
- * A ProcessGlobalValue struct exists for each internal value in
- * Tcl that is to be shared among several threads. Each thread
- * sees a (Tcl_Obj) copy of the value, and the master is kept as
- * a counted string, with epoch and mutex control. Each ProcessGlobalValue
- * struct should be a static variable in some file.
+ * A ProcessGlobalValue struct exists for each internal value in Tcl that is
+ * to be shared among several threads. Each thread sees a (Tcl_Obj) copy of
+ * the value, and the master is kept as a counted string, with epoch and mutex
+ * control. Each ProcessGlobalValue struct should be a static variable in some
+ * file.
*/
+
typedef struct ProcessGlobalValue {
- int epoch; /* Epoch counter to detect changes
- * in the master value */
- int numBytes; /* Length of the master string */
- char *value; /* The master string value */
- Tcl_Encoding encoding; /* system encoding when master string
- * was initialized */
+ int epoch; /* Epoch counter to detect changes in the
+ * master value. */
+ int numBytes; /* Length of the master string. */
+ char *value; /* The master string value. */
+ Tcl_Encoding encoding; /* system encoding when master string was
+ * initialized. */
TclInitProcessGlobalValueProc *proc;
- /* A procedure to initialize the
- * master string copy when a "get"
- * request comes in before any
- * "set" request has been received. */
- Tcl_Mutex mutex; /* Enforce orderly access from
- * multiple threads */
- Tcl_ThreadDataKey key; /* Key for per-thread data holding
- * the (Tcl_Obj) copy for each thread */
+ /* A procedure to initialize the master string
+ * copy when a "get" request comes in before
+ * any "set" request has been received. */
+ Tcl_Mutex mutex; /* Enforce orderly access from multiple
+ * threads. */
+ Tcl_ThreadDataKey key; /* Key for per-thread data holding the
+ * (Tcl_Obj) copy for each thread. */
} ProcessGlobalValue;
/*
@@ -1910,13 +1880,14 @@ MODULE_SCOPE char * tclMemDumpFileName;
MODULE_SCOPE TclPlatformType tclPlatform;
MODULE_SCOPE Tcl_NotifierProcs tclOriginalNotifier;
-/* TIP #233 (Virtualized Time)
+/*
+ * TIP #233 (Virtualized Time)
* Data for the time hooks, if any.
*/
MODULE_SCOPE Tcl_GetTimeProc* tclGetTimeProcPtr;
MODULE_SCOPE Tcl_ScaleTimeProc* tclScaleTimeProcPtr;
-MODULE_SCOPE ClientData tclTimeClientData;
+MODULE_SCOPE ClientData tclTimeClientData;
/*
* Variables denoting the Tcl object types defined in the core.
@@ -1961,9 +1932,9 @@ MODULE_SCOPE long tclObjsShared[TCL_MAX_SHARED_OBJ_STATS];
#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.
+ * 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.
*/
MODULE_SCOPE char * tclEmptyStringRep;
@@ -1971,248 +1942,206 @@ MODULE_SCOPE char tclEmptyString;
/*
*----------------------------------------------------------------
- * Procedures shared among Tcl modules but not used by the outside
- * world:
+ * Procedures shared among Tcl modules but not used by the outside world:
*----------------------------------------------------------------
*/
-MODULE_SCOPE void TclAppendLimitedToObj _ANSI_ARGS_((Tcl_Obj *objPtr,
+MODULE_SCOPE void TclAppendLimitedToObj(Tcl_Obj *objPtr,
CONST char *bytes, int length, int limit,
- CONST char *ellipsis));
-MODULE_SCOPE void TclAppendObjToErrorInfo _ANSI_ARGS_((
- Tcl_Interp *interp, Tcl_Obj *objPtr));
-MODULE_SCOPE int TclArraySet _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Obj *arrayNameObj, Tcl_Obj *arrayElemObj));
-MODULE_SCOPE double TclBignumToDouble _ANSI_ARGS_((mp_int* bignum));
-MODULE_SCOPE int TclCheckBadOctal _ANSI_ARGS_((Tcl_Interp *interp,
- CONST char *value));
-MODULE_SCOPE int TclChanCreateObjCmd _ANSI_ARGS_((ClientData clientData,
- Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclChanPostEventObjCmd _ANSI_ARGS_((ClientData clientData,
- Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclChanCaughtErrorBypass _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Channel chan));
-MODULE_SCOPE void TclCleanupLiteralTable _ANSI_ARGS_((
- Tcl_Interp* interp, LiteralTable* tablePtr));
-MODULE_SCOPE int TclDoubleDigits _ANSI_ARGS_((char* buf,
- double value,
- int* signum));
-MODULE_SCOPE void TclExpandTokenArray _ANSI_ARGS_((
- Tcl_Parse *parsePtr));
-MODULE_SCOPE int TclFileAttrsCmd _ANSI_ARGS_((Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclFileCopyCmd _ANSI_ARGS_((Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[])) ;
-MODULE_SCOPE int TclFileDeleteCmd _ANSI_ARGS_((Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclFileMakeDirsCmd _ANSI_ARGS_((Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[])) ;
-MODULE_SCOPE int TclFileRenameCmd _ANSI_ARGS_((Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[])) ;
-MODULE_SCOPE void TclFinalizeAllocSubsystem _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeAsync _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeCompilation _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeDoubleConversion _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeEncodingSubsystem _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeEnvironment _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeExecution _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeIOSubsystem _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeFilesystem _ANSI_ARGS_((void));
-MODULE_SCOPE void TclResetFilesystem _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeLoad _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeLock _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeMemorySubsystem _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeNotifier _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeObjects _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizePreserve _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeSynchronization _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFinalizeThreadData _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFormatNaN _ANSI_ARGS_((double value, char* buffer));
-MODULE_SCOPE int TclFSFileAttrIndex _ANSI_ARGS_((Tcl_Obj *pathPtr,
- CONST char *attributeName, int *indexPtr));
-MODULE_SCOPE Tcl_Obj * TclGetBgErrorHandler _ANSI_ARGS_((Tcl_Interp *interp));
-MODULE_SCOPE int TclGetEncodingFromObj _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Obj *objPtr, Tcl_Encoding *encodingPtr));
-MODULE_SCOPE int TclGetNamespaceFromObj _ANSI_ARGS_((
- Tcl_Interp *interp, Tcl_Obj *objPtr,
- Tcl_Namespace **nsPtrPtr));
-MODULE_SCOPE int TclGetOpenModeEx _ANSI_ARGS_((Tcl_Interp *interp,
+ CONST char *ellipsis);
+MODULE_SCOPE void TclAppendObjToErrorInfo(Tcl_Interp *interp,
+ Tcl_Obj *objPtr);
+MODULE_SCOPE int TclArraySet(Tcl_Interp *interp,
+ Tcl_Obj *arrayNameObj, Tcl_Obj *arrayElemObj);
+MODULE_SCOPE double TclBignumToDouble(mp_int* bignum);
+MODULE_SCOPE int TclCheckBadOctal(Tcl_Interp *interp,CONST char *value);
+MODULE_SCOPE int TclChanCreateObjCmd(ClientData clientData,
+ Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclChanPostEventObjCmd(ClientData clientData,
+ Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclChanCaughtErrorBypass(Tcl_Interp *interp,
+ Tcl_Channel chan);
+MODULE_SCOPE void TclCleanupLiteralTable(Tcl_Interp* interp,
+ LiteralTable* tablePtr);
+MODULE_SCOPE int TclDoubleDigits(char* buf, double value, int* signum);
+MODULE_SCOPE void TclExpandTokenArray(Tcl_Parse *parsePtr);
+MODULE_SCOPE int TclFileAttrsCmd(Tcl_Interp *interp,
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclFileCopyCmd(Tcl_Interp *interp,
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclFileDeleteCmd(Tcl_Interp *interp,
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclFileMakeDirsCmd(Tcl_Interp *interp,
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclFileRenameCmd(Tcl_Interp *interp,
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE void TclFinalizeAllocSubsystem(void);
+MODULE_SCOPE void TclFinalizeAsync(void);
+MODULE_SCOPE void TclFinalizeCompilation(void);
+MODULE_SCOPE void TclFinalizeDoubleConversion(void);
+MODULE_SCOPE void TclFinalizeEncodingSubsystem(void);
+MODULE_SCOPE void TclFinalizeEnvironment(void);
+MODULE_SCOPE void TclFinalizeExecution(void);
+MODULE_SCOPE void TclFinalizeIOSubsystem(void);
+MODULE_SCOPE void TclFinalizeFilesystem(void);
+MODULE_SCOPE void TclResetFilesystem(void);
+MODULE_SCOPE void TclFinalizeLoad(void);
+MODULE_SCOPE void TclFinalizeLock(void);
+MODULE_SCOPE void TclFinalizeMemorySubsystem(void);
+MODULE_SCOPE void TclFinalizeNotifier(void);
+MODULE_SCOPE void TclFinalizeObjects(void);
+MODULE_SCOPE void TclFinalizePreserve(void);
+MODULE_SCOPE void TclFinalizeSynchronization(void);
+MODULE_SCOPE void TclFinalizeThreadData(void);
+MODULE_SCOPE void TclFormatNaN(double value, char* buffer);
+MODULE_SCOPE int TclFSFileAttrIndex(Tcl_Obj *pathPtr,
+ CONST char *attributeName, int *indexPtr);
+MODULE_SCOPE Tcl_Obj * TclGetBgErrorHandler(Tcl_Interp *interp);
+MODULE_SCOPE int TclGetEncodingFromObj(Tcl_Interp *interp,
+ Tcl_Obj *objPtr, Tcl_Encoding *encodingPtr);
+MODULE_SCOPE int TclGetNamespaceFromObj(Tcl_Interp *interp,
+ Tcl_Obj *objPtr, Tcl_Namespace **nsPtrPtr);
+MODULE_SCOPE int TclGetOpenModeEx(Tcl_Interp *interp,
CONST char *modeString, int *seekFlagPtr,
- int *binaryPtr));
-MODULE_SCOPE Tcl_Obj * TclGetProcessGlobalValue _ANSI_ARGS_ ((
- ProcessGlobalValue *pgvPtr));
-MODULE_SCOPE int TclGlob _ANSI_ARGS_((Tcl_Interp *interp,
- char *pattern, Tcl_Obj *unquotedPrefix,
- int globFlags, Tcl_GlobTypeData* types));
-MODULE_SCOPE void TclInitAlloc _ANSI_ARGS_((void));
-MODULE_SCOPE void TclInitDbCkalloc _ANSI_ARGS_((void));
-MODULE_SCOPE void TclInitDoubleConversion _ANSI_ARGS_((void));
-MODULE_SCOPE void TclInitEmbeddedConfigurationInformation
- _ANSI_ARGS_((Tcl_Interp *interp));
-MODULE_SCOPE void TclInitEncodingSubsystem _ANSI_ARGS_((void));
-MODULE_SCOPE void TclInitIOSubsystem _ANSI_ARGS_((void));
-MODULE_SCOPE void TclInitLimitSupport _ANSI_ARGS_((Tcl_Interp *interp));
-MODULE_SCOPE void TclInitNamespaceSubsystem _ANSI_ARGS_((void));
-MODULE_SCOPE void TclInitNotifier _ANSI_ARGS_((void));
-MODULE_SCOPE void TclInitObjSubsystem _ANSI_ARGS_((void));
+ int *binaryPtr);
+MODULE_SCOPE Tcl_Obj * TclGetProcessGlobalValue(ProcessGlobalValue *pgvPtr);
+MODULE_SCOPE int TclGlob(Tcl_Interp *interp, char *pattern,
+ Tcl_Obj *unquotedPrefix, int globFlags,
+ Tcl_GlobTypeData* types);
+MODULE_SCOPE void TclInitAlloc(void);
+MODULE_SCOPE void TclInitDbCkalloc(void);
+MODULE_SCOPE void TclInitDoubleConversion(void);
+MODULE_SCOPE void TclInitEmbeddedConfigurationInformation(
+ Tcl_Interp *interp);
+MODULE_SCOPE void TclInitEncodingSubsystem(void);
+MODULE_SCOPE void TclInitIOSubsystem(void);
+MODULE_SCOPE void TclInitLimitSupport(Tcl_Interp *interp);
+MODULE_SCOPE void TclInitNamespaceSubsystem(void);
+MODULE_SCOPE void TclInitNotifier(void);
+MODULE_SCOPE void TclInitObjSubsystem(void);
MODULE_SCOPE void TclInitSubsystems ();
-MODULE_SCOPE int TclInterpReady _ANSI_ARGS_((Tcl_Interp *interp));
-MODULE_SCOPE int TclIsLocalScalar _ANSI_ARGS_((CONST char *src,
- int len));
-MODULE_SCOPE int TclJoinThread _ANSI_ARGS_((Tcl_ThreadId id,
- int* result));
-MODULE_SCOPE void TclLimitRemoveAllHandlers _ANSI_ARGS_((
- Tcl_Interp *interp));
-MODULE_SCOPE Tcl_Obj * TclLindexList _ANSI_ARGS_((Tcl_Interp* interp,
- Tcl_Obj* listPtr, Tcl_Obj* argPtr));
-MODULE_SCOPE Tcl_Obj * TclLindexFlat _ANSI_ARGS_((Tcl_Interp* interp,
- Tcl_Obj* listPtr, int indexCount,
- Tcl_Obj *CONST indexArray[]));
-MODULE_SCOPE int TclLoadFile _ANSI_ARGS_((Tcl_Interp* interp,
- Tcl_Obj *pathPtr, int symc,
- CONST char *symbols[],
+MODULE_SCOPE int TclInterpReady(Tcl_Interp *interp);
+MODULE_SCOPE int TclIsLocalScalar(CONST char *src, int len);
+MODULE_SCOPE int TclJoinThread(Tcl_ThreadId id, int* result);
+MODULE_SCOPE void TclLimitRemoveAllHandlers(Tcl_Interp *interp);
+MODULE_SCOPE Tcl_Obj * TclLindexList(Tcl_Interp* interp,
+ Tcl_Obj* listPtr, Tcl_Obj* argPtr);
+MODULE_SCOPE Tcl_Obj * TclLindexFlat(Tcl_Interp* interp, Tcl_Obj* listPtr,
+ int indexCount, Tcl_Obj *CONST indexArray[]);
+MODULE_SCOPE int TclLoadFile(Tcl_Interp* interp, Tcl_Obj *pathPtr,
+ int symc, CONST char *symbols[],
Tcl_PackageInitProc **procPtrs[],
Tcl_LoadHandle *handlePtr,
ClientData *clientDataPtr,
- Tcl_FSUnloadFileProc **unloadProcPtr));
-MODULE_SCOPE Tcl_Obj * TclLsetList _ANSI_ARGS_((Tcl_Interp* interp,
- Tcl_Obj* listPtr, Tcl_Obj* indexPtr,
- Tcl_Obj* valuePtr));
-MODULE_SCOPE Tcl_Obj * TclLsetFlat _ANSI_ARGS_((Tcl_Interp* interp,
- Tcl_Obj* listPtr, int indexCount,
- Tcl_Obj *CONST indexArray[], Tcl_Obj* valuePtr));
-MODULE_SCOPE int TclMergeReturnOptions _ANSI_ARGS_((Tcl_Interp *interp,
+ Tcl_FSUnloadFileProc **unloadProcPtr);
+MODULE_SCOPE Tcl_Obj * TclLsetList(Tcl_Interp* interp, Tcl_Obj* listPtr,
+ Tcl_Obj* indexPtr, Tcl_Obj* valuePtr);
+MODULE_SCOPE Tcl_Obj * TclLsetFlat(Tcl_Interp* interp, Tcl_Obj* listPtr,
+ int indexCount, Tcl_Obj *CONST indexArray[],
+ Tcl_Obj* valuePtr);
+MODULE_SCOPE int TclMergeReturnOptions(Tcl_Interp *interp, int objc,
+ Tcl_Obj *CONST objv[], Tcl_Obj **optionsPtrPtr,
+ int *codePtr, int *levelPtr);
+MODULE_SCOPE int TclObjInvokeNamespace(Tcl_Interp *interp,
int objc, Tcl_Obj *CONST objv[],
- Tcl_Obj **optionsPtrPtr, int *codePtr,
- int *levelPtr));
-MODULE_SCOPE int TclObjInvokeNamespace _ANSI_ARGS_((Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[],
- Tcl_Namespace *nsPtr, int flags));
-MODULE_SCOPE int TclParseBackslash _ANSI_ARGS_((CONST char *src,
- int numBytes, int *readPtr, char *dst));
-MODULE_SCOPE int TclParseHex _ANSI_ARGS_((CONST char *src, int numBytes,
- Tcl_UniChar *resultPtr));
-MODULE_SCOPE void TclParseInit _ANSI_ARGS_ ((Tcl_Interp *interp,
- CONST char *string, int numBytes,
- Tcl_Parse *parsePtr));
-MODULE_SCOPE int TclParseInteger _ANSI_ARGS_((CONST char *string,
- int numBytes));
-MODULE_SCOPE int TclParseWhiteSpace _ANSI_ARGS_((CONST char *src,
- int numBytes, Tcl_Parse *parsePtr, char *typePtr));
-MODULE_SCOPE int TclProcessReturn _ANSI_ARGS_((Tcl_Interp *interp,
- int code, int level, Tcl_Obj *returnOpts));
-MODULE_SCOPE int TclpObjLstat _ANSI_ARGS_((Tcl_Obj *pathPtr,
- Tcl_StatBuf *buf));
-MODULE_SCOPE int TclpCheckStackSpace _ANSI_ARGS_((void));
-MODULE_SCOPE Tcl_Obj * TclpTempFileName _ANSI_ARGS_((void));
-MODULE_SCOPE Tcl_Obj * TclNewFSPathObj _ANSI_ARGS_((Tcl_Obj *dirPtr,
- CONST char *addStrRep, int len));
-MODULE_SCOPE int TclpDeleteFile _ANSI_ARGS_((CONST char *path));
-MODULE_SCOPE void TclpFinalizeCondition _ANSI_ARGS_((
- Tcl_Condition *condPtr));
-MODULE_SCOPE void TclpFinalizeMutex _ANSI_ARGS_((Tcl_Mutex *mutexPtr));
-MODULE_SCOPE void TclpFinalizePipes _ANSI_ARGS_((void));
-MODULE_SCOPE int TclpThreadCreate _ANSI_ARGS_((
- Tcl_ThreadId *idPtr,
- Tcl_ThreadCreateProc proc,
- ClientData clientData,
- int stackSize, int flags));
-MODULE_SCOPE int TclpFindVariable _ANSI_ARGS_((CONST char *name,
- int *lengthPtr));
-MODULE_SCOPE void TclpInitLibraryPath _ANSI_ARGS_((char **valuePtr,
- int *lengthPtr, Tcl_Encoding *encodingPtr));
-MODULE_SCOPE void TclpInitLock _ANSI_ARGS_((void));
-MODULE_SCOPE void TclpInitPlatform _ANSI_ARGS_((void));
-MODULE_SCOPE void TclpInitUnlock _ANSI_ARGS_((void));
-MODULE_SCOPE int TclpLoadFile _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Obj *pathPtr, CONST char *sym1,
- CONST char *sym2, Tcl_PackageInitProc **proc1Ptr,
- Tcl_PackageInitProc **proc2Ptr,
+ Tcl_Namespace *nsPtr, int flags);
+MODULE_SCOPE int TclParseBackslash(CONST char *src,
+ int numBytes, int *readPtr, char *dst);
+MODULE_SCOPE int TclParseHex(CONST char *src, int numBytes,
+ Tcl_UniChar *resultPtr);
+MODULE_SCOPE void TclParseInit(Tcl_Interp *interp, CONST char *string,
+ int numBytes, Tcl_Parse *parsePtr);
+MODULE_SCOPE int TclParseInteger(CONST char *string, int numBytes);
+MODULE_SCOPE int TclParseWhiteSpace(CONST char *src,
+ int numBytes, Tcl_Parse *parsePtr, char *typePtr);
+MODULE_SCOPE int TclProcessReturn(Tcl_Interp *interp,
+ int code, int level, Tcl_Obj *returnOpts);
+MODULE_SCOPE int TclpObjLstat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf);
+MODULE_SCOPE int TclpCheckStackSpace(void);
+MODULE_SCOPE Tcl_Obj * TclpTempFileName(void);
+MODULE_SCOPE Tcl_Obj * TclNewFSPathObj(Tcl_Obj *dirPtr, CONST char *addStrRep,
+ int len);
+MODULE_SCOPE int TclpDeleteFile(CONST char *path);
+MODULE_SCOPE void TclpFinalizeCondition(Tcl_Condition *condPtr);
+MODULE_SCOPE void TclpFinalizeMutex(Tcl_Mutex *mutexPtr);
+MODULE_SCOPE void TclpFinalizePipes(void);
+MODULE_SCOPE int TclpThreadCreate(Tcl_ThreadId *idPtr,
+ Tcl_ThreadCreateProc proc, ClientData clientData,
+ int stackSize, int flags);
+MODULE_SCOPE int TclpFindVariable(CONST char *name, int *lengthPtr);
+MODULE_SCOPE void TclpInitLibraryPath(char **valuePtr,
+ int *lengthPtr, Tcl_Encoding *encodingPtr);
+MODULE_SCOPE void TclpInitLock(void);
+MODULE_SCOPE void TclpInitPlatform(void);
+MODULE_SCOPE void TclpInitUnlock(void);
+MODULE_SCOPE int TclpLoadFile(Tcl_Interp *interp, Tcl_Obj *pathPtr,
+ CONST char *sym1, CONST char *sym2,
+ Tcl_PackageInitProc **proc1Ptr,
+ Tcl_PackageInitProc **proc2Ptr,
ClientData *clientDataPtr,
- Tcl_FSUnloadFileProc **unloadProcPtr));
-MODULE_SCOPE Tcl_Obj * TclpObjListVolumes _ANSI_ARGS_((void));
-MODULE_SCOPE void TclpMasterLock _ANSI_ARGS_((void));
-MODULE_SCOPE void TclpMasterUnlock _ANSI_ARGS_((void));
-MODULE_SCOPE int TclpMatchFiles _ANSI_ARGS_((Tcl_Interp *interp,
- char *separators, Tcl_DString *dirPtr,
- char *pattern, char *tail));
-MODULE_SCOPE int TclpObjNormalizePath _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Obj *pathPtr, int nextCheckpoint));
-MODULE_SCOPE void TclpNativeJoinPath _ANSI_ARGS_((Tcl_Obj *prefix,
- char *joining));
-MODULE_SCOPE Tcl_Obj * TclpNativeSplitPath _ANSI_ARGS_((Tcl_Obj *pathPtr,
- int *lenPtr));
-MODULE_SCOPE Tcl_PathType TclpGetNativePathType _ANSI_ARGS_((Tcl_Obj *pathPtr,
- int *driveNameLengthPtr, Tcl_Obj **driveNameRef));
-MODULE_SCOPE int TclCrossFilesystemCopy _ANSI_ARGS_((
- Tcl_Interp *interp, Tcl_Obj *source,
- Tcl_Obj *target));
-MODULE_SCOPE int TclpMatchInDirectory _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Obj *resultPtr, Tcl_Obj *pathPtr,
- CONST char *pattern, Tcl_GlobTypeData *types));
-MODULE_SCOPE ClientData TclpGetNativeCwd _ANSI_ARGS_((ClientData clientData));
+ Tcl_FSUnloadFileProc **unloadProcPtr);
+MODULE_SCOPE Tcl_Obj * TclpObjListVolumes(void);
+MODULE_SCOPE void TclpMasterLock(void);
+MODULE_SCOPE void TclpMasterUnlock(void);
+MODULE_SCOPE int TclpMatchFiles(Tcl_Interp *interp, char *separators,
+ Tcl_DString *dirPtr, char *pattern, char *tail);
+MODULE_SCOPE int TclpObjNormalizePath(Tcl_Interp *interp,
+ Tcl_Obj *pathPtr, int nextCheckpoint);
+MODULE_SCOPE void TclpNativeJoinPath(Tcl_Obj *prefix, char *joining);
+MODULE_SCOPE Tcl_Obj * TclpNativeSplitPath(Tcl_Obj *pathPtr, int *lenPtr);
+MODULE_SCOPE Tcl_PathType TclpGetNativePathType(Tcl_Obj *pathPtr,
+ int *driveNameLengthPtr, Tcl_Obj **driveNameRef);
+MODULE_SCOPE int TclCrossFilesystemCopy(Tcl_Interp *interp,
+ Tcl_Obj *source, Tcl_Obj *target);
+MODULE_SCOPE int TclpMatchInDirectory(Tcl_Interp *interp,
+ Tcl_Obj *resultPtr, Tcl_Obj *pathPtr,
+ CONST char *pattern, Tcl_GlobTypeData *types);
+MODULE_SCOPE ClientData TclpGetNativeCwd(ClientData clientData);
MODULE_SCOPE Tcl_FSDupInternalRepProc TclNativeDupInternalRep;
-MODULE_SCOPE Tcl_Obj* TclpObjLink _ANSI_ARGS_((Tcl_Obj *pathPtr,
- Tcl_Obj *toPtr, int linkType));
-MODULE_SCOPE int TclpObjChdir _ANSI_ARGS_((Tcl_Obj *pathPtr));
-MODULE_SCOPE Tcl_Obj * TclPathPart _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Obj *pathPtr, Tcl_PathPart portion));
-MODULE_SCOPE void TclpPanic _ANSI_ARGS_(TCL_VARARGS(CONST char *,
- format));
-MODULE_SCOPE char * TclpReadlink _ANSI_ARGS_((CONST char *fileName,
- Tcl_DString *linkPtr));
-MODULE_SCOPE void TclpReleaseFile _ANSI_ARGS_((TclFile file));
-MODULE_SCOPE void TclpSetInterfaces ();
-MODULE_SCOPE void TclpSetVariables _ANSI_ARGS_((Tcl_Interp *interp));
-MODULE_SCOPE void TclpUnloadFile _ANSI_ARGS_((
- Tcl_LoadHandle loadHandle));
-MODULE_SCOPE VOID * TclpThreadDataKeyGet _ANSI_ARGS_((
- Tcl_ThreadDataKey *keyPtr));
-MODULE_SCOPE void TclpThreadDataKeySet _ANSI_ARGS_((
- Tcl_ThreadDataKey *keyPtr, VOID *data));
-MODULE_SCOPE void TclpThreadExit _ANSI_ARGS_((int status));
-MODULE_SCOPE int TclpThreadGetStackSize _ANSI_ARGS_((void));
-MODULE_SCOPE void TclRememberCondition _ANSI_ARGS_((
- Tcl_Condition *mutex));
-MODULE_SCOPE VOID TclRememberJoinableThread _ANSI_ARGS_((
- Tcl_ThreadId id));
-MODULE_SCOPE void TclRememberMutex _ANSI_ARGS_((Tcl_Mutex *mutex));
-MODULE_SCOPE void TclRemoveScriptLimitCallbacks _ANSI_ARGS_((
- Tcl_Interp *interp));
-MODULE_SCOPE void TclSetBgErrorHandler _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Obj *cmdPrefix));
-MODULE_SCOPE void TclSetProcessGlobalValue _ANSI_ARGS_ ((
- ProcessGlobalValue *pgvPtr, Tcl_Obj *newValue,
- Tcl_Encoding encoding));
-MODULE_SCOPE VOID TclSignalExitThread _ANSI_ARGS_((Tcl_ThreadId id,
- int result));
-MODULE_SCOPE double TclStrToD _ANSI_ARGS_((CONST char* string,
- CONST char** endPtr));
-MODULE_SCOPE int TclSubstTokens _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Token *tokenPtr, int count,
- int *tokensLeftPtr));
-MODULE_SCOPE void TclTransferResult _ANSI_ARGS_((
- Tcl_Interp *sourceInterp, int result,
- Tcl_Interp *targetInterp));
-MODULE_SCOPE Tcl_Obj * TclpNativeToNormalized _ANSI_ARGS_((
- ClientData clientData));
-MODULE_SCOPE Tcl_Obj * TclpFilesystemPathType _ANSI_ARGS_((
- Tcl_Obj* pathPtr));
-MODULE_SCOPE Tcl_PackageInitProc* TclpFindSymbol _ANSI_ARGS_((
- Tcl_Interp *interp, Tcl_LoadHandle loadHandle,
- CONST char *symbol));
-MODULE_SCOPE int TclpDlopen _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Obj *pathPtr, Tcl_LoadHandle *loadHandle,
- Tcl_FSUnloadFileProc **unloadProcPtr));
-MODULE_SCOPE int TclpUtime _ANSI_ARGS_((Tcl_Obj *pathPtr,
- struct utimbuf *tval));
+MODULE_SCOPE Tcl_Obj* TclpObjLink(Tcl_Obj *pathPtr, Tcl_Obj *toPtr,
+ int linkType);
+MODULE_SCOPE int TclpObjChdir(Tcl_Obj *pathPtr);
+MODULE_SCOPE Tcl_Obj * TclPathPart(Tcl_Interp *interp, Tcl_Obj *pathPtr,
+ Tcl_PathPart portion);
+MODULE_SCOPE void TclpPanic TCL_VARARGS(CONST char *, format);
+MODULE_SCOPE char * TclpReadlink(CONST char *fileName,
+ Tcl_DString *linkPtr);
+MODULE_SCOPE void TclpReleaseFile(TclFile file);
+MODULE_SCOPE void TclpSetInterfaces(void);
+MODULE_SCOPE void TclpSetVariables(Tcl_Interp *interp);
+MODULE_SCOPE void TclpUnloadFile(Tcl_LoadHandle loadHandle);
+MODULE_SCOPE VOID * TclpThreadDataKeyGet(Tcl_ThreadDataKey *keyPtr);
+MODULE_SCOPE void TclpThreadDataKeySet(Tcl_ThreadDataKey *keyPtr,
+ VOID *data);
+MODULE_SCOPE void TclpThreadExit(int status);
+MODULE_SCOPE int TclpThreadGetStackSize(void);
+MODULE_SCOPE void TclRememberCondition(Tcl_Condition *mutex);
+MODULE_SCOPE VOID TclRememberJoinableThread(Tcl_ThreadId id);
+MODULE_SCOPE void TclRememberMutex(Tcl_Mutex *mutex);
+MODULE_SCOPE void TclRemoveScriptLimitCallbacks(Tcl_Interp *interp);
+MODULE_SCOPE void TclSetBgErrorHandler(Tcl_Interp *interp,
+ Tcl_Obj *cmdPrefix);
+MODULE_SCOPE void TclSetProcessGlobalValue(ProcessGlobalValue *pgvPtr,
+ Tcl_Obj *newValue, Tcl_Encoding encoding);
+MODULE_SCOPE VOID TclSignalExitThread(Tcl_ThreadId id, int result);
+MODULE_SCOPE double TclStrToD(CONST char* string, CONST char** endPtr);
+MODULE_SCOPE int TclSubstTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr,
+ int count, int *tokensLeftPtr);
+MODULE_SCOPE void TclTransferResult(Tcl_Interp *sourceInterp, int result,
+ Tcl_Interp *targetInterp);
+MODULE_SCOPE Tcl_Obj * TclpNativeToNormalized(ClientData clientData);
+MODULE_SCOPE Tcl_Obj * TclpFilesystemPathType(Tcl_Obj* pathPtr);
+MODULE_SCOPE Tcl_PackageInitProc* TclpFindSymbol(Tcl_Interp *interp,
+ Tcl_LoadHandle loadHandle, CONST char *symbol);
+MODULE_SCOPE int TclpDlopen(Tcl_Interp *interp, Tcl_Obj *pathPtr,
+ Tcl_LoadHandle *loadHandle,
+ Tcl_FSUnloadFileProc **unloadProcPtr);
+MODULE_SCOPE int TclpUtime(Tcl_Obj *pathPtr, struct utimbuf *tval);
#ifdef TCL_LOAD_FROM_MEMORY
-MODULE_SCOPE void* TclpLoadMemoryGetBuffer _ANSI_ARGS_((
- Tcl_Interp *interp, int size));
-MODULE_SCOPE int TclpLoadMemory _ANSI_ARGS_((Tcl_Interp *interp,
- void *buffer, int size, int codeSize,
- Tcl_LoadHandle *loadHandle,
- Tcl_FSUnloadFileProc **unloadProcPtr));
+MODULE_SCOPE void* TclpLoadMemoryGetBuffer(Tcl_Interp *interp, int size);
+MODULE_SCOPE int TclpLoadMemory(Tcl_Interp *interp, void *buffer,
+ int size, int codeSize, Tcl_LoadHandle *loadHandle,
+ Tcl_FSUnloadFileProc **unloadProcPtr);
#endif
MODULE_SCOPE void TclInitThreadStorage(void);
MODULE_SCOPE void TclpFinalizeThreadDataThread(void);
@@ -2224,282 +2153,282 @@ MODULE_SCOPE void TclFinalizeThreadStorage(void);
*----------------------------------------------------------------
*/
-MODULE_SCOPE int Tcl_AfterObjCmd _ANSI_ARGS_((ClientData clientData,
+MODULE_SCOPE int Tcl_AfterObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_AppendObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_AppendObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ArrayObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ArrayObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_BinaryObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_BinaryObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_BreakObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_BreakObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_CaseObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_CaseObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_CatchObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_CatchObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_CdObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_CdObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclChanTruncateObjCmd _ANSI_ARGS_((
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclChanTruncateObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclClockClicksObjCmd _ANSI_ARGS_((
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclClockClicksObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclClockGetenvObjCmd _ANSI_ARGS_((
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclClockGetenvObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclClockMicrosecondsObjCmd _ANSI_ARGS_((
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclClockMicrosecondsObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclClockMillisecondsObjCmd _ANSI_ARGS_((
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclClockMillisecondsObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclClockSecondsObjCmd _ANSI_ARGS_((
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclClockSecondsObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclClockLocaltimeObjCmd _ANSI_ARGS_((
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclClockLocaltimeObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclClockMktimeObjCmd _ANSI_ARGS_((
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclClockMktimeObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclClockOldscanObjCmd _ANSI_ARGS_((
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclClockOldscanObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_CloseObjCmd _ANSI_ARGS_((ClientData clientData,
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_CloseObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ConcatObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ConcatObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ContinueObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ContinueObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler _ANSI_ARGS_((
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
Tcl_Time *timePtr, Tcl_TimerProc *proc,
- ClientData clientData));
-MODULE_SCOPE int TclDefaultBgErrorHandlerObjCmd _ANSI_ARGS_((
+ ClientData clientData);
+MODULE_SCOPE int TclDefaultBgErrorHandlerObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_DictObjCmd _ANSI_ARGS_((ClientData clientData,
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_DictObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_EncodingObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_EncodingObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int TclEncodingDirsObjCmd _ANSI_ARGS_((
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int TclEncodingDirsObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_EofObjCmd _ANSI_ARGS_((ClientData clientData,
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_EofObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ErrorObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ErrorObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_EvalObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_EvalObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ExecObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ExecObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ExitObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ExitObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ExprObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ExprObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_FblockedObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_FblockedObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_FconfigureObjCmd _ANSI_ARGS_((
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_FconfigureObjCmd(
ClientData clientData, Tcl_Interp *interp,
- int objc, Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_FcopyObjCmd _ANSI_ARGS_((ClientData dummy,
+ int objc, Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_FcopyObjCmd(ClientData dummy,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_FileObjCmd _ANSI_ARGS_((ClientData dummy,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_FileObjCmd(ClientData dummy,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_FileEventObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_FileEventObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_FlushObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_FlushObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ForObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ForObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ForeachObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ForeachObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_FormatObjCmd _ANSI_ARGS_((ClientData dummy,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_FormatObjCmd(ClientData dummy,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_GetsObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_GetsObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_GlobalObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_GlobalObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_GlobObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_GlobObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_IfObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_IfObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_IncrObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_IncrObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_InfoObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_InfoObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_InterpObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_InterpObjCmd(ClientData clientData,
Tcl_Interp *interp, int argc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_JoinObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_JoinObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LappendObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LappendObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LassignObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LassignObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LindexObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LindexObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LinsertObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LinsertObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LlengthObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LlengthObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ListObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ListObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LoadObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LoadObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LrangeObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LrangeObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LrepeatObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LrepeatObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LreplaceObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LreplaceObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LsearchObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LsearchObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LsetObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LsetObjCmd(ClientData clientData,
Tcl_Interp* interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_LsortObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_LsortObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_NamespaceObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_NamespaceObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_OpenObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_OpenObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_PackageObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_PackageObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_PidObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_PidObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_PutsObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_PutsObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_PwdObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_PwdObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ReadObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ReadObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_RegexpObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_RegexpObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_RegsubObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_RegsubObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_RenameObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_RenameObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ReturnObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ReturnObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_ScanObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_ScanObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_SeekObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_SeekObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_SetObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_SetObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_SplitObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_SplitObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_SocketObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_SocketObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_SourceObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_SourceObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_StringObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_StringObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_SubstObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_SubstObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_SwitchObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_SwitchObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_TellObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_TellObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_TimeObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_TimeObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_TraceObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_TraceObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_UnloadObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_UnloadObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_UnsetObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_UnsetObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_UpdateObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_UpdateObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_UplevelObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_UplevelObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_UpvarObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_UpvarObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_VariableObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_VariableObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_VwaitObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_VwaitObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
-MODULE_SCOPE int Tcl_WhileObjCmd _ANSI_ARGS_((ClientData clientData,
+ Tcl_Obj *CONST objv[]);
+MODULE_SCOPE int Tcl_WhileObjCmd(ClientData clientData,
Tcl_Interp *interp, int objc,
- Tcl_Obj *CONST objv[]));
+ Tcl_Obj *CONST objv[]);
/*
*----------------------------------------------------------------
@@ -2507,101 +2436,100 @@ MODULE_SCOPE int Tcl_WhileObjCmd _ANSI_ARGS_((ClientData clientData,
*----------------------------------------------------------------
*/
-MODULE_SCOPE int TclCompileAppendCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileBreakCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileCatchCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileContinueCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileDictCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileExprCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileForCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileForeachCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileIfCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileIncrCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileLappendCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileLassignCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileLindexCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileListCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileLlengthCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileLsetCmd _ANSI_ARGS_((Tcl_Interp* interp,
- Tcl_Parse* parsePtr, struct CompileEnv* envPtr));
-MODULE_SCOPE int TclCompileRegexpCmd _ANSI_ARGS_((Tcl_Interp* interp,
- Tcl_Parse* parsePtr, struct CompileEnv* envPtr));
-MODULE_SCOPE int TclCompileReturnCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileSetCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileStringCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileSwitchCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-MODULE_SCOPE int TclCompileWhileCmd _ANSI_ARGS_((Tcl_Interp *interp,
- Tcl_Parse *parsePtr, struct CompileEnv *envPtr));
-
-/*
- * Functions defined in generic/tclVar.c and currenttly exported only
- * for use by the bytecode compiler and engine. Some of these could later
- * be placed in the public interface.
- */
-
-MODULE_SCOPE Var * TclLookupArrayElement _ANSI_ARGS_((Tcl_Interp *interp,
+MODULE_SCOPE int TclCompileAppendCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileBreakCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileCatchCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileContinueCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileDictCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileExprCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileForCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileForeachCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileIfCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileIncrCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileLappendCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileLassignCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileLindexCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileListCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileLlengthCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileLsetCmd(Tcl_Interp* interp,
+ Tcl_Parse* parsePtr, struct CompileEnv* envPtr);
+MODULE_SCOPE int TclCompileRegexpCmd(Tcl_Interp* interp,
+ Tcl_Parse* parsePtr, struct CompileEnv* envPtr);
+MODULE_SCOPE int TclCompileReturnCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileSetCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileStringCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileSwitchCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+MODULE_SCOPE int TclCompileWhileCmd(Tcl_Interp *interp,
+ Tcl_Parse *parsePtr, struct CompileEnv *envPtr);
+
+/*
+ * Functions defined in generic/tclVar.c and currenttly exported only for use
+ * by the bytecode compiler and engine. Some of these could later be placed in
+ * the public interface.
+ */
+
+MODULE_SCOPE Var * TclLookupArrayElement(Tcl_Interp *interp,
CONST char *arrayName, CONST char *elName,
CONST int flags, CONST char *msg,
CONST int createPart1, CONST int createPart2,
- Var *arrayPtr));
-MODULE_SCOPE Var * TclObjLookupVar _ANSI_ARGS_((Tcl_Interp *interp,
+ Var *arrayPtr);
+MODULE_SCOPE Var * TclObjLookupVar(Tcl_Interp *interp,
Tcl_Obj *part1Ptr, CONST char *part2, int flags,
CONST char *msg, CONST int createPart1,
- CONST int createPart2, Var **arrayPtrPtr));
-MODULE_SCOPE Tcl_Obj * TclPtrGetVar _ANSI_ARGS_((Tcl_Interp *interp,
+ CONST int createPart2, Var **arrayPtrPtr);
+MODULE_SCOPE Tcl_Obj * TclPtrGetVar(Tcl_Interp *interp,
Var *varPtr, Var *arrayPtr, CONST char *part1,
- CONST char *part2, CONST int flags));
-MODULE_SCOPE Tcl_Obj * TclPtrSetVar _ANSI_ARGS_((Tcl_Interp *interp,
+ CONST char *part2, CONST int flags);
+MODULE_SCOPE Tcl_Obj * TclPtrSetVar(Tcl_Interp *interp,
Var *varPtr, Var *arrayPtr, CONST char *part1,
CONST char *part2, Tcl_Obj *newValuePtr,
- CONST int flags));
-MODULE_SCOPE Tcl_Obj * TclPtrIncrVar _ANSI_ARGS_((Tcl_Interp *interp,
+ CONST int flags);
+MODULE_SCOPE Tcl_Obj * TclPtrIncrVar(Tcl_Interp *interp,
Var *varPtr, Var *arrayPtr, CONST char *part1,
- CONST char *part2, CONST long i, CONST int flags));
-MODULE_SCOPE Tcl_Obj * TclPtrIncrWideVar _ANSI_ARGS_((Tcl_Interp *interp,
+ CONST char *part2, CONST long i, CONST int flags);
+MODULE_SCOPE Tcl_Obj * TclPtrIncrWideVar(Tcl_Interp *interp,
Var *varPtr, Var *arrayPtr, CONST char *part1,
CONST char *part2, CONST Tcl_WideInt i,
- CONST int flags));
-MODULE_SCOPE void TclInvalidateNsPath _ANSI_ARGS_((Namespace *nsPtr));
+ CONST int flags);
+MODULE_SCOPE void TclInvalidateNsPath(Namespace *nsPtr);
/*
*----------------------------------------------------------------
* 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:
+ * 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:
*
- * MODULE_SCOPE void TclNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
- * MODULE_SCOPE void TclDecrRefCount _ANSI_ARGS_((Tcl_Obj *objPtr));
+ * MODULE_SCOPE void TclNewObj(Tcl_Obj *objPtr);
+ * MODULE_SCOPE void TclDecrRefCount(Tcl_Obj *objPtr);
*
- * These macros are defined in terms of two macros that depend on
- * memory allocator in use: TclAllocObjStorage, TclFreeObjStorage.
- * They are defined below.
+ * These macros are defined in terms of two macros that depend on memory
+ * allocator in use: TclAllocObjStorage, TclFreeObjStorage. They are defined
+ * below.
*----------------------------------------------------------------
*/
@@ -2630,21 +2558,21 @@ MODULE_SCOPE void TclInvalidateNsPath _ANSI_ARGS_((Namespace *nsPtr));
TclFreeObj(objPtr); \
} else { \
if ((objPtr)->bytes \
- && ((objPtr)->bytes != tclEmptyStringRep)) { \
+ && ((objPtr)->bytes != tclEmptyStringRep)) { \
ckfree((char *) (objPtr)->bytes); \
} \
TclFreeObjStorage(objPtr); \
TclIncrObjsFreed(); \
} \
}
-
+
#if defined(PURIFY)
/*
* The PURIFY mode is like the regular mode, but instead of doing block
* Tcl_Obj allocation and keeping a freed list for efficiency, it always
- * allocates and frees a single Tcl_Obj so that tools like Purify can
- * better track memory leaks
+ * allocates and frees a single Tcl_Obj so that tools like Purify can better
+ * track memory leaks
*/
# define TclAllocObjStorage(objPtr) \
@@ -2656,19 +2584,19 @@ MODULE_SCOPE void TclInvalidateNsPath _ANSI_ARGS_((Namespace *nsPtr));
#elif defined(TCL_THREADS) && defined(USE_THREAD_ALLOC)
/*
- * The TCL_THREADS mode is like the regular mode but allocates Tcl_Obj's
- * from per-thread caches.
+ * The TCL_THREADS mode is like the regular mode but allocates Tcl_Obj's from
+ * per-thread caches.
*/
-MODULE_SCOPE Tcl_Obj * TclThreadAllocObj _ANSI_ARGS_((void));
-MODULE_SCOPE void TclThreadFreeObj _ANSI_ARGS_((Tcl_Obj *));
-MODULE_SCOPE Tcl_Mutex *TclpNewAllocMutex _ANSI_ARGS_((void));
-MODULE_SCOPE void TclFreeAllocCache _ANSI_ARGS_((void *));
-MODULE_SCOPE void * TclpGetAllocCache _ANSI_ARGS_((void));
-MODULE_SCOPE void TclpSetAllocCache _ANSI_ARGS_((void *));
-MODULE_SCOPE void TclFinalizeThreadAlloc _ANSI_ARGS_((void));
-MODULE_SCOPE void TclpFreeAllocMutex _ANSI_ARGS_((Tcl_Mutex* mutex));
-MODULE_SCOPE void TclpFreeAllocCache _ANSI_ARGS_((void *));
+MODULE_SCOPE Tcl_Obj * TclThreadAllocObj(void);
+MODULE_SCOPE void TclThreadFreeObj(Tcl_Obj *);
+MODULE_SCOPE Tcl_Mutex *TclpNewAllocMutex(void);
+MODULE_SCOPE void TclFreeAllocCache(void *);
+MODULE_SCOPE void * TclpGetAllocCache(void);
+MODULE_SCOPE void TclpSetAllocCache(void *);
+MODULE_SCOPE void TclFinalizeThreadAlloc(void);
+MODULE_SCOPE void TclpFreeAllocMutex(Tcl_Mutex* mutex);
+MODULE_SCOPE void TclpFreeAllocCache(void *);
# define TclAllocObjStorage(objPtr) \
(objPtr) = TclThreadAllocObj()
@@ -2701,7 +2629,7 @@ MODULE_SCOPE Tcl_Mutex tclObjMutex;
#endif
#else /* TCL_MEM_DEBUG */
-MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
+MODULE_SCOPE void TclDbInitNewObj(Tcl_Obj *objPtr);
# define TclDbNewObj(objPtr, file, line) \
TclIncrObjsAllocated(); \
@@ -2722,15 +2650,13 @@ MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
/*
*----------------------------------------------------------------
- * 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:
+ * 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:
*
- * MODULE_SCOPE void TclInitStringRep _ANSI_ARGS_((
- * Tcl_Obj *objPtr, char *bytePtr, int len));
+ * MODULE_SCOPE void TclInitStringRep(Tcl_Obj *objPtr, char *bytePtr, int len);
*
* This macro should only be called on an unshared objPtr where
* objPtr->typePtr->freeIntRepProc == NULL
@@ -2751,14 +2677,13 @@ MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
/*
*----------------------------------------------------------------
- * 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:
+ * 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:
*
- * MODULE_SCOPE char * TclGetString _ANSI_ARGS_((Tcl_Obj *objPtr));
+ * MODULE_SCOPE char * TclGetString(Tcl_Obj *objPtr);
*----------------------------------------------------------------
*/
@@ -2768,10 +2693,10 @@ MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
/*
*----------------------------------------------------------------
* Macro used by the Tcl core to clean out an object's internal
- * representation. Does not actually reset the rep's bytes.
- * The ANSI C "prototype" for this macro is:
+ * representation. Does not actually reset the rep's bytes. The ANSI C
+ * "prototype" for this macro is:
*
- * MODULE_SCOPE void TclFreeIntRep _ANSI_ARGS_((Tcl_Obj *objPtr));
+ * MODULE_SCOPE void TclFreeIntRep(Tcl_Obj *objPtr);
*----------------------------------------------------------------
*/
@@ -2783,10 +2708,10 @@ MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
/*
*----------------------------------------------------------------
- * Macro used by the Tcl core to clean out an object's string
- * representation. The ANSI C "prototype" for this macro is:
+ * Macro used by the Tcl core to clean out an object's string representation.
+ * The ANSI C "prototype" for this macro is:
*
- * MODULE_SCOPE void TclInvalidateStringRep _ANSI_ARGS_((Tcl_Obj *objPtr));
+ * MODULE_SCOPE void TclInvalidateStringRep(Tcl_Obj *objPtr);
*----------------------------------------------------------------
*/
@@ -2801,9 +2726,9 @@ MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
/*
*----------------------------------------------------------------
- * Macro used by the Tcl core to get a Tcl_WideInt value out of
- * a Tcl_Obj of the "wideInt" type. Different implementation on
- * different platforms depending whether TCL_WIDE_INT_IS_LONG.
+ * Macro used by the Tcl core to get a Tcl_WideInt value out of a Tcl_Obj of
+ * the "wideInt" type. Different implementation on different platforms
+ * depending whether TCL_WIDE_INT_IS_LONG.
*----------------------------------------------------------------
*/
@@ -2821,15 +2746,13 @@ MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
/*
*----------------------------------------------------------------
- * Macro used by the Tcl core get a unicode char from a utf string.
- * It checks to see if we have a one-byte utf char before calling
- * the real Tcl_UtfToUniChar, as this will save a lot of time for
- * primarily ascii string handling. The macro's expression result
- * is 1 for the 1-byte case or the result of Tcl_UtfToUniChar.
- * The ANSI C "prototype" for this macro is:
+ * Macro used by the Tcl core get a unicode char from a utf string. It checks
+ * to see if we have a one-byte utf char before calling the real
+ * Tcl_UtfToUniChar, as this will save a lot of time for primarily ascii
+ * string handling. The macro's expression result is 1 for the 1-byte case or
+ * the result of Tcl_UtfToUniChar. The ANSI C "prototype" for this macro is:
*
- * MODULE_SCOPE int TclUtfToUniChar _ANSI_ARGS_((
- * CONST char *string, Tcl_UniChar *ch));
+ * MODULE_SCOPE int TclUtfToUniChar(CONST char *string, Tcl_UniChar *ch);
*----------------------------------------------------------------
*/
@@ -2840,14 +2763,13 @@ MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
/*
*----------------------------------------------------------------
- * Macro used by the Tcl core to compare Unicode strings. On
- * big-endian systems we can use the more efficient memcmp, but
- * this would not be lexically correct on little-endian systems.
- * The ANSI C "prototype" for this macro is:
+ * Macro used by the Tcl core to compare Unicode strings. On big-endian
+ * systems we can use the more efficient memcmp, but this would not be
+ * lexically correct on little-endian systems. The ANSI C "prototype" for
+ * this macro is:
*
- * MODULE_SCOPE int TclUniCharNcmp _ANSI_ARGS_((
- * CONST Tcl_UniChar *cs,
- * CONST Tcl_UniChar *ct, unsigned long n));
+ * MODULE_SCOPE int TclUniCharNcmp(CONST Tcl_UniChar *cs,
+ * CONST Tcl_UniChar *ct, unsigned long n);
*----------------------------------------------------------------
*/
@@ -2859,12 +2781,10 @@ MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
/*
*----------------------------------------------------------------
- * Macro used by the Tcl core to increment a namespace's export
- * export epoch counter.
- * The ANSI C "prototype" for this macro is:
+ * Macro used by the Tcl core to increment a namespace's export export epoch
+ * counter. The ANSI C "prototype" for this macro is:
*
- * MODULE_SCOPE void TclInvalidateNsCmdLookup _ANSI_ARGS_((
- * Namespace *nsPtr));
+ * MODULE_SCOPE void TclInvalidateNsCmdLookup(Namespace *nsPtr);
*----------------------------------------------------------------
*/
@@ -2881,55 +2801,46 @@ MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr));
*----------------------------------------------------------------------
*/
-MODULE_SCOPE void* TclBNAlloc( size_t nBytes );
-MODULE_SCOPE void* TclBNRealloc( void* oldBlock, size_t newNBytes );
-MODULE_SCOPE void TclBNFree( void* block );
-MODULE_SCOPE void TclBNInitBignumFromLong( mp_int* bignum, long initVal );
+MODULE_SCOPE void * TclBNAlloc(size_t nBytes);
+MODULE_SCOPE void * TclBNRealloc(void *oldBlock, size_t newNBytes);
+MODULE_SCOPE void TclBNFree(void *block);
+MODULE_SCOPE void TclBNInitBignumFromLong(mp_int *bignum, long initVal);
/*
*----------------------------------------------------------------
- * Macro used by the Tcl core to check whether a pattern has
- * any characters special to [string match].
- * The ANSI C "prototype" for this macro is:
+ * Macro used by the Tcl core to check whether a pattern has any characters
+ * special to [string match]. The ANSI C "prototype" for this macro is:
*
- * MODULE_SCOPE int TclMatchIsTrivial _ANSI_ARGS_((
- * CONST char *pattern));
+ * MODULE_SCOPE int TclMatchIsTrivial(CONST char *pattern);
*----------------------------------------------------------------
*/
-#define TclMatchIsTrivial(pattern) strpbrk((pattern), "*[]]?\\") == NULL
+#define TclMatchIsTrivial(pattern) strpbrk((pattern), "*[]]?\\") == NULL
/*
*----------------------------------------------------------------
- * Macro used by the Tcl core to write the string rep of a long
- * integer to a character buffer.
- * The ANSI C "prototype" for this macro is:
+ * Macro used by the Tcl core to write the string rep of a long integer to a
+ * character buffer. The ANSI C "prototype" for this macro is:
*
- * MODULE_SCOPE int TclFormatInt _ANSI_ARGS_((char *buf, long n));
+ * MODULE_SCOPE int TclFormatInt(char *buf, long n);
*----------------------------------------------------------------
*/
-#define TclFormatInt(buf, n) sprintf((buf), "%ld", (long)(n))
+#define TclFormatInt(buf, n) sprintf((buf), "%ld", (long)(n))
/*
*----------------------------------------------------------------
* Macros used by the Tcl core to set a Tcl_Obj's numeric representation
* avoiding the corresponding function calls in time critical parts of the
* core. They should only be called on unshared objects. The ANSI C
- * "prototypes" for these macros are:
- *
- * MODULE_SCOPE void TclSetIntObj _ANSI_ARGS_((Tcl_Obj *objPtr,
- * int intValue));
- * MODULE_SCOPE void TclSetLongObj _ANSI_ARGS_((Tcl_Obj *objPtr,
- * long longValue));
- * MODULE_SCOPE void TclSetBooleanObj _ANSI_ARGS_((Tcl_Obj *objPtr,
- * long boolValue));
- * MODULE_SCOPE void TclSetWideIntObj _ANSI_ARGS_((Tcl_Obj *objPtr,
- * Tcl_WideInt w));
- * MODULE_SCOPE void TclSetDoubleObj _ANSI_ARGS_((Tcl_Obj *objPtr,
- * double d));
+ * "prototypes" for these macros are:
*
+ * MODULE_SCOPE void TclSetIntObj(Tcl_Obj *objPtr, int intValue);
+ * MODULE_SCOPE void TclSetLongObj(Tcl_Obj *objPtr, long longValue);
+ * MODULE_SCOPE void TclSetBooleanObj(Tcl_Obj *objPtr, long boolValue);
+ * MODULE_SCOPE void TclSetWideIntObj(Tcl_Obj *objPtr, Tcl_WideInt w);
+ * MODULE_SCOPE void TclSetDoubleObj(Tcl_Obj *objPtr, double d);
*----------------------------------------------------------------
*/
@@ -2943,12 +2854,12 @@ MODULE_SCOPE void TclBNInitBignumFromLong( mp_int* bignum, long initVal );
TclSetIntObj((objPtr), (l))
/*
- * NOTE: There is to be no such thing as a "pure" boolean.
- * Boolean values set programmatically go straight to being
- * "int" Tcl_Obj's, with value 0 or 1. The only "boolean"
- * Tcl_Obj's shall be those holding the cached boolean value
- * of strings like: "yes", "no", "true", "false", "on", "off".
+ * NOTE: There is to be no such thing as a "pure" boolean. Boolean values set
+ * programmatically go straight to being "int" Tcl_Obj's, with value 0 or 1.
+ * The only "boolean" Tcl_Obj's shall be those holding the cached boolean
+ * value of strings like: "yes", "no", "true", "false", "on", "off".
*/
+
#define TclSetBooleanObj(objPtr, b) \
TclSetIntObj((objPtr), ((b)? 1 : 0));
@@ -2966,26 +2877,20 @@ MODULE_SCOPE void TclBNInitBignumFromLong( mp_int* bignum, long initVal );
/*
*----------------------------------------------------------------
- * Macros used by the Tcl core to create and initialise objects of
- * standard types, avoiding the corresponding function calls in time
- * critical parts of the core. The ANSI C "prototypes" for these
- * macros are:
+ * Macros used by the Tcl core to create and initialise objects of standard
+ * types, avoiding the corresponding function calls in time critical parts of
+ * the core. The ANSI C "prototypes" for these macros are:
*
- * MODULE_SCOPE void TclNewIntObj _ANSI_ARGS_((Tcl_Obj *objPtr,
- * int i));
- * MODULE_SCOPE void TclNewLongObj _ANSI_ARGS_((Tcl_Obj *objPtr,
- * long l));
- * MODULE_SCOPE void TclNewBooleanObj _ANSI_ARGS_((Tcl_Obj *objPtr,
- * int b));
- * MODULE_SCOPE void TclNewWideObj _ANSI_ARGS_((Tcl_Obj *objPtr,
- * Tcl_WideInt w));
- * MODULE_SCOPE void TclNewDoubleObj _ANSI_ARGS_((Tcl_Obj *objPtr),
- * double d);
- * MODULE_SCOPE void TclNewStringObj _ANSI_ARGS_((Tcl_Obj *objPtr)
- * char *s, int len);
+ * MODULE_SCOPE void TclNewIntObj(Tcl_Obj *objPtr, int i);
+ * MODULE_SCOPE void TclNewLongObj(Tcl_Obj *objPtr, long l);
+ * MODULE_SCOPE void TclNewBooleanObj(Tcl_Obj *objPtr, int b);
+ * MODULE_SCOPE void TclNewWideObj(Tcl_Obj *objPtr, Tcl_WideInt w);
+ * MODULE_SCOPE void TclNewDoubleObj(Tcl_Obj *objPtr, double d);
+ * MODULE_SCOPE void TclNewStringObj(Tcl_Obj *objPtr, char *s, int len);
*
*----------------------------------------------------------------
*/
+
#ifndef TCL_MEM_DEBUG
#define TclNewIntObj(objPtr, i) \
TclIncrObjsAllocated(); \
@@ -3050,4 +2955,11 @@ MODULE_SCOPE void TclBNInitBignumFromLong( mp_int* bignum, long initVal );
#include "tclIntPlatDecls.h"
#endif /* _TCLINT */
-
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */