/[dtapublic]/projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclnamesp.c
ViewVC logotype

Annotation of /projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclnamesp.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 42 - (hide annotations) (download)
Fri Oct 14 01:50:00 2016 UTC (7 years, 8 months ago) by dashley
Original Path: projs/trunk/shared_source/tcl_base/tclnamesp.c
File MIME type: text/plain
File size: 130166 byte(s)
Move shared source code to commonize.
1 dashley 25 /* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tcl_base/tclnamesp.c,v 1.1.1.1 2001/06/13 04:43:37 dtashley Exp $ */
2    
3     /*
4     * tclNamesp.c --
5     *
6     * Contains support for namespaces, which provide a separate context of
7     * commands and global variables. The global :: namespace is the
8     * traditional Tcl "global" scope. Other namespaces are created as
9     * children of the global namespace. These other namespaces contain
10     * special-purpose commands and variables for packages.
11     *
12     * Copyright (c) 1993-1997 Lucent Technologies.
13     * Copyright (c) 1997 Sun Microsystems, Inc.
14     * Copyright (c) 1998-1999 by Scriptics Corporation.
15     *
16     * Originally implemented by
17     * Michael J. McLennan
18     * Bell Labs Innovations for Lucent Technologies
19     * mmclennan@lucent.com
20     *
21     * See the file "license.terms" for information on usage and redistribution
22     * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
23     *
24     * RCS: @(#) $Id: tclnamesp.c,v 1.1.1.1 2001/06/13 04:43:37 dtashley Exp $
25     */
26    
27     #include "tclInt.h"
28    
29     /*
30     * Flag passed to TclGetNamespaceForQualName to indicate that it should
31     * search for a namespace rather than a command or variable inside a
32     * namespace. Note that this flag's value must not conflict with the values
33     * of TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY, or CREATE_NS_IF_UNKNOWN.
34     */
35    
36     #define FIND_ONLY_NS 0x1000
37    
38     /*
39     * Initial size of stack allocated space for tail list - used when resetting
40     * shadowed command references in the functin: TclResetShadowedCmdRefs.
41     */
42    
43     #define NUM_TRAIL_ELEMS 5
44    
45     /*
46     * Count of the number of namespaces created. This value is used as a
47     * unique id for each namespace.
48     */
49    
50     static long numNsCreated = 0;
51     TCL_DECLARE_MUTEX(nsMutex)
52    
53     /*
54     * This structure contains a cached pointer to a namespace that is the
55     * result of resolving the namespace's name in some other namespace. It is
56     * the internal representation for a nsName object. It contains the
57     * pointer along with some information that is used to check the cached
58     * pointer's validity.
59     */
60    
61     typedef struct ResolvedNsName {
62     Namespace *nsPtr; /* A cached namespace pointer. */
63     long nsId; /* nsPtr's unique namespace id. Used to
64     * verify that nsPtr is still valid
65     * (e.g., it's possible that the namespace
66     * was deleted and a new one created at
67     * the same address). */
68     Namespace *refNsPtr; /* Points to the namespace containing the
69     * reference (not the namespace that
70     * contains the referenced namespace). */
71     int refCount; /* Reference count: 1 for each nsName
72     * object that has a pointer to this
73     * ResolvedNsName structure as its internal
74     * rep. This structure can be freed when
75     * refCount becomes zero. */
76     } ResolvedNsName;
77    
78     /*
79     * Declarations for procedures local to this file:
80     */
81    
82     static void DeleteImportedCmd _ANSI_ARGS_((
83     ClientData clientData));
84     static void DupNsNameInternalRep _ANSI_ARGS_((Tcl_Obj *objPtr,
85     Tcl_Obj *copyPtr));
86     static void FreeNsNameInternalRep _ANSI_ARGS_((
87     Tcl_Obj *objPtr));
88     static int GetNamespaceFromObj _ANSI_ARGS_((
89     Tcl_Interp *interp, Tcl_Obj *objPtr,
90     Tcl_Namespace **nsPtrPtr));
91     static int InvokeImportedCmd _ANSI_ARGS_((
92     ClientData clientData, Tcl_Interp *interp,
93     int objc, Tcl_Obj *CONST objv[]));
94     static int NamespaceChildrenCmd _ANSI_ARGS_((
95     ClientData dummy, Tcl_Interp *interp,
96     int objc, Tcl_Obj *CONST objv[]));
97     static int NamespaceCodeCmd _ANSI_ARGS_((
98     ClientData dummy, Tcl_Interp *interp,
99     int objc, Tcl_Obj *CONST objv[]));
100     static int NamespaceCurrentCmd _ANSI_ARGS_((
101     ClientData dummy, Tcl_Interp *interp,
102     int objc, Tcl_Obj *CONST objv[]));
103     static int NamespaceDeleteCmd _ANSI_ARGS_((
104     ClientData dummy, Tcl_Interp *interp,
105     int objc, Tcl_Obj *CONST objv[]));
106     static int NamespaceEvalCmd _ANSI_ARGS_((
107     ClientData dummy, Tcl_Interp *interp,
108     int objc, Tcl_Obj *CONST objv[]));
109     static int NamespaceExportCmd _ANSI_ARGS_((
110     ClientData dummy, Tcl_Interp *interp,
111     int objc, Tcl_Obj *CONST objv[]));
112     static int NamespaceForgetCmd _ANSI_ARGS_((
113     ClientData dummy, Tcl_Interp *interp,
114     int objc, Tcl_Obj *CONST objv[]));
115     static void NamespaceFree _ANSI_ARGS_((Namespace *nsPtr));
116     static int NamespaceImportCmd _ANSI_ARGS_((
117     ClientData dummy, Tcl_Interp *interp,
118     int objc, Tcl_Obj *CONST objv[]));
119     static int NamespaceInscopeCmd _ANSI_ARGS_((
120     ClientData dummy, Tcl_Interp *interp,
121     int objc, Tcl_Obj *CONST objv[]));
122     static int NamespaceOriginCmd _ANSI_ARGS_((
123     ClientData dummy, Tcl_Interp *interp,
124     int objc, Tcl_Obj *CONST objv[]));
125     static int NamespaceParentCmd _ANSI_ARGS_((
126     ClientData dummy, Tcl_Interp *interp,
127     int objc, Tcl_Obj *CONST objv[]));
128     static int NamespaceQualifiersCmd _ANSI_ARGS_((
129     ClientData dummy, Tcl_Interp *interp,
130     int objc, Tcl_Obj *CONST objv[]));
131     static int NamespaceTailCmd _ANSI_ARGS_((
132     ClientData dummy, Tcl_Interp *interp,
133     int objc, Tcl_Obj *CONST objv[]));
134     static int NamespaceWhichCmd _ANSI_ARGS_((
135     ClientData dummy, Tcl_Interp *interp,
136     int objc, Tcl_Obj *CONST objv[]));
137     static int SetNsNameFromAny _ANSI_ARGS_((
138     Tcl_Interp *interp, Tcl_Obj *objPtr));
139     static void UpdateStringOfNsName _ANSI_ARGS_((Tcl_Obj *objPtr));
140    
141     /*
142     * This structure defines a Tcl object type that contains a
143     * namespace reference. It is used in commands that take the
144     * name of a namespace as an argument. The namespace reference
145     * is resolved, and the result in cached in the object.
146     */
147    
148     Tcl_ObjType tclNsNameType = {
149     "nsName", /* the type's name */
150     FreeNsNameInternalRep, /* freeIntRepProc */
151     DupNsNameInternalRep, /* dupIntRepProc */
152     UpdateStringOfNsName, /* updateStringProc */
153     SetNsNameFromAny /* setFromAnyProc */
154     };
155    
156     /*
157     *----------------------------------------------------------------------
158     *
159     * TclInitNamespaceSubsystem --
160     *
161     * This procedure is called to initialize all the structures that
162     * are used by namespaces on a per-process basis.
163     *
164     * Results:
165     * None.
166     *
167     * Side effects:
168     * The namespace object type is registered with the Tcl compiler.
169     *
170     *----------------------------------------------------------------------
171     */
172    
173     void
174     TclInitNamespaceSubsystem()
175     {
176     Tcl_RegisterObjType(&tclNsNameType);
177     }
178    
179     /*
180     *----------------------------------------------------------------------
181     *
182     * Tcl_GetCurrentNamespace --
183     *
184     * Returns a pointer to an interpreter's currently active namespace.
185     *
186     * Results:
187     * Returns a pointer to the interpreter's current namespace.
188     *
189     * Side effects:
190     * None.
191     *
192     *----------------------------------------------------------------------
193     */
194    
195     Tcl_Namespace *
196     Tcl_GetCurrentNamespace(interp)
197     register Tcl_Interp *interp; /* Interpreter whose current namespace is
198     * being queried. */
199     {
200     register Interp *iPtr = (Interp *) interp;
201     register Namespace *nsPtr;
202    
203     if (iPtr->varFramePtr != NULL) {
204     nsPtr = iPtr->varFramePtr->nsPtr;
205     } else {
206     nsPtr = iPtr->globalNsPtr;
207     }
208     return (Tcl_Namespace *) nsPtr;
209     }
210    
211     /*
212     *----------------------------------------------------------------------
213     *
214     * Tcl_GetGlobalNamespace --
215     *
216     * Returns a pointer to an interpreter's global :: namespace.
217     *
218     * Results:
219     * Returns a pointer to the specified interpreter's global namespace.
220     *
221     * Side effects:
222     * None.
223     *
224     *----------------------------------------------------------------------
225     */
226    
227     Tcl_Namespace *
228     Tcl_GetGlobalNamespace(interp)
229     register Tcl_Interp *interp; /* Interpreter whose global namespace
230     * should be returned. */
231     {
232     register Interp *iPtr = (Interp *) interp;
233    
234     return (Tcl_Namespace *) iPtr->globalNsPtr;
235     }
236    
237     /*
238     *----------------------------------------------------------------------
239     *
240     * Tcl_PushCallFrame --
241     *
242     * Pushes a new call frame onto the interpreter's Tcl call stack.
243     * Called when executing a Tcl procedure or a "namespace eval" or
244     * "namespace inscope" command.
245     *
246     * Results:
247     * Returns TCL_OK if successful, or TCL_ERROR (along with an error
248     * message in the interpreter's result object) if something goes wrong.
249     *
250     * Side effects:
251     * Modifies the interpreter's Tcl call stack.
252     *
253     *----------------------------------------------------------------------
254     */
255    
256     int
257     Tcl_PushCallFrame(interp, callFramePtr, namespacePtr, isProcCallFrame)
258     Tcl_Interp *interp; /* Interpreter in which the new call frame
259     * is to be pushed. */
260     Tcl_CallFrame *callFramePtr; /* Points to a call frame structure to
261     * push. Storage for this has already been
262     * allocated by the caller; typically this
263     * is the address of a CallFrame structure
264     * allocated on the caller's C stack. The
265     * call frame will be initialized by this
266     * procedure. The caller can pop the frame
267     * later with Tcl_PopCallFrame, and it is
268     * responsible for freeing the frame's
269     * storage. */
270     Tcl_Namespace *namespacePtr; /* Points to the namespace in which the
271     * frame will execute. If NULL, the
272     * interpreter's current namespace will
273     * be used. */
274     int isProcCallFrame; /* If nonzero, the frame represents a
275     * called Tcl procedure and may have local
276     * vars. Vars will ordinarily be looked up
277     * in the frame. If new variables are
278     * created, they will be created in the
279     * frame. If 0, the frame is for a
280     * "namespace eval" or "namespace inscope"
281     * command and var references are treated
282     * as references to namespace variables. */
283     {
284     Interp *iPtr = (Interp *) interp;
285     register CallFrame *framePtr = (CallFrame *) callFramePtr;
286     register Namespace *nsPtr;
287    
288     if (namespacePtr == NULL) {
289     nsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
290     } else {
291     nsPtr = (Namespace *) namespacePtr;
292     if (nsPtr->flags & NS_DEAD) {
293     panic("Trying to push call frame for dead namespace");
294     /*NOTREACHED*/
295     }
296     }
297    
298     nsPtr->activationCount++;
299     framePtr->nsPtr = nsPtr;
300     framePtr->isProcCallFrame = isProcCallFrame;
301     framePtr->objc = 0;
302     framePtr->objv = NULL;
303     framePtr->callerPtr = iPtr->framePtr;
304     framePtr->callerVarPtr = iPtr->varFramePtr;
305     if (iPtr->varFramePtr != NULL) {
306     framePtr->level = (iPtr->varFramePtr->level + 1);
307     } else {
308     framePtr->level = 1;
309     }
310     framePtr->procPtr = NULL; /* no called procedure */
311     framePtr->varTablePtr = NULL; /* and no local variables */
312     framePtr->numCompiledLocals = 0;
313     framePtr->compiledLocals = NULL;
314    
315     /*
316     * Push the new call frame onto the interpreter's stack of procedure
317     * call frames making it the current frame.
318     */
319    
320     iPtr->framePtr = framePtr;
321     iPtr->varFramePtr = framePtr;
322     return TCL_OK;
323     }
324    
325     /*
326     *----------------------------------------------------------------------
327     *
328     * Tcl_PopCallFrame --
329     *
330     * Removes a call frame from the Tcl call stack for the interpreter.
331     * Called to remove a frame previously pushed by Tcl_PushCallFrame.
332     *
333     * Results:
334     * None.
335     *
336     * Side effects:
337     * Modifies the call stack of the interpreter. Resets various fields of
338     * the popped call frame. If a namespace has been deleted and
339     * has no more activations on the call stack, the namespace is
340     * destroyed.
341     *
342     *----------------------------------------------------------------------
343     */
344    
345     void
346     Tcl_PopCallFrame(interp)
347     Tcl_Interp* interp; /* Interpreter with call frame to pop. */
348     {
349     register Interp *iPtr = (Interp *) interp;
350     register CallFrame *framePtr = iPtr->framePtr;
351     int saveErrFlag;
352     Namespace *nsPtr;
353    
354     /*
355     * It's important to remove the call frame from the interpreter's stack
356     * of call frames before deleting local variables, so that traces
357     * invoked by the variable deletion don't see the partially-deleted
358     * frame.
359     */
360    
361     iPtr->framePtr = framePtr->callerPtr;
362     iPtr->varFramePtr = framePtr->callerVarPtr;
363    
364     /*
365     * Delete the local variables. As a hack, we save then restore the
366     * ERR_IN_PROGRESS flag in the interpreter. The problem is that there
367     * could be unset traces on the variables, which cause scripts to be
368     * evaluated. This will clear the ERR_IN_PROGRESS flag, losing stack
369     * trace information if the procedure was exiting with an error. The
370     * code below preserves the flag. Unfortunately, that isn't really
371     * enough: we really should preserve the errorInfo variable too
372     * (otherwise a nested error in the trace script will trash errorInfo).
373     * What's really needed is a general-purpose mechanism for saving and
374     * restoring interpreter state.
375     */
376    
377     saveErrFlag = (iPtr->flags & ERR_IN_PROGRESS);
378    
379     if (framePtr->varTablePtr != NULL) {
380     TclDeleteVars(iPtr, framePtr->varTablePtr);
381     ckfree((char *) framePtr->varTablePtr);
382     framePtr->varTablePtr = NULL;
383     }
384     if (framePtr->numCompiledLocals > 0) {
385     TclDeleteCompiledLocalVars(iPtr, framePtr);
386     }
387    
388     iPtr->flags |= saveErrFlag;
389    
390     /*
391     * Decrement the namespace's count of active call frames. If the
392     * namespace is "dying" and there are no more active call frames,
393     * call Tcl_DeleteNamespace to destroy it.
394     */
395    
396     nsPtr = framePtr->nsPtr;
397     nsPtr->activationCount--;
398     if ((nsPtr->flags & NS_DYING)
399     && (nsPtr->activationCount == 0)) {
400     Tcl_DeleteNamespace((Tcl_Namespace *) nsPtr);
401     }
402     framePtr->nsPtr = NULL;
403     }
404    
405     /*
406     *----------------------------------------------------------------------
407     *
408     * Tcl_CreateNamespace --
409     *
410     * Creates a new namespace with the given name. If there is no
411     * active namespace (i.e., the interpreter is being initialized),
412     * the global :: namespace is created and returned.
413     *
414     * Results:
415     * Returns a pointer to the new namespace if successful. If the
416     * namespace already exists or if another error occurs, this routine
417     * returns NULL, along with an error message in the interpreter's
418     * result object.
419     *
420     * Side effects:
421     * If the name contains "::" qualifiers and a parent namespace does
422     * not already exist, it is automatically created.
423     *
424     *----------------------------------------------------------------------
425     */
426    
427     Tcl_Namespace *
428     Tcl_CreateNamespace(interp, name, clientData, deleteProc)
429     Tcl_Interp *interp; /* Interpreter in which a new namespace
430     * is being created. Also used for
431     * error reporting. */
432     char *name; /* Name for the new namespace. May be a
433     * qualified name with names of ancestor
434     * namespaces separated by "::"s. */
435     ClientData clientData; /* One-word value to store with
436     * namespace. */
437     Tcl_NamespaceDeleteProc *deleteProc;
438     /* Procedure called to delete client
439     * data when the namespace is deleted.
440     * NULL if no procedure should be
441     * called. */
442     {
443     Interp *iPtr = (Interp *) interp;
444     register Namespace *nsPtr, *ancestorPtr;
445     Namespace *parentPtr, *dummy1Ptr, *dummy2Ptr;
446     Namespace *globalNsPtr = iPtr->globalNsPtr;
447     char *simpleName;
448     Tcl_HashEntry *entryPtr;
449     Tcl_DString buffer1, buffer2;
450     int newEntry;
451    
452     /*
453     * If there is no active namespace, the interpreter is being
454     * initialized.
455     */
456    
457     if ((globalNsPtr == NULL) && (iPtr->varFramePtr == NULL)) {
458     /*
459     * Treat this namespace as the global namespace, and avoid
460     * looking for a parent.
461     */
462    
463     parentPtr = NULL;
464     simpleName = "";
465     } else if (*name == '\0') {
466     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
467     "can't create namespace \"\": only global namespace can have empty name", (char *) NULL);
468     return NULL;
469     } else {
470     /*
471     * Find the parent for the new namespace.
472     */
473    
474     TclGetNamespaceForQualName(interp, name, (Namespace *) NULL,
475     /*flags*/ (CREATE_NS_IF_UNKNOWN | TCL_LEAVE_ERR_MSG),
476     &parentPtr, &dummy1Ptr, &dummy2Ptr, &simpleName);
477    
478     /*
479     * If the unqualified name at the end is empty, there were trailing
480     * "::"s after the namespace's name which we ignore. The new
481     * namespace was already (recursively) created and is pointed to
482     * by parentPtr.
483     */
484    
485     if (*simpleName == '\0') {
486     return (Tcl_Namespace *) parentPtr;
487     }
488    
489     /*
490     * Check for a bad namespace name and make sure that the name
491     * does not already exist in the parent namespace.
492     */
493    
494     if (Tcl_FindHashEntry(&parentPtr->childTable, simpleName) != NULL) {
495     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
496     "can't create namespace \"", name,
497     "\": already exists", (char *) NULL);
498     return NULL;
499     }
500     }
501    
502     /*
503     * Create the new namespace and root it in its parent. Increment the
504     * count of namespaces created.
505     */
506    
507    
508     nsPtr = (Namespace *) ckalloc(sizeof(Namespace));
509     nsPtr->name = (char *) ckalloc((unsigned) (strlen(simpleName)+1));
510     strcpy(nsPtr->name, simpleName);
511     nsPtr->fullName = NULL; /* set below */
512     nsPtr->clientData = clientData;
513     nsPtr->deleteProc = deleteProc;
514     nsPtr->parentPtr = parentPtr;
515     Tcl_InitHashTable(&nsPtr->childTable, TCL_STRING_KEYS);
516     Tcl_MutexLock(&nsMutex);
517     numNsCreated++;
518     nsPtr->nsId = numNsCreated;
519     Tcl_MutexUnlock(&nsMutex);
520     nsPtr->interp = interp;
521     nsPtr->flags = 0;
522     nsPtr->activationCount = 0;
523     nsPtr->refCount = 0;
524     Tcl_InitHashTable(&nsPtr->cmdTable, TCL_STRING_KEYS);
525     Tcl_InitHashTable(&nsPtr->varTable, TCL_STRING_KEYS);
526     nsPtr->exportArrayPtr = NULL;
527     nsPtr->numExportPatterns = 0;
528     nsPtr->maxExportPatterns = 0;
529     nsPtr->cmdRefEpoch = 0;
530     nsPtr->resolverEpoch = 0;
531     nsPtr->cmdResProc = NULL;
532     nsPtr->varResProc = NULL;
533     nsPtr->compiledVarResProc = NULL;
534    
535     if (parentPtr != NULL) {
536     entryPtr = Tcl_CreateHashEntry(&parentPtr->childTable, simpleName,
537     &newEntry);
538     Tcl_SetHashValue(entryPtr, (ClientData) nsPtr);
539     }
540    
541     /*
542     * Build the fully qualified name for this namespace.
543     */
544    
545     Tcl_DStringInit(&buffer1);
546     Tcl_DStringInit(&buffer2);
547     for (ancestorPtr = nsPtr; ancestorPtr != NULL;
548     ancestorPtr = ancestorPtr->parentPtr) {
549     if (ancestorPtr != globalNsPtr) {
550     Tcl_DStringAppend(&buffer1, "::", 2);
551     Tcl_DStringAppend(&buffer1, ancestorPtr->name, -1);
552     }
553     Tcl_DStringAppend(&buffer1, Tcl_DStringValue(&buffer2), -1);
554    
555     Tcl_DStringSetLength(&buffer2, 0);
556     Tcl_DStringAppend(&buffer2, Tcl_DStringValue(&buffer1), -1);
557     Tcl_DStringSetLength(&buffer1, 0);
558     }
559    
560     name = Tcl_DStringValue(&buffer2);
561     nsPtr->fullName = (char *) ckalloc((unsigned) (strlen(name)+1));
562     strcpy(nsPtr->fullName, name);
563    
564     Tcl_DStringFree(&buffer1);
565     Tcl_DStringFree(&buffer2);
566    
567     /*
568     * Return a pointer to the new namespace.
569     */
570    
571     return (Tcl_Namespace *) nsPtr;
572     }
573    
574     /*
575     *----------------------------------------------------------------------
576     *
577     * Tcl_DeleteNamespace --
578     *
579     * Deletes a namespace and all of the commands, variables, and other
580     * namespaces within it.
581     *
582     * Results:
583     * None.
584     *
585     * Side effects:
586     * When a namespace is deleted, it is automatically removed as a
587     * child of its parent namespace. Also, all its commands, variables
588     * and child namespaces are deleted.
589     *
590     *----------------------------------------------------------------------
591     */
592    
593     void
594     Tcl_DeleteNamespace(namespacePtr)
595     Tcl_Namespace *namespacePtr; /* Points to the namespace to delete. */
596     {
597     register Namespace *nsPtr = (Namespace *) namespacePtr;
598     Interp *iPtr = (Interp *) nsPtr->interp;
599     Namespace *globalNsPtr =
600     (Namespace *) Tcl_GetGlobalNamespace((Tcl_Interp *) iPtr);
601     Tcl_HashEntry *entryPtr;
602    
603     /*
604     * If the namespace is on the call frame stack, it is marked as "dying"
605     * (NS_DYING is OR'd into its flags): the namespace can't be looked up
606     * by name but its commands and variables are still usable by those
607     * active call frames. When all active call frames referring to the
608     * namespace have been popped from the Tcl stack, Tcl_PopCallFrame will
609     * call this procedure again to delete everything in the namespace.
610     * If no nsName objects refer to the namespace (i.e., if its refCount
611     * is zero), its commands and variables are deleted and the storage for
612     * its namespace structure is freed. Otherwise, if its refCount is
613     * nonzero, the namespace's commands and variables are deleted but the
614     * structure isn't freed. Instead, NS_DEAD is OR'd into the structure's
615     * flags to allow the namespace resolution code to recognize that the
616     * namespace is "deleted". The structure's storage is freed by
617     * FreeNsNameInternalRep when its refCount reaches 0.
618     */
619    
620     if (nsPtr->activationCount > 0) {
621     nsPtr->flags |= NS_DYING;
622     if (nsPtr->parentPtr != NULL) {
623     entryPtr = Tcl_FindHashEntry(&nsPtr->parentPtr->childTable,
624     nsPtr->name);
625     if (entryPtr != NULL) {
626     Tcl_DeleteHashEntry(entryPtr);
627     }
628     }
629     nsPtr->parentPtr = NULL;
630     } else {
631     /*
632     * Delete the namespace and everything in it. If this is the global
633     * namespace, then clear it but don't free its storage unless the
634     * interpreter is being torn down.
635     */
636    
637     TclTeardownNamespace(nsPtr);
638    
639     if ((nsPtr != globalNsPtr) || (iPtr->flags & DELETED)) {
640     /*
641     * If this is the global namespace, then it may have residual
642     * "errorInfo" and "errorCode" variables for errors that
643     * occurred while it was being torn down. Try to clear the
644     * variable list one last time.
645     */
646    
647     TclDeleteVars((Interp *) nsPtr->interp, &nsPtr->varTable);
648    
649     Tcl_DeleteHashTable(&nsPtr->childTable);
650     Tcl_DeleteHashTable(&nsPtr->cmdTable);
651    
652     /*
653     * If the reference count is 0, then discard the namespace.
654     * Otherwise, mark it as "dead" so that it can't be used.
655     */
656    
657     if (nsPtr->refCount == 0) {
658     NamespaceFree(nsPtr);
659     } else {
660     nsPtr->flags |= NS_DEAD;
661     }
662     }
663     }
664     }
665    
666     /*
667     *----------------------------------------------------------------------
668     *
669     * TclTeardownNamespace --
670     *
671     * Used internally to dismantle and unlink a namespace when it is
672     * deleted. Divorces the namespace from its parent, and deletes all
673     * commands, variables, and child namespaces.
674     *
675     * This is kept separate from Tcl_DeleteNamespace so that the global
676     * namespace can be handled specially. Global variables like
677     * "errorInfo" and "errorCode" need to remain intact while other
678     * namespaces and commands are torn down, in case any errors occur.
679     *
680     * Results:
681     * None.
682     *
683     * Side effects:
684     * Removes this namespace from its parent's child namespace hashtable.
685     * Deletes all commands, variables and namespaces in this namespace.
686     * If this is the global namespace, the "errorInfo" and "errorCode"
687     * variables are left alone and deleted later.
688     *
689     *----------------------------------------------------------------------
690     */
691    
692     void
693     TclTeardownNamespace(nsPtr)
694     register Namespace *nsPtr; /* Points to the namespace to be dismantled
695     * and unlinked from its parent. */
696     {
697     Interp *iPtr = (Interp *) nsPtr->interp;
698     register Tcl_HashEntry *entryPtr;
699     Tcl_HashSearch search;
700     Tcl_Namespace *childNsPtr;
701     Tcl_Command cmd;
702     Namespace *globalNsPtr =
703     (Namespace *) Tcl_GetGlobalNamespace((Tcl_Interp *) iPtr);
704     int i;
705    
706     /*
707     * Start by destroying the namespace's variable table,
708     * since variables might trigger traces.
709     */
710    
711     if (nsPtr == globalNsPtr) {
712     /*
713     * This is the global namespace, so be careful to preserve the
714     * "errorInfo" and "errorCode" variables. These might be needed
715     * later on if errors occur while deleting commands. We are careful
716     * to destroy and recreate the "errorInfo" and "errorCode"
717     * variables, in case they had any traces on them.
718     */
719    
720     char *str, *errorInfoStr, *errorCodeStr;
721    
722     str = Tcl_GetVar((Tcl_Interp *) iPtr, "errorInfo", TCL_GLOBAL_ONLY);
723     if (str != NULL) {
724     errorInfoStr = ckalloc((unsigned) (strlen(str)+1));
725     strcpy(errorInfoStr, str);
726     } else {
727     errorInfoStr = NULL;
728     }
729    
730     str = Tcl_GetVar((Tcl_Interp *) iPtr, "errorCode", TCL_GLOBAL_ONLY);
731     if (str != NULL) {
732     errorCodeStr = ckalloc((unsigned) (strlen(str)+1));
733     strcpy(errorCodeStr, str);
734     } else {
735     errorCodeStr = NULL;
736     }
737    
738     TclDeleteVars(iPtr, &nsPtr->varTable);
739     Tcl_InitHashTable(&nsPtr->varTable, TCL_STRING_KEYS);
740    
741     if (errorInfoStr != NULL) {
742     Tcl_SetVar((Tcl_Interp *) iPtr, "errorInfo", errorInfoStr,
743     TCL_GLOBAL_ONLY);
744     ckfree(errorInfoStr);
745     }
746     if (errorCodeStr != NULL) {
747     Tcl_SetVar((Tcl_Interp *) iPtr, "errorCode", errorCodeStr,
748     TCL_GLOBAL_ONLY);
749     ckfree(errorCodeStr);
750     }
751     } else {
752     /*
753     * Variable table should be cleared but not freed! TclDeleteVars
754     * frees it, so we reinitialize it afterwards.
755     */
756    
757     TclDeleteVars(iPtr, &nsPtr->varTable);
758     Tcl_InitHashTable(&nsPtr->varTable, TCL_STRING_KEYS);
759     }
760    
761     /*
762     * Remove the namespace from its parent's child hashtable.
763     */
764    
765     if (nsPtr->parentPtr != NULL) {
766     entryPtr = Tcl_FindHashEntry(&nsPtr->parentPtr->childTable,
767     nsPtr->name);
768     if (entryPtr != NULL) {
769     Tcl_DeleteHashEntry(entryPtr);
770     }
771     }
772     nsPtr->parentPtr = NULL;
773    
774     /*
775     * Delete all the child namespaces.
776     *
777     * BE CAREFUL: When each child is deleted, it will divorce
778     * itself from its parent. You can't traverse a hash table
779     * properly if its elements are being deleted. We use only
780     * the Tcl_FirstHashEntry function to be safe.
781     */
782    
783     for (entryPtr = Tcl_FirstHashEntry(&nsPtr->childTable, &search);
784     entryPtr != NULL;
785     entryPtr = Tcl_FirstHashEntry(&nsPtr->childTable, &search)) {
786     childNsPtr = (Tcl_Namespace *) Tcl_GetHashValue(entryPtr);
787     Tcl_DeleteNamespace(childNsPtr);
788     }
789    
790     /*
791     * Delete all commands in this namespace. Be careful when traversing the
792     * hash table: when each command is deleted, it removes itself from the
793     * command table.
794     */
795    
796     for (entryPtr = Tcl_FirstHashEntry(&nsPtr->cmdTable, &search);
797     entryPtr != NULL;
798     entryPtr = Tcl_FirstHashEntry(&nsPtr->cmdTable, &search)) {
799     cmd = (Tcl_Command) Tcl_GetHashValue(entryPtr);
800     Tcl_DeleteCommandFromToken((Tcl_Interp *) iPtr, cmd);
801     }
802     Tcl_DeleteHashTable(&nsPtr->cmdTable);
803     Tcl_InitHashTable(&nsPtr->cmdTable, TCL_STRING_KEYS);
804    
805     /*
806     * Free the namespace's export pattern array.
807     */
808    
809     if (nsPtr->exportArrayPtr != NULL) {
810     for (i = 0; i < nsPtr->numExportPatterns; i++) {
811     ckfree(nsPtr->exportArrayPtr[i]);
812     }
813     ckfree((char *) nsPtr->exportArrayPtr);
814     nsPtr->exportArrayPtr = NULL;
815     nsPtr->numExportPatterns = 0;
816     nsPtr->maxExportPatterns = 0;
817     }
818    
819     /*
820     * Free any client data associated with the namespace.
821     */
822    
823     if (nsPtr->deleteProc != NULL) {
824     (*nsPtr->deleteProc)(nsPtr->clientData);
825     }
826     nsPtr->deleteProc = NULL;
827     nsPtr->clientData = NULL;
828    
829     /*
830     * Reset the namespace's id field to ensure that this namespace won't
831     * be interpreted as valid by, e.g., the cache validation code for
832     * cached command references in Tcl_GetCommandFromObj.
833     */
834    
835     nsPtr->nsId = 0;
836     }
837    
838     /*
839     *----------------------------------------------------------------------
840     *
841     * NamespaceFree --
842     *
843     * Called after a namespace has been deleted, when its
844     * reference count reaches 0. Frees the data structure
845     * representing the namespace.
846     *
847     * Results:
848     * None.
849     *
850     * Side effects:
851     * None.
852     *
853     *----------------------------------------------------------------------
854     */
855    
856     static void
857     NamespaceFree(nsPtr)
858     register Namespace *nsPtr; /* Points to the namespace to free. */
859     {
860     /*
861     * Most of the namespace's contents are freed when the namespace is
862     * deleted by Tcl_DeleteNamespace. All that remains is to free its names
863     * (for error messages), and the structure itself.
864     */
865    
866     ckfree(nsPtr->name);
867     ckfree(nsPtr->fullName);
868    
869     ckfree((char *) nsPtr);
870     }
871    
872    
873     /*
874     *----------------------------------------------------------------------
875     *
876     * Tcl_Export --
877     *
878     * Makes all the commands matching a pattern available to later be
879     * imported from the namespace specified by namespacePtr (or the
880     * current namespace if namespacePtr is NULL). The specified pattern is
881     * appended onto the namespace's export pattern list, which is
882     * optionally cleared beforehand.
883     *
884     * Results:
885     * Returns TCL_OK if successful, or TCL_ERROR (along with an error
886     * message in the interpreter's result) if something goes wrong.
887     *
888     * Side effects:
889     * Appends the export pattern onto the namespace's export list.
890     * Optionally reset the namespace's export pattern list.
891     *
892     *----------------------------------------------------------------------
893     */
894    
895     int
896     Tcl_Export(interp, namespacePtr, pattern, resetListFirst)
897     Tcl_Interp *interp; /* Current interpreter. */
898     Tcl_Namespace *namespacePtr; /* Points to the namespace from which
899     * commands are to be exported. NULL for
900     * the current namespace. */
901     char *pattern; /* String pattern indicating which commands
902     * to export. This pattern may not include
903     * any namespace qualifiers; only commands
904     * in the specified namespace may be
905     * exported. */
906     int resetListFirst; /* If nonzero, resets the namespace's
907     * export list before appending.
908     * If 0, return an error if an imported
909     * cmd conflicts with an existing one. */
910     {
911     #define INIT_EXPORT_PATTERNS 5
912     Namespace *nsPtr, *exportNsPtr, *dummyPtr;
913     Namespace *currNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
914     char *simplePattern, *patternCpy;
915     int neededElems, len, i;
916    
917     /*
918     * If the specified namespace is NULL, use the current namespace.
919     */
920    
921     if (namespacePtr == NULL) {
922     nsPtr = (Namespace *) currNsPtr;
923     } else {
924     nsPtr = (Namespace *) namespacePtr;
925     }
926    
927     /*
928     * If resetListFirst is true (nonzero), clear the namespace's export
929     * pattern list.
930     */
931    
932     if (resetListFirst) {
933     if (nsPtr->exportArrayPtr != NULL) {
934     for (i = 0; i < nsPtr->numExportPatterns; i++) {
935     ckfree(nsPtr->exportArrayPtr[i]);
936     }
937     ckfree((char *) nsPtr->exportArrayPtr);
938     nsPtr->exportArrayPtr = NULL;
939     nsPtr->numExportPatterns = 0;
940     nsPtr->maxExportPatterns = 0;
941     }
942     }
943    
944     /*
945     * Check that the pattern doesn't have namespace qualifiers.
946     */
947    
948     TclGetNamespaceForQualName(interp, pattern, nsPtr,
949     /*flags*/ TCL_LEAVE_ERR_MSG, &exportNsPtr, &dummyPtr,
950     &dummyPtr, &simplePattern);
951    
952     if ((exportNsPtr != nsPtr) || (strcmp(pattern, simplePattern) != 0)) {
953     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
954     "invalid export pattern \"", pattern,
955     "\": pattern can't specify a namespace",
956     (char *) NULL);
957     return TCL_ERROR;
958     }
959    
960     /*
961     * Make sure that we don't already have the pattern in the array
962     */
963     if (nsPtr->exportArrayPtr != NULL) {
964     for (i = 0; i < nsPtr->numExportPatterns; i++) {
965     if (strcmp(pattern, nsPtr->exportArrayPtr[i]) == 0) {
966     /*
967     * The pattern already exists in the list
968     */
969     return TCL_OK;
970     }
971     }
972     }
973    
974     /*
975     * Make sure there is room in the namespace's pattern array for the
976     * new pattern.
977     */
978    
979     neededElems = nsPtr->numExportPatterns + 1;
980     if (nsPtr->exportArrayPtr == NULL) {
981     nsPtr->exportArrayPtr = (char **)
982     ckalloc((unsigned) (INIT_EXPORT_PATTERNS * sizeof(char *)));
983     nsPtr->numExportPatterns = 0;
984     nsPtr->maxExportPatterns = INIT_EXPORT_PATTERNS;
985     } else if (neededElems > nsPtr->maxExportPatterns) {
986     int numNewElems = 2 * nsPtr->maxExportPatterns;
987     size_t currBytes = nsPtr->numExportPatterns * sizeof(char *);
988     size_t newBytes = numNewElems * sizeof(char *);
989     char **newPtr = (char **) ckalloc((unsigned) newBytes);
990    
991     memcpy((VOID *) newPtr, (VOID *) nsPtr->exportArrayPtr,
992     currBytes);
993     ckfree((char *) nsPtr->exportArrayPtr);
994     nsPtr->exportArrayPtr = (char **) newPtr;
995     nsPtr->maxExportPatterns = numNewElems;
996     }
997    
998     /*
999     * Add the pattern to the namespace's array of export patterns.
1000     */
1001    
1002     len = strlen(pattern);
1003     patternCpy = (char *) ckalloc((unsigned) (len + 1));
1004     strcpy(patternCpy, pattern);
1005    
1006     nsPtr->exportArrayPtr[nsPtr->numExportPatterns] = patternCpy;
1007     nsPtr->numExportPatterns++;
1008     return TCL_OK;
1009     #undef INIT_EXPORT_PATTERNS
1010     }
1011    
1012     /*
1013     *----------------------------------------------------------------------
1014     *
1015     * Tcl_AppendExportList --
1016     *
1017     * Appends onto the argument object the list of export patterns for the
1018     * specified namespace.
1019     *
1020     * Results:
1021     * The return value is normally TCL_OK; in this case the object
1022     * referenced by objPtr has each export pattern appended to it. If an
1023     * error occurs, TCL_ERROR is returned and the interpreter's result
1024     * holds an error message.
1025     *
1026     * Side effects:
1027     * If necessary, the object referenced by objPtr is converted into
1028     * a list object.
1029     *
1030     *----------------------------------------------------------------------
1031     */
1032    
1033     int
1034     Tcl_AppendExportList(interp, namespacePtr, objPtr)
1035     Tcl_Interp *interp; /* Interpreter used for error reporting. */
1036     Tcl_Namespace *namespacePtr; /* Points to the namespace whose export
1037     * pattern list is appended onto objPtr.
1038     * NULL for the current namespace. */
1039     Tcl_Obj *objPtr; /* Points to the Tcl object onto which the
1040     * export pattern list is appended. */
1041     {
1042     Namespace *nsPtr;
1043     int i, result;
1044    
1045     /*
1046     * If the specified namespace is NULL, use the current namespace.
1047     */
1048    
1049     if (namespacePtr == NULL) {
1050     nsPtr = (Namespace *) (Namespace *) Tcl_GetCurrentNamespace(interp);
1051     } else {
1052     nsPtr = (Namespace *) namespacePtr;
1053     }
1054    
1055     /*
1056     * Append the export pattern list onto objPtr.
1057     */
1058    
1059     for (i = 0; i < nsPtr->numExportPatterns; i++) {
1060     result = Tcl_ListObjAppendElement(interp, objPtr,
1061     Tcl_NewStringObj(nsPtr->exportArrayPtr[i], -1));
1062     if (result != TCL_OK) {
1063     return result;
1064     }
1065     }
1066     return TCL_OK;
1067     }
1068    
1069     /*
1070     *----------------------------------------------------------------------
1071     *
1072     * Tcl_Import --
1073     *
1074     * Imports all of the commands matching a pattern into the namespace
1075     * specified by namespacePtr (or the current namespace if contextNsPtr
1076     * is NULL). This is done by creating a new command (the "imported
1077     * command") that points to the real command in its original namespace.
1078     *
1079     * If matching commands are on the autoload path but haven't been
1080     * loaded yet, this command forces them to be loaded, then creates
1081     * the links to them.
1082     *
1083     * Results:
1084     * Returns TCL_OK if successful, or TCL_ERROR (along with an error
1085     * message in the interpreter's result) if something goes wrong.
1086     *
1087     * Side effects:
1088     * Creates new commands in the importing namespace. These indirect
1089     * calls back to the real command and are deleted if the real commands
1090     * are deleted.
1091     *
1092     *----------------------------------------------------------------------
1093     */
1094    
1095     int
1096     Tcl_Import(interp, namespacePtr, pattern, allowOverwrite)
1097     Tcl_Interp *interp; /* Current interpreter. */
1098     Tcl_Namespace *namespacePtr; /* Points to the namespace into which the
1099     * commands are to be imported. NULL for
1100     * the current namespace. */
1101     char *pattern; /* String pattern indicating which commands
1102     * to import. This pattern should be
1103     * qualified by the name of the namespace
1104     * from which to import the command(s). */
1105     int allowOverwrite; /* If nonzero, allow existing commands to
1106     * be overwritten by imported commands.
1107     * If 0, return an error if an imported
1108     * cmd conflicts with an existing one. */
1109     {
1110     Interp *iPtr = (Interp *) interp;
1111     Namespace *nsPtr, *importNsPtr, *dummyPtr;
1112     Namespace *currNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
1113     char *simplePattern, *cmdName;
1114     register Tcl_HashEntry *hPtr;
1115     Tcl_HashSearch search;
1116     Command *cmdPtr, *realCmdPtr;
1117     ImportRef *refPtr;
1118     Tcl_Command autoCmd, importedCmd;
1119     ImportedCmdData *dataPtr;
1120     int wasExported, i, result;
1121    
1122     /*
1123     * If the specified namespace is NULL, use the current namespace.
1124     */
1125    
1126     if (namespacePtr == NULL) {
1127     nsPtr = (Namespace *) currNsPtr;
1128     } else {
1129     nsPtr = (Namespace *) namespacePtr;
1130     }
1131    
1132     /*
1133     * First, invoke the "auto_import" command with the pattern
1134     * being imported. This command is part of the Tcl library.
1135     * It looks for imported commands in autoloaded libraries and
1136     * loads them in. That way, they will be found when we try
1137     * to create links below.
1138     */
1139    
1140     autoCmd = Tcl_FindCommand(interp, "auto_import",
1141     (Tcl_Namespace *) NULL, /*flags*/ TCL_GLOBAL_ONLY);
1142    
1143     if (autoCmd != NULL) {
1144     Tcl_Obj *objv[2];
1145    
1146     objv[0] = Tcl_NewStringObj("auto_import", -1);
1147     Tcl_IncrRefCount(objv[0]);
1148     objv[1] = Tcl_NewStringObj(pattern, -1);
1149     Tcl_IncrRefCount(objv[1]);
1150    
1151     cmdPtr = (Command *) autoCmd;
1152     result = (*cmdPtr->objProc)(cmdPtr->objClientData, interp,
1153     2, objv);
1154    
1155     Tcl_DecrRefCount(objv[0]);
1156     Tcl_DecrRefCount(objv[1]);
1157    
1158     if (result != TCL_OK) {
1159     return TCL_ERROR;
1160     }
1161     Tcl_ResetResult(interp);
1162     }
1163    
1164     /*
1165     * From the pattern, find the namespace from which we are importing
1166     * and get the simple pattern (no namespace qualifiers or ::'s) at
1167     * the end.
1168     */
1169    
1170     if (strlen(pattern) == 0) {
1171     Tcl_SetStringObj(Tcl_GetObjResult(interp),
1172     "empty import pattern", -1);
1173     return TCL_ERROR;
1174     }
1175     TclGetNamespaceForQualName(interp, pattern, nsPtr,
1176     /*flags*/ TCL_LEAVE_ERR_MSG, &importNsPtr, &dummyPtr,
1177     &dummyPtr, &simplePattern);
1178    
1179     if (importNsPtr == NULL) {
1180     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
1181     "unknown namespace in import pattern \"",
1182     pattern, "\"", (char *) NULL);
1183     return TCL_ERROR;
1184     }
1185     if (importNsPtr == nsPtr) {
1186     if (pattern == simplePattern) {
1187     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
1188     "no namespace specified in import pattern \"", pattern,
1189     "\"", (char *) NULL);
1190     } else {
1191     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
1192     "import pattern \"", pattern,
1193     "\" tries to import from namespace \"",
1194     importNsPtr->name, "\" into itself", (char *) NULL);
1195     }
1196     return TCL_ERROR;
1197     }
1198    
1199     /*
1200     * Scan through the command table in the source namespace and look for
1201     * exported commands that match the string pattern. Create an "imported
1202     * command" in the current namespace for each imported command; these
1203     * commands redirect their invocations to the "real" command.
1204     */
1205    
1206     for (hPtr = Tcl_FirstHashEntry(&importNsPtr->cmdTable, &search);
1207     (hPtr != NULL);
1208     hPtr = Tcl_NextHashEntry(&search)) {
1209     cmdName = Tcl_GetHashKey(&importNsPtr->cmdTable, hPtr);
1210     if (Tcl_StringMatch(cmdName, simplePattern)) {
1211     /*
1212     * The command cmdName in the source namespace matches the
1213     * pattern. Check whether it was exported. If it wasn't,
1214     * we ignore it.
1215     */
1216    
1217     wasExported = 0;
1218     for (i = 0; i < importNsPtr->numExportPatterns; i++) {
1219     if (Tcl_StringMatch(cmdName,
1220     importNsPtr->exportArrayPtr[i])) {
1221     wasExported = 1;
1222     break;
1223     }
1224     }
1225     if (!wasExported) {
1226     continue;
1227     }
1228    
1229     /*
1230     * Unless there is a name clash, create an imported command
1231     * in the current namespace that refers to cmdPtr.
1232     */
1233    
1234     if ((Tcl_FindHashEntry(&nsPtr->cmdTable, cmdName) == NULL)
1235     || allowOverwrite) {
1236     /*
1237     * Create the imported command and its client data.
1238     * To create the new command in the current namespace,
1239     * generate a fully qualified name for it.
1240     */
1241    
1242     Tcl_DString ds;
1243    
1244     Tcl_DStringInit(&ds);
1245     Tcl_DStringAppend(&ds, nsPtr->fullName, -1);
1246     if (nsPtr != iPtr->globalNsPtr) {
1247     Tcl_DStringAppend(&ds, "::", 2);
1248     }
1249     Tcl_DStringAppend(&ds, cmdName, -1);
1250    
1251     /*
1252     * Check whether creating the new imported command in the
1253     * current namespace would create a cycle of imported->real
1254     * command references that also would destroy an existing
1255     * "real" command already in the current namespace.
1256     */
1257    
1258     cmdPtr = (Command *) Tcl_GetHashValue(hPtr);
1259     if (cmdPtr->deleteProc == DeleteImportedCmd) {
1260     realCmdPtr = (Command *) TclGetOriginalCommand(
1261     (Tcl_Command) cmdPtr);
1262     if ((realCmdPtr != NULL)
1263     && (realCmdPtr->nsPtr == currNsPtr)
1264     && (Tcl_FindHashEntry(&currNsPtr->cmdTable,
1265     cmdName) != NULL)) {
1266     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
1267     "import pattern \"", pattern,
1268     "\" would create a loop containing command \"",
1269     Tcl_DStringValue(&ds), "\"", (char *) NULL);
1270     return TCL_ERROR;
1271     }
1272     }
1273    
1274     dataPtr = (ImportedCmdData *)
1275     ckalloc(sizeof(ImportedCmdData));
1276     importedCmd = Tcl_CreateObjCommand(interp,
1277     Tcl_DStringValue(&ds), InvokeImportedCmd,
1278     (ClientData) dataPtr, DeleteImportedCmd);
1279     dataPtr->realCmdPtr = cmdPtr;
1280     dataPtr->selfPtr = (Command *) importedCmd;
1281     dataPtr->selfPtr->compileProc = cmdPtr->compileProc;
1282    
1283     /*
1284     * Create an ImportRef structure describing this new import
1285     * command and add it to the import ref list in the "real"
1286     * command.
1287     */
1288    
1289     refPtr = (ImportRef *) ckalloc(sizeof(ImportRef));
1290     refPtr->importedCmdPtr = (Command *) importedCmd;
1291     refPtr->nextPtr = cmdPtr->importRefPtr;
1292     cmdPtr->importRefPtr = refPtr;
1293     } else {
1294     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
1295     "can't import command \"", cmdName,
1296     "\": already exists", (char *) NULL);
1297     return TCL_ERROR;
1298     }
1299     }
1300     }
1301     return TCL_OK;
1302     }
1303    
1304     /*
1305     *----------------------------------------------------------------------
1306     *
1307     * Tcl_ForgetImport --
1308     *
1309     * Deletes previously imported commands. Given a pattern that may
1310     * include the name of an exporting namespace, this procedure first
1311     * finds all matching exported commands. It then looks in the namespace
1312     * specified by namespacePtr for any corresponding previously imported
1313     * commands, which it deletes. If namespacePtr is NULL, commands are
1314     * deleted from the current namespace.
1315     *
1316     * Results:
1317     * Returns TCL_OK if successful. If there is an error, returns
1318     * TCL_ERROR and puts an error message in the interpreter's result
1319     * object.
1320     *
1321     * Side effects:
1322     * May delete commands.
1323     *
1324     *----------------------------------------------------------------------
1325     */
1326    
1327     int
1328     Tcl_ForgetImport(interp, namespacePtr, pattern)
1329     Tcl_Interp *interp; /* Current interpreter. */
1330     Tcl_Namespace *namespacePtr; /* Points to the namespace from which
1331     * previously imported commands should be
1332     * removed. NULL for current namespace. */
1333     char *pattern; /* String pattern indicating which imported
1334     * commands to remove. This pattern should
1335     * be qualified by the name of the
1336     * namespace from which the command(s) were
1337     * imported. */
1338     {
1339     Namespace *nsPtr, *importNsPtr, *dummyPtr, *actualCtxPtr;
1340     char *simplePattern, *cmdName;
1341     register Tcl_HashEntry *hPtr;
1342     Tcl_HashSearch search;
1343     Command *cmdPtr;
1344    
1345     /*
1346     * If the specified namespace is NULL, use the current namespace.
1347     */
1348    
1349     if (namespacePtr == NULL) {
1350     nsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
1351     } else {
1352     nsPtr = (Namespace *) namespacePtr;
1353     }
1354    
1355     /*
1356     * From the pattern, find the namespace from which we are importing
1357     * and get the simple pattern (no namespace qualifiers or ::'s) at
1358     * the end.
1359     */
1360    
1361     TclGetNamespaceForQualName(interp, pattern, nsPtr,
1362     /*flags*/ TCL_LEAVE_ERR_MSG, &importNsPtr, &dummyPtr,
1363     &actualCtxPtr, &simplePattern);
1364    
1365     if (importNsPtr == NULL) {
1366     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
1367     "unknown namespace in namespace forget pattern \"",
1368     pattern, "\"", (char *) NULL);
1369     return TCL_ERROR;
1370     }
1371    
1372     /*
1373     * Scan through the command table in the source namespace and look for
1374     * exported commands that match the string pattern. If the current
1375     * namespace has an imported command that refers to one of those real
1376     * commands, delete it.
1377     */
1378    
1379     for (hPtr = Tcl_FirstHashEntry(&importNsPtr->cmdTable, &search);
1380     (hPtr != NULL);
1381     hPtr = Tcl_NextHashEntry(&search)) {
1382     cmdName = Tcl_GetHashKey(&importNsPtr->cmdTable, hPtr);
1383     if (Tcl_StringMatch(cmdName, simplePattern)) {
1384     hPtr = Tcl_FindHashEntry(&nsPtr->cmdTable, cmdName);
1385     if (hPtr != NULL) { /* cmd of same name in current namespace */
1386     cmdPtr = (Command *) Tcl_GetHashValue(hPtr);
1387     if (cmdPtr->deleteProc == DeleteImportedCmd) {
1388     Tcl_DeleteCommandFromToken(interp, (Tcl_Command) cmdPtr);
1389     }
1390     }
1391     }
1392     }
1393     return TCL_OK;
1394     }
1395    
1396     /*
1397     *----------------------------------------------------------------------
1398     *
1399     * TclGetOriginalCommand --
1400     *
1401     * An imported command is created in an namespace when a "real" command
1402     * is imported from another namespace. If the specified command is an
1403     * imported command, this procedure returns the original command it
1404     * refers to.
1405     *
1406     * Results:
1407     * If the command was imported into a sequence of namespaces a, b,...,n
1408     * where each successive namespace just imports the command from the
1409     * previous namespace, this procedure returns the Tcl_Command token in
1410     * the first namespace, a. Otherwise, if the specified command is not
1411     * an imported command, the procedure returns NULL.
1412     *
1413     * Side effects:
1414     * None.
1415     *
1416     *----------------------------------------------------------------------
1417     */
1418    
1419     Tcl_Command
1420     TclGetOriginalCommand(command)
1421     Tcl_Command command; /* The imported command for which the
1422     * original command should be returned. */
1423     {
1424     register Command *cmdPtr = (Command *) command;
1425     ImportedCmdData *dataPtr;
1426    
1427     if (cmdPtr->deleteProc != DeleteImportedCmd) {
1428     return (Tcl_Command) NULL;
1429     }
1430    
1431     while (cmdPtr->deleteProc == DeleteImportedCmd) {
1432     dataPtr = (ImportedCmdData *) cmdPtr->objClientData;
1433     cmdPtr = dataPtr->realCmdPtr;
1434     }
1435     return (Tcl_Command) cmdPtr;
1436     }
1437    
1438     /*
1439     *----------------------------------------------------------------------
1440     *
1441     * InvokeImportedCmd --
1442     *
1443     * Invoked by Tcl whenever the user calls an imported command that
1444     * was created by Tcl_Import. Finds the "real" command (in another
1445     * namespace), and passes control to it.
1446     *
1447     * Results:
1448     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
1449     *
1450     * Side effects:
1451     * Returns a result in the interpreter's result object. If anything
1452     * goes wrong, the result object is set to an error message.
1453     *
1454     *----------------------------------------------------------------------
1455     */
1456    
1457     static int
1458     InvokeImportedCmd(clientData, interp, objc, objv)
1459     ClientData clientData; /* Points to the imported command's
1460     * ImportedCmdData structure. */
1461     Tcl_Interp *interp; /* Current interpreter. */
1462     int objc; /* Number of arguments. */
1463     Tcl_Obj *CONST objv[]; /* The argument objects. */
1464     {
1465     register ImportedCmdData *dataPtr = (ImportedCmdData *) clientData;
1466     register Command *realCmdPtr = dataPtr->realCmdPtr;
1467    
1468     return (*realCmdPtr->objProc)(realCmdPtr->objClientData, interp,
1469     objc, objv);
1470     }
1471    
1472     /*
1473     *----------------------------------------------------------------------
1474     *
1475     * DeleteImportedCmd --
1476     *
1477     * Invoked by Tcl whenever an imported command is deleted. The "real"
1478     * command keeps a list of all the imported commands that refer to it,
1479     * so those imported commands can be deleted when the real command is
1480     * deleted. This procedure removes the imported command reference from
1481     * the real command's list, and frees up the memory associated with
1482     * the imported command.
1483     *
1484     * Results:
1485     * None.
1486     *
1487     * Side effects:
1488     * Removes the imported command from the real command's import list.
1489     *
1490     *----------------------------------------------------------------------
1491     */
1492    
1493     static void
1494     DeleteImportedCmd(clientData)
1495     ClientData clientData; /* Points to the imported command's
1496     * ImportedCmdData structure. */
1497     {
1498     ImportedCmdData *dataPtr = (ImportedCmdData *) clientData;
1499     Command *realCmdPtr = dataPtr->realCmdPtr;
1500     Command *selfPtr = dataPtr->selfPtr;
1501     register ImportRef *refPtr, *prevPtr;
1502    
1503     prevPtr = NULL;
1504     for (refPtr = realCmdPtr->importRefPtr; refPtr != NULL;
1505     refPtr = refPtr->nextPtr) {
1506     if (refPtr->importedCmdPtr == selfPtr) {
1507     /*
1508     * Remove *refPtr from real command's list of imported commands
1509     * that refer to it.
1510     */
1511    
1512     if (prevPtr == NULL) { /* refPtr is first in list */
1513     realCmdPtr->importRefPtr = refPtr->nextPtr;
1514     } else {
1515     prevPtr->nextPtr = refPtr->nextPtr;
1516     }
1517     ckfree((char *) refPtr);
1518     ckfree((char *) dataPtr);
1519     return;
1520     }
1521     prevPtr = refPtr;
1522     }
1523    
1524     panic("DeleteImportedCmd: did not find cmd in real cmd's list of import references");
1525     }
1526    
1527     /*
1528     *----------------------------------------------------------------------
1529     *
1530     * TclGetNamespaceForQualName --
1531     *
1532     * Given a qualified name specifying a command, variable, or namespace,
1533     * and a namespace in which to resolve the name, this procedure returns
1534     * a pointer to the namespace that contains the item. A qualified name
1535     * consists of the "simple" name of an item qualified by the names of
1536     * an arbitrary number of containing namespace separated by "::"s. If
1537     * the qualified name starts with "::", it is interpreted absolutely
1538     * from the global namespace. Otherwise, it is interpreted relative to
1539     * the namespace specified by cxtNsPtr if it is non-NULL. If cxtNsPtr
1540     * is NULL, the name is interpreted relative to the current namespace.
1541     *
1542     * A relative name like "foo::bar::x" can be found starting in either
1543     * the current namespace or in the global namespace. So each search
1544     * usually follows two tracks, and two possible namespaces are
1545     * returned. If the procedure sets either *nsPtrPtr or *altNsPtrPtr to
1546     * NULL, then that path failed.
1547     *
1548     * If "flags" contains TCL_GLOBAL_ONLY, the relative qualified name is
1549     * sought only in the global :: namespace. The alternate search
1550     * (also) starting from the global namespace is ignored and
1551     * *altNsPtrPtr is set NULL.
1552     *
1553     * If "flags" contains TCL_NAMESPACE_ONLY, the relative qualified
1554     * name is sought only in the namespace specified by cxtNsPtr. The
1555     * alternate search starting from the global namespace is ignored and
1556     * *altNsPtrPtr is set NULL. If both TCL_GLOBAL_ONLY and
1557     * TCL_NAMESPACE_ONLY are specified, TCL_GLOBAL_ONLY is ignored and
1558     * the search starts from the namespace specified by cxtNsPtr.
1559     *
1560     * If "flags" contains CREATE_NS_IF_UNKNOWN, all namespace
1561     * components of the qualified name that cannot be found are
1562     * automatically created within their specified parent. This makes sure
1563     * that functions like Tcl_CreateCommand always succeed. There is no
1564     * alternate search path, so *altNsPtrPtr is set NULL.
1565     *
1566     * If "flags" contains FIND_ONLY_NS, the qualified name is treated as a
1567     * reference to a namespace, and the entire qualified name is
1568     * followed. If the name is relative, the namespace is looked up only
1569     * in the current namespace. A pointer to the namespace is stored in
1570     * *nsPtrPtr and NULL is stored in *simpleNamePtr. Otherwise, if
1571     * FIND_ONLY_NS is not specified, only the leading components are
1572     * treated as namespace names, and a pointer to the simple name of the
1573     * final component is stored in *simpleNamePtr.
1574     *
1575     * Results:
1576     * It sets *nsPtrPtr and *altNsPtrPtr to point to the two possible
1577     * namespaces which represent the last (containing) namespace in the
1578     * qualified name. If the procedure sets either *nsPtrPtr or *altNsPtrPtr
1579     * to NULL, then the search along that path failed. The procedure also
1580     * stores a pointer to the simple name of the final component in
1581     * *simpleNamePtr. If the qualified name is "::" or was treated as a
1582     * namespace reference (FIND_ONLY_NS), the procedure stores a pointer
1583     * to the namespace in *nsPtrPtr, NULL in *altNsPtrPtr, and sets
1584     * *simpleNamePtr to point to an empty string.
1585     *
1586     * If there is an error, this procedure returns TCL_ERROR. If "flags"
1587     * contains TCL_LEAVE_ERR_MSG, an error message is returned in the
1588     * interpreter's result object. Otherwise, the interpreter's result
1589     * object is left unchanged.
1590     *
1591     * *actualCxtPtrPtr is set to the actual context namespace. It is
1592     * set to the input context namespace pointer in cxtNsPtr. If cxtNsPtr
1593     * is NULL, it is set to the current namespace context.
1594     *
1595     * For backwards compatibility with the TclPro byte code loader,
1596     * this function always returns TCL_OK.
1597     *
1598     * Side effects:
1599     * If "flags" contains CREATE_NS_IF_UNKNOWN, new namespaces may be
1600     * created.
1601     *
1602     *----------------------------------------------------------------------
1603     */
1604    
1605     int
1606     TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags,
1607     nsPtrPtr, altNsPtrPtr, actualCxtPtrPtr, simpleNamePtr)
1608     Tcl_Interp *interp; /* Interpreter in which to find the
1609     * namespace containing qualName. */
1610     register char *qualName; /* A namespace-qualified name of an
1611     * command, variable, or namespace. */
1612     Namespace *cxtNsPtr; /* The namespace in which to start the
1613     * search for qualName's namespace. If NULL
1614     * start from the current namespace.
1615     * Ignored if TCL_GLOBAL_ONLY or
1616     * TCL_NAMESPACE_ONLY are set. */
1617     int flags; /* Flags controlling the search: an OR'd
1618     * combination of TCL_GLOBAL_ONLY,
1619     * TCL_NAMESPACE_ONLY,
1620     * CREATE_NS_IF_UNKNOWN, and
1621     * FIND_ONLY_NS. */
1622     Namespace **nsPtrPtr; /* Address where procedure stores a pointer
1623     * to containing namespace if qualName is
1624     * found starting from *cxtNsPtr or, if
1625     * TCL_GLOBAL_ONLY is set, if qualName is
1626     * found in the global :: namespace. NULL
1627     * is stored otherwise. */
1628     Namespace **altNsPtrPtr; /* Address where procedure stores a pointer
1629     * to containing namespace if qualName is
1630     * found starting from the global ::
1631     * namespace. NULL is stored if qualName
1632     * isn't found starting from :: or if the
1633     * TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
1634     * CREATE_NS_IF_UNKNOWN, FIND_ONLY_NS flag
1635     * is set. */
1636     Namespace **actualCxtPtrPtr; /* Address where procedure stores a pointer
1637     * to the actual namespace from which the
1638     * search started. This is either cxtNsPtr,
1639     * the :: namespace if TCL_GLOBAL_ONLY was
1640     * specified, or the current namespace if
1641     * cxtNsPtr was NULL. */
1642     char **simpleNamePtr; /* Address where procedure stores the
1643     * simple name at end of the qualName, or
1644     * NULL if qualName is "::" or the flag
1645     * FIND_ONLY_NS was specified. */
1646     {
1647     Interp *iPtr = (Interp *) interp;
1648     Namespace *nsPtr = cxtNsPtr;
1649     Namespace *altNsPtr;
1650     Namespace *globalNsPtr = iPtr->globalNsPtr;
1651     register char *start, *end;
1652     char *nsName;
1653     Tcl_HashEntry *entryPtr;
1654     Tcl_DString buffer;
1655     int len;
1656    
1657     /*
1658     * Determine the context namespace nsPtr in which to start the primary
1659     * search. If TCL_NAMESPACE_ONLY or FIND_ONLY_NS was specified, search
1660     * from the current namespace. If the qualName name starts with a "::"
1661     * or TCL_GLOBAL_ONLY was specified, search from the global
1662     * namespace. Otherwise, use the given namespace given in cxtNsPtr, or
1663     * if that is NULL, use the current namespace context. Note that we
1664     * always treat two or more adjacent ":"s as a namespace separator.
1665     */
1666    
1667     if (flags & (TCL_NAMESPACE_ONLY | FIND_ONLY_NS)) {
1668     nsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
1669     } else if (flags & TCL_GLOBAL_ONLY) {
1670     nsPtr = globalNsPtr;
1671     } else if (nsPtr == NULL) {
1672     if (iPtr->varFramePtr != NULL) {
1673     nsPtr = iPtr->varFramePtr->nsPtr;
1674     } else {
1675     nsPtr = iPtr->globalNsPtr;
1676     }
1677     }
1678    
1679     start = qualName; /* pts to start of qualifying namespace */
1680     if ((*qualName == ':') && (*(qualName+1) == ':')) {
1681     start = qualName+2; /* skip over the initial :: */
1682     while (*start == ':') {
1683     start++; /* skip over a subsequent : */
1684     }
1685     nsPtr = globalNsPtr;
1686     if (*start == '\0') { /* qualName is just two or more ":"s */
1687     *nsPtrPtr = globalNsPtr;
1688     *altNsPtrPtr = NULL;
1689     *actualCxtPtrPtr = globalNsPtr;
1690     *simpleNamePtr = start; /* points to empty string */
1691     return TCL_OK;
1692     }
1693     }
1694     *actualCxtPtrPtr = nsPtr;
1695    
1696     /*
1697     * Start an alternate search path starting with the global namespace.
1698     * However, if the starting context is the global namespace, or if the
1699     * flag is set to search only the namespace *cxtNsPtr, ignore the
1700     * alternate search path.
1701     */
1702    
1703     altNsPtr = globalNsPtr;
1704     if ((nsPtr == globalNsPtr)
1705     || (flags & (TCL_NAMESPACE_ONLY | FIND_ONLY_NS))) {
1706     altNsPtr = NULL;
1707     }
1708    
1709     /*
1710     * Loop to resolve each namespace qualifier in qualName.
1711     */
1712    
1713     Tcl_DStringInit(&buffer);
1714     end = start;
1715     while (*start != '\0') {
1716     /*
1717     * Find the next namespace qualifier (i.e., a name ending in "::")
1718     * or the end of the qualified name (i.e., a name ending in "\0").
1719     * Set len to the number of characters, starting from start,
1720     * in the name; set end to point after the "::"s or at the "\0".
1721     */
1722    
1723     len = 0;
1724     for (end = start; *end != '\0'; end++) {
1725     if ((*end == ':') && (*(end+1) == ':')) {
1726     end += 2; /* skip over the initial :: */
1727     while (*end == ':') {
1728     end++; /* skip over the subsequent : */
1729     }
1730     break; /* exit for loop; end is after ::'s */
1731     }
1732     len++;
1733     }
1734    
1735     if ((*end == '\0')
1736     && !((end-start >= 2) && (*(end-1) == ':') && (*(end-2) == ':'))) {
1737     /*
1738     * qualName ended with a simple name at start. If FIND_ONLY_NS
1739     * was specified, look this up as a namespace. Otherwise,
1740     * start is the name of a cmd or var and we are done.
1741     */
1742    
1743     if (flags & FIND_ONLY_NS) {
1744     nsName = start;
1745     } else {
1746     *nsPtrPtr = nsPtr;
1747     *altNsPtrPtr = altNsPtr;
1748     *simpleNamePtr = start;
1749     Tcl_DStringFree(&buffer);
1750     return TCL_OK;
1751     }
1752     } else {
1753     /*
1754     * start points to the beginning of a namespace qualifier ending
1755     * in "::". end points to the start of a name in that namespace
1756     * that might be empty. Copy the namespace qualifier to a
1757     * buffer so it can be null terminated. We can't modify the
1758     * incoming qualName since it may be a string constant.
1759     */
1760    
1761     Tcl_DStringSetLength(&buffer, 0);
1762     Tcl_DStringAppend(&buffer, start, len);
1763     nsName = Tcl_DStringValue(&buffer);
1764     }
1765    
1766     /*
1767     * Look up the namespace qualifier nsName in the current namespace
1768     * context. If it isn't found but CREATE_NS_IF_UNKNOWN is set,
1769     * create that qualifying namespace. This is needed for procedures
1770     * like Tcl_CreateCommand that cannot fail.
1771     */
1772    
1773     if (nsPtr != NULL) {
1774     entryPtr = Tcl_FindHashEntry(&nsPtr->childTable, nsName);
1775     if (entryPtr != NULL) {
1776     nsPtr = (Namespace *) Tcl_GetHashValue(entryPtr);
1777     } else if (flags & CREATE_NS_IF_UNKNOWN) {
1778     Tcl_CallFrame frame;
1779    
1780     (void) Tcl_PushCallFrame(interp, &frame,
1781     (Tcl_Namespace *) nsPtr, /*isProcCallFrame*/ 0);
1782    
1783     nsPtr = (Namespace *) Tcl_CreateNamespace(interp, nsName,
1784     (ClientData) NULL, (Tcl_NamespaceDeleteProc *) NULL);
1785     Tcl_PopCallFrame(interp);
1786    
1787     if (nsPtr == NULL) {
1788     panic("Could not create namespace '%s'", nsName);
1789     }
1790     } else { /* namespace not found and wasn't created */
1791     nsPtr = NULL;
1792     }
1793     }
1794    
1795     /*
1796     * Look up the namespace qualifier in the alternate search path too.
1797     */
1798    
1799     if (altNsPtr != NULL) {
1800     entryPtr = Tcl_FindHashEntry(&altNsPtr->childTable, nsName);
1801     if (entryPtr != NULL) {
1802     altNsPtr = (Namespace *) Tcl_GetHashValue(entryPtr);
1803     } else {
1804     altNsPtr = NULL;
1805     }
1806     }
1807    
1808     /*
1809     * If both search paths have failed, return NULL results.
1810     */
1811    
1812     if ((nsPtr == NULL) && (altNsPtr == NULL)) {
1813     *nsPtrPtr = NULL;
1814     *altNsPtrPtr = NULL;
1815     *simpleNamePtr = NULL;
1816     Tcl_DStringFree(&buffer);
1817     return TCL_OK;
1818     }
1819    
1820     start = end;
1821     }
1822    
1823     /*
1824     * We ignore trailing "::"s in a namespace name, but in a command or
1825     * variable name, trailing "::"s refer to the cmd or var named {}.
1826     */
1827    
1828     if ((flags & FIND_ONLY_NS)
1829     || ((end > start ) && (*(end-1) != ':'))) {
1830     *simpleNamePtr = NULL; /* found namespace name */
1831     } else {
1832     *simpleNamePtr = end; /* found cmd/var: points to empty string */
1833     }
1834    
1835     /*
1836     * As a special case, if we are looking for a namespace and qualName
1837     * is "" and the current active namespace (nsPtr) is not the global
1838     * namespace, return NULL (no namespace was found). This is because
1839     * namespaces can not have empty names except for the global namespace.
1840     */
1841    
1842     if ((flags & FIND_ONLY_NS) && (*qualName == '\0')
1843     && (nsPtr != globalNsPtr)) {
1844     nsPtr = NULL;
1845     }
1846    
1847     *nsPtrPtr = nsPtr;
1848     *altNsPtrPtr = altNsPtr;
1849     Tcl_DStringFree(&buffer);
1850     return TCL_OK;
1851     }
1852    
1853     /*
1854     *----------------------------------------------------------------------
1855     *
1856     * Tcl_FindNamespace --
1857     *
1858     * Searches for a namespace.
1859     *
1860     * Results:
1861     * Returns a pointer to the namespace if it is found. Otherwise,
1862     * returns NULL and leaves an error message in the interpreter's
1863     * result object if "flags" contains TCL_LEAVE_ERR_MSG.
1864     *
1865     * Side effects:
1866     * None.
1867     *
1868     *----------------------------------------------------------------------
1869     */
1870    
1871     Tcl_Namespace *
1872     Tcl_FindNamespace(interp, name, contextNsPtr, flags)
1873     Tcl_Interp *interp; /* The interpreter in which to find the
1874     * namespace. */
1875     char *name; /* Namespace name. If it starts with "::",
1876     * will be looked up in global namespace.
1877     * Else, looked up first in contextNsPtr
1878     * (current namespace if contextNsPtr is
1879     * NULL), then in global namespace. */
1880     Tcl_Namespace *contextNsPtr; /* Ignored if TCL_GLOBAL_ONLY flag is set
1881     * or if the name starts with "::".
1882     * Otherwise, points to namespace in which
1883     * to resolve name; if NULL, look up name
1884     * in the current namespace. */
1885     register int flags; /* Flags controlling namespace lookup: an
1886     * OR'd combination of TCL_GLOBAL_ONLY and
1887     * TCL_LEAVE_ERR_MSG flags. */
1888     {
1889     Namespace *nsPtr, *dummy1Ptr, *dummy2Ptr;
1890     char *dummy;
1891    
1892     /*
1893     * Find the namespace(s) that contain the specified namespace name.
1894     * Add the FIND_ONLY_NS flag to resolve the name all the way down
1895     * to its last component, a namespace.
1896     */
1897    
1898     TclGetNamespaceForQualName(interp, name, (Namespace *) contextNsPtr,
1899     (flags | FIND_ONLY_NS), &nsPtr, &dummy1Ptr, &dummy2Ptr, &dummy);
1900    
1901     if (nsPtr != NULL) {
1902     return (Tcl_Namespace *) nsPtr;
1903     } else if (flags & TCL_LEAVE_ERR_MSG) {
1904     Tcl_ResetResult(interp);
1905     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
1906     "unknown namespace \"", name, "\"", (char *) NULL);
1907     }
1908     return NULL;
1909     }
1910    
1911     /*
1912     *----------------------------------------------------------------------
1913     *
1914     * Tcl_FindCommand --
1915     *
1916     * Searches for a command.
1917     *
1918     * Results:
1919     * Returns a token for the command if it is found. Otherwise, if it
1920     * can't be found or there is an error, returns NULL and leaves an
1921     * error message in the interpreter's result object if "flags"
1922     * contains TCL_LEAVE_ERR_MSG.
1923     *
1924     * Side effects:
1925     * None.
1926     *
1927     *----------------------------------------------------------------------
1928     */
1929    
1930     Tcl_Command
1931     Tcl_FindCommand(interp, name, contextNsPtr, flags)
1932     Tcl_Interp *interp; /* The interpreter in which to find the
1933     * command and to report errors. */
1934     char *name; /* Command's name. If it starts with "::",
1935     * will be looked up in global namespace.
1936     * Else, looked up first in contextNsPtr
1937     * (current namespace if contextNsPtr is
1938     * NULL), then in global namespace. */
1939     Tcl_Namespace *contextNsPtr; /* Ignored if TCL_GLOBAL_ONLY flag set.
1940     * Otherwise, points to namespace in which
1941     * to resolve name. If NULL, look up name
1942     * in the current namespace. */
1943     int flags; /* An OR'd combination of flags:
1944     * TCL_GLOBAL_ONLY (look up name only in
1945     * global namespace), TCL_NAMESPACE_ONLY
1946     * (look up only in contextNsPtr, or the
1947     * current namespace if contextNsPtr is
1948     * NULL), and TCL_LEAVE_ERR_MSG. If both
1949     * TCL_GLOBAL_ONLY and TCL_NAMESPACE_ONLY
1950     * are given, TCL_GLOBAL_ONLY is
1951     * ignored. */
1952     {
1953     Interp *iPtr = (Interp*)interp;
1954    
1955     ResolverScheme *resPtr;
1956     Namespace *nsPtr[2], *cxtNsPtr;
1957     char *simpleName;
1958     register Tcl_HashEntry *entryPtr;
1959     register Command *cmdPtr;
1960     register int search;
1961     int result;
1962     Tcl_Command cmd;
1963    
1964     /*
1965     * If this namespace has a command resolver, then give it first
1966     * crack at the command resolution. If the interpreter has any
1967     * command resolvers, consult them next. The command resolver
1968     * procedures may return a Tcl_Command value, they may signal
1969     * to continue onward, or they may signal an error.
1970     */
1971     if ((flags & TCL_GLOBAL_ONLY) != 0) {
1972     cxtNsPtr = (Namespace *) Tcl_GetGlobalNamespace(interp);
1973     }
1974     else if (contextNsPtr != NULL) {
1975     cxtNsPtr = (Namespace *) contextNsPtr;
1976     }
1977     else {
1978     cxtNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
1979     }
1980    
1981     if (cxtNsPtr->cmdResProc != NULL || iPtr->resolverPtr != NULL) {
1982     resPtr = iPtr->resolverPtr;
1983    
1984     if (cxtNsPtr->cmdResProc) {
1985     result = (*cxtNsPtr->cmdResProc)(interp, name,
1986     (Tcl_Namespace *) cxtNsPtr, flags, &cmd);
1987     } else {
1988     result = TCL_CONTINUE;
1989     }
1990    
1991     while (result == TCL_CONTINUE && resPtr) {
1992     if (resPtr->cmdResProc) {
1993     result = (*resPtr->cmdResProc)(interp, name,
1994     (Tcl_Namespace *) cxtNsPtr, flags, &cmd);
1995     }
1996     resPtr = resPtr->nextPtr;
1997     }
1998    
1999     if (result == TCL_OK) {
2000     return cmd;
2001     }
2002     else if (result != TCL_CONTINUE) {
2003     return (Tcl_Command) NULL;
2004     }
2005     }
2006    
2007     /*
2008     * Find the namespace(s) that contain the command.
2009     */
2010    
2011     TclGetNamespaceForQualName(interp, name, (Namespace *) contextNsPtr,
2012     flags, &nsPtr[0], &nsPtr[1], &cxtNsPtr, &simpleName);
2013    
2014     /*
2015     * Look for the command in the command table of its namespace.
2016     * Be sure to check both possible search paths: from the specified
2017     * namespace context and from the global namespace.
2018     */
2019    
2020     cmdPtr = NULL;
2021     for (search = 0; (search < 2) && (cmdPtr == NULL); search++) {
2022     if ((nsPtr[search] != NULL) && (simpleName != NULL)) {
2023     entryPtr = Tcl_FindHashEntry(&nsPtr[search]->cmdTable,
2024     simpleName);
2025     if (entryPtr != NULL) {
2026     cmdPtr = (Command *) Tcl_GetHashValue(entryPtr);
2027     }
2028     }
2029     }
2030     if (cmdPtr != NULL) {
2031     return (Tcl_Command) cmdPtr;
2032     } else if (flags & TCL_LEAVE_ERR_MSG) {
2033     Tcl_ResetResult(interp);
2034     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
2035     "unknown command \"", name, "\"", (char *) NULL);
2036     }
2037    
2038     return (Tcl_Command) NULL;
2039     }
2040    
2041     /*
2042     *----------------------------------------------------------------------
2043     *
2044     * Tcl_FindNamespaceVar --
2045     *
2046     * Searches for a namespace variable, a variable not local to a
2047     * procedure. The variable can be either a scalar or an array, but
2048     * may not be an element of an array.
2049     *
2050     * Results:
2051     * Returns a token for the variable if it is found. Otherwise, if it
2052     * can't be found or there is an error, returns NULL and leaves an
2053     * error message in the interpreter's result object if "flags"
2054     * contains TCL_LEAVE_ERR_MSG.
2055     *
2056     * Side effects:
2057     * None.
2058     *
2059     *----------------------------------------------------------------------
2060     */
2061    
2062     Tcl_Var
2063     Tcl_FindNamespaceVar(interp, name, contextNsPtr, flags)
2064     Tcl_Interp *interp; /* The interpreter in which to find the
2065     * variable. */
2066     char *name; /* Variable's name. If it starts with "::",
2067     * will be looked up in global namespace.
2068     * Else, looked up first in contextNsPtr
2069     * (current namespace if contextNsPtr is
2070     * NULL), then in global namespace. */
2071     Tcl_Namespace *contextNsPtr; /* Ignored if TCL_GLOBAL_ONLY flag set.
2072     * Otherwise, points to namespace in which
2073     * to resolve name. If NULL, look up name
2074     * in the current namespace. */
2075     int flags; /* An OR'd combination of flags:
2076     * TCL_GLOBAL_ONLY (look up name only in
2077     * global namespace), TCL_NAMESPACE_ONLY
2078     * (look up only in contextNsPtr, or the
2079     * current namespace if contextNsPtr is
2080     * NULL), and TCL_LEAVE_ERR_MSG. If both
2081     * TCL_GLOBAL_ONLY and TCL_NAMESPACE_ONLY
2082     * are given, TCL_GLOBAL_ONLY is
2083     * ignored. */
2084     {
2085     Interp *iPtr = (Interp*)interp;
2086     ResolverScheme *resPtr;
2087     Namespace *nsPtr[2], *cxtNsPtr;
2088     char *simpleName;
2089     Tcl_HashEntry *entryPtr;
2090     Var *varPtr;
2091     register int search;
2092     int result;
2093     Tcl_Var var;
2094    
2095     /*
2096     * If this namespace has a variable resolver, then give it first
2097     * crack at the variable resolution. It may return a Tcl_Var
2098     * value, it may signal to continue onward, or it may signal
2099     * an error.
2100     */
2101     if ((flags & TCL_GLOBAL_ONLY) != 0) {
2102     cxtNsPtr = (Namespace *) Tcl_GetGlobalNamespace(interp);
2103     }
2104     else if (contextNsPtr != NULL) {
2105     cxtNsPtr = (Namespace *) contextNsPtr;
2106     }
2107     else {
2108     cxtNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
2109     }
2110    
2111     if (cxtNsPtr->varResProc != NULL || iPtr->resolverPtr != NULL) {
2112     resPtr = iPtr->resolverPtr;
2113    
2114     if (cxtNsPtr->varResProc) {
2115     result = (*cxtNsPtr->varResProc)(interp, name,
2116     (Tcl_Namespace *) cxtNsPtr, flags, &var);
2117     } else {
2118     result = TCL_CONTINUE;
2119     }
2120    
2121     while (result == TCL_CONTINUE && resPtr) {
2122     if (resPtr->varResProc) {
2123     result = (*resPtr->varResProc)(interp, name,
2124     (Tcl_Namespace *) cxtNsPtr, flags, &var);
2125     }
2126     resPtr = resPtr->nextPtr;
2127     }
2128    
2129     if (result == TCL_OK) {
2130     return var;
2131     }
2132     else if (result != TCL_CONTINUE) {
2133     return (Tcl_Var) NULL;
2134     }
2135     }
2136    
2137     /*
2138     * Find the namespace(s) that contain the variable.
2139     */
2140    
2141     TclGetNamespaceForQualName(interp, name, (Namespace *) contextNsPtr,
2142     flags, &nsPtr[0], &nsPtr[1], &cxtNsPtr, &simpleName);
2143    
2144     /*
2145     * Look for the variable in the variable table of its namespace.
2146     * Be sure to check both possible search paths: from the specified
2147     * namespace context and from the global namespace.
2148     */
2149    
2150     varPtr = NULL;
2151     for (search = 0; (search < 2) && (varPtr == NULL); search++) {
2152     if ((nsPtr[search] != NULL) && (simpleName != NULL)) {
2153     entryPtr = Tcl_FindHashEntry(&nsPtr[search]->varTable,
2154     simpleName);
2155     if (entryPtr != NULL) {
2156     varPtr = (Var *) Tcl_GetHashValue(entryPtr);
2157     }
2158     }
2159     }
2160     if (varPtr != NULL) {
2161     return (Tcl_Var) varPtr;
2162     } else if (flags & TCL_LEAVE_ERR_MSG) {
2163     Tcl_ResetResult(interp);
2164     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
2165     "unknown variable \"", name, "\"", (char *) NULL);
2166     }
2167     return (Tcl_Var) NULL;
2168     }
2169    
2170     /*
2171     *----------------------------------------------------------------------
2172     *
2173     * TclResetShadowedCmdRefs --
2174     *
2175     * Called when a command is added to a namespace to check for existing
2176     * command references that the new command may invalidate. Consider the
2177     * following cases that could happen when you add a command "foo" to a
2178     * namespace "b":
2179     * 1. It could shadow a command named "foo" at the global scope.
2180     * If it does, all command references in the namespace "b" are
2181     * suspect.
2182     * 2. Suppose the namespace "b" resides in a namespace "a".
2183     * Then to "a" the new command "b::foo" could shadow another
2184     * command "b::foo" in the global namespace. If so, then all
2185     * command references in "a" are suspect.
2186     * The same checks are applied to all parent namespaces, until we
2187     * reach the global :: namespace.
2188     *
2189     * Results:
2190     * None.
2191     *
2192     * Side effects:
2193     * If the new command shadows an existing command, the cmdRefEpoch
2194     * counter is incremented in each namespace that sees the shadow.
2195     * This invalidates all command references that were previously cached
2196     * in that namespace. The next time the commands are used, they are
2197     * resolved from scratch.
2198     *
2199     *----------------------------------------------------------------------
2200     */
2201    
2202     void
2203     TclResetShadowedCmdRefs(interp, newCmdPtr)
2204     Tcl_Interp *interp; /* Interpreter containing the new command. */
2205     Command *newCmdPtr; /* Points to the new command. */
2206     {
2207     char *cmdName;
2208     Tcl_HashEntry *hPtr;
2209     register Namespace *nsPtr;
2210     Namespace *trailNsPtr, *shadowNsPtr;
2211     Namespace *globalNsPtr = (Namespace *) Tcl_GetGlobalNamespace(interp);
2212     int found, i;
2213    
2214     /*
2215     * This procedure generates an array used to hold the trail list. This
2216     * starts out with stack-allocated space but uses dynamically-allocated
2217     * storage if needed.
2218     */
2219    
2220     Namespace *(trailStorage[NUM_TRAIL_ELEMS]);
2221     Namespace **trailPtr = trailStorage;
2222     int trailFront = -1;
2223     int trailSize = NUM_TRAIL_ELEMS;
2224    
2225     /*
2226     * Start at the namespace containing the new command, and work up
2227     * through the list of parents. Stop just before the global namespace,
2228     * since the global namespace can't "shadow" its own entries.
2229     *
2230     * The namespace "trail" list we build consists of the names of each
2231     * namespace that encloses the new command, in order from outermost to
2232     * innermost: for example, "a" then "b". Each iteration of this loop
2233     * eventually extends the trail upwards by one namespace, nsPtr. We use
2234     * this trail list to see if nsPtr (e.g. "a" in 2. above) could have
2235     * now-invalid cached command references. This will happen if nsPtr
2236     * (e.g. "a") contains a sequence of child namespaces (e.g. "b")
2237     * such that there is a identically-named sequence of child namespaces
2238     * starting from :: (e.g. "::b") whose tail namespace contains a command
2239     * also named cmdName.
2240     */
2241    
2242     cmdName = Tcl_GetHashKey(newCmdPtr->hPtr->tablePtr, newCmdPtr->hPtr);
2243     for (nsPtr = newCmdPtr->nsPtr;
2244     (nsPtr != NULL) && (nsPtr != globalNsPtr);
2245     nsPtr = nsPtr->parentPtr) {
2246     /*
2247     * Find the maximal sequence of child namespaces contained in nsPtr
2248     * such that there is a identically-named sequence of child
2249     * namespaces starting from ::. shadowNsPtr will be the tail of this
2250     * sequence, or the deepest namespace under :: that might contain a
2251     * command now shadowed by cmdName. We check below if shadowNsPtr
2252     * actually contains a command cmdName.
2253     */
2254    
2255     found = 1;
2256     shadowNsPtr = globalNsPtr;
2257    
2258     for (i = trailFront; i >= 0; i--) {
2259     trailNsPtr = trailPtr[i];
2260     hPtr = Tcl_FindHashEntry(&shadowNsPtr->childTable,
2261     trailNsPtr->name);
2262     if (hPtr != NULL) {
2263     shadowNsPtr = (Namespace *) Tcl_GetHashValue(hPtr);
2264     } else {
2265     found = 0;
2266     break;
2267     }
2268     }
2269    
2270     /*
2271     * If shadowNsPtr contains a command named cmdName, we invalidate
2272     * all of the command refs cached in nsPtr. As a boundary case,
2273     * shadowNsPtr is initially :: and we check for case 1. above.
2274     */
2275    
2276     if (found) {
2277     hPtr = Tcl_FindHashEntry(&shadowNsPtr->cmdTable, cmdName);
2278     if (hPtr != NULL) {
2279     nsPtr->cmdRefEpoch++;
2280     }
2281     }
2282    
2283     /*
2284     * Insert nsPtr at the front of the trail list: i.e., at the end
2285     * of the trailPtr array.
2286     */
2287    
2288     trailFront++;
2289     if (trailFront == trailSize) {
2290     size_t currBytes = trailSize * sizeof(Namespace *);
2291     int newSize = 2*trailSize;
2292     size_t newBytes = newSize * sizeof(Namespace *);
2293     Namespace **newPtr =
2294     (Namespace **) ckalloc((unsigned) newBytes);
2295    
2296     memcpy((VOID *) newPtr, (VOID *) trailPtr, currBytes);
2297     if (trailPtr != trailStorage) {
2298     ckfree((char *) trailPtr);
2299     }
2300     trailPtr = newPtr;
2301     trailSize = newSize;
2302     }
2303     trailPtr[trailFront] = nsPtr;
2304     }
2305    
2306     /*
2307     * Free any allocated storage.
2308     */
2309    
2310     if (trailPtr != trailStorage) {
2311     ckfree((char *) trailPtr);
2312     }
2313     }
2314    
2315     /*
2316     *----------------------------------------------------------------------
2317     *
2318     * GetNamespaceFromObj --
2319     *
2320     * Gets the namespace specified by the name in a Tcl_Obj.
2321     *
2322     * Results:
2323     * Returns TCL_OK if the namespace was resolved successfully, and
2324     * stores a pointer to the namespace in the location specified by
2325     * nsPtrPtr. If the namespace can't be found, the procedure stores
2326     * NULL in *nsPtrPtr and returns TCL_OK. If anything else goes wrong,
2327     * this procedure returns TCL_ERROR.
2328     *
2329     * Side effects:
2330     * May update the internal representation for the object, caching the
2331     * namespace reference. The next time this procedure is called, the
2332     * namespace value can be found quickly.
2333     *
2334     * If anything goes wrong, an error message is left in the
2335     * interpreter's result object.
2336     *
2337     *----------------------------------------------------------------------
2338     */
2339    
2340     static int
2341     GetNamespaceFromObj(interp, objPtr, nsPtrPtr)
2342     Tcl_Interp *interp; /* The current interpreter. */
2343     Tcl_Obj *objPtr; /* The object to be resolved as the name
2344     * of a namespace. */
2345     Tcl_Namespace **nsPtrPtr; /* Result namespace pointer goes here. */
2346     {
2347     register ResolvedNsName *resNamePtr;
2348     register Namespace *nsPtr;
2349     Namespace *currNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
2350     int result;
2351    
2352     /*
2353     * Get the internal representation, converting to a namespace type if
2354     * needed. The internal representation is a ResolvedNsName that points
2355     * to the actual namespace.
2356     */
2357    
2358     if (objPtr->typePtr != &tclNsNameType) {
2359     result = tclNsNameType.setFromAnyProc(interp, objPtr);
2360     if (result != TCL_OK) {
2361     return TCL_ERROR;
2362     }
2363     }
2364     resNamePtr = (ResolvedNsName *) objPtr->internalRep.otherValuePtr;
2365    
2366     /*
2367     * Check the context namespace of the resolved symbol to make sure that
2368     * it is fresh. If not, then force another conversion to the namespace
2369     * type, to discard the old rep and create a new one. Note that we
2370     * verify that the namespace id of the cached namespace is the same as
2371     * the id when we cached it; this insures that the namespace wasn't
2372     * deleted and a new one created at the same address.
2373     */
2374    
2375     nsPtr = NULL;
2376     if ((resNamePtr != NULL)
2377     && (resNamePtr->refNsPtr == currNsPtr)
2378     && (resNamePtr->nsId == resNamePtr->nsPtr->nsId)) {
2379     nsPtr = resNamePtr->nsPtr;
2380     if (nsPtr->flags & NS_DEAD) {
2381     nsPtr = NULL;
2382     }
2383     }
2384     if (nsPtr == NULL) { /* try again */
2385     result = tclNsNameType.setFromAnyProc(interp, objPtr);
2386     if (result != TCL_OK) {
2387     return TCL_ERROR;
2388     }
2389     resNamePtr = (ResolvedNsName *) objPtr->internalRep.otherValuePtr;
2390     if (resNamePtr != NULL) {
2391     nsPtr = resNamePtr->nsPtr;
2392     if (nsPtr->flags & NS_DEAD) {
2393     nsPtr = NULL;
2394     }
2395     }
2396     }
2397     *nsPtrPtr = (Tcl_Namespace *) nsPtr;
2398     return TCL_OK;
2399     }
2400    
2401     /*
2402     *----------------------------------------------------------------------
2403     *
2404     * Tcl_NamespaceObjCmd --
2405     *
2406     * Invoked to implement the "namespace" command that creates, deletes,
2407     * or manipulates Tcl namespaces. Handles the following syntax:
2408     *
2409     * namespace children ?name? ?pattern?
2410     * namespace code arg
2411     * namespace current
2412     * namespace delete ?name name...?
2413     * namespace eval name arg ?arg...?
2414     * namespace export ?-clear? ?pattern pattern...?
2415     * namespace forget ?pattern pattern...?
2416     * namespace import ?-force? ?pattern pattern...?
2417     * namespace inscope name arg ?arg...?
2418     * namespace origin name
2419     * namespace parent ?name?
2420     * namespace qualifiers string
2421     * namespace tail string
2422     * namespace which ?-command? ?-variable? name
2423     *
2424     * Results:
2425     * Returns TCL_OK if the command is successful. Returns TCL_ERROR if
2426     * anything goes wrong.
2427     *
2428     * Side effects:
2429     * Based on the subcommand name (e.g., "import"), this procedure
2430     * dispatches to a corresponding procedure NamespaceXXXCmd defined
2431     * statically in this file. This procedure's side effects depend on
2432     * whatever that subcommand procedure does. If there is an error, this
2433     * procedure returns an error message in the interpreter's result
2434     * object. Otherwise it may return a result in the interpreter's result
2435     * object.
2436     *
2437     *----------------------------------------------------------------------
2438     */
2439    
2440     int
2441     Tcl_NamespaceObjCmd(clientData, interp, objc, objv)
2442     ClientData clientData; /* Arbitrary value passed to cmd. */
2443     Tcl_Interp *interp; /* Current interpreter. */
2444     register int objc; /* Number of arguments. */
2445     register Tcl_Obj *CONST objv[]; /* Argument objects. */
2446     {
2447     static char *subCmds[] = {
2448     "children", "code", "current", "delete",
2449     "eval", "export", "forget", "import",
2450     "inscope", "origin", "parent", "qualifiers",
2451     "tail", "which", (char *) NULL};
2452     enum NSSubCmdIdx {
2453     NSChildrenIdx, NSCodeIdx, NSCurrentIdx, NSDeleteIdx,
2454     NSEvalIdx, NSExportIdx, NSForgetIdx, NSImportIdx,
2455     NSInscopeIdx, NSOriginIdx, NSParentIdx, NSQualifiersIdx,
2456     NSTailIdx, NSWhichIdx
2457     };
2458     int index, result;
2459    
2460     if (objc < 2) {
2461     Tcl_WrongNumArgs(interp, 1, objv, "subcommand ?arg ...?");
2462     return TCL_ERROR;
2463     }
2464    
2465     /*
2466     * Return an index reflecting the particular subcommand.
2467     */
2468    
2469     result = Tcl_GetIndexFromObj((Tcl_Interp *) interp, objv[1], subCmds,
2470     "option", /*flags*/ 0, (int *) &index);
2471     if (result != TCL_OK) {
2472     return result;
2473     }
2474    
2475     switch (index) {
2476     case NSChildrenIdx:
2477     result = NamespaceChildrenCmd(clientData, interp, objc, objv);
2478     break;
2479     case NSCodeIdx:
2480     result = NamespaceCodeCmd(clientData, interp, objc, objv);
2481     break;
2482     case NSCurrentIdx:
2483     result = NamespaceCurrentCmd(clientData, interp, objc, objv);
2484     break;
2485     case NSDeleteIdx:
2486     result = NamespaceDeleteCmd(clientData, interp, objc, objv);
2487     break;
2488     case NSEvalIdx:
2489     result = NamespaceEvalCmd(clientData, interp, objc, objv);
2490     break;
2491     case NSExportIdx:
2492     result = NamespaceExportCmd(clientData, interp, objc, objv);
2493     break;
2494     case NSForgetIdx:
2495     result = NamespaceForgetCmd(clientData, interp, objc, objv);
2496     break;
2497     case NSImportIdx:
2498     result = NamespaceImportCmd(clientData, interp, objc, objv);
2499     break;
2500     case NSInscopeIdx:
2501     result = NamespaceInscopeCmd(clientData, interp, objc, objv);
2502     break;
2503     case NSOriginIdx:
2504     result = NamespaceOriginCmd(clientData, interp, objc, objv);
2505     break;
2506     case NSParentIdx:
2507     result = NamespaceParentCmd(clientData, interp, objc, objv);
2508     break;
2509     case NSQualifiersIdx:
2510     result = NamespaceQualifiersCmd(clientData, interp, objc, objv);
2511     break;
2512     case NSTailIdx:
2513     result = NamespaceTailCmd(clientData, interp, objc, objv);
2514     break;
2515     case NSWhichIdx:
2516     result = NamespaceWhichCmd(clientData, interp, objc, objv);
2517     break;
2518     }
2519     return result;
2520     }
2521    
2522     /*
2523     *----------------------------------------------------------------------
2524     *
2525     * NamespaceChildrenCmd --
2526     *
2527     * Invoked to implement the "namespace children" command that returns a
2528     * list containing the fully-qualified names of the child namespaces of
2529     * a given namespace. Handles the following syntax:
2530     *
2531     * namespace children ?name? ?pattern?
2532     *
2533     * Results:
2534     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
2535     *
2536     * Side effects:
2537     * Returns a result in the interpreter's result object. If anything
2538     * goes wrong, the result is an error message.
2539     *
2540     *----------------------------------------------------------------------
2541     */
2542    
2543     static int
2544     NamespaceChildrenCmd(dummy, interp, objc, objv)
2545     ClientData dummy; /* Not used. */
2546     Tcl_Interp *interp; /* Current interpreter. */
2547     int objc; /* Number of arguments. */
2548     Tcl_Obj *CONST objv[]; /* Argument objects. */
2549     {
2550     Tcl_Namespace *namespacePtr;
2551     Namespace *nsPtr, *childNsPtr;
2552     Namespace *globalNsPtr = (Namespace *) Tcl_GetGlobalNamespace(interp);
2553     char *pattern = NULL;
2554     Tcl_DString buffer;
2555     register Tcl_HashEntry *entryPtr;
2556     Tcl_HashSearch search;
2557     Tcl_Obj *listPtr, *elemPtr;
2558    
2559     /*
2560     * Get a pointer to the specified namespace, or the current namespace.
2561     */
2562    
2563     if (objc == 2) {
2564     nsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
2565     } else if ((objc == 3) || (objc == 4)) {
2566     if (GetNamespaceFromObj(interp, objv[2], &namespacePtr) != TCL_OK) {
2567     return TCL_ERROR;
2568     }
2569     if (namespacePtr == NULL) {
2570     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
2571     "unknown namespace \"", Tcl_GetString(objv[2]),
2572     "\" in namespace children command", (char *) NULL);
2573     return TCL_ERROR;
2574     }
2575     nsPtr = (Namespace *) namespacePtr;
2576     } else {
2577     Tcl_WrongNumArgs(interp, 2, objv, "?name? ?pattern?");
2578     return TCL_ERROR;
2579     }
2580    
2581     /*
2582     * Get the glob-style pattern, if any, used to narrow the search.
2583     */
2584    
2585     Tcl_DStringInit(&buffer);
2586     if (objc == 4) {
2587     char *name = Tcl_GetString(objv[3]);
2588    
2589     if ((*name == ':') && (*(name+1) == ':')) {
2590     pattern = name;
2591     } else {
2592     Tcl_DStringAppend(&buffer, nsPtr->fullName, -1);
2593     if (nsPtr != globalNsPtr) {
2594     Tcl_DStringAppend(&buffer, "::", 2);
2595     }
2596     Tcl_DStringAppend(&buffer, name, -1);
2597     pattern = Tcl_DStringValue(&buffer);
2598     }
2599     }
2600    
2601     /*
2602     * Create a list containing the full names of all child namespaces
2603     * whose names match the specified pattern, if any.
2604     */
2605    
2606     listPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
2607     entryPtr = Tcl_FirstHashEntry(&nsPtr->childTable, &search);
2608     while (entryPtr != NULL) {
2609     childNsPtr = (Namespace *) Tcl_GetHashValue(entryPtr);
2610     if ((pattern == NULL)
2611     || Tcl_StringMatch(childNsPtr->fullName, pattern)) {
2612     elemPtr = Tcl_NewStringObj(childNsPtr->fullName, -1);
2613     Tcl_ListObjAppendElement(interp, listPtr, elemPtr);
2614     }
2615     entryPtr = Tcl_NextHashEntry(&search);
2616     }
2617    
2618     Tcl_SetObjResult(interp, listPtr);
2619     Tcl_DStringFree(&buffer);
2620     return TCL_OK;
2621     }
2622    
2623     /*
2624     *----------------------------------------------------------------------
2625     *
2626     * NamespaceCodeCmd --
2627     *
2628     * Invoked to implement the "namespace code" command to capture the
2629     * namespace context of a command. Handles the following syntax:
2630     *
2631     * namespace code arg
2632     *
2633     * Here "arg" can be a list. "namespace code arg" produces a result
2634     * equivalent to that produced by the command
2635     *
2636     * list namespace inscope [namespace current] $arg
2637     *
2638     * However, if "arg" is itself a scoped value starting with
2639     * "namespace inscope", then the result is just "arg".
2640     *
2641     * Results:
2642     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
2643     *
2644     * Side effects:
2645     * If anything goes wrong, this procedure returns an error
2646     * message as the result in the interpreter's result object.
2647     *
2648     *----------------------------------------------------------------------
2649     */
2650    
2651     static int
2652     NamespaceCodeCmd(dummy, interp, objc, objv)
2653     ClientData dummy; /* Not used. */
2654     Tcl_Interp *interp; /* Current interpreter. */
2655     int objc; /* Number of arguments. */
2656     Tcl_Obj *CONST objv[]; /* Argument objects. */
2657     {
2658     Namespace *currNsPtr;
2659     Tcl_Obj *listPtr, *objPtr;
2660     register char *arg, *p;
2661     int length;
2662    
2663     if (objc != 3) {
2664     Tcl_WrongNumArgs(interp, 2, objv, "arg");
2665     return TCL_ERROR;
2666     }
2667    
2668     /*
2669     * If "arg" is already a scoped value, then return it directly.
2670     */
2671    
2672     arg = Tcl_GetStringFromObj(objv[2], &length);
2673     if ((*arg == 'n') && (length > 17)
2674     && (strncmp(arg, "namespace", 9) == 0)) {
2675     for (p = (arg + 9); (*p == ' '); p++) {
2676     /* empty body: skip over spaces */
2677     }
2678     if ((*p == 'i') && ((p + 7) <= (arg + length))
2679     && (strncmp(p, "inscope", 7) == 0)) {
2680     Tcl_SetObjResult(interp, objv[2]);
2681     return TCL_OK;
2682     }
2683     }
2684    
2685     /*
2686     * Otherwise, construct a scoped command by building a list with
2687     * "namespace inscope", the full name of the current namespace, and
2688     * the argument "arg". By constructing a list, we ensure that scoped
2689     * commands are interpreted properly when they are executed later,
2690     * by the "namespace inscope" command.
2691     */
2692    
2693     listPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
2694     Tcl_ListObjAppendElement(interp, listPtr,
2695     Tcl_NewStringObj("namespace", -1));
2696     Tcl_ListObjAppendElement(interp, listPtr,
2697     Tcl_NewStringObj("inscope", -1));
2698    
2699     currNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
2700     if (currNsPtr == (Namespace *) Tcl_GetGlobalNamespace(interp)) {
2701     objPtr = Tcl_NewStringObj("::", -1);
2702     } else {
2703     objPtr = Tcl_NewStringObj(currNsPtr->fullName, -1);
2704     }
2705     Tcl_ListObjAppendElement(interp, listPtr, objPtr);
2706    
2707     Tcl_ListObjAppendElement(interp, listPtr, objv[2]);
2708    
2709     Tcl_SetObjResult(interp, listPtr);
2710     return TCL_OK;
2711     }
2712    
2713     /*
2714     *----------------------------------------------------------------------
2715     *
2716     * NamespaceCurrentCmd --
2717     *
2718     * Invoked to implement the "namespace current" command which returns
2719     * the fully-qualified name of the current namespace. Handles the
2720     * following syntax:
2721     *
2722     * namespace current
2723     *
2724     * Results:
2725     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
2726     *
2727     * Side effects:
2728     * Returns a result in the interpreter's result object. If anything
2729     * goes wrong, the result is an error message.
2730     *
2731     *----------------------------------------------------------------------
2732     */
2733    
2734     static int
2735     NamespaceCurrentCmd(dummy, interp, objc, objv)
2736     ClientData dummy; /* Not used. */
2737     Tcl_Interp *interp; /* Current interpreter. */
2738     int objc; /* Number of arguments. */
2739     Tcl_Obj *CONST objv[]; /* Argument objects. */
2740     {
2741     register Namespace *currNsPtr;
2742    
2743     if (objc != 2) {
2744     Tcl_WrongNumArgs(interp, 2, objv, NULL);
2745     return TCL_ERROR;
2746     }
2747    
2748     /*
2749     * The "real" name of the global namespace ("::") is the null string,
2750     * but we return "::" for it as a convenience to programmers. Note that
2751     * "" and "::" are treated as synonyms by the namespace code so that it
2752     * is still easy to do things like:
2753     *
2754     * namespace [namespace current]::bar { ... }
2755     */
2756    
2757     currNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
2758     if (currNsPtr == (Namespace *) Tcl_GetGlobalNamespace(interp)) {
2759     Tcl_AppendToObj(Tcl_GetObjResult(interp), "::", -1);
2760     } else {
2761     Tcl_AppendToObj(Tcl_GetObjResult(interp), currNsPtr->fullName, -1);
2762     }
2763     return TCL_OK;
2764     }
2765    
2766     /*
2767     *----------------------------------------------------------------------
2768     *
2769     * NamespaceDeleteCmd --
2770     *
2771     * Invoked to implement the "namespace delete" command to delete
2772     * namespace(s). Handles the following syntax:
2773     *
2774     * namespace delete ?name name...?
2775     *
2776     * Each name identifies a namespace. It may include a sequence of
2777     * namespace qualifiers separated by "::"s. If a namespace is found, it
2778     * is deleted: all variables and procedures contained in that namespace
2779     * are deleted. If that namespace is being used on the call stack, it
2780     * is kept alive (but logically deleted) until it is removed from the
2781     * call stack: that is, it can no longer be referenced by name but any
2782     * currently executing procedure that refers to it is allowed to do so
2783     * until the procedure returns. If the namespace can't be found, this
2784     * procedure returns an error. If no namespaces are specified, this
2785     * command does nothing.
2786     *
2787     * Results:
2788     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
2789     *
2790     * Side effects:
2791     * Deletes the specified namespaces. If anything goes wrong, this
2792     * procedure returns an error message in the interpreter's
2793     * result object.
2794     *
2795     *----------------------------------------------------------------------
2796     */
2797    
2798     static int
2799     NamespaceDeleteCmd(dummy, interp, objc, objv)
2800     ClientData dummy; /* Not used. */
2801     Tcl_Interp *interp; /* Current interpreter. */
2802     int objc; /* Number of arguments. */
2803     Tcl_Obj *CONST objv[]; /* Argument objects. */
2804     {
2805     Tcl_Namespace *namespacePtr;
2806     char *name;
2807     register int i;
2808    
2809     if (objc < 2) {
2810     Tcl_WrongNumArgs(interp, 2, objv, "?name name...?");
2811     return TCL_ERROR;
2812     }
2813    
2814     /*
2815     * Destroying one namespace may cause another to be destroyed. Break
2816     * this into two passes: first check to make sure that all namespaces on
2817     * the command line are valid, and report any errors.
2818     */
2819    
2820     for (i = 2; i < objc; i++) {
2821     name = Tcl_GetString(objv[i]);
2822     namespacePtr = Tcl_FindNamespace(interp, name,
2823     (Tcl_Namespace *) NULL, /*flags*/ 0);
2824     if (namespacePtr == NULL) {
2825     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
2826     "unknown namespace \"", Tcl_GetString(objv[i]),
2827     "\" in namespace delete command", (char *) NULL);
2828     return TCL_ERROR;
2829     }
2830     }
2831    
2832     /*
2833     * Okay, now delete each namespace.
2834     */
2835    
2836     for (i = 2; i < objc; i++) {
2837     name = Tcl_GetString(objv[i]);
2838     namespacePtr = Tcl_FindNamespace(interp, name,
2839     (Tcl_Namespace *) NULL, /* flags */ 0);
2840     if (namespacePtr) {
2841     Tcl_DeleteNamespace(namespacePtr);
2842     }
2843     }
2844     return TCL_OK;
2845     }
2846    
2847     /*
2848     *----------------------------------------------------------------------
2849     *
2850     * NamespaceEvalCmd --
2851     *
2852     * Invoked to implement the "namespace eval" command. Executes
2853     * commands in a namespace. If the namespace does not already exist,
2854     * it is created. Handles the following syntax:
2855     *
2856     * namespace eval name arg ?arg...?
2857     *
2858     * If more than one arg argument is specified, the command that is
2859     * executed is the result of concatenating the arguments together with
2860     * a space between each argument.
2861     *
2862     * Results:
2863     * Returns TCL_OK if the namespace is found and the commands are
2864     * executed successfully. Returns TCL_ERROR if anything goes wrong.
2865     *
2866     * Side effects:
2867     * Returns the result of the command in the interpreter's result
2868     * object. If anything goes wrong, this procedure returns an error
2869     * message as the result.
2870     *
2871     *----------------------------------------------------------------------
2872     */
2873    
2874     static int
2875     NamespaceEvalCmd(dummy, interp, objc, objv)
2876     ClientData dummy; /* Not used. */
2877     Tcl_Interp *interp; /* Current interpreter. */
2878     int objc; /* Number of arguments. */
2879     Tcl_Obj *CONST objv[]; /* Argument objects. */
2880     {
2881     Tcl_Namespace *namespacePtr;
2882     Tcl_CallFrame frame;
2883     Tcl_Obj *objPtr;
2884     char *name;
2885     int length, result;
2886    
2887     if (objc < 4) {
2888     Tcl_WrongNumArgs(interp, 2, objv, "name arg ?arg...?");
2889     return TCL_ERROR;
2890     }
2891    
2892     /*
2893     * Try to resolve the namespace reference, caching the result in the
2894     * namespace object along the way.
2895     */
2896    
2897     result = GetNamespaceFromObj(interp, objv[2], &namespacePtr);
2898     if (result != TCL_OK) {
2899     return result;
2900     }
2901    
2902     /*
2903     * If the namespace wasn't found, try to create it.
2904     */
2905    
2906     if (namespacePtr == NULL) {
2907     name = Tcl_GetStringFromObj(objv[2], &length);
2908     namespacePtr = Tcl_CreateNamespace(interp, name, (ClientData) NULL,
2909     (Tcl_NamespaceDeleteProc *) NULL);
2910     if (namespacePtr == NULL) {
2911     return TCL_ERROR;
2912     }
2913     }
2914    
2915     /*
2916     * Make the specified namespace the current namespace and evaluate
2917     * the command(s).
2918     */
2919    
2920     result = Tcl_PushCallFrame(interp, &frame, namespacePtr,
2921     /*isProcCallFrame*/ 0);
2922     if (result != TCL_OK) {
2923     return TCL_ERROR;
2924     }
2925    
2926     if (objc == 4) {
2927     result = Tcl_EvalObjEx(interp, objv[3], 0);
2928     } else {
2929     /*
2930     * More than one argument: concatenate them together with spaces
2931     * between, then evaluate the result. Tcl_EvalObjEx will delete
2932     * the object when it decrements its refcount after eval'ing it.
2933     */
2934     objPtr = Tcl_ConcatObj(objc-3, objv+3);
2935     result = Tcl_EvalObjEx(interp, objPtr, TCL_EVAL_DIRECT);
2936     }
2937     if (result == TCL_ERROR) {
2938     char msg[256 + TCL_INTEGER_SPACE];
2939    
2940     sprintf(msg, "\n (in namespace eval \"%.200s\" script line %d)",
2941     namespacePtr->fullName, interp->errorLine);
2942     Tcl_AddObjErrorInfo(interp, msg, -1);
2943     }
2944    
2945     /*
2946     * Restore the previous "current" namespace.
2947     */
2948    
2949     Tcl_PopCallFrame(interp);
2950     return result;
2951     }
2952    
2953     /*
2954     *----------------------------------------------------------------------
2955     *
2956     * NamespaceExportCmd --
2957     *
2958     * Invoked to implement the "namespace export" command that specifies
2959     * which commands are exported from a namespace. The exported commands
2960     * are those that can be imported into another namespace using
2961     * "namespace import". Both commands defined in a namespace and
2962     * commands the namespace has imported can be exported by a
2963     * namespace. This command has the following syntax:
2964     *
2965     * namespace export ?-clear? ?pattern pattern...?
2966     *
2967     * Each pattern may contain "string match"-style pattern matching
2968     * special characters, but the pattern may not include any namespace
2969     * qualifiers: that is, the pattern must specify commands in the
2970     * current (exporting) namespace. The specified patterns are appended
2971     * onto the namespace's list of export patterns.
2972     *
2973     * To reset the namespace's export pattern list, specify the "-clear"
2974     * flag.
2975     *
2976     * If there are no export patterns and the "-clear" flag isn't given,
2977     * this command returns the namespace's current export list.
2978     *
2979     * Results:
2980     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
2981     *
2982     * Side effects:
2983     * Returns a result in the interpreter's result object. If anything
2984     * goes wrong, the result is an error message.
2985     *
2986     *----------------------------------------------------------------------
2987     */
2988    
2989     static int
2990     NamespaceExportCmd(dummy, interp, objc, objv)
2991     ClientData dummy; /* Not used. */
2992     Tcl_Interp *interp; /* Current interpreter. */
2993     int objc; /* Number of arguments. */
2994     Tcl_Obj *CONST objv[]; /* Argument objects. */
2995     {
2996     Namespace *currNsPtr = (Namespace*) Tcl_GetCurrentNamespace(interp);
2997     char *pattern, *string;
2998     int resetListFirst = 0;
2999     int firstArg, patternCt, i, result;
3000    
3001     if (objc < 2) {
3002     Tcl_WrongNumArgs(interp, 2, objv,
3003     "?-clear? ?pattern pattern...?");
3004     return TCL_ERROR;
3005     }
3006    
3007     /*
3008     * Process the optional "-clear" argument.
3009     */
3010    
3011     firstArg = 2;
3012     if (firstArg < objc) {
3013     string = Tcl_GetString(objv[firstArg]);
3014     if (strcmp(string, "-clear") == 0) {
3015     resetListFirst = 1;
3016     firstArg++;
3017     }
3018     }
3019    
3020     /*
3021     * If no pattern arguments are given, and "-clear" isn't specified,
3022     * return the namespace's current export pattern list.
3023     */
3024    
3025     patternCt = (objc - firstArg);
3026     if (patternCt == 0) {
3027     if (firstArg > 2) {
3028     return TCL_OK;
3029     } else { /* create list with export patterns */
3030     Tcl_Obj *listPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
3031     result = Tcl_AppendExportList(interp,
3032     (Tcl_Namespace *) currNsPtr, listPtr);
3033     if (result != TCL_OK) {
3034     return result;
3035     }
3036     Tcl_SetObjResult(interp, listPtr);
3037     return TCL_OK;
3038     }
3039     }
3040    
3041     /*
3042     * Add each pattern to the namespace's export pattern list.
3043     */
3044    
3045     for (i = firstArg; i < objc; i++) {
3046     pattern = Tcl_GetString(objv[i]);
3047     result = Tcl_Export(interp, (Tcl_Namespace *) currNsPtr, pattern,
3048     ((i == firstArg)? resetListFirst : 0));
3049     if (result != TCL_OK) {
3050     return result;
3051     }
3052     }
3053     return TCL_OK;
3054     }
3055    
3056     /*
3057     *----------------------------------------------------------------------
3058     *
3059     * NamespaceForgetCmd --
3060     *
3061     * Invoked to implement the "namespace forget" command to remove
3062     * imported commands from a namespace. Handles the following syntax:
3063     *
3064     * namespace forget ?pattern pattern...?
3065     *
3066     * Each pattern is a name like "foo::*" or "a::b::x*". That is, the
3067     * pattern may include the special pattern matching characters
3068     * recognized by the "string match" command, but only in the command
3069     * name at the end of the qualified name; the special pattern
3070     * characters may not appear in a namespace name. All of the commands
3071     * that match that pattern are checked to see if they have an imported
3072     * command in the current namespace that refers to the matched
3073     * command. If there is an alias, it is removed.
3074     *
3075     * Results:
3076     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
3077     *
3078     * Side effects:
3079     * Imported commands are removed from the current namespace. If
3080     * anything goes wrong, this procedure returns an error message in the
3081     * interpreter's result object.
3082     *
3083     *----------------------------------------------------------------------
3084     */
3085    
3086     static int
3087     NamespaceForgetCmd(dummy, interp, objc, objv)
3088     ClientData dummy; /* Not used. */
3089     Tcl_Interp *interp; /* Current interpreter. */
3090     int objc; /* Number of arguments. */
3091     Tcl_Obj *CONST objv[]; /* Argument objects. */
3092     {
3093     char *pattern;
3094     register int i, result;
3095    
3096     if (objc < 2) {
3097     Tcl_WrongNumArgs(interp, 2, objv, "?pattern pattern...?");
3098     return TCL_ERROR;
3099     }
3100    
3101     for (i = 2; i < objc; i++) {
3102     pattern = Tcl_GetString(objv[i]);
3103     result = Tcl_ForgetImport(interp, (Tcl_Namespace *) NULL, pattern);
3104     if (result != TCL_OK) {
3105     return result;
3106     }
3107     }
3108     return TCL_OK;
3109     }
3110    
3111     /*
3112     *----------------------------------------------------------------------
3113     *
3114     * NamespaceImportCmd --
3115     *
3116     * Invoked to implement the "namespace import" command that imports
3117     * commands into a namespace. Handles the following syntax:
3118     *
3119     * namespace import ?-force? ?pattern pattern...?
3120     *
3121     * Each pattern is a namespace-qualified name like "foo::*",
3122     * "a::b::x*", or "bar::p". That is, the pattern may include the
3123     * special pattern matching characters recognized by the "string match"
3124     * command, but only in the command name at the end of the qualified
3125     * name; the special pattern characters may not appear in a namespace
3126     * name. All of the commands that match the pattern and which are
3127     * exported from their namespace are made accessible from the current
3128     * namespace context. This is done by creating a new "imported command"
3129     * in the current namespace that points to the real command in its
3130     * original namespace; when the imported command is called, it invokes
3131     * the real command.
3132     *
3133     * If an imported command conflicts with an existing command, it is
3134     * treated as an error. But if the "-force" option is included, then
3135     * existing commands are overwritten by the imported commands.
3136     *
3137     * Results:
3138     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
3139     *
3140     * Side effects:
3141     * Adds imported commands to the current namespace. If anything goes
3142     * wrong, this procedure returns an error message in the interpreter's
3143     * result object.
3144     *
3145     *----------------------------------------------------------------------
3146     */
3147    
3148     static int
3149     NamespaceImportCmd(dummy, interp, objc, objv)
3150     ClientData dummy; /* Not used. */
3151     Tcl_Interp *interp; /* Current interpreter. */
3152     int objc; /* Number of arguments. */
3153     Tcl_Obj *CONST objv[]; /* Argument objects. */
3154     {
3155     int allowOverwrite = 0;
3156     char *string, *pattern;
3157     register int i, result;
3158     int firstArg;
3159    
3160     if (objc < 2) {
3161     Tcl_WrongNumArgs(interp, 2, objv,
3162     "?-force? ?pattern pattern...?");
3163     return TCL_ERROR;
3164     }
3165    
3166     /*
3167     * Skip over the optional "-force" as the first argument.
3168     */
3169    
3170     firstArg = 2;
3171     if (firstArg < objc) {
3172     string = Tcl_GetString(objv[firstArg]);
3173     if ((*string == '-') && (strcmp(string, "-force") == 0)) {
3174     allowOverwrite = 1;
3175     firstArg++;
3176     }
3177     }
3178    
3179     /*
3180     * Handle the imports for each of the patterns.
3181     */
3182    
3183     for (i = firstArg; i < objc; i++) {
3184     pattern = Tcl_GetString(objv[i]);
3185     result = Tcl_Import(interp, (Tcl_Namespace *) NULL, pattern,
3186     allowOverwrite);
3187     if (result != TCL_OK) {
3188     return result;
3189     }
3190     }
3191     return TCL_OK;
3192     }
3193    
3194     /*
3195     *----------------------------------------------------------------------
3196     *
3197     * NamespaceInscopeCmd --
3198     *
3199     * Invoked to implement the "namespace inscope" command that executes a
3200     * script in the context of a particular namespace. This command is not
3201     * expected to be used directly by programmers; calls to it are
3202     * generated implicitly when programs use "namespace code" commands
3203     * to register callback scripts. Handles the following syntax:
3204     *
3205     * namespace inscope name arg ?arg...?
3206     *
3207     * The "namespace inscope" command is much like the "namespace eval"
3208     * command except that it has lappend semantics and the namespace must
3209     * already exist. It treats the first argument as a list, and appends
3210     * any arguments after the first onto the end as proper list elements.
3211     * For example,
3212     *
3213     * namespace inscope ::foo a b c d
3214     *
3215     * is equivalent to
3216     *
3217     * namespace eval ::foo [concat a [list b c d]]
3218     *
3219     * This lappend semantics is important because many callback scripts
3220     * are actually prefixes.
3221     *
3222     * Results:
3223     * Returns TCL_OK to indicate success, or TCL_ERROR to indicate
3224     * failure.
3225     *
3226     * Side effects:
3227     * Returns a result in the Tcl interpreter's result object.
3228     *
3229     *----------------------------------------------------------------------
3230     */
3231    
3232     static int
3233     NamespaceInscopeCmd(dummy, interp, objc, objv)
3234     ClientData dummy; /* Not used. */
3235     Tcl_Interp *interp; /* Current interpreter. */
3236     int objc; /* Number of arguments. */
3237     Tcl_Obj *CONST objv[]; /* Argument objects. */
3238     {
3239     Tcl_Namespace *namespacePtr;
3240     Tcl_CallFrame frame;
3241     int i, result;
3242    
3243     if (objc < 4) {
3244     Tcl_WrongNumArgs(interp, 2, objv, "name arg ?arg...?");
3245     return TCL_ERROR;
3246     }
3247    
3248     /*
3249     * Resolve the namespace reference.
3250     */
3251    
3252     result = GetNamespaceFromObj(interp, objv[2], &namespacePtr);
3253     if (result != TCL_OK) {
3254     return result;
3255     }
3256     if (namespacePtr == NULL) {
3257     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
3258     "unknown namespace \"", Tcl_GetString(objv[2]),
3259     "\" in inscope namespace command", (char *) NULL);
3260     return TCL_ERROR;
3261     }
3262    
3263     /*
3264     * Make the specified namespace the current namespace.
3265     */
3266    
3267     result = Tcl_PushCallFrame(interp, &frame, namespacePtr,
3268     /*isProcCallFrame*/ 0);
3269     if (result != TCL_OK) {
3270     return result;
3271     }
3272    
3273     /*
3274     * Execute the command. If there is just one argument, just treat it as
3275     * a script and evaluate it. Otherwise, create a list from the arguments
3276     * after the first one, then concatenate the first argument and the list
3277     * of extra arguments to form the command to evaluate.
3278     */
3279    
3280     if (objc == 4) {
3281     result = Tcl_EvalObjEx(interp, objv[3], 0);
3282     } else {
3283     Tcl_Obj *concatObjv[2];
3284     register Tcl_Obj *listPtr, *cmdObjPtr;
3285    
3286     listPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL);
3287     for (i = 4; i < objc; i++) {
3288     result = Tcl_ListObjAppendElement(interp, listPtr, objv[i]);
3289     if (result != TCL_OK) {
3290     Tcl_DecrRefCount(listPtr); /* free unneeded obj */
3291     return result;
3292     }
3293     }
3294    
3295     concatObjv[0] = objv[3];
3296     concatObjv[1] = listPtr;
3297     cmdObjPtr = Tcl_ConcatObj(2, concatObjv);
3298     result = Tcl_EvalObjEx(interp, cmdObjPtr, TCL_EVAL_DIRECT);
3299     Tcl_DecrRefCount(listPtr); /* we're done with the list object */
3300     }
3301     if (result == TCL_ERROR) {
3302     char msg[256 + TCL_INTEGER_SPACE];
3303    
3304     sprintf(msg,
3305     "\n (in namespace inscope \"%.200s\" script line %d)",
3306     namespacePtr->fullName, interp->errorLine);
3307     Tcl_AddObjErrorInfo(interp, msg, -1);
3308     }
3309    
3310     /*
3311     * Restore the previous "current" namespace.
3312     */
3313    
3314     Tcl_PopCallFrame(interp);
3315     return result;
3316     }
3317    
3318     /*
3319     *----------------------------------------------------------------------
3320     *
3321     * NamespaceOriginCmd --
3322     *
3323     * Invoked to implement the "namespace origin" command to return the
3324     * fully-qualified name of the "real" command to which the specified
3325     * "imported command" refers. Handles the following syntax:
3326     *
3327     * namespace origin name
3328     *
3329     * Results:
3330     * An imported command is created in an namespace when that namespace
3331     * imports a command from another namespace. If a command is imported
3332     * into a sequence of namespaces a, b,...,n where each successive
3333     * namespace just imports the command from the previous namespace, this
3334     * command returns the fully-qualified name of the original command in
3335     * the first namespace, a. If "name" does not refer to an alias, its
3336     * fully-qualified name is returned. The returned name is stored in the
3337     * interpreter's result object. This procedure returns TCL_OK if
3338     * successful, and TCL_ERROR if anything goes wrong.
3339     *
3340     * Side effects:
3341     * If anything goes wrong, this procedure returns an error message in
3342     * the interpreter's result object.
3343     *
3344     *----------------------------------------------------------------------
3345     */
3346    
3347     static int
3348     NamespaceOriginCmd(dummy, interp, objc, objv)
3349     ClientData dummy; /* Not used. */
3350     Tcl_Interp *interp; /* Current interpreter. */
3351     int objc; /* Number of arguments. */
3352     Tcl_Obj *CONST objv[]; /* Argument objects. */
3353     {
3354     Tcl_Command command, origCommand;
3355    
3356     if (objc != 3) {
3357     Tcl_WrongNumArgs(interp, 2, objv, "name");
3358     return TCL_ERROR;
3359     }
3360    
3361     command = Tcl_GetCommandFromObj(interp, objv[2]);
3362     if (command == (Tcl_Command) NULL) {
3363     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
3364     "invalid command name \"", Tcl_GetString(objv[2]),
3365     "\"", (char *) NULL);
3366     return TCL_ERROR;
3367     }
3368     origCommand = TclGetOriginalCommand(command);
3369     if (origCommand == (Tcl_Command) NULL) {
3370     /*
3371     * The specified command isn't an imported command. Return the
3372     * command's name qualified by the full name of the namespace it
3373     * was defined in.
3374     */
3375    
3376     Tcl_GetCommandFullName(interp, command, Tcl_GetObjResult(interp));
3377     } else {
3378     Tcl_GetCommandFullName(interp, origCommand, Tcl_GetObjResult(interp));
3379     }
3380     return TCL_OK;
3381     }
3382    
3383     /*
3384     *----------------------------------------------------------------------
3385     *
3386     * NamespaceParentCmd --
3387     *
3388     * Invoked to implement the "namespace parent" command that returns the
3389     * fully-qualified name of the parent namespace for a specified
3390     * namespace. Handles the following syntax:
3391     *
3392     * namespace parent ?name?
3393     *
3394     * Results:
3395     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
3396     *
3397     * Side effects:
3398     * Returns a result in the interpreter's result object. If anything
3399     * goes wrong, the result is an error message.
3400     *
3401     *----------------------------------------------------------------------
3402     */
3403    
3404     static int
3405     NamespaceParentCmd(dummy, interp, objc, objv)
3406     ClientData dummy; /* Not used. */
3407     Tcl_Interp *interp; /* Current interpreter. */
3408     int objc; /* Number of arguments. */
3409     Tcl_Obj *CONST objv[]; /* Argument objects. */
3410     {
3411     Tcl_Namespace *nsPtr;
3412     int result;
3413    
3414     if (objc == 2) {
3415     nsPtr = Tcl_GetCurrentNamespace(interp);
3416     } else if (objc == 3) {
3417     result = GetNamespaceFromObj(interp, objv[2], &nsPtr);
3418     if (result != TCL_OK) {
3419     return result;
3420     }
3421     if (nsPtr == NULL) {
3422     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
3423     "unknown namespace \"", Tcl_GetString(objv[2]),
3424     "\" in namespace parent command", (char *) NULL);
3425     return TCL_ERROR;
3426     }
3427     } else {
3428     Tcl_WrongNumArgs(interp, 2, objv, "?name?");
3429     return TCL_ERROR;
3430     }
3431    
3432     /*
3433     * Report the parent of the specified namespace.
3434     */
3435    
3436     if (nsPtr->parentPtr != NULL) {
3437     Tcl_SetStringObj(Tcl_GetObjResult(interp),
3438     nsPtr->parentPtr->fullName, -1);
3439     }
3440     return TCL_OK;
3441     }
3442    
3443     /*
3444     *----------------------------------------------------------------------
3445     *
3446     * NamespaceQualifiersCmd --
3447     *
3448     * Invoked to implement the "namespace qualifiers" command that returns
3449     * any leading namespace qualifiers in a string. These qualifiers are
3450     * namespace names separated by "::"s. For example, for "::foo::p" this
3451     * command returns "::foo", and for "::" it returns "". This command
3452     * is the complement of the "namespace tail" command. Note that this
3453     * command does not check whether the "namespace" names are, in fact,
3454     * the names of currently defined namespaces. Handles the following
3455     * syntax:
3456     *
3457     * namespace qualifiers string
3458     *
3459     * Results:
3460     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
3461     *
3462     * Side effects:
3463     * Returns a result in the interpreter's result object. If anything
3464     * goes wrong, the result is an error message.
3465     *
3466     *----------------------------------------------------------------------
3467     */
3468    
3469     static int
3470     NamespaceQualifiersCmd(dummy, interp, objc, objv)
3471     ClientData dummy; /* Not used. */
3472     Tcl_Interp *interp; /* Current interpreter. */
3473     int objc; /* Number of arguments. */
3474     Tcl_Obj *CONST objv[]; /* Argument objects. */
3475     {
3476     register char *name, *p;
3477     int length;
3478    
3479     if (objc != 3) {
3480     Tcl_WrongNumArgs(interp, 2, objv, "string");
3481     return TCL_ERROR;
3482     }
3483    
3484     /*
3485     * Find the end of the string, then work backward and find
3486     * the start of the last "::" qualifier.
3487     */
3488    
3489     name = Tcl_GetString(objv[2]);
3490     for (p = name; *p != '\0'; p++) {
3491     /* empty body */
3492     }
3493     while (--p >= name) {
3494     if ((*p == ':') && (p > name) && (*(p-1) == ':')) {
3495     p -= 2; /* back up over the :: */
3496     while ((p >= name) && (*p == ':')) {
3497     p--; /* back up over the preceeding : */
3498     }
3499     break;
3500     }
3501     }
3502    
3503     if (p >= name) {
3504     length = p-name+1;
3505     Tcl_AppendToObj(Tcl_GetObjResult(interp), name, length);
3506     }
3507     return TCL_OK;
3508     }
3509    
3510     /*
3511     *----------------------------------------------------------------------
3512     *
3513     * NamespaceTailCmd --
3514     *
3515     * Invoked to implement the "namespace tail" command that returns the
3516     * trailing name at the end of a string with "::" namespace
3517     * qualifiers. These qualifiers are namespace names separated by
3518     * "::"s. For example, for "::foo::p" this command returns "p", and for
3519     * "::" it returns "". This command is the complement of the "namespace
3520     * qualifiers" command. Note that this command does not check whether
3521     * the "namespace" names are, in fact, the names of currently defined
3522     * namespaces. Handles the following syntax:
3523     *
3524     * namespace tail string
3525     *
3526     * Results:
3527     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
3528     *
3529     * Side effects:
3530     * Returns a result in the interpreter's result object. If anything
3531     * goes wrong, the result is an error message.
3532     *
3533     *----------------------------------------------------------------------
3534     */
3535    
3536     static int
3537     NamespaceTailCmd(dummy, interp, objc, objv)
3538     ClientData dummy; /* Not used. */
3539     Tcl_Interp *interp; /* Current interpreter. */
3540     int objc; /* Number of arguments. */
3541     Tcl_Obj *CONST objv[]; /* Argument objects. */
3542     {
3543     register char *name, *p;
3544    
3545     if (objc != 3) {
3546     Tcl_WrongNumArgs(interp, 2, objv, "string");
3547     return TCL_ERROR;
3548     }
3549    
3550     /*
3551     * Find the end of the string, then work backward and find the
3552     * last "::" qualifier.
3553     */
3554    
3555     name = Tcl_GetString(objv[2]);
3556     for (p = name; *p != '\0'; p++) {
3557     /* empty body */
3558     }
3559     while (--p > name) {
3560     if ((*p == ':') && (*(p-1) == ':')) {
3561     p++; /* just after the last "::" */
3562     break;
3563     }
3564     }
3565    
3566     if (p >= name) {
3567     Tcl_AppendToObj(Tcl_GetObjResult(interp), p, -1);
3568     }
3569     return TCL_OK;
3570     }
3571    
3572     /*
3573     *----------------------------------------------------------------------
3574     *
3575     * NamespaceWhichCmd --
3576     *
3577     * Invoked to implement the "namespace which" command that returns the
3578     * fully-qualified name of a command or variable. If the specified
3579     * command or variable does not exist, it returns "". Handles the
3580     * following syntax:
3581     *
3582     * namespace which ?-command? ?-variable? name
3583     *
3584     * Results:
3585     * Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
3586     *
3587     * Side effects:
3588     * Returns a result in the interpreter's result object. If anything
3589     * goes wrong, the result is an error message.
3590     *
3591     *----------------------------------------------------------------------
3592     */
3593    
3594     static int
3595     NamespaceWhichCmd(dummy, interp, objc, objv)
3596     ClientData dummy; /* Not used. */
3597     Tcl_Interp *interp; /* Current interpreter. */
3598     int objc; /* Number of arguments. */
3599     Tcl_Obj *CONST objv[]; /* Argument objects. */
3600     {
3601     register char *arg;
3602     Tcl_Command cmd;
3603     Tcl_Var variable;
3604     int argIndex, lookup;
3605    
3606     if (objc < 3) {
3607     badArgs:
3608     Tcl_WrongNumArgs(interp, 2, objv,
3609     "?-command? ?-variable? name");
3610     return TCL_ERROR;
3611     }
3612    
3613     /*
3614     * Look for a flag controlling the lookup.
3615     */
3616    
3617     argIndex = 2;
3618     lookup = 0; /* assume command lookup by default */
3619     arg = Tcl_GetString(objv[2]);
3620     if (*arg == '-') {
3621     if (strncmp(arg, "-command", 8) == 0) {
3622     lookup = 0;
3623     } else if (strncmp(arg, "-variable", 9) == 0) {
3624     lookup = 1;
3625     } else {
3626     goto badArgs;
3627     }
3628     argIndex = 3;
3629     }
3630     if (objc != (argIndex + 1)) {
3631     goto badArgs;
3632     }
3633    
3634     switch (lookup) {
3635     case 0: /* -command */
3636     cmd = Tcl_GetCommandFromObj(interp, objv[argIndex]);
3637     if (cmd == (Tcl_Command) NULL) {
3638     return TCL_OK; /* cmd not found, just return (no error) */
3639     }
3640     Tcl_GetCommandFullName(interp, cmd, Tcl_GetObjResult(interp));
3641     break;
3642    
3643     case 1: /* -variable */
3644     arg = Tcl_GetString(objv[argIndex]);
3645     variable = Tcl_FindNamespaceVar(interp, arg, (Tcl_Namespace *) NULL,
3646     /*flags*/ 0);
3647     if (variable != (Tcl_Var) NULL) {
3648     Tcl_GetVariableFullName(interp, variable, Tcl_GetObjResult(interp));
3649     }
3650     break;
3651     }
3652     return TCL_OK;
3653     }
3654    
3655     /*
3656     *----------------------------------------------------------------------
3657     *
3658     * FreeNsNameInternalRep --
3659     *
3660     * Frees the resources associated with a nsName object's internal
3661     * representation.
3662     *
3663     * Results:
3664     * None.
3665     *
3666     * Side effects:
3667     * Decrements the ref count of any Namespace structure pointed
3668     * to by the nsName's internal representation. If there are no more
3669     * references to the namespace, it's structure will be freed.
3670     *
3671     *----------------------------------------------------------------------
3672     */
3673    
3674     static void
3675     FreeNsNameInternalRep(objPtr)
3676     register Tcl_Obj *objPtr; /* nsName object with internal
3677     * representation to free */
3678     {
3679     register ResolvedNsName *resNamePtr =
3680     (ResolvedNsName *) objPtr->internalRep.otherValuePtr;
3681     Namespace *nsPtr;
3682    
3683     /*
3684     * Decrement the reference count of the namespace. If there are no
3685     * more references, free it up.
3686     */
3687    
3688     if (resNamePtr != NULL) {
3689     resNamePtr->refCount--;
3690     if (resNamePtr->refCount == 0) {
3691    
3692     /*
3693     * Decrement the reference count for the cached namespace. If
3694     * the namespace is dead, and there are no more references to
3695     * it, free it.
3696     */
3697    
3698     nsPtr = resNamePtr->nsPtr;
3699     nsPtr->refCount--;
3700     if ((nsPtr->refCount == 0) && (nsPtr->flags & NS_DEAD)) {
3701     NamespaceFree(nsPtr);
3702     }
3703     ckfree((char *) resNamePtr);
3704     }
3705     }
3706     }
3707    
3708     /*
3709     *----------------------------------------------------------------------
3710     *
3711     * DupNsNameInternalRep --
3712     *
3713     * Initializes the internal representation of a nsName object to a copy
3714     * of the internal representation of another nsName object.
3715     *
3716     * Results:
3717     * None.
3718     *
3719     * Side effects:
3720     * copyPtr's internal rep is set to refer to the same namespace
3721     * referenced by srcPtr's internal rep. Increments the ref count of
3722     * the ResolvedNsName structure used to hold the namespace reference.
3723     *
3724     *----------------------------------------------------------------------
3725     */
3726    
3727     static void
3728     DupNsNameInternalRep(srcPtr, copyPtr)
3729     Tcl_Obj *srcPtr; /* Object with internal rep to copy. */
3730     register Tcl_Obj *copyPtr; /* Object with internal rep to set. */
3731     {
3732     register ResolvedNsName *resNamePtr =
3733     (ResolvedNsName *) srcPtr->internalRep.otherValuePtr;
3734    
3735     copyPtr->internalRep.otherValuePtr = (VOID *) resNamePtr;
3736     if (resNamePtr != NULL) {
3737     resNamePtr->refCount++;
3738     }
3739     copyPtr->typePtr = &tclNsNameType;
3740     }
3741    
3742     /*
3743     *----------------------------------------------------------------------
3744     *
3745     * SetNsNameFromAny --
3746     *
3747     * Attempt to generate a nsName internal representation for a
3748     * Tcl object.
3749     *
3750     * Results:
3751     * Returns TCL_OK if the value could be converted to a proper
3752     * namespace reference. Otherwise, it returns TCL_ERROR, along
3753     * with an error message in the interpreter's result object.
3754     *
3755     * Side effects:
3756     * If successful, the object is made a nsName object. Its internal rep
3757     * is set to point to a ResolvedNsName, which contains a cached pointer
3758     * to the Namespace. Reference counts are kept on both the
3759     * ResolvedNsName and the Namespace, so we can keep track of their
3760     * usage and free them when appropriate.
3761     *
3762     *----------------------------------------------------------------------
3763     */
3764    
3765     static int
3766     SetNsNameFromAny(interp, objPtr)
3767     Tcl_Interp *interp; /* Points to the namespace in which to
3768     * resolve name. Also used for error
3769     * reporting if not NULL. */
3770     register Tcl_Obj *objPtr; /* The object to convert. */
3771     {
3772     register Tcl_ObjType *oldTypePtr = objPtr->typePtr;
3773     char *name, *dummy;
3774     Namespace *nsPtr, *dummy1Ptr, *dummy2Ptr;
3775     register ResolvedNsName *resNamePtr;
3776    
3777     /*
3778     * Get the string representation. Make it up-to-date if necessary.
3779     */
3780    
3781     name = objPtr->bytes;
3782     if (name == NULL) {
3783     name = Tcl_GetString(objPtr);
3784     }
3785    
3786     /*
3787     * Look for the namespace "name" in the current namespace. If there is
3788     * an error parsing the (possibly qualified) name, return an error.
3789     * If the namespace isn't found, we convert the object to an nsName
3790     * object with a NULL ResolvedNsName* internal rep.
3791     */
3792    
3793     TclGetNamespaceForQualName(interp, name, (Namespace *) NULL,
3794     FIND_ONLY_NS, &nsPtr, &dummy1Ptr, &dummy2Ptr, &dummy);
3795    
3796     /*
3797     * If we found a namespace, then create a new ResolvedNsName structure
3798     * that holds a reference to it.
3799     */
3800    
3801     if (nsPtr != NULL) {
3802     Namespace *currNsPtr =
3803     (Namespace *) Tcl_GetCurrentNamespace(interp);
3804    
3805     nsPtr->refCount++;
3806     resNamePtr = (ResolvedNsName *) ckalloc(sizeof(ResolvedNsName));
3807     resNamePtr->nsPtr = nsPtr;
3808     resNamePtr->nsId = nsPtr->nsId;
3809     resNamePtr->refNsPtr = currNsPtr;
3810     resNamePtr->refCount = 1;
3811     } else {
3812     resNamePtr = NULL;
3813     }
3814    
3815     /*
3816     * Free the old internalRep before setting the new one.
3817     * We do this as late as possible to allow the conversion code
3818     * (in particular, Tcl_GetStringFromObj) to use that old internalRep.
3819     */
3820    
3821     if ((oldTypePtr != NULL) && (oldTypePtr->freeIntRepProc != NULL)) {
3822     oldTypePtr->freeIntRepProc(objPtr);
3823     }
3824    
3825     objPtr->internalRep.otherValuePtr = (VOID *) resNamePtr;
3826     objPtr->typePtr = &tclNsNameType;
3827     return TCL_OK;
3828     }
3829    
3830     /*
3831     *----------------------------------------------------------------------
3832     *
3833     * UpdateStringOfNsName --
3834     *
3835     * Updates the string representation for a nsName object.
3836     * Note: This procedure does not free an existing old string rep
3837     * so storage will be lost if this has not already been done.
3838     *
3839     * Results:
3840     * None.
3841     *
3842     * Side effects:
3843     * The object's string is set to a copy of the fully qualified
3844     * namespace name.
3845     *
3846     *----------------------------------------------------------------------
3847     */
3848    
3849     static void
3850     UpdateStringOfNsName(objPtr)
3851     register Tcl_Obj *objPtr; /* nsName object with string rep to update. */
3852     {
3853     ResolvedNsName *resNamePtr =
3854     (ResolvedNsName *) objPtr->internalRep.otherValuePtr;
3855     register Namespace *nsPtr;
3856     char *name = "";
3857     int length;
3858    
3859     if ((resNamePtr != NULL)
3860     && (resNamePtr->nsId == resNamePtr->nsPtr->nsId)) {
3861     nsPtr = resNamePtr->nsPtr;
3862     if (nsPtr->flags & NS_DEAD) {
3863     nsPtr = NULL;
3864     }
3865     if (nsPtr != NULL) {
3866     name = nsPtr->fullName;
3867     }
3868     }
3869    
3870     /*
3871     * The following sets the string rep to an empty string on the heap
3872     * if the internal rep is NULL.
3873     */
3874    
3875     length = strlen(name);
3876     if (length == 0) {
3877     objPtr->bytes = tclEmptyStringRep;
3878     } else {
3879     objPtr->bytes = (char *) ckalloc((unsigned) (length + 1));
3880     memcpy((VOID *) objPtr->bytes, (VOID *) name, (unsigned) length);
3881     objPtr->bytes[length] = '\0';
3882     }
3883     objPtr->length = length;
3884     }
3885    
3886    
3887     /* $History: tclnamesp.c $
3888     *
3889     * ***************** Version 1 *****************
3890     * User: Dtashley Date: 1/02/01 Time: 1:31a
3891     * Created in $/IjuScripter, IjuConsole/Source/Tcl Base
3892     * Initial check-in.
3893     */
3894    
3895     /* End of TCLNAMESP.C */

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25