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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 71 - (hide annotations) (download)
Sat Nov 5 11:07:06 2016 UTC (7 years, 8 months ago) by dashley
File MIME type: text/plain
File size: 14056 byte(s)
Set EOL properties appropriately to facilitate simultaneous Linux and Windows development.
1 dashley 71 /* $Header$ */
2     /*
3     * tclResolve.c --
4     *
5     * Contains hooks for customized command/variable name resolution
6     * schemes. These hooks allow extensions like [incr Tcl] to add
7     * their own name resolution rules to the Tcl language. Rules can
8     * be applied to a particular namespace, to the interpreter as a
9     * whole, or both.
10     *
11     * Copyright (c) 1998 Lucent Technologies, Inc.
12     *
13     * See the file "license.terms" for information on usage and redistribution
14     * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
15     *
16     * RCS: @(#) $Id: tclresolve.c,v 1.1.1.1 2001/06/13 04:45:45 dtashley Exp $
17     */
18    
19     #include "tclInt.h"
20    
21     /*
22     * Declarations for procedures local to this file:
23     */
24    
25     static void BumpCmdRefEpochs _ANSI_ARGS_((Namespace *nsPtr));
26    
27    
28     /*
29     *----------------------------------------------------------------------
30     *
31     * Tcl_AddInterpResolvers --
32     *
33     * Adds a set of command/variable resolution procedures to an
34     * interpreter. These procedures are consulted when commands
35     * are resolved in Tcl_FindCommand, and when variables are
36     * resolved in TclLookupVar and LookupCompiledLocal. Each
37     * namespace may also have its own set of resolution procedures
38     * which take precedence over those for the interpreter.
39     *
40     * When a name is resolved, it is handled as follows. First,
41     * the name is passed to the resolution procedures for the
42     * namespace. If not resolved, the name is passed to each of
43     * the resolution procedures added to the interpreter. Finally,
44     * if still not resolved, the name is handled using the default
45     * Tcl rules for name resolution.
46     *
47     * Results:
48     * Returns pointers to the current name resolution procedures
49     * in the cmdProcPtr, varProcPtr and compiledVarProcPtr
50     * arguments.
51     *
52     * Side effects:
53     * If a compiledVarProc is specified, this procedure bumps the
54     * compileEpoch for the interpreter, forcing all code to be
55     * recompiled. If a cmdProc is specified, this procedure bumps
56     * the cmdRefEpoch in all namespaces, forcing commands to be
57     * resolved again using the new rules.
58     *
59     *----------------------------------------------------------------------
60     */
61    
62     void
63     Tcl_AddInterpResolvers(interp, name, cmdProc, varProc, compiledVarProc)
64    
65     Tcl_Interp *interp; /* Interpreter whose name resolution
66     * rules are being modified. */
67     char *name; /* Name of this resolution scheme. */
68     Tcl_ResolveCmdProc *cmdProc; /* New procedure for command
69     * resolution */
70     Tcl_ResolveVarProc *varProc; /* Procedure for variable resolution
71     * at runtime */
72     Tcl_ResolveCompiledVarProc *compiledVarProc;
73     /* Procedure for variable resolution
74     * at compile time. */
75     {
76     Interp *iPtr = (Interp*)interp;
77     ResolverScheme *resPtr;
78    
79     /*
80     * Since we're adding a new name resolution scheme, we must force
81     * all code to be recompiled to use the new scheme. If there
82     * are new compiled variable resolution rules, bump the compiler
83     * epoch to invalidate compiled code. If there are new command
84     * resolution rules, bump the cmdRefEpoch in all namespaces.
85     */
86     if (compiledVarProc) {
87     iPtr->compileEpoch++;
88     }
89     if (cmdProc) {
90     BumpCmdRefEpochs(iPtr->globalNsPtr);
91     }
92    
93     /*
94     * Look for an existing scheme with the given name. If found,
95     * then replace its rules.
96     */
97     for (resPtr = iPtr->resolverPtr; resPtr != NULL; resPtr = resPtr->nextPtr) {
98     if (*name == *resPtr->name && strcmp(name, resPtr->name) == 0) {
99     resPtr->cmdResProc = cmdProc;
100     resPtr->varResProc = varProc;
101     resPtr->compiledVarResProc = compiledVarProc;
102     return;
103     }
104     }
105    
106     /*
107     * Otherwise, this is a new scheme. Add it to the FRONT
108     * of the linked list, so that it overrides existing schemes.
109     */
110     resPtr = (ResolverScheme *) ckalloc(sizeof(ResolverScheme));
111     resPtr->name = (char*)ckalloc((unsigned)(strlen(name)+1));
112     strcpy(resPtr->name, name);
113     resPtr->cmdResProc = cmdProc;
114     resPtr->varResProc = varProc;
115     resPtr->compiledVarResProc = compiledVarProc;
116     resPtr->nextPtr = iPtr->resolverPtr;
117     iPtr->resolverPtr = resPtr;
118     }
119    
120     /*
121     *----------------------------------------------------------------------
122     *
123     * Tcl_GetInterpResolvers --
124     *
125     * Looks for a set of command/variable resolution procedures with
126     * the given name in an interpreter. These procedures are
127     * registered by calling Tcl_AddInterpResolvers.
128     *
129     * Results:
130     * If the name is recognized, this procedure returns non-zero,
131     * along with pointers to the name resolution procedures in
132     * the Tcl_ResolverInfo structure. If the name is not recognized,
133     * this procedure returns zero.
134     *
135     * Side effects:
136     * None.
137     *
138     *----------------------------------------------------------------------
139     */
140    
141     int
142     Tcl_GetInterpResolvers(interp, name, resInfoPtr)
143    
144     Tcl_Interp *interp; /* Interpreter whose name resolution
145     * rules are being queried. */
146     char *name; /* Look for a scheme with this name. */
147     Tcl_ResolverInfo *resInfoPtr; /* Returns pointers to the procedures,
148     * if found */
149     {
150     Interp *iPtr = (Interp*)interp;
151     ResolverScheme *resPtr;
152    
153     /*
154     * Look for an existing scheme with the given name. If found,
155     * then return pointers to its procedures.
156     */
157     for (resPtr = iPtr->resolverPtr; resPtr != NULL; resPtr = resPtr->nextPtr) {
158     if (*name == *resPtr->name && strcmp(name, resPtr->name) == 0) {
159     resInfoPtr->cmdResProc = resPtr->cmdResProc;
160     resInfoPtr->varResProc = resPtr->varResProc;
161     resInfoPtr->compiledVarResProc = resPtr->compiledVarResProc;
162     return 1;
163     }
164     }
165    
166     return 0;
167     }
168    
169     /*
170     *----------------------------------------------------------------------
171     *
172     * Tcl_RemoveInterpResolvers --
173     *
174     * Removes a set of command/variable resolution procedures
175     * previously added by Tcl_AddInterpResolvers. The next time
176     * a command/variable name is resolved, these procedures
177     * won't be consulted.
178     *
179     * Results:
180     * Returns non-zero if the name was recognized and the
181     * resolution scheme was deleted. Returns zero otherwise.
182     *
183     * Side effects:
184     * If a scheme with a compiledVarProc was deleted, this procedure
185     * bumps the compileEpoch for the interpreter, forcing all code
186     * to be recompiled. If a scheme with a cmdProc was deleted,
187     * this procedure bumps the cmdRefEpoch in all namespaces,
188     * forcing commands to be resolved again using the new rules.
189     *
190     *----------------------------------------------------------------------
191     */
192    
193     int
194     Tcl_RemoveInterpResolvers(interp, name)
195    
196     Tcl_Interp *interp; /* Interpreter whose name resolution
197     * rules are being modified. */
198     char *name; /* Name of the scheme to be removed. */
199     {
200     Interp *iPtr = (Interp*)interp;
201     ResolverScheme **prevPtrPtr, *resPtr;
202    
203     /*
204     * Look for an existing scheme with the given name.
205     */
206     prevPtrPtr = &iPtr->resolverPtr;
207     for (resPtr = iPtr->resolverPtr; resPtr != NULL; resPtr = resPtr->nextPtr) {
208     if (*name == *resPtr->name && strcmp(name, resPtr->name) == 0) {
209     break;
210     }
211     prevPtrPtr = &resPtr->nextPtr;
212     }
213    
214     /*
215     * If we found the scheme, delete it.
216     */
217     if (resPtr) {
218     /*
219     * If we're deleting a scheme with compiled variable resolution
220     * rules, bump the compiler epoch to invalidate compiled code.
221     * If we're deleting a scheme with command resolution rules,
222     * bump the cmdRefEpoch in all namespaces.
223     */
224     if (resPtr->compiledVarResProc) {
225     iPtr->compileEpoch++;
226     }
227     if (resPtr->cmdResProc) {
228     BumpCmdRefEpochs(iPtr->globalNsPtr);
229     }
230    
231     *prevPtrPtr = resPtr->nextPtr;
232     ckfree(resPtr->name);
233     ckfree((char *) resPtr);
234    
235     return 1;
236     }
237     return 0;
238     }
239    
240     /*
241     *----------------------------------------------------------------------
242     *
243     * BumpCmdRefEpochs --
244     *
245     * This procedure is used to bump the cmdRefEpoch counters in
246     * the specified namespace and all of its child namespaces.
247     * It is used whenever name resolution schemes are added/removed
248     * from an interpreter, to invalidate all command references.
249     *
250     * Results:
251     * None.
252     *
253     * Side effects:
254     * Bumps the cmdRefEpoch in the specified namespace and its
255     * children, recursively.
256     *
257     *----------------------------------------------------------------------
258     */
259    
260     static void
261     BumpCmdRefEpochs(nsPtr)
262     Namespace *nsPtr; /* Namespace being modified. */
263     {
264     Tcl_HashEntry *entry;
265     Tcl_HashSearch search;
266     Namespace *childNsPtr;
267    
268     nsPtr->cmdRefEpoch++;
269    
270     for (entry = Tcl_FirstHashEntry(&nsPtr->childTable, &search);
271     entry != NULL;
272     entry = Tcl_NextHashEntry(&search)) {
273    
274     childNsPtr = (Namespace *) Tcl_GetHashValue(entry);
275     BumpCmdRefEpochs(childNsPtr);
276     }
277     }
278    
279    
280     /*
281     *----------------------------------------------------------------------
282     *
283     * Tcl_SetNamespaceResolvers --
284     *
285     * Sets the command/variable resolution procedures for a namespace,
286     * thereby changing the way that command/variable names are
287     * interpreted. This allows extension writers to support different
288     * name resolution schemes, such as those for object-oriented
289     * packages.
290     *
291     * Command resolution is handled by a procedure of the following
292     * type:
293     *
294     * typedef int (Tcl_ResolveCmdProc) _ANSI_ARGS_((
295     * Tcl_Interp* interp, char* name, Tcl_Namespace *context,
296     * int flags, Tcl_Command *rPtr));
297     *
298     * Whenever a command is executed or Tcl_FindCommand is invoked
299     * within the namespace, this procedure is called to resolve the
300     * command name. If this procedure is able to resolve the name,
301     * it should return the status code TCL_OK, along with the
302     * corresponding Tcl_Command in the rPtr argument. Otherwise,
303     * the procedure can return TCL_CONTINUE, and the command will
304     * be treated under the usual name resolution rules. Or, it can
305     * return TCL_ERROR, and the command will be considered invalid.
306     *
307     * Variable resolution is handled by two procedures. The first
308     * is called whenever a variable needs to be resolved at compile
309     * time:
310     *
311     * typedef int (Tcl_ResolveCompiledVarProc) _ANSI_ARGS_((
312     * Tcl_Interp* interp, char* name, Tcl_Namespace *context,
313     * Tcl_ResolvedVarInfo *rPtr));
314     *
315     * If this procedure is able to resolve the name, it should return
316     * the status code TCL_OK, along with variable resolution info in
317     * the rPtr argument; this info will be used to set up compiled
318     * locals in the call frame at runtime. The procedure may also
319     * return TCL_CONTINUE, and the variable will be treated under
320     * the usual name resolution rules. Or, it can return TCL_ERROR,
321     * and the variable will be considered invalid.
322     *
323     * Another procedure is used whenever a variable needs to be
324     * resolved at runtime but it is not recognized as a compiled local.
325     * (For example, the variable may be requested via
326     * Tcl_FindNamespaceVar.) This procedure has the following type:
327     *
328     * typedef int (Tcl_ResolveVarProc) _ANSI_ARGS_((
329     * Tcl_Interp* interp, char* name, Tcl_Namespace *context,
330     * int flags, Tcl_Var *rPtr));
331     *
332     * This procedure is quite similar to the compile-time version.
333     * It returns the same status codes, but if variable resolution
334     * succeeds, this procedure returns a Tcl_Var directly via the
335     * rPtr argument.
336     *
337     * Results:
338     * Nothing.
339     *
340     * Side effects:
341     * Bumps the command epoch counter for the namespace, invalidating
342     * all command references in that namespace. Also bumps the
343     * resolver epoch counter for the namespace, forcing all code
344     * in the namespace to be recompiled.
345     *
346     *----------------------------------------------------------------------
347     */
348    
349     void
350     Tcl_SetNamespaceResolvers(namespacePtr, cmdProc, varProc, compiledVarProc)
351     Tcl_Namespace *namespacePtr; /* Namespace whose resolution rules
352     * are being modified. */
353     Tcl_ResolveCmdProc *cmdProc; /* Procedure for command resolution */
354     Tcl_ResolveVarProc *varProc; /* Procedure for variable resolution
355     * at runtime */
356     Tcl_ResolveCompiledVarProc *compiledVarProc;
357     /* Procedure for variable resolution
358     * at compile time. */
359     {
360     Namespace *nsPtr = (Namespace*)namespacePtr;
361    
362     /*
363     * Plug in the new command resolver, and bump the epoch counters
364     * so that all code will have to be recompiled and all commands
365     * will have to be resolved again using the new policy.
366     */
367     nsPtr->cmdResProc = cmdProc;
368     nsPtr->varResProc = varProc;
369     nsPtr->compiledVarResProc = compiledVarProc;
370    
371     nsPtr->cmdRefEpoch++;
372     nsPtr->resolverEpoch++;
373     }
374    
375     /*
376     *----------------------------------------------------------------------
377     *
378     * Tcl_GetNamespaceResolvers --
379     *
380     * Returns the current command/variable resolution procedures
381     * for a namespace. By default, these procedures are NULL.
382     * New procedures can be installed by calling
383     * Tcl_SetNamespaceResolvers, to provide new name resolution
384     * rules.
385     *
386     * Results:
387     * Returns non-zero if any name resolution procedures have been
388     * assigned to this namespace; also returns pointers to the
389     * procedures in the Tcl_ResolverInfo structure. Returns zero
390     * otherwise.
391     *
392     * Side effects:
393     * None.
394     *
395     *----------------------------------------------------------------------
396     */
397    
398     int
399     Tcl_GetNamespaceResolvers(namespacePtr, resInfoPtr)
400    
401     Tcl_Namespace *namespacePtr; /* Namespace whose resolution rules
402     * are being modified. */
403     Tcl_ResolverInfo *resInfoPtr; /* Returns: pointers for all
404     * name resolution procedures
405     * assigned to this namespace. */
406     {
407     Namespace *nsPtr = (Namespace*)namespacePtr;
408    
409     resInfoPtr->cmdResProc = nsPtr->cmdResProc;
410     resInfoPtr->varResProc = nsPtr->varResProc;
411     resInfoPtr->compiledVarResProc = nsPtr->compiledVarResProc;
412    
413     if (nsPtr->cmdResProc != NULL ||
414     nsPtr->varResProc != NULL ||
415     nsPtr->compiledVarResProc != NULL) {
416     return 1;
417     }
418     return 0;
419     }
420    
421     /* End of tclresolve.c */

Properties

Name Value
svn:eol-style native
svn:keywords Header

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25