diff options
| author | dkf <donal.k.fellows@manchester.ac.uk> | 2005-07-15 15:53:52 (GMT) |
|---|---|---|
| committer | dkf <donal.k.fellows@manchester.ac.uk> | 2005-07-15 15:53:52 (GMT) |
| commit | d70bdad3a4f08813f469ec8657f35f9096d3f454 (patch) | |
| tree | 67cbc963e74dcc4f64b4826d78edb41c4da11566 | |
| parent | 3b6daa4ddbfd2ba80a0c6b58b5736ede11562262 (diff) | |
| download | tcl-d70bdad3a4f08813f469ec8657f35f9096d3f454.zip tcl-d70bdad3a4f08813f469ec8657f35f9096d3f454.tar.gz tcl-d70bdad3a4f08813f469ec8657f35f9096d3f454.tar.bz2 | |
Whitespace/comment tidying
| -rw-r--r-- | generic/tclNamesp.c | 1845 |
1 files changed, 914 insertions, 931 deletions
diff --git a/generic/tclNamesp.c b/generic/tclNamesp.c index f1a86d6..e9a9494 100644 --- a/generic/tclNamesp.c +++ b/generic/tclNamesp.c @@ -21,7 +21,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclNamesp.c,v 1.78 2005/07/05 17:33:06 dgp Exp $ + * RCS: @(#) $Id: tclNamesp.c,v 1.79 2005/07/15 15:53:52 dkf Exp $ */ #include "tclInt.h" @@ -34,8 +34,8 @@ #define NUM_TRAIL_ELEMS 5 /* - * Thread-local storage used to avoid having a global lock on data - * that is not limited to a single interpreter. + * Thread-local storage used to avoid having a global lock on data that is not + * limited to a single interpreter. */ typedef struct ThreadSpecificData { @@ -53,46 +53,43 @@ typedef struct ThreadSpecificData { static Tcl_ThreadDataKey dataKey; /* - * This structure contains a cached pointer to a namespace that is the - * result of resolving the namespace's name in some other namespace. It is - * the internal representation for a nsName object. It contains the - * pointer along with some information that is used to check the cached - * pointer's validity. + * This structure contains a cached pointer to a namespace that is the result + * of resolving the namespace's name in some other namespace. It is the + * internal representation for a nsName object. It contains the pointer along + * with some information that is used to check the cached pointer's validity. */ typedef struct ResolvedNsName { Namespace *nsPtr; /* A cached namespace pointer. */ - long nsId; /* nsPtr's unique namespace id. Used to - * verify that nsPtr is still valid - * (e.g., it's possible that the namespace - * was deleted and a new one created at - * the same address). */ + long nsId; /* nsPtr's unique namespace id. Used to verify + * that nsPtr is still valid (e.g., it's + * possible that the namespace was deleted and + * a new one created at the same address). */ Namespace *refNsPtr; /* Points to the namespace containing the - * reference (not the namespace that - * contains the referenced namespace). */ - int refCount; /* Reference count: 1 for each nsName - * object that has a pointer to this - * ResolvedNsName structure as its internal - * rep. This structure can be freed when - * refCount becomes zero. */ + * reference (not the namespace that contains + * the referenced namespace). */ + int refCount; /* Reference count: 1 for each nsName object + * that has a pointer to this ResolvedNsName + * structure as its internal rep. This + * structure can be freed when refCount + * becomes zero. */ } ResolvedNsName; /* - * The client data for an ensemble command. This consists of the - * table of commands that are actually exported by the namespace, and - * an epoch counter that, combined with the exportLookupEpoch field of - * the namespace structure, defines whether the table contains valid - * data or will need to be recomputed next time the ensemble command - * is called. + * The client data for an ensemble command. This consists of the table of + * commands that are actually exported by the namespace, and an epoch counter + * that, combined with the exportLookupEpoch field of the namespace structure, + * defines whether the table contains valid data or will need to be recomputed + * next time the ensemble command is called. */ typedef struct EnsembleConfig { Namespace *nsPtr; /* The namspace backing this ensemble up. */ Tcl_Command token; /* The token for the command that provides - * ensemble support for the namespace, or - * NULL if the command has been deleted (or - * never existed; the global namespace never - * has an ensemble command.) */ + * ensemble support for the namespace, or NULL + * if the command has been deleted (or never + * existed; the global namespace never has an + * ensemble command.) */ int epoch; /* The epoch at which this ensemble's table of * exported commands is valid. */ char **subcommandArrayPtr; /* Array of ensemble subcommand names. At all @@ -103,14 +100,14 @@ typedef struct EnsembleConfig { /* Hash table of ensemble subcommand names, * which are its keys so this also provides * the storage management for those subcommand - * names. The contents of the entry values are - * object version the prefix lists to use when - * substituting for the command/subcommand to - * build the ensemble implementation command. - * Has to be stored here as well as in - * subcommandDict because that field is NULL - * when we are deriving the ensemble from the - * namespace exports list. + * names. The contents of the entry values + * are object version the prefix lists to use + * when substituting for the + * command/subcommand to build the ensemble + * implementation command. Has to be stored + * here as well as in subcommandDict because + * that field is NULL when we are deriving the + * ensemble from the namespace exports list. * FUTURE WORK: use object hash table here. */ struct EnsembleConfig *next;/* The next ensemble in the linked list of * ensembles associated with a namespace. If @@ -145,19 +142,19 @@ typedef struct EnsembleConfig { * (including objv[0]) and will have the * results passed directly back to the caller * (including the error code) unless the code - * is TCL_CONTINUE in which case the subcommand - * will be reparsed by the ensemble core, - * presumably because the ensemble itself has - * been updated. */ + * is TCL_CONTINUE in which case the + * subcommand will be reparsed by the ensemble + * core, presumably because the ensemble + * itself has been updated. */ } EnsembleConfig; #define ENS_DEAD 0x1 /* Flag value to say that the ensemble is dead * and on its way out. */ /* - * The data cached in a subcommand's Tcl_Obj rep. This structure is - * not shared between Tcl_Objs referring to the same subcommand, even - * where one is a duplicate of another. + * The data cached in a subcommand's Tcl_Obj rep. This structure is not + * shared between Tcl_Objs referring to the same subcommand, even where one is + * a duplicate of another. */ typedef struct EnsembleCmdRep { @@ -176,7 +173,7 @@ typedef struct EnsembleCmdRep { } EnsembleCmdRep; /* - * Declarations for procedures local to this file: + * Declarations for functions local to this file: */ static void DeleteImportedCmd _ANSI_ARGS_((ClientData clientData)); @@ -186,10 +183,10 @@ static int DoImport _ANSI_ARGS_((Tcl_Interp *interp, Namespace *importNsPtr, int allowOverwrite)); static void DupNsNameInternalRep _ANSI_ARGS_((Tcl_Obj *objPtr, Tcl_Obj *copyPtr)); -static char * ErrorCodeRead _ANSI_ARGS_(( ClientData clientData, +static char * ErrorCodeRead _ANSI_ARGS_((ClientData clientData, Tcl_Interp *interp, CONST char *name1, CONST char *name2, int flags)); -static char * ErrorInfoRead _ANSI_ARGS_(( ClientData clientData, +static char * ErrorInfoRead _ANSI_ARGS_((ClientData clientData, Tcl_Interp *interp, CONST char *name1, CONST char *name2, int flags)); static char * EstablishErrorCodeTraces _ANSI_ARGS_(( @@ -278,10 +275,10 @@ static void SetNsPath _ANSI_ARGS_((Namespace *nsPtr, int pathLength, Tcl_Namespace *pathAry[])); /* - * This structure defines a Tcl object type that contains a - * namespace reference. It is used in commands that take the - * name of a namespace as an argument. The namespace reference - * is resolved, and the result in cached in the object. + * This structure defines a Tcl object type that contains a namespace + * reference. It is used in commands that take the name of a namespace as an + * argument. The namespace reference is resolved, and the result in cached in + * the object. */ Tcl_ObjType tclNsNameType = { @@ -293,10 +290,10 @@ Tcl_ObjType tclNsNameType = { }; /* - * This structure defines a Tcl object type that contains a reference - * to an ensemble subcommand (e.g. the "length" in [string length ab]) - * It is used to cache the mapping between the subcommand itself and - * the real command that implements it. + * This structure defines a Tcl object type that contains a reference to an + * ensemble subcommand (e.g. the "length" in [string length ab]) It is used to + * cache the mapping between the subcommand itself and the real command that + * implements it. */ static Tcl_ObjType ensembleCmdType = { @@ -312,8 +309,8 @@ static Tcl_ObjType ensembleCmdType = { * * TclInitNamespaceSubsystem -- * - * This procedure is called to initialize all the structures that - * are used by namespaces on a per-process basis. + * This function is called to initialize all the structures that are used + * by namespaces on a per-process basis. * * Results: * None. @@ -382,8 +379,8 @@ Tcl_GetCurrentNamespace(interp) Tcl_Namespace * Tcl_GetGlobalNamespace(interp) - register Tcl_Interp *interp; /* Interpreter whose global namespace - * should be returned. */ + register Tcl_Interp *interp; /* Interpreter whose global namespace should + * be returned. */ { register Interp *iPtr = (Interp *) interp; @@ -395,9 +392,9 @@ Tcl_GetGlobalNamespace(interp) * * Tcl_PushCallFrame -- * - * Pushes a new call frame onto the interpreter's Tcl call stack. - * Called when executing a Tcl procedure or a "namespace eval" or - * "namespace inscope" command. + * Pushes a new call frame onto the interpreter's Tcl call stack. Called + * when executing a Tcl procedure or a "namespace eval" or "namespace + * inscope" command. * * Results: * Returns TCL_OK if successful, or TCL_ERROR (along with an error @@ -411,31 +408,30 @@ Tcl_GetGlobalNamespace(interp) int Tcl_PushCallFrame(interp, callFramePtr, namespacePtr, isProcCallFrame) - Tcl_Interp *interp; /* Interpreter in which the new call frame - * is to be pushed. */ - Tcl_CallFrame *callFramePtr; /* Points to a call frame structure to - * push. Storage for this has already been - * allocated by the caller; typically this - * is the address of a CallFrame structure - * allocated on the caller's C stack. The + Tcl_Interp *interp; /* Interpreter in which the new call frame is + * to be pushed. */ + Tcl_CallFrame *callFramePtr; /* Points to a call frame structure to push. + * Storage for this has already been + * allocated by the caller; typically this is + * the address of a CallFrame structure + * allocated on the caller's C stack. The * call frame will be initialized by this - * procedure. The caller can pop the frame + * function. The caller can pop the frame * later with Tcl_PopCallFrame, and it is * responsible for freeing the frame's * storage. */ - Tcl_Namespace *namespacePtr; /* Points to the namespace in which the - * frame will execute. If NULL, the - * interpreter's current namespace will - * be used. */ - int isProcCallFrame; /* If nonzero, the frame represents a - * called Tcl procedure and may have local - * vars. Vars will ordinarily be looked up - * in the frame. If new variables are - * created, they will be created in the - * frame. If 0, the frame is for a - * "namespace eval" or "namespace inscope" - * command and var references are treated - * as references to namespace variables. */ + Tcl_Namespace *namespacePtr; /* Points to the namespace in which the frame + * will execute. If NULL, the interpreter's + * current namespace will be used. */ + int isProcCallFrame; /* If nonzero, the frame represents a called + * Tcl procedure and may have local vars. + * Vars will ordinarily be looked up in the + * frame. If new variables are created, they + * will be created in the frame. If 0, the + * frame is for a "namespace eval" or + * "namespace inscope" command and var + * references are treated as references to + * namespace variables. */ { Interp *iPtr = (Interp *) interp; register CallFrame *framePtr = (CallFrame *) callFramePtr; @@ -469,8 +465,8 @@ Tcl_PushCallFrame(interp, callFramePtr, namespacePtr, isProcCallFrame) framePtr->compiledLocals = NULL; /* - * Push the new call frame onto the interpreter's stack of procedure - * call frames making it the current frame. + * Push the new call frame onto the interpreter's stack of procedure call + * frames making it the current frame. */ iPtr->framePtr = framePtr; @@ -491,9 +487,8 @@ Tcl_PushCallFrame(interp, callFramePtr, namespacePtr, isProcCallFrame) * * Side effects: * Modifies the call stack of the interpreter. Resets various fields of - * the popped call frame. If a namespace has been deleted and - * has no more activations on the call stack, the namespace is - * destroyed. + * the popped call frame. If a namespace has been deleted and has no more + * activations on the call stack, the namespace is destroyed. * *---------------------------------------------------------------------- */ @@ -507,10 +502,9 @@ Tcl_PopCallFrame(interp) Namespace *nsPtr; /* - * It's important to remove the call frame from the interpreter's stack - * of call frames before deleting local variables, so that traces - * invoked by the variable deletion don't see the partially-deleted - * frame. + * It's important to remove the call frame from the interpreter's stack of + * call frames before deleting local variables, so that traces invoked by + * the variable deletion don't see the partially-deleted frame. */ iPtr->framePtr = framePtr->callerPtr; @@ -526,9 +520,9 @@ Tcl_PopCallFrame(interp) } /* - * Decrement the namespace's count of active call frames. If the - * namespace is "dying" and there are no more active call frames, - * call Tcl_DeleteNamespace to destroy it. + * Decrement the namespace's count of active call frames. If the namespace + * is "dying" and there are no more active call frames, call + * Tcl_DeleteNamespace to destroy it. */ nsPtr = framePtr->nsPtr; @@ -545,9 +539,8 @@ Tcl_PopCallFrame(interp) * TclPushStackFrame -- * * Allocates a new call frame in the interpreter's execution stack, then - * pushes it onto the interpreter's Tcl call stack. - * Called when executing a Tcl procedure or a "namespace eval" or - * "namespace inscope" command. + * pushes it onto the interpreter's Tcl call stack. Called when executing + * a Tcl procedure or a "namespace eval" or "namespace inscope" command. * * Results: * Returns TCL_OK if successful, or TCL_ERROR (along with an error @@ -561,27 +554,26 @@ Tcl_PopCallFrame(interp) int TclPushStackFrame(interp, framePtrPtr, namespacePtr, isProcCallFrame) - Tcl_Interp *interp; /* Interpreter in which the new call frame - * is to be pushed. */ + Tcl_Interp *interp; /* Interpreter in which the new call frame is + * to be pushed. */ Tcl_CallFrame **framePtrPtr; /* Place to store a pointer to the stack * allocated call frame.*/ - Tcl_Namespace *namespacePtr; /* Points to the namespace in which the - * frame will execute. If NULL, the - * interpreter's current namespace will - * be used. */ - int isProcCallFrame; /* If nonzero, the frame represents a - * called Tcl procedure and may have local - * vars. Vars will ordinarily be looked up - * in the frame. If new variables are - * created, they will be created in the - * frame. If 0, the frame is for a - * "namespace eval" or "namespace inscope" - * command and var references are treated - * as references to namespace variables. */ + Tcl_Namespace *namespacePtr; /* Points to the namespace in which the frame + * will execute. If NULL, the interpreter's + * current namespace will be used. */ + int isProcCallFrame; /* If nonzero, the frame represents a called + * Tcl procedure and may have local vars. + * Vars will ordinarily be looked up in the + * frame. If new variables are created, they + * will be created in the frame. If 0, the + * frame is for a "namespace eval" or + * "namespace inscope" command and var + * references are treated as references to + * namespace variables. */ { - *framePtrPtr = (Tcl_CallFrame *) TclStackAlloc(interp, sizeof(CallFrame)); - return Tcl_PushCallFrame(interp, *framePtrPtr, namespacePtr, isProcCallFrame); + return Tcl_PushCallFrame(interp, *framePtrPtr, namespacePtr, + isProcCallFrame); } void @@ -589,7 +581,7 @@ TclPopStackFrame(interp) Tcl_Interp* interp; /* Interpreter with call frame to pop. */ { Tcl_PopCallFrame(interp); - TclStackFree(interp); + TclStackFree(interp); } /* @@ -629,8 +621,8 @@ EstablishErrorCodeTraces(clientData, interp, name1, name2, flags) * * ErrorCodeRead -- * - * Called when the ::errorCode variable is read. Copies the - * current value of the interp's errorCode field into ::errorCode. + * Called when the ::errorCode variable is read. Copies the current value + * of the interp's errorCode field into ::errorCode. * * Results: * None. @@ -651,9 +643,11 @@ ErrorCodeRead(clientData, interp, name1, name2, flags) { Interp *iPtr = (Interp *)interp; - if (flags & TCL_INTERP_DESTROYED) return NULL; - if (iPtr->errorCode == NULL) return NULL; - Tcl_ObjSetVar2(interp, iPtr->ecVar, NULL, iPtr->errorCode, TCL_GLOBAL_ONLY); + if (flags & TCL_INTERP_DESTROYED || iPtr->errorCode == NULL) { + return NULL; + } + Tcl_ObjSetVar2(interp, iPtr->ecVar, NULL, iPtr->errorCode, + TCL_GLOBAL_ONLY); return NULL; } @@ -694,8 +688,8 @@ EstablishErrorInfoTraces(clientData, interp, name1, name2, flags) * * ErrorInfoRead -- * - * Called when the ::errorInfo variable is read. Copies the - * current value of the interp's errorInfo field into ::errorInfo. + * Called when the ::errorInfo variable is read. Copies the current value + * of the interp's errorInfo field into ::errorInfo. * * Results: * None. @@ -716,9 +710,11 @@ ErrorInfoRead(clientData, interp, name1, name2, flags) { Interp *iPtr = (Interp *)interp; - if (flags & TCL_INTERP_DESTROYED) return NULL; - if (iPtr->errorInfo == NULL) return NULL; - Tcl_ObjSetVar2(interp, iPtr->eiVar, NULL, iPtr->errorInfo, TCL_GLOBAL_ONLY); + if (flags & TCL_INTERP_DESTROYED || iPtr->errorInfo == NULL) { + return NULL; + } + Tcl_ObjSetVar2(interp, iPtr->eiVar, NULL, iPtr->errorInfo, + TCL_GLOBAL_ONLY); return NULL; } @@ -727,38 +723,36 @@ ErrorInfoRead(clientData, interp, name1, name2, flags) * * Tcl_CreateNamespace -- * - * Creates a new namespace with the given name. If there is no - * active namespace (i.e., the interpreter is being initialized), - * the global :: namespace is created and returned. + * Creates a new namespace with the given name. If there is no active + * namespace (i.e., the interpreter is being initialized), the global :: + * namespace is created and returned. * * Results: - * Returns a pointer to the new namespace if successful. If the - * namespace already exists or if another error occurs, this routine - * returns NULL, along with an error message in the interpreter's - * result object. + * Returns a pointer to the new namespace if successful. If the namespace + * already exists or if another error occurs, this routine returns NULL, + * along with an error message in the interpreter's result object. * * Side effects: - * If the name contains "::" qualifiers and a parent namespace does - * not already exist, it is automatically created. + * If the name contains "::" qualifiers and a parent namespace does not + * already exist, it is automatically created. * *---------------------------------------------------------------------- */ Tcl_Namespace * Tcl_CreateNamespace(interp, name, clientData, deleteProc) - Tcl_Interp *interp; /* Interpreter in which a new namespace - * is being created. Also used for - * error reporting. */ + Tcl_Interp *interp; /* Interpreter in which a new namespace is + * being created. Also used for error + * reporting. */ CONST char *name; /* Name for the new namespace. May be a * qualified name with names of ancestor * namespaces separated by "::"s. */ ClientData clientData; /* One-word value to store with * namespace. */ Tcl_NamespaceDeleteProc *deleteProc; - /* Procedure called to delete client - * data when the namespace is deleted. - * NULL if no procedure should be - * called. */ + /* Function called to delete client data + * when the namespace is deleted. NULL if + * no function should be called. */ { Interp *iPtr = (Interp *) interp; register Namespace *nsPtr, *ancestorPtr; @@ -771,14 +765,13 @@ Tcl_CreateNamespace(interp, name, clientData, deleteProc) ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); /* - * If there is no active namespace, the interpreter is being - * initialized. + * If there is no active namespace, the interpreter is being initialized. */ if ((globalNsPtr == NULL) && (iPtr->varFramePtr == NULL)) { /* - * Treat this namespace as the global namespace, and avoid - * looking for a parent. + * Treat this namespace as the global namespace, and avoid looking for + * a parent. */ parentPtr = NULL; @@ -799,9 +792,8 @@ Tcl_CreateNamespace(interp, name, clientData, deleteProc) /* * If the unqualified name at the end is empty, there were trailing - * "::"s after the namespace's name which we ignore. The new - * namespace was already (recursively) created and is pointed to - * by parentPtr. + * "::"s after the namespace's name which we ignore. The new namespace + * was already (recursively) created and is pointed to by parentPtr. */ if (*simpleName == '\0') { @@ -809,8 +801,8 @@ Tcl_CreateNamespace(interp, name, clientData, deleteProc) } /* - * Check for a bad namespace name and make sure that the name - * does not already exist in the parent namespace. + * Check for a bad namespace name and make sure that the name does not + * already exist in the parent namespace. */ if (Tcl_FindHashEntry(&parentPtr->childTable, simpleName) != NULL) { @@ -821,8 +813,8 @@ Tcl_CreateNamespace(interp, name, clientData, deleteProc) } /* - * Create the new namespace and root it in its parent. Increment the - * count of namespaces created. + * Create the new namespace and root it in its parent. Increment the count + * of namespaces created. */ nsPtr = (Namespace *) ckalloc(sizeof(Namespace)); @@ -859,10 +851,11 @@ Tcl_CreateNamespace(interp, name, clientData, deleteProc) &newEntry); Tcl_SetHashValue(entryPtr, (ClientData) nsPtr); } else { - /* - * In the global namespace create traces to maintain the - * ::errorInfo and ::errorCode variables. + /* + * In the global namespace create traces to maintain the ::errorInfo + * and ::errorCode variables. */ + iPtr->globalNsPtr = nsPtr; EstablishErrorInfoTraces(NULL, interp, NULL, NULL, 0); EstablishErrorCodeTraces(NULL, interp, NULL, NULL, 0); @@ -913,9 +906,9 @@ Tcl_CreateNamespace(interp, name, clientData, deleteProc) * None. * * Side effects: - * When a namespace is deleted, it is automatically removed as a - * child of its parent namespace. Also, all its commands, variables - * and child namespaces are deleted. + * When a namespace is deleted, it is automatically removed as a child of + * its parent namespace. Also, all its commands, variables and child + * namespaces are deleted. * *---------------------------------------------------------------------- */ @@ -940,8 +933,7 @@ Tcl_DeleteNamespace(namespacePtr) while (nsPtr->ensembles != NULL) { /* - * Splice out and link to indicate that we've already been - * killed. + * Splice out and link to indicate that we've already been killed. */ EnsembleConfig *ensemblePtr = (EnsembleConfig *) nsPtr->ensembles; nsPtr->ensembles = (Tcl_Ensemble *) ensemblePtr->next; @@ -951,19 +943,19 @@ Tcl_DeleteNamespace(namespacePtr) /* * If the namespace is on the call frame stack, it is marked as "dying" - * (NS_DYING is OR'd into its flags): the namespace can't be looked up - * by name but its commands and variables are still usable by those - * active call frames. When all active call frames referring to the - * namespace have been popped from the Tcl stack, Tcl_PopCallFrame will - * call this procedure again to delete everything in the namespace. - * If no nsName objects refer to the namespace (i.e., if its refCount - * is zero), its commands and variables are deleted and the storage for - * its namespace structure is freed. Otherwise, if its refCount is - * nonzero, the namespace's commands and variables are deleted but the - * structure isn't freed. Instead, NS_DEAD is OR'd into the structure's - * flags to allow the namespace resolution code to recognize that the - * namespace is "deleted". The structure's storage is freed by - * FreeNsNameInternalRep when its refCount reaches 0. + * (NS_DYING is OR'd into its flags): the namespace can't be looked up by + * name but its commands and variables are still usable by those active + * call frames. When all active call frames referring to the namespace + * have been popped from the Tcl stack, Tcl_PopCallFrame will call this + * function again to delete everything in the namespace. If no nsName + * objects refer to the namespace (i.e., if its refCount is zero), its + * commands and variables are deleted and the storage for its namespace + * structure is freed. Otherwise, if its refCount is nonzero, the + * namespace's commands and variables are deleted but the structure isn't + * freed. Instead, NS_DEAD is OR'd into the structure's flags to allow the + * namespace resolution code to recognize that the namespace is "deleted". + * The structure's storage is freed by FreeNsNameInternalRep when its + * refCount reaches 0. */ if (nsPtr->activationCount > 0) { @@ -988,9 +980,9 @@ Tcl_DeleteNamespace(namespacePtr) if ((nsPtr != globalNsPtr) || (iPtr->flags & DELETED)) { /* * If this is the global namespace, then it may have residual - * "errorInfo" and "errorCode" variables for errors that - * occurred while it was being torn down. Try to clear the - * variable list one last time. + * "errorInfo" and "errorCode" variables for errors that occurred + * while it was being torn down. Try to clear the variable list + * one last time. */ TclDeleteVars((Interp *) nsPtr->interp, &nsPtr->varTable); @@ -1009,7 +1001,10 @@ Tcl_DeleteNamespace(namespacePtr) nsPtr->flags |= NS_DEAD; } } else { - /* Restore the ::errorInfo and ::errorCode traces */ + /* + * Restore the ::errorInfo and ::errorCode traces. + */ + EstablishErrorInfoTraces(NULL, nsPtr->interp, NULL, NULL, 0); EstablishErrorCodeTraces(NULL, nsPtr->interp, NULL, NULL, 0); } @@ -1026,7 +1021,7 @@ Tcl_DeleteNamespace(namespacePtr) * commands, variables, and child namespaces. * * This is kept separate from Tcl_DeleteNamespace so that the global - * namespace can be handled specially. + * namespace can be handled specially. * * Results: * None. @@ -1051,9 +1046,8 @@ TclTeardownNamespace(nsPtr) int i; /* - * Start by destroying the namespace's variable table, - * since variables might trigger traces. - * Variable table should be cleared but not freed! + * Start by destroying the namespace's variable table, since variables + * might trigger traces. Variable table should be cleared but not freed! * TclDeleteVars frees it, so we reinitialize it afterwards. */ @@ -1092,10 +1086,10 @@ TclTeardownNamespace(nsPtr) /* * Delete all the child namespaces. * - * BE CAREFUL: When each child is deleted, it will divorce - * itself from its parent. You can't traverse a hash table - * properly if its elements are being deleted. We use only - * the Tcl_FirstHashEntry function to be safe. + * BE CAREFUL: When each child is deleted, it will divorce itself from its + * parent. You can't traverse a hash table properly if its elements are + * being deleted. We use only the Tcl_FirstHashEntry function to be + * safe. * * Don't optimize to Tcl_NextHashEntry() because of traces. */ @@ -1149,9 +1143,9 @@ TclTeardownNamespace(nsPtr) nsPtr->clientData = NULL; /* - * Reset the namespace's id field to ensure that this namespace won't - * be interpreted as valid by, e.g., the cache validation code for - * cached command references in Tcl_GetCommandFromObj. + * Reset the namespace's id field to ensure that this namespace won't be + * interpreted as valid by, e.g., the cache validation code for cached + * command references in Tcl_GetCommandFromObj. */ nsPtr->nsId = 0; @@ -1162,9 +1156,8 @@ TclTeardownNamespace(nsPtr) * * NamespaceFree -- * - * Called after a namespace has been deleted, when its - * reference count reaches 0. Frees the data structure - * representing the namespace. + * Called after a namespace has been deleted, when its reference count + * reaches 0. Frees the data structure representing the namespace. * * Results: * None. @@ -1197,10 +1190,10 @@ NamespaceFree(nsPtr) * Tcl_Export -- * * Makes all the commands matching a pattern available to later be - * imported from the namespace specified by namespacePtr (or the - * current namespace if namespacePtr is NULL). The specified pattern is - * appended onto the namespace's export pattern list, which is - * optionally cleared beforehand. + * imported from the namespace specified by namespacePtr (or the current + * namespace if namespacePtr is NULL). The specified pattern is appended + * onto the namespace's export pattern list, which is optionally cleared + * beforehand. * * Results: * Returns TCL_OK if successful, or TCL_ERROR (along with an error @@ -1216,18 +1209,18 @@ NamespaceFree(nsPtr) int Tcl_Export(interp, namespacePtr, pattern, resetListFirst) Tcl_Interp *interp; /* Current interpreter. */ - Tcl_Namespace *namespacePtr; /* Points to the namespace from which - * commands are to be exported. NULL for - * the current namespace. */ + Tcl_Namespace *namespacePtr; /* Points to the namespace from which + * commands are to be exported. NULL for the + * current namespace. */ CONST char *pattern; /* String pattern indicating which commands * to export. This pattern may not include - * any namespace qualifiers; only commands - * in the specified namespace may be + * any namespace qualifiers; only commands in + * the specified namespace may be * exported. */ - int resetListFirst; /* If nonzero, resets the namespace's - * export list before appending. */ + int resetListFirst; /* If nonzero, resets the namespace's export + * list before appending. */ { -#define INIT_EXPORT_PATTERNS 5 +#define INIT_EXPORT_PATTERNS 5 Namespace *nsPtr, *exportNsPtr, *dummyPtr; Namespace *currNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp); CONST char *simplePattern; @@ -1279,6 +1272,7 @@ Tcl_Export(interp, namespacePtr, pattern, resetListFirst) /* * Make sure that we don't already have the pattern in the array */ + if (nsPtr->exportArrayPtr != NULL) { for (i = 0; i < nsPtr->numExportPatterns; i++) { if (strcmp(pattern, nsPtr->exportArrayPtr[i]) == 0) { @@ -1291,8 +1285,8 @@ Tcl_Export(interp, namespacePtr, pattern, resetListFirst) } /* - * Make sure there is room in the namespace's pattern array for the - * new pattern. + * Make sure there is room in the namespace's pattern array for the new + * pattern. */ neededElems = nsPtr->numExportPatterns + 1; @@ -1325,10 +1319,9 @@ Tcl_Export(interp, namespacePtr, pattern, resetListFirst) nsPtr->numExportPatterns++; /* - * The list of commands actually exported from the namespace might - * have changed (probably will have!) However, we do not need to - * recompute this just yet; next time we need the info will be - * soon enough. + * The list of commands actually exported from the namespace might have + * changed (probably will have!) However, we do not need to recompute + * this just yet; next time we need the info will be soon enough. */ TclInvalidateNsCmdLookup(nsPtr); @@ -1348,12 +1341,12 @@ Tcl_Export(interp, namespacePtr, pattern, resetListFirst) * Results: * The return value is normally TCL_OK; in this case the object * referenced by objPtr has each export pattern appended to it. If an - * error occurs, TCL_ERROR is returned and the interpreter's result - * holds an error message. + * error occurs, TCL_ERROR is returned and the interpreter's result holds + * an error message. * * Side effects: - * If necessary, the object referenced by objPtr is converted into - * a list object. + * If necessary, the object referenced by objPtr is converted into a list + * object. * *---------------------------------------------------------------------- */ @@ -1400,22 +1393,22 @@ Tcl_AppendExportList(interp, namespacePtr, objPtr) * Tcl_Import -- * * Imports all of the commands matching a pattern into the namespace - * specified by namespacePtr (or the current namespace if contextNsPtr - * is NULL). This is done by creating a new command (the "imported - * command") that points to the real command in its original namespace. + * specified by namespacePtr (or the current namespace if contextNsPtr is + * NULL). This is done by creating a new command (the "imported command") + * that points to the real command in its original namespace. * - * If matching commands are on the autoload path but haven't been - * loaded yet, this command forces them to be loaded, then creates - * the links to them. + * If matching commands are on the autoload path but haven't been loaded + * yet, this command forces them to be loaded, then creates the links to + * them. * * Results: * Returns TCL_OK if successful, or TCL_ERROR (along with an error * message in the interpreter's result) if something goes wrong. * * Side effects: - * Creates new commands in the importing namespace. These indirect - * calls back to the real command and are deleted if the real commands - * are deleted. + * Creates new commands in the importing namespace. These indirect calls + * back to the real command and are deleted if the real commands are + * deleted. * *---------------------------------------------------------------------- */ @@ -1424,16 +1417,16 @@ int Tcl_Import(interp, namespacePtr, pattern, allowOverwrite) Tcl_Interp *interp; /* Current interpreter. */ Tcl_Namespace *namespacePtr; /* Points to the namespace into which the - * commands are to be imported. NULL for - * the current namespace. */ + * commands are to be imported. NULL for the + * current namespace. */ CONST char *pattern; /* String pattern indicating which commands * to import. This pattern should be * qualified by the name of the namespace * from which to import the command(s). */ - int allowOverwrite; /* If nonzero, allow existing commands to - * be overwritten by imported commands. - * If 0, return an error if an imported - * cmd conflicts with an existing one. */ + int allowOverwrite; /* If nonzero, allow existing commands to be + * overwritten by imported commands. If 0, + * return an error if an imported cmd + * conflicts with an existing one. */ { Namespace *nsPtr, *importNsPtr, *dummyPtr; CONST char *simplePattern; @@ -1451,14 +1444,13 @@ Tcl_Import(interp, namespacePtr, pattern, allowOverwrite) } /* - * First, invoke the "auto_import" command with the pattern - * being imported. This command is part of the Tcl library. - * It looks for imported commands in autoloaded libraries and - * loads them in. That way, they will be found when we try - * to create links below. + * First, invoke the "auto_import" command with the pattern being + * imported. This command is part of the Tcl library. It looks for + * imported commands in autoloaded libraries and loads them in. That way, + * they will be found when we try to create links below. * - * Note that we don't just call Tcl_EvalObjv() directly because we - * do not want absence of the command to be a failure case. + * Note that we don't just call Tcl_EvalObjv() directly because we do not + * want absence of the command to be a failure case. */ if (Tcl_FindCommand(interp,"auto_import",NULL,TCL_GLOBAL_ONLY) != NULL) { @@ -1481,9 +1473,8 @@ Tcl_Import(interp, namespacePtr, pattern, allowOverwrite) } /* - * From the pattern, find the namespace from which we are importing - * and get the simple pattern (no namespace qualifiers or ::'s) at - * the end. + * From the pattern, find the namespace from which we are importing and + * get the simple pattern (no namespace qualifiers or ::'s) at the end. */ if (strlen(pattern) == 0) { @@ -1530,9 +1521,9 @@ Tcl_Import(interp, namespacePtr, pattern, allowOverwrite) for (hPtr = Tcl_FirstHashEntry(&importNsPtr->cmdTable, &search); (hPtr != NULL); hPtr = Tcl_NextHashEntry(&search)) { char *cmdName = Tcl_GetHashKey(&importNsPtr->cmdTable, hPtr); - if (Tcl_StringMatch(cmdName, simplePattern) - && (TCL_ERROR == DoImport( interp, nsPtr, hPtr, cmdName, - pattern, importNsPtr, allowOverwrite))) { + if (Tcl_StringMatch(cmdName, simplePattern) && + DoImport(interp, nsPtr, hPtr, cmdName, pattern, importNsPtr, + allowOverwrite) == TCL_ERROR) { return TCL_ERROR; } } @@ -1553,9 +1544,8 @@ DoImport(interp, nsPtr, hPtr, cmdName, pattern, importNsPtr, allowOverwrite) Tcl_HashEntry *found; /* - * The command cmdName in the source namespace matches the - * pattern. Check whether it was exported. If it wasn't, - * we ignore it. + * The command cmdName in the source namespace matches the pattern. Check + * whether it was exported. If it wasn't, we ignore it. */ while (!exported && (i < importNsPtr->numExportPatterns)) { @@ -1566,16 +1556,16 @@ DoImport(interp, nsPtr, hPtr, cmdName, pattern, importNsPtr, allowOverwrite) } /* - * Unless there is a name clash, create an imported command - * in the current namespace that refers to cmdPtr. + * Unless there is a name clash, create an imported command in the current + * namespace that refers to cmdPtr. */ found = Tcl_FindHashEntry(&nsPtr->cmdTable, cmdName); if ((found == NULL) || allowOverwrite) { /* - * Create the imported command and its client data. - * To create the new command in the current namespace, - * generate a fully qualified name for it. + * Create the imported command and its client data. To create the new + * command in the current namespace, generate a fully qualified name + * for it. */ Tcl_DString ds; @@ -1592,9 +1582,8 @@ DoImport(interp, nsPtr, hPtr, cmdName, pattern, importNsPtr, allowOverwrite) Tcl_DStringAppend(&ds, cmdName, -1); /* - * Check whether creating the new imported command in the - * current namespace would create a cycle of imported - * command references. + * Check whether creating the new imported command in the current + * namespace would create a cycle of imported command references. */ cmdPtr = (Command *) Tcl_GetHashValue(hPtr); @@ -1608,11 +1597,9 @@ DoImport(interp, nsPtr, hPtr, cmdName, pattern, importNsPtr, allowOverwrite) dataPtr = (ImportedCmdData *) link->objClientData; link = dataPtr->realCmdPtr; if (overwrite == link) { - Tcl_AppendResult(interp, "import pattern \"", - pattern, - "\" would create a loop containing ", - "command \"", Tcl_DStringValue(&ds), - "\"", (char *) NULL); + Tcl_AppendResult(interp, "import pattern \"", pattern, + "\" would create a loop containing command \"", + Tcl_DStringValue(&ds), "\"", (char *) NULL); Tcl_DStringFree(&ds); return TCL_ERROR; } @@ -1620,18 +1607,16 @@ DoImport(interp, nsPtr, hPtr, cmdName, pattern, importNsPtr, allowOverwrite) } dataPtr = (ImportedCmdData *) ckalloc(sizeof(ImportedCmdData)); - importedCmd = Tcl_CreateObjCommand(interp, - Tcl_DStringValue(&ds), InvokeImportedCmd, - (ClientData) dataPtr, DeleteImportedCmd); + importedCmd = Tcl_CreateObjCommand(interp, Tcl_DStringValue(&ds), + InvokeImportedCmd, (ClientData) dataPtr, DeleteImportedCmd); dataPtr->realCmdPtr = cmdPtr; dataPtr->selfPtr = (Command *) importedCmd; dataPtr->selfPtr->compileProc = cmdPtr->compileProc; Tcl_DStringFree(&ds); /* - * Create an ImportRef structure describing this new import - * command and add it to the import ref list in the "real" - * command. + * Create an ImportRef structure describing this new import command + * and add it to the import ref list in the "real" command. */ refPtr = (ImportRef *) ckalloc(sizeof(ImportRef)); @@ -1640,9 +1625,10 @@ DoImport(interp, nsPtr, hPtr, cmdName, pattern, importNsPtr, allowOverwrite) cmdPtr->importRefPtr = refPtr; } else { Command *overwrite = (Command *) Tcl_GetHashValue(found); + if (overwrite->deleteProc == DeleteImportedCmd) { - ImportedCmdData *dataPtr = - (ImportedCmdData *) overwrite->objClientData; + ImportedCmdData *dataPtr = (ImportedCmdData *) + overwrite->objClientData; if (dataPtr->realCmdPtr == (Command *) Tcl_GetHashValue(hPtr)) { /* Repeated import of same command -- acceptable */ return TCL_OK; @@ -1660,25 +1646,24 @@ DoImport(interp, nsPtr, hPtr, cmdName, pattern, importNsPtr, allowOverwrite) * * Tcl_ForgetImport -- * - * Deletes commands previously imported into the namespace indicated. The - * by namespacePtr, or the current namespace of interp, when + * Deletes commands previously imported into the namespace indicated. + * The by namespacePtr, or the current namespace of interp, when * namespacePtr is NULL. The pattern controls which imported commands - * are deleted. A simple pattern, one without namespace separators, + * are deleted. A simple pattern, one without namespace separators, * matches the current command names of imported commands in the - * namespace. Matching imported commands are deleted. A qualified - * pattern is interpreted as deletion selection on the basis of where - * the command is imported from. The original command and "first link" - * command for each imported command are determined, and they are matched - * against the pattern. A match leads to deletion of the imported - * command. + * namespace. Matching imported commands are deleted. A qualified pattern + * is interpreted as deletion selection on the basis of where the command + * is imported from. The original command and "first link" command for + * each imported command are determined, and they are matched against the + * pattern. A match leads to deletion of the imported command. * * Results: - * Returns TCL_ERROR and records an error message in the interp - * result if a namespace qualified pattern refers to a namespace - * that does not exist. Otherwise, returns TCL_OK. + * Returns TCL_ERROR and records an error message in the interp result if + * a namespace qualified pattern refers to a namespace that does not + * exist. Otherwise, returns TCL_OK. * * Side effects: - * May delete commands. + * May delete commands. * *---------------------------------------------------------------------- */ @@ -1709,8 +1694,8 @@ Tcl_ForgetImport(interp, namespacePtr, pattern) } /* - * Parse the pattern into its namespace-qualification (if any) - * and the simple pattern. + * Parse the pattern into its namespace-qualification (if any) and the + * simple pattern. */ TclGetNamespaceForQualName(interp, pattern, nsPtr, @@ -1726,8 +1711,7 @@ Tcl_ForgetImport(interp, namespacePtr, pattern) if (strcmp(pattern, simplePattern) == 0) { /* - * The pattern is simple. - * Delete any imported commands that match it. + * The pattern is simple. Delete any imported commands that match it. */ if (TclMatchIsTrivial(simplePattern)) { @@ -1741,8 +1725,7 @@ Tcl_ForgetImport(interp, namespacePtr, pattern) return TCL_OK; } for (hPtr = Tcl_FirstHashEntry(&nsPtr->cmdTable, &search); - (hPtr != NULL); - hPtr = Tcl_NextHashEntry(&search)) { + (hPtr != NULL); hPtr = Tcl_NextHashEntry(&search)) { Command *cmdPtr = (Command *) Tcl_GetHashValue(hPtr); if (cmdPtr->deleteProc != DeleteImportedCmd) { continue; @@ -1755,7 +1738,9 @@ Tcl_ForgetImport(interp, namespacePtr, pattern) return TCL_OK; } - /* The pattern was namespace-qualified */ + /* + * The pattern was namespace-qualified. + */ for (hPtr = Tcl_FirstHashEntry(&nsPtr->cmdTable, &search); (hPtr != NULL); hPtr = Tcl_NextHashEntry(&search)) { @@ -1764,13 +1749,14 @@ Tcl_ForgetImport(interp, namespacePtr, pattern) Tcl_Command origin = TclGetOriginalCommand(token); if (Tcl_GetCommandInfoFromToken(origin, &info) == 0) { - continue; /* Not an imported command */ + continue; /* Not an imported command */ } if (info.namespacePtr != (Tcl_Namespace *) sourceNsPtr) { /* - * Original not in namespace we're matching. - * Check the first link in the import chain. + * Original not in namespace we're matching. Check the first link + * in the import chain. */ + Command *cmdPtr = (Command *) token; ImportedCmdData *dataPtr = (ImportedCmdData *) cmdPtr->objClientData; @@ -1798,15 +1784,15 @@ Tcl_ForgetImport(interp, namespacePtr, pattern) * * An imported command is created in an namespace when a "real" command * is imported from another namespace. If the specified command is an - * imported command, this procedure returns the original command it - * refers to. + * imported command, this function returns the original command it refers + * to. * * Results: * If the command was imported into a sequence of namespaces a, b,...,n * where each successive namespace just imports the command from the - * previous namespace, this procedure returns the Tcl_Command token in - * the first namespace, a. Otherwise, if the specified command is not - * an imported command, the procedure returns NULL. + * previous namespace, this function returns the Tcl_Command token in the + * first namespace, a. Otherwise, if the specified command is not an + * imported command, the function returns NULL. * * Side effects: * None. @@ -1816,8 +1802,8 @@ Tcl_ForgetImport(interp, namespacePtr, pattern) Tcl_Command TclGetOriginalCommand(command) - Tcl_Command command; /* The imported command for which the - * original command should be returned. */ + Tcl_Command command; /* The imported command for which the original + * command should be returned. */ { register Command *cmdPtr = (Command *) command; ImportedCmdData *dataPtr; @@ -1838,16 +1824,16 @@ TclGetOriginalCommand(command) * * InvokeImportedCmd -- * - * Invoked by Tcl whenever the user calls an imported command that - * was created by Tcl_Import. Finds the "real" command (in another + * Invoked by Tcl whenever the user calls an imported command that was + * created by Tcl_Import. Finds the "real" command (in another * namespace), and passes control to it. * * Results: - * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. + * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * Returns a result in the interpreter's result object. If anything - * goes wrong, the result object is set to an error message. + * Returns a result in the interpreter's result object. If anything goes + * wrong, the result object is set to an error message. * *---------------------------------------------------------------------- */ @@ -1873,11 +1859,11 @@ InvokeImportedCmd(clientData, interp, objc, objv) * DeleteImportedCmd -- * * Invoked by Tcl whenever an imported command is deleted. The "real" - * command keeps a list of all the imported commands that refer to it, - * so those imported commands can be deleted when the real command is - * deleted. This procedure removes the imported command reference from - * the real command's list, and frees up the memory associated with - * the imported command. + * command keeps a list of all the imported commands that refer to it, so + * those imported commands can be deleted when the real command is + * deleted. This function removes the imported command reference from the + * real command's list, and frees up the memory associated with the + * imported command. * * Results: * None. @@ -1928,70 +1914,70 @@ DeleteImportedCmd(clientData) * TclGetNamespaceForQualName -- * * Given a qualified name specifying a command, variable, or namespace, - * and a namespace in which to resolve the name, this procedure returns - * a pointer to the namespace that contains the item. A qualified name - * consists of the "simple" name of an item qualified by the names of - * an arbitrary number of containing namespace separated by "::"s. If - * the qualified name starts with "::", it is interpreted absolutely - * from the global namespace. Otherwise, it is interpreted relative to - * the namespace specified by cxtNsPtr if it is non-NULL. If cxtNsPtr - * is NULL, the name is interpreted relative to the current namespace. - * - * A relative name like "foo::bar::x" can be found starting in either - * the current namespace or in the global namespace. So each search - * usually follows two tracks, and two possible namespaces are - * returned. If the procedure sets either *nsPtrPtr or *altNsPtrPtr to - * NULL, then that path failed. + * and a namespace in which to resolve the name, this function returns a + * pointer to the namespace that contains the item. A qualified name + * consists of the "simple" name of an item qualified by the names of an + * arbitrary number of containing namespace separated by "::"s. If the + * qualified name starts with "::", it is interpreted absolutely from the + * global namespace. Otherwise, it is interpreted relative to the + * namespace specified by cxtNsPtr if it is non-NULL. If cxtNsPtr is + * NULL, the name is interpreted relative to the current namespace. + * + * A relative name like "foo::bar::x" can be found starting in either the + * current namespace or in the global namespace. So each search usually + * follows two tracks, and two possible namespaces are returned. If the + * function sets either *nsPtrPtr or *altNsPtrPtr to NULL, then that path + * failed. * * If "flags" contains TCL_GLOBAL_ONLY, the relative qualified name is - * sought only in the global :: namespace. The alternate search - * (also) starting from the global namespace is ignored and - * *altNsPtrPtr is set NULL. - * - * If "flags" contains TCL_NAMESPACE_ONLY, the relative qualified - * name is sought only in the namespace specified by cxtNsPtr. The - * alternate search starting from the global namespace is ignored and - * *altNsPtrPtr is set NULL. If both TCL_GLOBAL_ONLY and - * TCL_NAMESPACE_ONLY are specified, TCL_GLOBAL_ONLY is ignored and - * the search starts from the namespace specified by cxtNsPtr. - * - * If "flags" contains TCL_CREATE_NS_IF_UNKNOWN, all namespace - * components of the qualified name that cannot be found are - * automatically created within their specified parent. This makes sure - * that functions like Tcl_CreateCommand always succeed. There is no - * alternate search path, so *altNsPtrPtr is set NULL. - * - * If "flags" contains TCL_FIND_ONLY_NS, the qualified name is treated as a - * reference to a namespace, and the entire qualified name is - * followed. If the name is relative, the namespace is looked up only - * in the current namespace. A pointer to the namespace is stored in - * *nsPtrPtr and NULL is stored in *simpleNamePtr. Otherwise, if - * TCL_FIND_ONLY_NS is not specified, only the leading components are - * treated as namespace names, and a pointer to the simple name of the - * final component is stored in *simpleNamePtr. + * sought only in the global :: namespace. The alternate search (also) + * starting from the global namespace is ignored and *altNsPtrPtr is set + * NULL. + * + * If "flags" contains TCL_NAMESPACE_ONLY, the relative qualified name is + * sought only in the namespace specified by cxtNsPtr. The alternate + * search starting from the global namespace is ignored and *altNsPtrPtr + * is set NULL. If both TCL_GLOBAL_ONLY and TCL_NAMESPACE_ONLY are + * specified, TCL_GLOBAL_ONLY is ignored and the search starts from the + * namespace specified by cxtNsPtr. + * + * If "flags" contains TCL_CREATE_NS_IF_UNKNOWN, all namespace components + * of the qualified name that cannot be found are automatically created + * within their specified parent. This makes sure that functions like + * Tcl_CreateCommand always succeed. There is no alternate search path, + * so *altNsPtrPtr is set NULL. + * + * If "flags" contains TCL_FIND_ONLY_NS, the qualified name is treated as + * a reference to a namespace, and the entire qualified name is followed. + * If the name is relative, the namespace is looked up only in the + * current namespace. A pointer to the namespace is stored in *nsPtrPtr + * and NULL is stored in *simpleNamePtr. Otherwise, if TCL_FIND_ONLY_NS + * is not specified, only the leading components are treated as namespace + * names, and a pointer to the simple name of the final component is + * stored in *simpleNamePtr. * * Results: * It sets *nsPtrPtr and *altNsPtrPtr to point to the two possible * namespaces which represent the last (containing) namespace in the - * qualified name. If the procedure sets either *nsPtrPtr or *altNsPtrPtr - * to NULL, then the search along that path failed. The procedure also + * qualified name. If the function sets either *nsPtrPtr or *altNsPtrPtr + * to NULL, then the search along that path failed. The function also * stores a pointer to the simple name of the final component in * *simpleNamePtr. If the qualified name is "::" or was treated as a - * namespace reference (TCL_FIND_ONLY_NS), the procedure stores a pointer + * namespace reference (TCL_FIND_ONLY_NS), the function stores a pointer * to the namespace in *nsPtrPtr, NULL in *altNsPtrPtr, and sets * *simpleNamePtr to point to an empty string. * - * If there is an error, this procedure returns TCL_ERROR. If "flags" + * If there is an error, this function returns TCL_ERROR. If "flags" * contains TCL_LEAVE_ERR_MSG, an error message is returned in the * interpreter's result object. Otherwise, the interpreter's result * object is left unchanged. * - * *actualCxtPtrPtr is set to the actual context namespace. It is - * set to the input context namespace pointer in cxtNsPtr. If cxtNsPtr - * is NULL, it is set to the current namespace context. + * *actualCxtPtrPtr is set to the actual context namespace. It is set to + * the input context namespace pointer in cxtNsPtr. If cxtNsPtr is NULL, + * it is set to the current namespace context. * - * For backwards compatibility with the TclPro byte code loader, - * this function always returns TCL_OK. + * For backwards compatibility with the TclPro byte code loader, this + * function always returns TCL_OK. * * Side effects: * If "flags" contains TCL_CREATE_NS_IF_UNKNOWN, new namespaces may be @@ -2003,42 +1989,42 @@ DeleteImportedCmd(clientData) int TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags, nsPtrPtr, altNsPtrPtr, actualCxtPtrPtr, simpleNamePtr) - Tcl_Interp *interp; /* Interpreter in which to find the - * namespace containing qualName. */ - CONST char *qualName; /* A namespace-qualified name of an - * command, variable, or namespace. */ - Namespace *cxtNsPtr; /* The namespace in which to start the - * search for qualName's namespace. If NULL - * start from the current namespace. - * Ignored if TCL_GLOBAL_ONLY is set. */ + Tcl_Interp *interp; /* Interpreter in which to find the namespace + * containing qualName. */ + CONST char *qualName; /* A namespace-qualified name of an command, + * variable, or namespace. */ + Namespace *cxtNsPtr; /* The namespace in which to start the search + * for qualName's namespace. If NULL start + * from the current namespace. Ignored if + * TCL_GLOBAL_ONLY is set. */ int flags; /* Flags controlling the search: an OR'd * combination of TCL_GLOBAL_ONLY, * TCL_NAMESPACE_ONLY, * TCL_CREATE_NS_IF_UNKNOWN, and * TCL_FIND_ONLY_NS. */ - Namespace **nsPtrPtr; /* Address where procedure stores a pointer - * to containing namespace if qualName is - * found starting from *cxtNsPtr or, if + Namespace **nsPtrPtr; /* Address where function stores a pointer to + * containing namespace if qualName is found + * starting from *cxtNsPtr or, if * TCL_GLOBAL_ONLY is set, if qualName is - * found in the global :: namespace. NULL - * is stored otherwise. */ - Namespace **altNsPtrPtr; /* Address where procedure stores a pointer - * to containing namespace if qualName is - * found starting from the global :: - * namespace. NULL is stored if qualName - * isn't found starting from :: or if the + * found in the global :: namespace. NULL is + * stored otherwise. */ + Namespace **altNsPtrPtr; /* Address where function stores a pointer to + * containing namespace if qualName is found + * starting from the global :: namespace. + * NULL is stored if qualName isn't found + * starting from :: or if the * TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY, * TCL_CREATE_NS_IF_UNKNOWN, TCL_FIND_ONLY_NS * flag is set. */ - Namespace **actualCxtPtrPtr; /* Address where procedure stores a pointer - * to the actual namespace from which the - * search started. This is either cxtNsPtr, - * the :: namespace if TCL_GLOBAL_ONLY was + Namespace **actualCxtPtrPtr; /* Address where function stores a pointer to + * the actual namespace from which the search + * started. This is either cxtNsPtr, the :: + * namespace if TCL_GLOBAL_ONLY was * specified, or the current namespace if * cxtNsPtr was NULL. */ - CONST char **simpleNamePtr; /* Address where procedure stores the - * simple name at end of the qualName, or - * NULL if qualName is "::" or the flag + CONST char **simpleNamePtr; /* Address where function stores the simple + * name at end of the qualName, or NULL if + * qualName is "::" or the flag * TCL_FIND_ONLY_NS was specified. */ { Interp *iPtr = (Interp *) interp; @@ -2053,11 +2039,11 @@ TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags, /* * Determine the context namespace nsPtr in which to start the primary - * search. If the qualName name starts with a "::" or TCL_GLOBAL_ONLY - * was specified, search from the global namespace. Otherwise, use the + * search. If the qualName name starts with a "::" or TCL_GLOBAL_ONLY was + * specified, search from the global namespace. Otherwise, use the * namespace given in cxtNsPtr, or if that is NULL, use the current - * namespace context. Note that we always treat two or more - * adjacent ":"s as a namespace separator. + * namespace context. Note that we always treat two or more adjacent ":"s + * as a namespace separator. */ if (flags & TCL_GLOBAL_ONLY) { @@ -2108,10 +2094,10 @@ TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags, end = start; while (*start != '\0') { /* - * Find the next namespace qualifier (i.e., a name ending in "::") - * or the end of the qualified name (i.e., a name ending in "\0"). - * Set len to the number of characters, starting from start, - * in the name; set end to point after the "::"s or at the "\0". + * Find the next namespace qualifier (i.e., a name ending in "::") or + * the end of the qualified name (i.e., a name ending in "\0"). Set + * len to the number of characters, starting from start, in the name; + * set end to point after the "::"s or at the "\0". */ len = 0; @@ -2129,8 +2115,8 @@ TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags, if (*end=='\0' && !(end-start>=2 && *(end-1)==':' && *(end-2)==':')) { /* * qualName ended with a simple name at start. If TCL_FIND_ONLY_NS - * was specified, look this up as a namespace. Otherwise, - * start is the name of a cmd or var and we are done. + * was specified, look this up as a namespace. Otherwise, start is + * the name of a cmd or var and we are done. */ if (flags & TCL_FIND_ONLY_NS) { @@ -2146,9 +2132,9 @@ TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags, /* * start points to the beginning of a namespace qualifier ending * in "::". end points to the start of a name in that namespace - * that might be empty. Copy the namespace qualifier to a - * buffer so it can be null terminated. We can't modify the - * incoming qualName since it may be a string constant. + * that might be empty. Copy the namespace qualifier to a buffer + * so it can be null terminated. We can't modify the incoming + * qualName since it may be a string constant. */ Tcl_DStringSetLength(&buffer, 0); @@ -2159,8 +2145,8 @@ TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags, /* * Look up the namespace qualifier nsName in the current namespace * context. If it isn't found but TCL_CREATE_NS_IF_UNKNOWN is set, - * create that qualifying namespace. This is needed for procedures - * like Tcl_CreateCommand that cannot fail. + * create that qualifying namespace. This is needed for functions like + * Tcl_CreateCommand that cannot fail. */ if (nsPtr != NULL) { @@ -2225,10 +2211,10 @@ TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags, } /* - * As a special case, if we are looking for a namespace and qualName - * is "" and the current active namespace (nsPtr) is not the global - * namespace, return NULL (no namespace was found). This is because - * namespaces can not have empty names except for the global namespace. + * As a special case, if we are looking for a namespace and qualName is "" + * and the current active namespace (nsPtr) is not the global namespace, + * return NULL (no namespace was found). This is because namespaces can + * not have empty names except for the global namespace. */ if ((flags & TCL_FIND_ONLY_NS) && (*qualName == '\0') @@ -2250,9 +2236,9 @@ TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags, * Searches for a namespace. * * Results: - * Returns a pointer to the namespace if it is found. Otherwise, - * returns NULL and leaves an error message in the interpreter's - * result object if "flags" contains TCL_LEAVE_ERR_MSG. + * Returns a pointer to the namespace if it is found. Otherwise, returns + * NULL and leaves an error message in the interpreter's result object if + * "flags" contains TCL_LEAVE_ERR_MSG. * * Side effects: * None. @@ -2269,11 +2255,11 @@ Tcl_FindNamespace(interp, name, contextNsPtr, flags) * Else, looked up first in contextNsPtr * (current namespace if contextNsPtr is * NULL), then in global namespace. */ - Tcl_Namespace *contextNsPtr; /* Ignored if TCL_GLOBAL_ONLY flag is set - * or if the name starts with "::". - * Otherwise, points to namespace in which - * to resolve name; if NULL, look up name - * in the current namespace. */ + Tcl_Namespace *contextNsPtr; /* Ignored if TCL_GLOBAL_ONLY flag is set or + * if the name starts with "::". Otherwise, + * points to namespace in which to resolve + * name; if NULL, look up name in the current + * namespace. */ register int flags; /* Flags controlling namespace lookup: an * OR'd combination of TCL_GLOBAL_ONLY and * TCL_LEAVE_ERR_MSG flags. */ @@ -2282,9 +2268,9 @@ Tcl_FindNamespace(interp, name, contextNsPtr, flags) CONST char *dummy; /* - * Find the namespace(s) that contain the specified namespace name. - * Add the TCL_FIND_ONLY_NS flag to resolve the name all the way down - * to its last component, a namespace. + * Find the namespace(s) that contain the specified namespace name. Add + * the TCL_FIND_ONLY_NS flag to resolve the name all the way down to its + * last component, a namespace. */ TclGetNamespaceForQualName(interp, name, (Namespace *) contextNsPtr, @@ -2308,10 +2294,10 @@ Tcl_FindNamespace(interp, name, contextNsPtr, flags) * Searches for a command. * * Results: - * Returns a token for the command if it is found. Otherwise, if it - * can't be found or there is an error, returns NULL and leaves an - * error message in the interpreter's result object if "flags" - * contains TCL_LEAVE_ERR_MSG. + * Returns a token for the command if it is found. Otherwise, if it can't + * be found or there is an error, returns NULL and leaves an error + * message in the interpreter's result object if "flags" contains + * TCL_LEAVE_ERR_MSG. * * Side effects: * None. @@ -2329,18 +2315,17 @@ Tcl_FindCommand(interp, name, contextNsPtr, flags) * (current namespace if contextNsPtr is * NULL), then in global namespace. */ Tcl_Namespace *contextNsPtr; /* Ignored if TCL_GLOBAL_ONLY flag set. - * Otherwise, points to namespace in which - * to resolve name. If NULL, look up name - * in the current namespace. */ + * Otherwise, points to namespace in which to + * resolve name. If NULL, look up name in the + * current namespace. */ int flags; /* An OR'd combination of flags: * TCL_GLOBAL_ONLY (look up name only in * global namespace), TCL_NAMESPACE_ONLY * (look up only in contextNsPtr, or the * current namespace if contextNsPtr is * NULL), and TCL_LEAVE_ERR_MSG. If both - * TCL_GLOBAL_ONLY and TCL_NAMESPACE_ONLY - * are given, TCL_GLOBAL_ONLY is - * ignored. */ + * TCL_GLOBAL_ONLY and TCL_NAMESPACE_ONLY are + * given, TCL_GLOBAL_ONLY is ignored. */ { Interp *iPtr = (Interp*)interp; Namespace *cxtNsPtr; @@ -2350,12 +2335,13 @@ Tcl_FindCommand(interp, name, contextNsPtr, flags) int result; /* - * If this namespace has a command resolver, then give it first - * crack at the command resolution. If the interpreter has any - * command resolvers, consult them next. The command resolver - * procedures may return a Tcl_Command value, they may signal - * to continue onward, or they may signal an error. + * If this namespace has a command resolver, then give it first crack at + * the command resolution. If the interpreter has any command resolvers, + * consult them next. The command resolver functions may return a + * Tcl_Command value, they may signal to continue onward, or they may + * signal an error. */ + if (flags & TCL_GLOBAL_ONLY) { cxtNsPtr = (Namespace *) Tcl_GetGlobalNamespace(interp); } else if (contextNsPtr != NULL) { @@ -2430,8 +2416,8 @@ Tcl_FindCommand(interp, name, contextNsPtr, flags) } /* - * If we've still not found the command, look in the global - * namespace as a last resort. + * If we've still not found the command, look in the global namespace + * as a last resort. */ if (cmdPtr == NULL) { @@ -2453,9 +2439,9 @@ Tcl_FindCommand(interp, name, contextNsPtr, flags) flags, &nsPtr[0], &nsPtr[1], &cxtNsPtr, &simpleName); /* - * Look for the command in the command table of its namespace. - * Be sure to check both possible search paths: from the - * specified namespace context and from the global namespace. + * Look for the command in the command table of its namespace. Be sure + * to check both possible search paths: from the specified namespace + * context and from the global namespace. */ for (search = 0; (search < 2) && (cmdPtr == NULL); search++) { @@ -2487,14 +2473,14 @@ Tcl_FindCommand(interp, name, contextNsPtr, flags) * Tcl_FindNamespaceVar -- * * Searches for a namespace variable, a variable not local to a - * procedure. The variable can be either a scalar or an array, but - * may not be an element of an array. + * procedure. The variable can be either a scalar or an array, but may + * not be an element of an array. * * Results: * Returns a token for the variable if it is found. Otherwise, if it - * can't be found or there is an error, returns NULL and leaves an - * error message in the interpreter's result object if "flags" - * contains TCL_LEAVE_ERR_MSG. + * can't be found or there is an error, returns NULL and leaves an error + * message in the interpreter's result object if "flags" contains + * TCL_LEAVE_ERR_MSG. * * Side effects: * None. @@ -2512,18 +2498,17 @@ Tcl_FindNamespaceVar(interp, name, contextNsPtr, flags) * (current namespace if contextNsPtr is * NULL), then in global namespace. */ Tcl_Namespace *contextNsPtr; /* Ignored if TCL_GLOBAL_ONLY flag set. - * Otherwise, points to namespace in which - * to resolve name. If NULL, look up name - * in the current namespace. */ + * Otherwise, points to namespace in which to + * resolve name. If NULL, look up name in the + * current namespace. */ int flags; /* An OR'd combination of flags: * TCL_GLOBAL_ONLY (look up name only in * global namespace), TCL_NAMESPACE_ONLY * (look up only in contextNsPtr, or the * current namespace if contextNsPtr is * NULL), and TCL_LEAVE_ERR_MSG. If both - * TCL_GLOBAL_ONLY and TCL_NAMESPACE_ONLY - * are given, TCL_GLOBAL_ONLY is - * ignored. */ + * TCL_GLOBAL_ONLY and TCL_NAMESPACE_ONLY are + * given, TCL_GLOBAL_ONLY is ignored. */ { Interp *iPtr = (Interp*)interp; ResolverScheme *resPtr; @@ -2536,11 +2521,11 @@ Tcl_FindNamespaceVar(interp, name, contextNsPtr, flags) Tcl_Var var; /* - * If this namespace has a variable resolver, then give it first - * crack at the variable resolution. It may return a Tcl_Var - * value, it may signal to continue onward, or it may signal - * an error. + * If this namespace has a variable resolver, then give it first crack at + * the variable resolution. It may return a Tcl_Var value, it may signal + * to continue onward, or it may signal an error. */ + if ((flags & TCL_GLOBAL_ONLY) != 0) { cxtNsPtr = (Namespace *) Tcl_GetGlobalNamespace(interp); } else if (contextNsPtr != NULL) { @@ -2582,9 +2567,9 @@ Tcl_FindNamespaceVar(interp, name, contextNsPtr, flags) flags, &nsPtr[0], &nsPtr[1], &cxtNsPtr, &simpleName); /* - * Look for the variable in the variable table of its namespace. - * Be sure to check both possible search paths: from the specified - * namespace context and from the global namespace. + * Look for the variable in the variable table of its namespace. Be sure + * to check both possible search paths: from the specified namespace + * context and from the global namespace. */ varPtr = NULL; @@ -2615,25 +2600,25 @@ Tcl_FindNamespaceVar(interp, name, contextNsPtr, flags) * command references that the new command may invalidate. Consider the * following cases that could happen when you add a command "foo" to a * namespace "b": - * 1. It could shadow a command named "foo" at the global scope. - * If it does, all command references in the namespace "b" are + * 1. It could shadow a command named "foo" at the global scope. If + * it does, all command references in the namespace "b" are * suspect. - * 2. Suppose the namespace "b" resides in a namespace "a". - * Then to "a" the new command "b::foo" could shadow another - * command "b::foo" in the global namespace. If so, then all - * command references in "a" are suspect. - * The same checks are applied to all parent namespaces, until we - * reach the global :: namespace. + * 2. Suppose the namespace "b" resides in a namespace "a". Then to + * "a" the new command "b::foo" could shadow another command + * "b::foo" in the global namespace. If so, then all command + * references in "a" * are suspect. + * The same checks are applied to all parent namespaces, until we reach + * the global :: namespace. * * Results: * None. * * Side effects: * If the new command shadows an existing command, the cmdRefEpoch - * counter is incremented in each namespace that sees the shadow. - * This invalidates all command references that were previously cached - * in that namespace. The next time the commands are used, they are - * resolved from scratch. + * counter is incremented in each namespace that sees the shadow. This + * invalidates all command references that were previously cached in that + * namespace. The next time the commands are used, they are resolved from + * scratch. * *---------------------------------------------------------------------- */ @@ -2651,7 +2636,7 @@ TclResetShadowedCmdRefs(interp, newCmdPtr) int found, i; /* - * This procedure generates an array used to hold the trail list. This + * This function generates an array used to hold the trail list. This * starts out with stack-allocated space but uses dynamically-allocated * storage if needed. */ @@ -2662,9 +2647,9 @@ TclResetShadowedCmdRefs(interp, newCmdPtr) int trailSize = NUM_TRAIL_ELEMS; /* - * Start at the namespace containing the new command, and work up - * through the list of parents. Stop just before the global namespace, - * since the global namespace can't "shadow" its own entries. + * Start at the namespace containing the new command, and work up through + * the list of parents. Stop just before the global namespace, since the + * global namespace can't "shadow" its own entries. * * The namespace "trail" list we build consists of the names of each * namespace that encloses the new command, in order from outermost to @@ -2672,23 +2657,22 @@ TclResetShadowedCmdRefs(interp, newCmdPtr) * eventually extends the trail upwards by one namespace, nsPtr. We use * this trail list to see if nsPtr (e.g. "a" in 2. above) could have * now-invalid cached command references. This will happen if nsPtr - * (e.g. "a") contains a sequence of child namespaces (e.g. "b") - * such that there is a identically-named sequence of child namespaces - * starting from :: (e.g. "::b") whose tail namespace contains a command - * also named cmdName. + * (e.g. "a") contains a sequence of child namespaces (e.g. "b") such that + * there is a identically-named sequence of child namespaces starting from + * :: (e.g. "::b") whose tail namespace contains a command also named + * cmdName. */ cmdName = Tcl_GetHashKey(newCmdPtr->hPtr->tablePtr, newCmdPtr->hPtr); - for (nsPtr = newCmdPtr->nsPtr; - (nsPtr != NULL) && (nsPtr != globalNsPtr); - nsPtr = nsPtr->parentPtr) { + for (nsPtr=newCmdPtr->nsPtr ; (nsPtr!=NULL) && (nsPtr!=globalNsPtr) ; + nsPtr=nsPtr->parentPtr) { /* * Find the maximal sequence of child namespaces contained in nsPtr - * such that there is a identically-named sequence of child - * namespaces starting from ::. shadowNsPtr will be the tail of this - * sequence, or the deepest namespace under :: that might contain a - * command now shadowed by cmdName. We check below if shadowNsPtr - * actually contains a command cmdName. + * such that there is a identically-named sequence of child namespaces + * starting from ::. shadowNsPtr will be the tail of this sequence, or + * the deepest namespace under :: that might contain a command now + * shadowed by cmdName. We check below if shadowNsPtr actually + * contains a command cmdName. */ found = 1; @@ -2707,8 +2691,8 @@ TclResetShadowedCmdRefs(interp, newCmdPtr) } /* - * If shadowNsPtr contains a command named cmdName, we invalidate - * all of the command refs cached in nsPtr. As a boundary case, + * If shadowNsPtr contains a command named cmdName, we invalidate all + * of the command refs cached in nsPtr. As a boundary case, * shadowNsPtr is initially :: and we check for case 1. above. */ @@ -2718,7 +2702,7 @@ TclResetShadowedCmdRefs(interp, newCmdPtr) nsPtr->cmdRefEpoch++; TclInvalidateNsPath(nsPtr); - /* + /* * If the shadowed command was compiled to bytecodes, we * invalidate all the bytecodes in nsPtr, to force a new * compilation. We use the resolverEpoch to signal the need @@ -2732,8 +2716,8 @@ TclResetShadowedCmdRefs(interp, newCmdPtr) } /* - * Insert nsPtr at the front of the trail list: i.e., at the end - * of the trailPtr array. + * Insert nsPtr at the front of the trail list: i.e., at the end of + * the trailPtr array. */ trailFront++; @@ -2741,8 +2725,7 @@ TclResetShadowedCmdRefs(interp, newCmdPtr) size_t currBytes = trailSize * sizeof(Namespace *); int newSize = 2*trailSize; size_t newBytes = newSize * sizeof(Namespace *); - Namespace **newPtr = - (Namespace **) ckalloc((unsigned) newBytes); + Namespace **newPtr = (Namespace **) ckalloc((unsigned) newBytes); memcpy((VOID *) newPtr, (VOID *) trailPtr, currBytes); if (trailPtr != trailStorage) { @@ -2771,19 +2754,19 @@ TclResetShadowedCmdRefs(interp, newCmdPtr) * Gets the namespace specified by the name in a Tcl_Obj. * * Results: - * Returns TCL_OK if the namespace was resolved successfully, and - * stores a pointer to the namespace in the location specified by - * nsPtrPtr. If the namespace can't be found, the procedure stores - * NULL in *nsPtrPtr and returns TCL_OK. If anything else goes wrong, - * this procedure returns TCL_ERROR. + * Returns TCL_OK if the namespace was resolved successfully, and stores + * a pointer to the namespace in the location specified by nsPtrPtr. If + * the namespace can't be found, the function stores NULL in *nsPtrPtr + * and returns TCL_OK. If anything else goes wrong, this function returns + * TCL_ERROR. * * Side effects: * May update the internal representation for the object, caching the - * namespace reference. The next time this procedure is called, the + * namespace reference. The next time this function is called, the * namespace value can be found quickly. * - * If anything goes wrong, an error message is left in the - * interpreter's result object. + * If anything goes wrong, an error message is left in the interpreter's + * result object. * *---------------------------------------------------------------------- */ @@ -2791,8 +2774,8 @@ TclResetShadowedCmdRefs(interp, newCmdPtr) int TclGetNamespaceFromObj(interp, objPtr, nsPtrPtr) Tcl_Interp *interp; /* The current interpreter. */ - Tcl_Obj *objPtr; /* The object to be resolved as the name - * of a namespace. */ + Tcl_Obj *objPtr; /* The object to be resolved as the name of a + * namespace. */ Tcl_Namespace **nsPtrPtr; /* Result namespace pointer goes here. */ { Interp *iPtr = (Interp *) interp; @@ -2804,9 +2787,9 @@ TclGetNamespaceFromObj(interp, objPtr, nsPtrPtr) char *name; /* - * If the namespace name is fully qualified, do as if the lookup were - * done from the global namespace; this helps avoid repeated lookups - * of fully qualified names. + * If the namespace name is fully qualified, do as if the lookup were done + * from the global namespace; this helps avoid repeated lookups of fully + * qualified names. */ savedFramePtr = iPtr->varFramePtr; @@ -2819,8 +2802,8 @@ TclGetNamespaceFromObj(interp, objPtr, nsPtrPtr) /* * Get the internal representation, converting to a namespace type if - * needed. The internal representation is a ResolvedNsName that points - * to the actual namespace. + * needed. The internal representation is a ResolvedNsName that points to + * the actual namespace. */ if (objPtr->typePtr != &tclNsNameType) { @@ -2832,17 +2815,16 @@ TclGetNamespaceFromObj(interp, objPtr, nsPtrPtr) resNamePtr = (ResolvedNsName *) objPtr->internalRep.otherValuePtr; /* - * Check the context namespace of the resolved symbol to make sure that - * it is fresh. If not, then force another conversion to the namespace - * type, to discard the old rep and create a new one. Note that we - * verify that the namespace id of the cached namespace is the same as - * the id when we cached it; this insures that the namespace wasn't - * deleted and a new one created at the same address. + * Check the context namespace of the resolved symbol to make sure that it + * is fresh. If not, then force another conversion to the namespace type, + * to discard the old rep and create a new one. Note that we verify that + * the namespace id of the cached namespace is the same as the id when we + * cached it; this insures that the namespace wasn't deleted and a new one + * created at the same address. */ nsPtr = NULL; - if ((resNamePtr != NULL) - && (resNamePtr->refNsPtr == currNsPtr) + if ((resNamePtr != NULL) && (resNamePtr->refNsPtr == currNsPtr) && (resNamePtr->nsId == resNamePtr->nsPtr->nsId)) { nsPtr = resNamePtr->nsPtr; if (nsPtr->flags & NS_DEAD) { @@ -2874,8 +2856,8 @@ TclGetNamespaceFromObj(interp, objPtr, nsPtrPtr) * * Tcl_NamespaceObjCmd -- * - * Invoked to implement the "namespace" command that creates, deletes, - * or manipulates Tcl namespaces. Handles the following syntax: + * Invoked to implement the "namespace" command that creates, deletes, or + * manipulates Tcl namespaces. Handles the following syntax: * * namespace children ?name? ?pattern? * namespace code arg @@ -2899,13 +2881,12 @@ TclGetNamespaceFromObj(interp, objPtr, nsPtrPtr) * anything goes wrong. * * Side effects: - * Based on the subcommand name (e.g., "import"), this procedure - * dispatches to a corresponding procedure NamespaceXXXCmd defined - * statically in this file. This procedure's side effects depend on - * whatever that subcommand procedure does. If there is an error, this - * procedure returns an error message in the interpreter's result - * object. Otherwise it may return a result in the interpreter's result - * object. + * Based on the subcommand name (e.g., "import"), this function + * dispatches to a corresponding function NamespaceXXXCmd defined + * statically in this file. This function's side effects depend on + * whatever that subcommand function does. If there is an error, this + * function returns an error message in the interpreter's result object. + * Otherwise it may return a result in the interpreter's result object. * *---------------------------------------------------------------------- */ @@ -3008,8 +2989,8 @@ Tcl_NamespaceObjCmd(clientData, interp, objc, objv) * NamespaceChildrenCmd -- * * Invoked to implement the "namespace children" command that returns a - * list containing the fully-qualified names of the child namespaces of - * a given namespace. Handles the following syntax: + * list containing the fully-qualified names of the child namespaces of a + * given namespace. Handles the following syntax: * * namespace children ?name? ?pattern? * @@ -3017,8 +2998,8 @@ Tcl_NamespaceObjCmd(clientData, interp, objc, objv) * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * Returns a result in the interpreter's result object. If anything - * goes wrong, the result is an error message. + * Returns a result in the interpreter's result object. If anything goes + * wrong, the result is an error message. * *---------------------------------------------------------------------- */ @@ -3082,8 +3063,8 @@ NamespaceChildrenCmd(dummy, interp, objc, objv) } /* - * Create a list containing the full names of all child namespaces - * whose names match the specified pattern, if any. + * Create a list containing the full names of all child namespaces whose + * names match the specified pattern, if any. */ listPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); @@ -3105,7 +3086,7 @@ NamespaceChildrenCmd(dummy, interp, objc, objv) entryPtr = Tcl_NextHashEntry(&search); } -searchDone: + searchDone: Tcl_SetObjResult(interp, listPtr); Tcl_DStringFree(&buffer); return TCL_OK; @@ -3126,15 +3107,15 @@ searchDone: * * list ::namespace inscope [namespace current] $arg * - * However, if "arg" is itself a scoped value starting with - * "::namespace inscope", then the result is just "arg". + * However, if "arg" is itself a scoped value starting with "::namespace + * inscope", then the result is just "arg". * * Results: * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * If anything goes wrong, this procedure returns an error - * message as the result in the interpreter's result object. + * If anything goes wrong, this function returns an error message as the + * result in the interpreter's result object. * *---------------------------------------------------------------------- */ @@ -3177,10 +3158,10 @@ NamespaceCodeCmd(dummy, interp, objc, objv) /* * Otherwise, construct a scoped command by building a list with - * "namespace inscope", the full name of the current namespace, and - * the argument "arg". By constructing a list, we ensure that scoped - * commands are interpreted properly when they are executed later, - * by the "namespace inscope" command. + * "namespace inscope", the full name of the current namespace, and the + * argument "arg". By constructing a list, we ensure that scoped commands + * are interpreted properly when they are executed later, by the + * "namespace inscope" command. */ listPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); @@ -3208,9 +3189,9 @@ NamespaceCodeCmd(dummy, interp, objc, objv) * * NamespaceCurrentCmd -- * - * Invoked to implement the "namespace current" command which returns - * the fully-qualified name of the current namespace. Handles the - * following syntax: + * Invoked to implement the "namespace current" command which returns the + * fully-qualified name of the current namespace. Handles the following + * syntax: * * namespace current * @@ -3218,8 +3199,8 @@ NamespaceCodeCmd(dummy, interp, objc, objv) * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * Returns a result in the interpreter's result object. If anything - * goes wrong, the result is an error message. + * Returns a result in the interpreter's result object. If anything goes + * wrong, the result is an error message. * *---------------------------------------------------------------------- */ @@ -3239,10 +3220,10 @@ NamespaceCurrentCmd(dummy, interp, objc, objv) } /* - * The "real" name of the global namespace ("::") is the null string, - * but we return "::" for it as a convenience to programmers. Note that - * "" and "::" are treated as synonyms by the namespace code so that it - * is still easy to do things like: + * The "real" name of the global namespace ("::") is the null string, but + * we return "::" for it as a convenience to programmers. Note that "" and + * "::" are treated as synonyms by the namespace code so that it is still + * easy to do things like: * * namespace [namespace current]::bar { ... } */ @@ -3269,12 +3250,12 @@ NamespaceCurrentCmd(dummy, interp, objc, objv) * Each name identifies a namespace. It may include a sequence of * namespace qualifiers separated by "::"s. If a namespace is found, it * is deleted: all variables and procedures contained in that namespace - * are deleted. If that namespace is being used on the call stack, it - * is kept alive (but logically deleted) until it is removed from the - * call stack: that is, it can no longer be referenced by name but any + * are deleted. If that namespace is being used on the call stack, it is + * kept alive (but logically deleted) until it is removed from the call + * stack: that is, it can no longer be referenced by name but any * currently executing procedure that refers to it is allowed to do so * until the procedure returns. If the namespace can't be found, this - * procedure returns an error. If no namespaces are specified, this + * function returns an error. If no namespaces are specified, this * command does nothing. * * Results: @@ -3282,8 +3263,7 @@ NamespaceCurrentCmd(dummy, interp, objc, objv) * * Side effects: * Deletes the specified namespaces. If anything goes wrong, this - * procedure returns an error message in the interpreter's - * result object. + * function returns an error message in the interpreter's result object. * *---------------------------------------------------------------------- */ @@ -3305,9 +3285,9 @@ NamespaceDeleteCmd(dummy, interp, objc, objv) } /* - * Destroying one namespace may cause another to be destroyed. Break - * this into two passes: first check to make sure that all namespaces on - * the command line are valid, and report any errors. + * Destroying one namespace may cause another to be destroyed. Break this + * into two passes: first check to make sure that all namespaces on the + * command line are valid, and report any errors. */ for (i = 2; i < objc; i++) { @@ -3342,24 +3322,24 @@ NamespaceDeleteCmd(dummy, interp, objc, objv) * * NamespaceEvalCmd -- * - * Invoked to implement the "namespace eval" command. Executes - * commands in a namespace. If the namespace does not already exist, - * it is created. Handles the following syntax: + * Invoked to implement the "namespace eval" command. Executes commands + * in a namespace. If the namespace does not already exist, it is + * created. Handles the following syntax: * * namespace eval name arg ?arg...? * * If more than one arg argument is specified, the command that is - * executed is the result of concatenating the arguments together with - * a space between each argument. + * executed is the result of concatenating the arguments together with a + * space between each argument. * * Results: - * Returns TCL_OK if the namespace is found and the commands are - * executed successfully. Returns TCL_ERROR if anything goes wrong. + * Returns TCL_OK if the namespace is found and the commands are executed + * successfully. Returns TCL_ERROR if anything goes wrong. * * Side effects: - * Returns the result of the command in the interpreter's result - * object. If anything goes wrong, this procedure returns an error - * message as the result. + * Returns the result of the command in the interpreter's result object. + * If anything goes wrong, this function returns an error message as the + * result. * *---------------------------------------------------------------------- */ @@ -3397,7 +3377,7 @@ NamespaceEvalCmd(dummy, interp, objc, objv) if (namespacePtr == NULL) { char *name = TclGetString(objv[2]); - namespacePtr = Tcl_CreateNamespace(interp, name, (ClientData) NULL, + namespacePtr = Tcl_CreateNamespace(interp, name, (ClientData) NULL, (Tcl_NamespaceDeleteProc *) NULL); if (namespacePtr == NULL) { return TCL_ERROR; @@ -3411,7 +3391,7 @@ NamespaceEvalCmd(dummy, interp, objc, objv) /* This is needed to satisfy GCC 3.3's strict aliasing rules */ framePtrPtr = &framePtr; - result = TclPushStackFrame(interp, (Tcl_CallFrame **) framePtrPtr, + result = TclPushStackFrame(interp, (Tcl_CallFrame **) framePtrPtr, namespacePtr, /*isProcCallFrame*/ 0); if (result != TCL_OK) { return TCL_ERROR; @@ -3424,9 +3404,10 @@ NamespaceEvalCmd(dummy, interp, objc, objv) } else { /* * More than one argument: concatenate them together with spaces - * between, then evaluate the result. Tcl_EvalObjEx will delete - * the object when it decrements its refcount after eval'ing it. + * between, then evaluate the result. Tcl_EvalObjEx will delete the + * object when it decrements its refcount after eval'ing it. */ + objPtr = Tcl_ConcatObj(objc-3, objv+3); result = Tcl_EvalObjEx(interp, objPtr, TCL_EVAL_DIRECT); } @@ -3458,7 +3439,7 @@ NamespaceEvalCmd(dummy, interp, objc, objv) * * NamespaceExistsCmd -- * - * Invoked to implement the "namespace exists" command that returns + * Invoked to implement the "namespace exists" command that returns * true if the given namespace currently exists, and false otherwise. * Handles the following syntax: * @@ -3507,18 +3488,18 @@ NamespaceExistsCmd(dummy, interp, objc, objv) * * Invoked to implement the "namespace export" command that specifies * which commands are exported from a namespace. The exported commands - * are those that can be imported into another namespace using - * "namespace import". Both commands defined in a namespace and - * commands the namespace has imported can be exported by a - * namespace. This command has the following syntax: + * are those that can be imported into another namespace using "namespace + * import". Both commands defined in a namespace and commands the + * namespace has imported can be exported by a namespace. This command + * has the following syntax: * * namespace export ?-clear? ?pattern pattern...? * - * Each pattern may contain "string match"-style pattern matching - * special characters, but the pattern may not include any namespace - * qualifiers: that is, the pattern must specify commands in the - * current (exporting) namespace. The specified patterns are appended - * onto the namespace's list of export patterns. + * Each pattern may contain "string match"-style pattern matching special + * characters, but the pattern may not include any namespace qualifiers: + * that is, the pattern must specify commands in the current (exporting) + * namespace. The specified patterns are appended onto the namespace's + * list of export patterns. * * To reset the namespace's export pattern list, specify the "-clear" * flag. @@ -3530,8 +3511,8 @@ NamespaceExistsCmd(dummy, interp, objc, objv) * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * Returns a result in the interpreter's result object. If anything - * goes wrong, the result is an error message. + * Returns a result in the interpreter's result object. If anything goes + * wrong, the result is an error message. * *---------------------------------------------------------------------- */ @@ -3567,8 +3548,8 @@ NamespaceExportCmd(dummy, interp, objc, objv) } /* - * If no pattern arguments are given, and "-clear" isn't specified, - * return the namespace's current export pattern list. + * If no pattern arguments are given, and "-clear" isn't specified, return + * the namespace's current export pattern list. */ patternCt = (objc - firstArg); @@ -3607,26 +3588,26 @@ NamespaceExportCmd(dummy, interp, objc, objv) * * NamespaceForgetCmd -- * - * Invoked to implement the "namespace forget" command to remove - * imported commands from a namespace. Handles the following syntax: + * Invoked to implement the "namespace forget" command to remove imported + * commands from a namespace. Handles the following syntax: * * namespace forget ?pattern pattern...? * * Each pattern is a name like "foo::*" or "a::b::x*". That is, the - * pattern may include the special pattern matching characters - * recognized by the "string match" command, but only in the command - * name at the end of the qualified name; the special pattern - * characters may not appear in a namespace name. All of the commands - * that match that pattern are checked to see if they have an imported - * command in the current namespace that refers to the matched - * command. If there is an alias, it is removed. - * + * pattern may include the special pattern matching characters recognized + * by the "string match" command, but only in the command name at the end + * of the qualified name; the special pattern characters may not appear + * in a namespace name. All of the commands that match that pattern are + * checked to see if they have an imported command in the current + * namespace that refers to the matched command. If there is an alias, it + * is removed. + * * Results: * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * Imported commands are removed from the current namespace. If - * anything goes wrong, this procedure returns an error message in the + * Imported commands are removed from the current namespace. If anything + * goes wrong, this function returns an error message in the * interpreter's result object. * *---------------------------------------------------------------------- @@ -3667,28 +3648,27 @@ NamespaceForgetCmd(dummy, interp, objc, objv) * * namespace import ?-force? ?pattern pattern...? * - * Each pattern is a namespace-qualified name like "foo::*", - * "a::b::x*", or "bar::p". That is, the pattern may include the - * special pattern matching characters recognized by the "string match" - * command, but only in the command name at the end of the qualified - * name; the special pattern characters may not appear in a namespace - * name. All of the commands that match the pattern and which are - * exported from their namespace are made accessible from the current - * namespace context. This is done by creating a new "imported command" - * in the current namespace that points to the real command in its - * original namespace; when the imported command is called, it invokes - * the real command. + * Each pattern is a namespace-qualified name like "foo::*", "a::b::x*", + * or "bar::p". That is, the pattern may include the special pattern + * matching characters recognized by the "string match" command, but only + * in the command name at the end of the qualified name; the special + * pattern characters may not appear in a namespace name. All of the + * commands that match the pattern and which are exported from their + * namespace are made accessible from the current namespace context. This + * is done by creating a new "imported command" in the current namespace + * that points to the real command in its original namespace; when the + * imported command is called, it invokes the real command. * * If an imported command conflicts with an existing command, it is * treated as an error. But if the "-force" option is included, then * existing commands are overwritten by the imported commands. - * + * * Results: * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: * Adds imported commands to the current namespace. If anything goes - * wrong, this procedure returns an error message in the interpreter's + * wrong, this function returns an error message in the interpreter's * result object. * *---------------------------------------------------------------------- @@ -3746,17 +3726,17 @@ NamespaceImportCmd(dummy, interp, objc, objv) * * Invoked to implement the "namespace inscope" command that executes a * script in the context of a particular namespace. This command is not - * expected to be used directly by programmers; calls to it are - * generated implicitly when programs use "namespace code" commands - * to register callback scripts. Handles the following syntax: + * expected to be used directly by programmers; calls to it are generated + * implicitly when programs use "namespace code" commands to register + * callback scripts. Handles the following syntax: * * namespace inscope name arg ?arg...? * * The "namespace inscope" command is much like the "namespace eval" * command except that it has lappend semantics and the namespace must - * already exist. It treats the first argument as a list, and appends - * any arguments after the first onto the end as proper list elements. - * For example, + * already exist. It treats the first argument as a list, and appends any + * arguments after the first onto the end as proper list elements. For + * example, * * namespace inscope ::foo a b c d * @@ -3764,12 +3744,11 @@ NamespaceImportCmd(dummy, interp, objc, objv) * * namespace eval ::foo [concat a [list b c d]] * - * This lappend semantics is important because many callback scripts - * are actually prefixes. + * This lappend semantics is important because many callback scripts are + * actually prefixes. * * Results: - * Returns TCL_OK to indicate success, or TCL_ERROR to indicate - * failure. + * Returns TCL_OK to indicate success, or TCL_ERROR to indicate failure. * * Side effects: * Returns a result in the Tcl interpreter's result object. @@ -3818,8 +3797,8 @@ NamespaceInscopeCmd(dummy, interp, objc, objv) } /* - * Execute the command. If there is just one argument, just treat it as - * a script and evaluate it. Otherwise, create a list from the arguments + * Execute the command. If there is just one argument, just treat it as a + * script and evaluate it. Otherwise, create a list from the arguments * after the first one, then concatenate the first argument and the list * of extra arguments to form the command to evaluate. */ @@ -3849,6 +3828,7 @@ NamespaceInscopeCmd(dummy, interp, objc, objv) if (result == TCL_ERROR) { Tcl_Obj *errorLine = Tcl_NewIntObj(interp->errorLine); Tcl_Obj *msg = Tcl_NewStringObj("\n (in namespace inscope \"", -1); + Tcl_IncrRefCount(errorLine); Tcl_IncrRefCount(msg); TclAppendLimitedToObj(msg, namespacePtr->fullName, -1, 200, ""); @@ -3887,12 +3867,12 @@ NamespaceInscopeCmd(dummy, interp, objc, objv) * command returns the fully-qualified name of the original command in * the first namespace, a. If "name" does not refer to an alias, its * fully-qualified name is returned. The returned name is stored in the - * interpreter's result object. This procedure returns TCL_OK if + * interpreter's result object. This function returns TCL_OK if * successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * If anything goes wrong, this procedure returns an error message in - * the interpreter's result object. + * If anything goes wrong, this function returns an error message in the + * interpreter's result object. * *---------------------------------------------------------------------- */ @@ -3923,8 +3903,8 @@ NamespaceOriginCmd(dummy, interp, objc, objv) if (origCommand == (Tcl_Command) NULL) { /* * The specified command isn't an imported command. Return the - * command's name qualified by the full name of the namespace it - * was defined in. + * command's name qualified by the full name of the namespace it was + * defined in. */ Tcl_GetCommandFullName(interp, command, resultPtr); @@ -3950,8 +3930,8 @@ NamespaceOriginCmd(dummy, interp, objc, objv) * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * Returns a result in the interpreter's result object. If anything - * goes wrong, the result is an error message. + * Returns a result in the interpreter's result object. If anything goes + * wrong, the result is an error message. * *---------------------------------------------------------------------- */ @@ -4000,24 +3980,24 @@ NamespaceParentCmd(dummy, interp, objc, objv) * * NamespacePathCmd -- * - * Invoked to implement the "namespace path" command that reads - * and writes the current namespace's command resolution path. - * Has one optional argument: if present, it is a list of named - * namespaces to set the path to, and if absent, the current path - * should be returned. Handles the following syntax: + * Invoked to implement the "namespace path" command that reads and + * writes the current namespace's command resolution path. Has one + * optional argument: if present, it is a list of named namespaces to set + * the path to, and if absent, the current path should be returned. + * Handles the following syntax: * * namespace path ?nsList? * * Results: - * Returns TCL_OK if successful, and TCL_ERROR if anything goes - * wrong (most notably if the namespace list contains the name of - * something other than a namespace). In the successful-exit - * case, may set the interpreter result to the list of names of - * the namespaces on the current namespace's path. + * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong + * (most notably if the namespace list contains the name of something + * other than a namespace). In the successful-exit case, may set the + * interpreter result to the list of names of the namespaces on the + * current namespace's path. * * Side effects: - * May update the namespace path (triggering a recomputing of all - * command names that depend on the namespace for resolution). + * May update the namespace path (triggering a recomputing of all command + * names that depend on the namespace for resolution). * *---------------------------------------------------------------------- */ @@ -4048,6 +4028,7 @@ NamespacePathCmd(dummy, interp, objc, objv) /* * Not a very fast way to compute this, but easy to get right. */ + for (i=0 ; i<nsPtr->commandPathLength ; i++) { if (nsPtr->commandPathArray[i].nsPtr != NULL) { Tcl_AppendElement(interp, @@ -4058,8 +4039,7 @@ NamespacePathCmd(dummy, interp, objc, objv) } /* - * There is a path given, so parse it into an array of namespace - * pointers. + * There is a path given, so parse it into an array of namespace pointers. */ if (Tcl_ListObjGetElements(interp, objv[2], &nsObjc, &nsObjv) != TCL_OK) { @@ -4087,8 +4067,7 @@ NamespacePathCmd(dummy, interp, objc, objv) } /* - * Now we have the list of valid namespaces, install it as the - * path. + * Now we have the list of valid namespaces, install it as the path. */ SetNsPath(nsPtr, nsObjc, namespaceList); @@ -4106,10 +4085,10 @@ NamespacePathCmd(dummy, interp, objc, objv) * * SetNsPath -- * - * Sets the namespace command name resolution path to the given - * list of namespaces. If the list is empty (of zero length) the - * path is set to empty and the default old-style behaviour of - * command name resolution is used. + * Sets the namespace command name resolution path to the given list of + * namespaces. If the list is empty (of zero length) the path is set to + * empty and the default old-style behaviour of command name resolution + * is used. * * Results: * nothing @@ -4165,16 +4144,16 @@ SetNsPath(nsPtr, pathLength, pathAry) * * UnlinkNsPath -- * - * Delete the given namespace's command name resolution path. Only - * call if the path is non-empty. Caller must reset the counter - * containing the path size. + * Delete the given namespace's command name resolution path. Only call + * if the path is non-empty. Caller must reset the counter containing the + * path size. * * Results: * nothing * * Side effects: - * Deletes the array of path entries and unlinks those path entries - * from the target namespace's list of interested namespaces. + * Deletes the array of path entries and unlinks those path entries from + * the target namespace's list of interested namespaces. * *---------------------------------------------------------------------- */ @@ -4206,17 +4185,17 @@ UnlinkNsPath(nsPtr) * * TclInvalidateNsPath -- * - * Invalidate the name resolution caches for all names looked up - * in namespaces whose name path includes the given namespace. + * Invalidate the name resolution caches for all names looked up in + * namespaces whose name path includes the given namespace. * * Results: * nothing * * Side effects: - * Increments the command reference epoch in each namespace whose - * path includes the given namespace. This causes any cached - * resolved names whose root cacheing context starts at that - * namespace to be recomputed the next time they are used. + * Increments the command reference epoch in each namespace whose path + * includes the given namespace. This causes any cached resolved names + * whose root cacheing context starts at that namespace to be recomputed + * the next time they are used. * *---------------------------------------------------------------------- */ @@ -4242,11 +4221,10 @@ TclInvalidateNsPath(nsPtr) * Invoked to implement the "namespace qualifiers" command that returns * any leading namespace qualifiers in a string. These qualifiers are * namespace names separated by "::"s. For example, for "::foo::p" this - * command returns "::foo", and for "::" it returns "". This command - * is the complement of the "namespace tail" command. Note that this - * command does not check whether the "namespace" names are, in fact, - * the names of currently defined namespaces. Handles the following - * syntax: + * command returns "::foo", and for "::" it returns "". This command is + * the complement of the "namespace tail" command. Note that this command + * does not check whether the "namespace" names are, in fact, the names + * of currently defined namespaces. Handles the following syntax: * * namespace qualifiers string * @@ -4254,8 +4232,8 @@ TclInvalidateNsPath(nsPtr) * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * Returns a result in the interpreter's result object. If anything - * goes wrong, the result is an error message. + * Returns a result in the interpreter's result object. If anything goes + * wrong, the result is an error message. * *---------------------------------------------------------------------- */ @@ -4276,8 +4254,8 @@ NamespaceQualifiersCmd(dummy, interp, objc, objv) } /* - * Find the end of the string, then work backward and find - * the start of the last "::" qualifier. + * Find the end of the string, then work backward and find the start of + * the last "::" qualifier. */ name = TclGetString(objv[2]); @@ -4307,13 +4285,13 @@ NamespaceQualifiersCmd(dummy, interp, objc, objv) * NamespaceTailCmd -- * * Invoked to implement the "namespace tail" command that returns the - * trailing name at the end of a string with "::" namespace - * qualifiers. These qualifiers are namespace names separated by - * "::"s. For example, for "::foo::p" this command returns "p", and for - * "::" it returns "". This command is the complement of the "namespace - * qualifiers" command. Note that this command does not check whether - * the "namespace" names are, in fact, the names of currently defined - * namespaces. Handles the following syntax: + * trailing name at the end of a string with "::" namespace qualifiers. + * These qualifiers are namespace names separated by "::"s. For example, + * for "::foo::p" this command returns "p", and for "::" it returns + * "". This command is the complement of the "namespace qualifiers" + * command. Note that this command does not check whether the "namespace" + * names are, in fact, the names of currently defined namespaces. Handles + * the following syntax: * * namespace tail string * @@ -4321,8 +4299,8 @@ NamespaceQualifiersCmd(dummy, interp, objc, objv) * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * Returns a result in the interpreter's result object. If anything - * goes wrong, the result is an error message. + * Returns a result in the interpreter's result object. If anything goes + * wrong, the result is an error message. * *---------------------------------------------------------------------- */ @@ -4342,8 +4320,8 @@ NamespaceTailCmd(dummy, interp, objc, objv) } /* - * Find the end of the string, then work backward and find the - * last "::" qualifier. + * Find the end of the string, then work backward and find the last "::" + * qualifier. */ name = TclGetString(objv[2]); @@ -4379,8 +4357,8 @@ NamespaceTailCmd(dummy, interp, objc, objv) * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * Returns a result in the interpreter's result object. If anything - * goes wrong, the result is an error message. + * Returns a result in the interpreter's result object. If anything goes + * wrong, the result is an error message. * *---------------------------------------------------------------------- */ @@ -4421,7 +4399,7 @@ NamespaceWhichCmd(dummy, interp, objc, objv) switch (lookupType) { case 0: { /* -command */ Tcl_Command cmd = Tcl_GetCommandFromObj(interp, objv[objc-1]); - if (cmd != (Tcl_Command) NULL) { + if (cmd != (Tcl_Command) NULL) { Tcl_GetCommandFullName(interp, cmd, resultPtr); } break; @@ -4451,9 +4429,9 @@ NamespaceWhichCmd(dummy, interp, objc, objv) * None. * * Side effects: - * Decrements the ref count of any Namespace structure pointed - * to by the nsName's internal representation. If there are no more - * references to the namespace, it's structure will be freed. + * Decrements the ref count of any Namespace structure pointed to by the + * nsName's internal representation. If there are no more references to + * the namespace, it's structure will be freed. * *---------------------------------------------------------------------- */ @@ -4468,8 +4446,8 @@ FreeNsNameInternalRep(objPtr) Namespace *nsPtr; /* - * Decrement the reference count of the namespace. If there are no - * more references, free it up. + * Decrement the reference count of the namespace. If there are no more + * references, free it up. */ if (resNamePtr != NULL) { @@ -4477,9 +4455,9 @@ FreeNsNameInternalRep(objPtr) if (resNamePtr->refCount == 0) { /* - * Decrement the reference count for the cached namespace. If - * the namespace is dead, and there are no more references to - * it, free it. + * Decrement the reference count for the cached namespace. If the + * namespace is dead, and there are no more references to it, free + * it. */ nsPtr = resNamePtr->nsPtr; @@ -4505,8 +4483,8 @@ FreeNsNameInternalRep(objPtr) * * Side effects: * copyPtr's internal rep is set to refer to the same namespace - * referenced by srcPtr's internal rep. Increments the ref count of - * the ResolvedNsName structure used to hold the namespace reference. + * referenced by srcPtr's internal rep. Increments the ref count of the + * ResolvedNsName structure used to hold the namespace reference. * *---------------------------------------------------------------------- */ @@ -4531,29 +4509,28 @@ DupNsNameInternalRep(srcPtr, copyPtr) * * SetNsNameFromAny -- * - * Attempt to generate a nsName internal representation for a - * Tcl object. + * Attempt to generate a nsName internal representation for a Tcl object. * * Results: - * Returns TCL_OK if the value could be converted to a proper - * namespace reference. Otherwise, it returns TCL_ERROR, along - * with an error message in the interpreter's result object. + * Returns TCL_OK if the value could be converted to a proper namespace + * reference. Otherwise, it returns TCL_ERROR, along with an error + * message in the interpreter's result object. * * Side effects: - * If successful, the object is made a nsName object. Its internal rep - * is set to point to a ResolvedNsName, which contains a cached pointer - * to the Namespace. Reference counts are kept on both the - * ResolvedNsName and the Namespace, so we can keep track of their - * usage and free them when appropriate. + * If successful, the object is made a nsName object. Its internal rep is + * set to point to a ResolvedNsName, which contains a cached pointer to + * the Namespace. Reference counts are kept on both the ResolvedNsName + * and the Namespace, so we can keep track of their usage and free them + * when appropriate. * *---------------------------------------------------------------------- */ static int SetNsNameFromAny(interp, objPtr) - Tcl_Interp *interp; /* Points to the namespace in which to - * resolve name. Also used for error - * reporting if not NULL. */ + Tcl_Interp *interp; /* Points to the namespace in which to resolve + * name. Also used for error reporting if not + * NULL. */ register Tcl_Obj *objPtr; /* The object to convert. */ { char *name; @@ -4571,10 +4548,10 @@ SetNsNameFromAny(interp, objPtr) } /* - * Look for the namespace "name" in the current namespace. If there is - * an error parsing the (possibly qualified) name, return an error. - * If the namespace isn't found, we convert the object to an nsName - * object with a NULL ResolvedNsName* internal rep. + * Look for the namespace "name" in the current namespace. If there is an + * error parsing the (possibly qualified) name, return an error. If the + * namespace isn't found, we convert the object to an nsName object with a + * NULL ResolvedNsName* internal rep. */ TclGetNamespaceForQualName(interp, name, (Namespace *) NULL, @@ -4600,9 +4577,9 @@ SetNsNameFromAny(interp, objPtr) } /* - * Free the old internalRep before setting the new one. - * We do this as late as possible to allow the conversion code - * (in particular, Tcl_GetStringFromObj) to use that old internalRep. + * Free the old internalRep before setting the new one. We do this as + * late as possible to allow the conversion code (in particular, + * Tcl_GetStringFromObj) to use that old internalRep. */ TclFreeIntRep(objPtr); @@ -4616,16 +4593,16 @@ SetNsNameFromAny(interp, objPtr) * * UpdateStringOfNsName -- * - * Updates the string representation for a nsName object. - * Note: This procedure does not free an existing old string rep - * so storage will be lost if this has not already been done. + * Updates the string representation for a nsName object. Note: This + * function does not free an existing old string rep so storage will be + * lost if this has not already been done. * * Results: * None. * * Side effects: - * The object's string is set to a copy of the fully qualified - * namespace name. + * The object's string is set to a copy of the fully qualified namespace + * name. * *---------------------------------------------------------------------- */ @@ -4652,8 +4629,8 @@ UpdateStringOfNsName(objPtr) } /* - * The following sets the string rep to an empty string on the heap - * if the internal rep is NULL. + * The following sets the string rep to an empty string on the heap if the + * internal rep is NULL. */ length = strlen(name); @@ -4672,9 +4649,9 @@ UpdateStringOfNsName(objPtr) * * NamespaceEnsembleCmd -- * - * Invoked to implement the "namespace ensemble" command that - * creates and manipulates ensembles built on top of namespaces. - * Handles the following syntax: + * Invoked to implement the "namespace ensemble" command that creates and + * manipulates ensembles built on top of namespaces. Handles the + * following syntax: * * namespace ensemble name ?dictionary? * @@ -4682,9 +4659,9 @@ UpdateStringOfNsName(objPtr) * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong. * * Side effects: - * Creates the ensemble for the namespace if one did not - * previously exist. Alternatively, alters the way that the - * ensemble's subcommand => implementation prefix is configured. + * Creates the ensemble for the namespace if one did not previously + * exist. Alternatively, alters the way that the ensemble's subcommand + * => implementation prefix is configured. * *---------------------------------------------------------------------- */ @@ -4754,19 +4731,18 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) objc -= 3; /* - * Work out what name to use for the command to create. If - * supplied, it is either fully specified or relative to the - * current namespace. If not supplied, it is exactly the name - * of the current namespace. + * Work out what name to use for the command to create. If supplied, + * it is either fully specified or relative to the current namespace. + * If not supplied, it is exactly the name of the current namespace. */ name = nsPtr->fullName; /* - * Parse the option list, applying type checks as we go. Note - * that we are not incrementing any reference counts in the - * objects at this stage, so the presence of an option - * multiple times won't cause any memory leaks. + * Parse the option list, applying type checks as we go. Note that we + * are not incrementing any reference counts in the objects at this + * stage, so the presence of an option multiple times won't cause any + * memory leaks. */ for (; objc>1 ; objc-=2,objv+=2 ) { @@ -4792,9 +4768,11 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) continue; case CRT_MAP: { Tcl_Obj *patchedDict = NULL, *subcmdObj; + /* * Verify that the map is sensible. */ + if (Tcl_DictObjFirst(interp, objv[1], &search, &subcmdObj, &listObj, &done) != TCL_OK) { if (allocatedMapFlag) { @@ -4837,8 +4815,8 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) cmd = TclGetString(listv[0]); if (!(cmd[0] == ':' && cmd[1] == ':')) { Tcl_Obj *newList = Tcl_NewListObj(len, listv); - Tcl_Obj *newCmd = - Tcl_NewStringObj(nsPtr->fullName, -1); + Tcl_Obj *newCmd = Tcl_NewStringObj(nsPtr->fullName,-1); + if (nsPtr->parentPtr) { Tcl_AppendStringsToObj(newCmd, "::", NULL); } @@ -4851,6 +4829,7 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) } Tcl_DictObjNext(&search, &subcmdObj, &listObj, &done); } while (!done); + if (allocatedMapFlag) { Tcl_DecrRefCount(mapObj); } @@ -4882,11 +4861,10 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) } /* - * Create the ensemble. Note that this might delete another - * ensemble linked to the same namespace, so we must be - * careful. However, we should be OK because we only link the - * namespace into the list once we've created it (and after - * any deletions have occurred.) + * Create the ensemble. Note that this might delete another ensemble + * linked to the same namespace, so we must be careful. However, we + * should be OK because we only link the namespace into the list once + * we've created it (and after any deletions have occurred.) */ token = Tcl_CreateEnsemble(interp, name, NULL, @@ -4976,6 +4954,7 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) int flags; TclNewObj(resultObj); + /* -map option */ Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj(configOptions[CONF_MAP], -1)); @@ -4985,6 +4964,7 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) } else { Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewObj()); } + /* -namespace option */ Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj(configOptions[CONF_NAMESPACE], -1)); @@ -4992,12 +4972,14 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj(((Namespace *)namespacePtr)->fullName, -1)); + /* -prefix option */ Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj(configOptions[CONF_PREFIX], -1)); Tcl_GetEnsembleFlags(NULL, token, &flags); Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewBooleanObj(flags & TCL_ENSEMBLE_PREFIX)); + /* -subcommands option */ Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj(configOptions[CONF_SUBCMDS], -1)); @@ -5007,6 +4989,7 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) } else { Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewObj()); } + /* -unknown option */ Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj(configOptions[CONF_UNKNOWN], -1)); @@ -5016,9 +4999,9 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) } else { Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewObj()); } + Tcl_SetObjResult(interp, resultObj); return TCL_OK; - } else { Tcl_DictSearch search; Tcl_Obj *listObj; @@ -5039,10 +5022,10 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) objc -= 4; /* - * Parse the option list, applying type checks as we go. - * Note that we are not incrementing any reference counts - * in the objects at this stage, so the presence of an - * option multiple times won't cause any memory leaks. + * Parse the option list, applying type checks as we go. Note + * that we are not incrementing any reference counts in the + * objects at this stage, so the presence of an option multiple + * times won't cause any memory leaks. */ for (; objc>0 ; objc-=2,objv+=2 ) { @@ -5163,8 +5146,7 @@ NamespaceEnsembleCmd(dummy, interp, objc, objv) } /* - * Update the namespace now that we've finished the - * parsing stage. + * Update the namespace now that we've finished the parsing stage. */ flags = (permitPrefix ? flags|TCL_ENSEMBLE_PREFIX @@ -5215,8 +5197,8 @@ Tcl_CreateEnsemble(interp, name, namespacePtr, flags) } /* - * Make the name of the ensemble into a fully qualified name. - * This might allocate a temporary object. + * Make the name of the ensemble into a fully qualified name. This might + * allocate a temporary object. */ if (!(name[0] == ':' && name[1] == ':')) { @@ -5243,12 +5225,14 @@ Tcl_CreateEnsemble(interp, name, namespacePtr, flags) DeleteEnsembleConfig); ensemblePtr->next = (EnsembleConfig *) nsPtr->ensembles; nsPtr->ensembles = (Tcl_Ensemble *) ensemblePtr; + /* - * Trigger an eventual recomputation of the ensemble command - * set. Note that this is slightly tricky, as it means that - * we are not actually counting the number of namespace export - * actions, but it is the simplest way to go! + * Trigger an eventual recomputation of the ensemble command set. Note + * that this is slightly tricky, as it means that we are not actually + * counting the number of namespace export actions, but it is the simplest + * way to go! */ + nsPtr->exportLookupEpoch++; if (nameObj != NULL) { @@ -5265,8 +5249,8 @@ Tcl_CreateEnsemble(interp, name, namespacePtr, flags) * Set the subcommand list for a particular ensemble. * * Results: - * Tcl result code (error if command token does not indicate an - * ensemble or the subcommand list - if non-NULL - is not a list). + * Tcl result code (error if command token does not indicate an ensemble + * or the subcommand list - if non-NULL - is not a list). * * Side effects: * The ensemble is updated and marked for recompilation. @@ -5311,11 +5295,12 @@ Tcl_SetEnsembleSubcommandList(interp, token, subcmdList) } /* - * Trigger an eventual recomputation of the ensemble command - * set. Note that this is slightly tricky, as it means that - * we are not actually counting the number of namespace export - * actions, but it is the simplest way to go! + * Trigger an eventual recomputation of the ensemble command set. Note + * that this is slightly tricky, as it means that we are not actually + * counting the number of namespace export actions, but it is the simplest + * way to go! */ + ensemblePtr->nsPtr->exportLookupEpoch++; return TCL_OK; @@ -5329,8 +5314,8 @@ Tcl_SetEnsembleSubcommandList(interp, token, subcmdList) * Set the mapping dictionary for a particular ensemble. * * Results: - * Tcl result code (error if command token does not indicate an - * ensemble or the mapping - if non-NULL - is not a dict). + * Tcl result code (error if command token does not indicate an ensemble + * or the mapping - if non-NULL - is not a dict). * * Side effects: * The ensemble is updated and marked for recompilation. @@ -5375,11 +5360,12 @@ Tcl_SetEnsembleMappingDict(interp, token, mapDict) } /* - * Trigger an eventual recomputation of the ensemble command - * set. Note that this is slightly tricky, as it means that - * we are not actually counting the number of namespace export - * actions, but it is the simplest way to go! + * Trigger an eventual recomputation of the ensemble command set. Note + * that this is slightly tricky, as it means that we are not actually + * counting the number of namespace export actions, but it is the simplest + * way to go! */ + ensemblePtr->nsPtr->exportLookupEpoch++; return TCL_OK; @@ -5393,8 +5379,8 @@ Tcl_SetEnsembleMappingDict(interp, token, mapDict) * Set the unknown handler for a particular ensemble. * * Results: - * Tcl result code (error if command token does not indicate an - * ensemble or the unknown handler - if non-NULL - is not a list). + * Tcl result code (error if command token does not indicate an ensemble + * or the unknown handler - if non-NULL - is not a list). * * Side effects: * The ensemble is updated and marked for recompilation. @@ -5440,11 +5426,12 @@ Tcl_SetEnsembleUnknownHandler(interp, token, unknownList) } /* - * Trigger an eventual recomputation of the ensemble command - * set. Note that this is slightly tricky, as it means that - * we are not actually counting the number of namespace export - * actions, but it is the simplest way to go! + * Trigger an eventual recomputation of the ensemble command set. Note + * that this is slightly tricky, as it means that we are not actually + * counting the number of namespace export actions, but it is the simplest + * way to go! */ + ensemblePtr->nsPtr->exportLookupEpoch++; return TCL_OK; @@ -5491,11 +5478,12 @@ Tcl_SetEnsembleFlags(interp, token, flags) ensemblePtr->flags |= flags & ~ENS_DEAD; /* - * Trigger an eventual recomputation of the ensemble command - * set. Note that this is slightly tricky, as it means that - * we are not actually counting the number of namespace export - * actions, but it is the simplest way to go! + * Trigger an eventual recomputation of the ensemble command set. Note + * that this is slightly tricky, as it means that we are not actually + * counting the number of namespace export actions, but it is the simplest + * way to go! */ + ensemblePtr->nsPtr->exportLookupEpoch++; return TCL_OK; @@ -5511,9 +5499,9 @@ Tcl_SetEnsembleFlags(interp, token, flags) * Results: * Tcl result code (error if command token does not indicate an * ensemble). The list of subcommands is returned by updating the - * variable pointed to by the last parameter (NULL if this is to - * be derived from the mapping dictionary or the associated - * namespace's exported commands). + * variable pointed to by the last parameter (NULL if this is to be + * derived from the mapping dictionary or the associated namespace's + * exported commands). * * Side effects: * None @@ -5547,14 +5535,13 @@ Tcl_GetEnsembleSubcommandList(interp, token, subcmdListPtr) * * Tcl_GetEnsembleMappingDict -- * - * Get the command mapping dictionary associated with a - * particular ensemble. + * Get the command mapping dictionary associated with a particular + * ensemble. * * Results: * Tcl result code (error if command token does not indicate an - * ensemble). The mapping dict is returned by updating the - * variable pointed to by the last parameter (NULL if none is - * installed). + * ensemble). The mapping dict is returned by updating the variable + * pointed to by the last parameter (NULL if none is installed). * * Side effects: * None @@ -5592,9 +5579,8 @@ Tcl_GetEnsembleMappingDict(interp, token, mapDictPtr) * * Results: * Tcl result code (error if command token does not indicate an - * ensemble). The unknown handler is returned by updating the - * variable pointed to by the last parameter (NULL if no handler - * is installed). + * ensemble). The unknown handler is returned by updating the variable + * pointed to by the last parameter (NULL if no handler is installed). * * Side effects: * None @@ -5632,8 +5618,8 @@ Tcl_GetEnsembleUnknownHandler(interp, token, unknownListPtr) * * Results: * Tcl result code (error if command token does not indicate an - * ensemble). The flags are returned by updating the variable - * pointed to by the last parameter. + * ensemble). The flags are returned by updating the variable pointed to + * by the last parameter. * * Side effects: * None @@ -5671,8 +5657,8 @@ Tcl_GetEnsembleFlags(interp, token, flagsPtr) * * Results: * Tcl result code (error if command token does not indicate an - * ensemble). Namespace is returned by updating the variable - * pointed to by the last parameter. + * ensemble). Namespace is returned by updating the variable pointed to + * by the last parameter. * * Side effects: * None @@ -5706,14 +5692,13 @@ Tcl_GetEnsembleNamespace(interp, token, namespacePtrPtr) * * Tcl_FindEnsemble -- * - * Given a command name, get the ensemble token for it, allowing - * for [namespace import]s. [Bug 1017022] + * Given a command name, get the ensemble token for it, allowing for + * [namespace import]s. [Bug 1017022] * * Results: - * The token for the ensemble command with the given name, or - * NULL if the command either does not exist or is not an - * ensemble (when an error message will be written into the - * interp if thats non-NULL). + * The token for the ensemble command with the given name, or NULL if the + * command either does not exist or is not an ensemble (when an error + * message will be written into the interp if thats non-NULL). * * Side effects: * None @@ -5728,8 +5713,9 @@ Tcl_FindEnsemble(interp, cmdNameObj, flags) * TCL_LEAVE_ERR_MSG is set in the * flags. */ Tcl_Obj *cmdNameObj; /* Name of command to look up. */ - int flags; /* Either 0 or TCL_LEAVE_ERR_MSG; other - * flags are probably not useful. */ + int flags; /* Either 0 or TCL_LEAVE_ERR_MSG; + * other flags are probably not + * useful. */ { Command *cmdPtr; @@ -5740,9 +5726,10 @@ Tcl_FindEnsemble(interp, cmdNameObj, flags) } if (cmdPtr->objProc != NsEnsembleImplementationCmd) { /* - * Reuse existing infrastructure for following import link - * chains rather than duplicating it. + * Reuse existing infrastructure for following import link chains + * rather than duplicating it. */ + cmdPtr = (Command *) TclGetOriginalCommand((Tcl_Command) cmdPtr); if (cmdPtr == NULL || cmdPtr->objProc != NsEnsembleImplementationCmd) { @@ -5794,18 +5781,18 @@ Tcl_IsEnsemble(token) * NsEnsembleImplementationCmd -- * * Implements an ensemble of commands (being those exported by a - * namespace other than the global namespace) as a command with - * the same (short) name as the namespace in the parent namespace. + * namespace other than the global namespace) as a command with the same + * (short) name as the namespace in the parent namespace. * * Results: - * A standard Tcl result code. Will be TCL_ERROR if the command - * is not an unambiguous prefix of any command exported by the - * ensemble's namespace. + * A standard Tcl result code. Will be TCL_ERROR if the command is not + * an unambiguous prefix of any command exported by the ensemble's + * namespace. * * Side effects: - * Depends on the command within the namespace that gets executed. - * If the ensemble itself returns TCL_ERROR, a descriptive error - * message will be placed in the interpreter's result. + * Depends on the command within the namespace that gets executed. If + * the ensemble itself returns TCL_ERROR, a descriptive error message + * will be placed in the interpreter's result. * *---------------------------------------------------------------------- */ @@ -5826,13 +5813,13 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) int result; /* The result of the subcommand * execution. */ Tcl_Obj *prefixObj; /* An object containing the prefix - * words of the command that implements - * the subcommand. */ + * words of the command that + * implements the subcommand. */ Tcl_HashEntry *hPtr; /* Used for efficient lookup of fully - * specified but not yet cached command - * names. */ - Tcl_Obj **prefixObjv; /* The list of objects to substitute in - * as the target command prefix. */ + * specified but not yet cached + * command names. */ + Tcl_Obj **prefixObjv; /* The list of objects to substitute + * in as the target command prefix. */ int prefixObjc; /* Size of prefixObjv of course! */ int reparseCount = 0; /* Number of reparses. */ @@ -5846,6 +5833,7 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) /* * Don't know how we got here, but make things give up quickly. */ + if (!Tcl_InterpDeleted(interp)) { Tcl_AppendResult(interp, "ensemble activated for deleted namespace", NULL); @@ -5858,11 +5846,10 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) BuildEnsembleConfig(ensemblePtr); } else { /* - * Table of subcommands is still valid; therefore there might - * be a valid cache of discovered information which we can - * reuse. Do the check here, and if we're still valid, we can - * jump straight to the part where we do the invocation of the - * subcommand. + * Table of subcommands is still valid; therefore there might be a + * valid cache of discovered information which we can reuse. Do the + * check here, and if we're still valid, we can jump straight to the + * part where we do the invocation of the subcommand. */ if (objv[1]->typePtr == &ensembleCmdType) { @@ -5879,8 +5866,8 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) } /* - * Look in the hashtable for the subcommand name; this is the - * fastest way of all. + * Look in the hashtable for the subcommand name; this is the fastest way + * of all. */ hPtr = Tcl_FindHashEntry(&ensemblePtr->subcommandTable, @@ -5901,9 +5888,9 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) goto unknownOrAmbiguousSubcommand; } else { /* - * If we've not already confirmed the command with the hash as - * part of building our export table, we need to scan the - * sorted array for matches. + * If we've not already confirmed the command with the hash as part of + * building our export table, we need to scan the sorted array for + * matches. */ char *subcmdName; /* Name of the subcommand, or unique @@ -5918,24 +5905,23 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) for (i=0 ; i<tableLength ; i++) { register int cmp = strncmp(subcmdName, ensemblePtr->subcommandArrayPtr[i], - (unsigned)stringLength); + (unsigned) stringLength); if (cmp == 0) { if (fullName != NULL) { /* - * Since there's never the exact-match case to - * worry about (hash search filters this), getting - * here indicates that our subcommand is an - * ambiguous prefix of (at least) two exported - * subcommands, which is an error case. + * Since there's never the exact-match case to worry about + * (hash search filters this), getting here indicates that + * our subcommand is an ambiguous prefix of (at least) two + * exported subcommands, which is an error case. */ goto unknownOrAmbiguousSubcommand; } fullName = ensemblePtr->subcommandArrayPtr[i]; } else if (cmp < 0) { /* - * Because we are searching a sorted table, we can now - * stop searching because we have gone past anything - * that could possibly match. + * Because we are searching a sorted table, we can now stop + * searching because we have gone past anything that could + * possibly match. */ break; } @@ -5961,14 +5947,13 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) } /* - * Do the real work of execution of the subcommand by building an - * array of objects (note that this is potentially not the same - * length as the number of arguments to this ensemble command), - * populating it and then feeding it back through the main - * command-lookup engine. In theory, we could look up the command - * in the namespace ourselves, as we already have the namespace in - * which it is guaranteed to exist, but we don't do that (the - * cacheing of the command object used should help with that.) + * Do the real work of execution of the subcommand by building an array of + * objects (note that this is potentially not the same length as the + * number of arguments to this ensemble command), populating it and then + * feeding it back through the main command-lookup engine. In theory, we + * could look up the command in the namespace ourselves, as we already + * have the namespace in which it is guaranteed to exist, but we don't do + * that (the cacheing of the command object used should help with that.) */ Tcl_IncrRefCount(prefixObj); @@ -6008,10 +5993,10 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) unknownOrAmbiguousSubcommand: /* - * Have not been able to match the subcommand asked for with a - * real subcommand that we export. See whether a handler has been - * registered for dealing with this situation. Will only call (at - * most) once for any particular ensemble invocation. + * Have not been able to match the subcommand asked for with a real + * subcommand that we export. See whether a handler has been registered + * for dealing with this situation. Will only call (at most) once for any + * particular ensemble invocation. */ if (ensemblePtr->unknownHandler != NULL && reparseCount++ < 1) { @@ -6044,9 +6029,9 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) } /* - * Namespace is still there. Check if the result is a - * valid list. If it is, and it is non-empty, that list - * is what we are using as our replacement. + * Namespace is still there. Check if the result is a valid list. + * If it is, and it is non-empty, that list is what we are using + * as our replacement. */ if (Tcl_ListObjLength(interp, prefixObj, &prefixObjc) != TCL_OK) { @@ -6103,9 +6088,9 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) /* * Cannot determine what subcommand to hand off to, so generate a - * (standard) failure message. Note the one odd case compared - * with standard ensemble-like command, which is where a namespace - * has no exported commands at all... + * (standard) failure message. Note the one odd case compared with + * standard ensemble-like command, which is where a namespace has no + * exported commands at all... */ Tcl_ResetResult(interp); @@ -6137,11 +6122,10 @@ NsEnsembleImplementationCmd(clientData, interp, objc, objv) * * MakeCachedEnsembleCommand -- * - * Cache what we've computed so far; it's not nice to repeatedly - * copy strings about. Note that to do this, we start by - * deleting any old representation that there was (though if it - * was an out of date ensemble rep, we can skip some of the - * deallocation process.) + * Cache what we've computed so far; it's not nice to repeatedly copy + * strings about. Note that to do this, we start by deleting any old + * representation that there was (though if it was an out of date + * ensemble rep, we can skip some of the deallocation process.) * * Results: * None @@ -6172,8 +6156,8 @@ MakeCachedEnsembleCommand(objPtr, ensemblePtr, subcommandName, prefixObjPtr) ckfree(ensembleCmd->fullSubcmdName); } else { /* - * Kill the old internal rep, and replace it with a brand new - * one of our own. + * Kill the old internal rep, and replace it with a brand new one of + * our own. */ TclFreeIntRep(objPtr); ensembleCmd = (EnsembleCmdRep *) ckalloc(sizeof(EnsembleCmdRep)); @@ -6184,6 +6168,7 @@ MakeCachedEnsembleCommand(objPtr, ensemblePtr, subcommandName, prefixObjPtr) /* * Populate the internal rep. */ + ensembleCmd->nsPtr = ensemblePtr->nsPtr; ensembleCmd->epoch = ensemblePtr->epoch; ensembleCmd->token = ensemblePtr->token; @@ -6200,11 +6185,11 @@ MakeCachedEnsembleCommand(objPtr, ensemblePtr, subcommandName, prefixObjPtr) * * DeleteEnsembleConfig -- * - * Destroys the data structure used to represent an ensemble. - * This is called when the ensemble's command is deleted (which - * happens automatically if the ensemble's namespace is deleted.) - * Maintainers should note that ensembles should be deleted by - * deleting their commands. + * Destroys the data structure used to represent an ensemble. This is + * called when the ensemble's command is deleted (which happens + * automatically if the ensemble's namespace is deleted.) Maintainers + * should note that ensembles should be deleted by deleting their + * commands. * * Results: * None. @@ -6225,8 +6210,8 @@ DeleteEnsembleConfig(clientData) Tcl_HashEntry *hEnt; /* - * Unlink from the ensemble chain if it has not been marked as - * having been done already. + * Unlink from the ensemble chain if it has not been marked as having been + * done already. */ if (ensemblePtr->next != ensemblePtr) { @@ -6245,8 +6230,8 @@ DeleteEnsembleConfig(clientData) } /* - * Mark the namespace as dead so code that uses Tcl_Preserve() can - * tell whether disaster happened anyway. + * Mark the namespace as dead so code that uses Tcl_Preserve() can tell + * whether disaster happened anyway. */ ensemblePtr->flags |= ENS_DEAD; @@ -6276,10 +6261,10 @@ DeleteEnsembleConfig(clientData) } /* - * Arrange for the structure to be reclaimed. Note that this is - * complex because we have to make sure that we can react sensibly - * when an ensemble is deleted during the process of initialising - * the ensemble (especially the unknown callback.) + * Arrange for the structure to be reclaimed. Note that this is complex + * because we have to make sure that we can react sensibly when an + * ensemble is deleted during the process of initialising the ensemble + * (especially the unknown callback.) */ Tcl_EventuallyFree((ClientData) ensemblePtr, TCL_DYNAMIC); @@ -6290,19 +6275,19 @@ DeleteEnsembleConfig(clientData) * * BuildEnsembleConfig -- * - * Create the internal data structures that describe how an - * ensemble looks, being a hash mapping from the full command - * name to the Tcl list that describes the implementation prefix - * words, and a sorted array of all the full command names to - * allow for reasonably efficient unambiguous prefix handling. + * Create the internal data structures that describe how an ensemble + * looks, being a hash mapping from the full command name to the Tcl list + * that describes the implementation prefix words, and a sorted array of + * all the full command names to allow for reasonably efficient + * unambiguous prefix handling. * * Results: * None. * * Side effects: - * Reallocates and rebuilds the hash table and array stored at - * the ensemblePtr argument. For large ensembles or large - * namespaces, this is a potentially expensive operation. + * Reallocates and rebuilds the hash table and array stored at the + * ensemblePtr argument. For large ensembles or large namespaces, this + * is a potentially expensive operation. * *---------------------------------------------------------------------- */ @@ -6336,10 +6321,9 @@ BuildEnsembleConfig(ensemblePtr) } /* - * See if we've got an export list. If so, we will only export - * exactly those commands, which may be either implemented by the - * prefix in the subcommandDict or mapped directly onto the - * namespace's commands. + * See if we've got an export list. If so, we will only export exactly + * those commands, which may be either implemented by the prefix in the + * subcommandDict or mapped directly onto the namespace's commands. */ if (ensemblePtr->subcmdList != NULL) { @@ -6357,9 +6341,11 @@ BuildEnsembleConfig(ensemblePtr) if (!isNew) { continue; } + /* * Look in our dictionary (if present) for the command. */ + if (ensemblePtr->subcommandDict != NULL) { Tcl_DictObjGet(NULL, ensemblePtr->subcommandDict, subcmdv[i], &target); @@ -6369,12 +6355,13 @@ BuildEnsembleConfig(ensemblePtr) continue; } } + /* - * Not there, so map onto the namespace. Note in this - * case that we do not guarantee that the command is - * actually there; that is the programmer's responsibility - * (or [::unknown] of course). + * Not there, so map onto the namespace. Note in this case that + * we do not guarantee that the command is actually there; that is + * the programmer's responsibility (or [::unknown] of course). */ + cmdObj = Tcl_NewStringObj(ensemblePtr->nsPtr->fullName, -1); if (ensemblePtr->nsPtr->parentPtr != NULL) { Tcl_AppendStringsToObj(cmdObj, "::", name, NULL); @@ -6387,11 +6374,11 @@ BuildEnsembleConfig(ensemblePtr) } } else if (ensemblePtr->subcommandDict != NULL) { /* - * No subcmd list, but we do have a mapping dictionary so we - * should use the keys of that. Convert the dictionary's - * contents into the form required for the ensemble's internal - * hashtable. + * No subcmd list, but we do have a mapping dictionary so we should + * use the keys of that. Convert the dictionary's contents into the + * form required for the ensemble's internal hashtable. */ + Tcl_DictSearch dictSearch; Tcl_Obj *keyObj, *valueObj; int done; @@ -6400,6 +6387,7 @@ BuildEnsembleConfig(ensemblePtr) &keyObj, &valueObj, &done); while (!done) { char *name = TclGetString(keyObj); + hPtr = Tcl_CreateHashEntry(hash, name, &isNew); Tcl_SetHashValue(hPtr, (ClientData) valueObj); Tcl_IncrRefCount(valueObj); @@ -6407,19 +6395,18 @@ BuildEnsembleConfig(ensemblePtr) } } else { /* - * Discover what commands are actually exported by the - * namespace. What we have is an array of patterns and a hash - * table whose keys are the command names exported by the - * namespace (the contents do not matter here.) We must find - * out what commands are actually exported by filtering each - * command in the namespace against each of the patterns in - * the export list. Note that we use an intermediate hash - * table to make memory management easier, and because that - * makes exact matching far easier too. + * Discover what commands are actually exported by the namespace. + * What we have is an array of patterns and a hash table whose keys + * are the command names exported by the namespace (the contents do + * not matter here.) We must find out what commands are actually + * exported by filtering each command in the namespace against each of + * the patterns in the export list. Note that we use an intermediate + * hash table to make memory management easier, and because that makes + * exact matching far easier too. * - * Suggestion for future enhancement: compute the unique - * prefixes and place them in the hash too, which should make - * for even faster matching. + * Suggestion for future enhancement: compute the unique prefixes and + * place them in the hash too, which should make for even faster + * matching. */ hPtr = Tcl_FirstHashEntry(&ensemblePtr->nsPtr->cmdTable, &search); @@ -6433,9 +6420,9 @@ BuildEnsembleConfig(ensemblePtr) hPtr = Tcl_CreateHashEntry(hash, nsCmdName, &isNew); /* - * Remember, hash entries have a full reference to - * the substituted part of the command (as a list) - * as their content! + * Remember, hash entries have a full reference to the + * substituted part of the command (as a list) as their + * content! */ if (isNew) { @@ -6462,40 +6449,36 @@ BuildEnsembleConfig(ensemblePtr) } /* - * Create a sorted array of all subcommands in the ensemble; hash - * tables are all very well for a quick look for an exact match, - * but they can't determine things like whether a string is a - * prefix of another (not without lots of preparation anyway) and - * they're no good for when we're generating the error message - * either. + * Create a sorted array of all subcommands in the ensemble; hash tables + * are all very well for a quick look for an exact match, but they can't + * determine things like whether a string is a prefix of another (not + * without lots of preparation anyway) and they're no good for when we're + * generating the error message either. * - * We do this by filling an array with the names (we use the hash - * keys directly to save a copy, since any time we change the - * array we change the hash too, and vice versa) and running - * quicksort over the array. + * We do this by filling an array with the names (we use the hash keys + * directly to save a copy, since any time we change the array we change + * the hash too, and vice versa) and running quicksort over the array. */ ensemblePtr->subcommandArrayPtr = (char **) ckalloc(sizeof(char *) * hash->numEntries); /* - * Fill array from both ends as this makes us less likely to end - * up with performance problems in qsort(), which is good. Note - * that doing this makes this code much more opaque, but the naive - * alternatve: + * Fill array from both ends as this makes us less likely to end up with + * performance problems in qsort(), which is good. Note that doing this + * makes this code much more opaque, but the naive alternatve: * * for (hPtr=Tcl_FirstHashEntry(hash,&search),i=0 ; - * hPtr!=NULL ; hPtr=Tcl_NextHashEntry(&search),i++) { - * ensemblePtr->subcommandArrayPtr[i] = - * Tcl_GetHashKey(hash, &hPtr); + * hPtr!=NULL ; hPtr=Tcl_NextHashEntry(&search),i++) { + * ensemblePtr->subcommandArrayPtr[i] = Tcl_GetHashKey(hash, &hPtr); * } * - * can produce long runs of precisely ordered table entries when - * the commands in the namespace are declared in a sorted fashion - * (an ordering some people like) and the hashing functions (or - * the command names themselves) are fairly unfortunate. By - * filling from both ends, it requires active malice (and probably - * a debugger) to get qsort() to have awful runtime behaviour. + * can produce long runs of precisely ordered table entries when the + * commands in the namespace are declared in a sorted fashion (an ordering + * some people like) and the hashing functions (or the command names + * themselves) are fairly unfortunate. By filling from both ends, it + * requires active malice (and probably a debugger) to get qsort() to have + * awful runtime behaviour. */ i = 0; @@ -6521,12 +6504,12 @@ BuildEnsembleConfig(ensemblePtr) * * NsEnsembleStringOrder -- * - * Helper function to compare two pointers to two strings for use - * with qsort(). + * Helper function to compare two pointers to two strings for use with + * qsort(). * * Results: - * -1 if the first string is smaller, 1 if the second string is - * smaller, and 0 if they are equal. + * -1 if the first string is smaller, 1 if the second string is smaller, + * and 0 if they are equal. * * Side effects: * None. @@ -6582,15 +6565,15 @@ FreeEnsembleCmdRep(objPtr) * * DupEnsembleCmdRep -- * - * Makes one Tcl_Obj into a copy of another that is a subcommand - * of an ensemble. + * Makes one Tcl_Obj into a copy of another that is a subcommand of an + * ensemble. * * Results: * None. * * Side effects: - * Memory is allocated, and the namespace that the ensemble is - * built on top of gains another reference. + * Memory is allocated, and the namespace that the ensemble is built on + * top of gains another reference. * *---------------------------------------------------------------------- */ @@ -6623,8 +6606,8 @@ DupEnsembleCmdRep(objPtr, copyPtr) * * StringOfEnsembleCmdRep -- * - * Creates a string representation of a Tcl_Obj that holds a - * subcommand of an ensemble. + * Creates a string representation of a Tcl_Obj that holds a subcommand + * of an ensemble. * * Results: * None. |