source: trunk/kitgen/8.x/blt/generic/bltInterp.h@ 191

Last change on this file since 191 was 175, checked in by demin, 12 years ago

initial commit
File size: 14.9 KB
RevLine 
[175]1/*
2 * bltInterp.h --
3 *
4 * Excerpts from tclInt.h. Used to examine interpreter internals.
5 * Needed by the former (now obsoleted) TclParse* functions.
6 *
7 * Copyright (c) 1987-1993 The Regents of the University of California.
8 * Copyright (c) 1993-1997 Lucent Technologies.
9 * Copyright (c) 1994-1998 Sun Microsystems, Inc.
10 *
11 */
12
13/*
14 *----------------------------------------------------------------
15 * Data structures related to command parsing. These are used in
16 * tclParse.c and its clients.
17 *----------------------------------------------------------------
18 */
19
20/*
21 * The following data structure is used by various parsing procedures
22 * to hold information about where to store the results of parsing
23 * (e.g. the substituted contents of a quoted argument, or the result
24 * of a nested command). At any given time, the space available
25 * for output is fixed, but a procedure may be called to expand the
26 * space available if the current space runs out.
27 */
28typedef struct ParseValueStruct ParseValue;
29
30struct ParseValueStruct {
31 char *buffer; /* Address of first character in
32 * output buffer. */
33 char *next; /* Place to store next character in
34 * output buffer. */
35 char *end; /* Address of the last usable character
36 * in the buffer. */
37 void (*expandProc) _ANSI_ARGS_((ParseValue *pvPtr, int needed));
38 /* Procedure to call when space runs out;
39 * it will make more space. */
40 ClientData clientData; /* Arbitrary information for use of
41 * expandProc. */
42};
43
44
45/*
46 * The definitions for the LiteralTable and LiteralEntry structures. Each
47 * interpreter contains a LiteralTable. It is used to reduce the storage
48 * needed for all the Tcl objects that hold the literals of scripts compiled
49 * by the interpreter. A literal's object is shared by all the ByteCodes
50 * that refer to the literal. Each distinct literal has one LiteralEntry
51 * entry in the LiteralTable. A literal table is a specialized hash table
52 * that is indexed by the literal's string representation, which may contain
53 * null characters.
54 *
55 * Note that we reduce the space needed for literals by sharing literal
56 * objects both within a ByteCode (each ByteCode contains a local
57 * LiteralTable) and across all an interpreter's ByteCodes (with the
58 * interpreter's global LiteralTable).
59 */
60
61typedef struct LiteralEntryStruct LiteralEntry;
62
63struct LiteralEntryStruct {
64 LiteralEntry *nextPtr; /* Points to next entry in this
65 * hash bucket or NULL if end of
66 * chain. */
67 Tcl_Obj *objPtr; /* Points to Tcl object that
68 * holds the literal's bytes and
69 * length. */
70 int refCount; /* If in an interpreter's global
71 * literal table, the number of
72 * ByteCode structures that share
73 * the literal object; the literal
74 * entry can be freed when refCount
75 * drops to 0. If in a local literal
76 * table, -1. */
77};
78
79typedef struct {
80 LiteralEntry **buckets; /* Pointer to bucket array. Each
81 * element points to first entry in
82 * bucket's hash chain, or NULL. */
83 LiteralEntry *staticBuckets[TCL_SMALL_HASH_TABLE];
84 /* Bucket array used for small
85 * tables to avoid mallocs and
86 * frees. */
87 int numBuckets; /* Total number of buckets allocated
88 * at **buckets. */
89 int numEntries; /* Total number of entries present
90 * in table. */
91 int rebuildSize; /* Enlarge table when numEntries
92 * gets to be this large. */
93 int mask; /* Mask value used in hashing
94 * function. */
95} LiteralTable;
96
97/*
98 * The following structure defines for each Tcl interpreter various
99 * statistics-related information about the bytecode compiler and
100 * interpreter's operation in that interpreter.
101 */
102
103#ifdef TCL_COMPILE_STATS
104typedef struct {
105 long numExecutions; /* Number of ByteCodes executed. */
106 long numCompilations; /* Number of ByteCodes created. */
107 long numByteCodesFreed; /* Number of ByteCodes destroyed. */
108 long instructionCount[256]; /* Number of times each instruction was
109 * executed. */
110
111 double totalSrcBytes; /* Total source bytes ever compiled. */
112 double totalByteCodeBytes; /* Total bytes for all ByteCodes. */
113 double currentSrcBytes; /* Src bytes for all current ByteCodes. */
114 double currentByteCodeBytes;/* Code bytes in all current ByteCodes. */
115
116 long srcCount[32]; /* Source size distribution: # of srcs of
117 * size [2**(n-1)..2**n), n in [0..32). */
118 long byteCodeCount[32]; /* ByteCode size distribution. */
119 long lifetimeCount[32]; /* ByteCode lifetime distribution (ms). */
120
121 double currentInstBytes; /* Instruction bytes-current ByteCodes. */
122 double currentLitBytes; /* Current literal bytes. */
123 double currentExceptBytes; /* Current exception table bytes. */
124 double currentAuxBytes; /* Current auxiliary information bytes. */
125 double currentCmdMapBytes; /* Current src<->code map bytes. */
126
127 long numLiteralsCreated; /* Total literal objects ever compiled. */
128 double totalLitStringBytes; /* Total string bytes in all literals. */
129 double currentLitStringBytes; /* String bytes in current literals. */
130 long literalCount[32]; /* Distribution of literal string sizes. */
131} ByteCodeStats;
132
133#endif /* TCL_COMPILE_STATS */
134
135
136/*
137 *----------------------------------------------------------------
138 * Data structures and procedures related to TclHandles, which
139 * are a very lightweight method of preserving enough information
140 * to determine if an arbitrary malloc'd block has been deleted.
141 *----------------------------------------------------------------
142 */
143
144typedef VOID **TclHandle;
145
146
147/*
148 * The following fills in dummy types for structure refered to
149 * internally by the Tcl interpreter. Since we don't need the actual
150 * size of the structures (they are only pointer references), we'll
151 * simply provide empty opaque types.
152 *
153 */
154typedef struct CallFrameStruct CallFrame;
155typedef struct NamespaceStruct Namespace;
156typedef struct ActiveVarTraceStruct ActiveVarTrace;
157typedef struct ProcStruct Proc;
158typedef struct TraceStruct Trace;
159
160typedef struct TclRegexpStruct TclRegexp;
161typedef struct ExecEnvStruct ExecEnv;
162
163
164/*
165 *----------------------------------------------------------------
166 * This structure defines an interpreter, which is a collection of
167 * commands plus other state information related to interpreting
168 * commands, such as variable storage. Primary responsibility for
169 * this data structure is in tclBasic.c, but almost every Tcl
170 * source file uses something in here.
171 *----------------------------------------------------------------
172 */
173
174typedef struct {
175
176 /*
177 * Note: the first three fields must match exactly the fields in
178 * a Tcl_Interp struct (see tcl.h). If you change one, be sure to
179 * change the other.
180 *
181 * The interpreter's result is held in both the string and the
182 * objResultPtr fields. These fields hold, respectively, the result's
183 * string or object value. The interpreter's result is always in the
184 * result field if that is non-empty, otherwise it is in objResultPtr.
185 * The two fields are kept consistent unless some C code sets
186 * interp->result directly. Programs should not access result and
187 * objResultPtr directly; instead, they should always get and set the
188 * result using procedures such as Tcl_SetObjResult, Tcl_GetObjResult,
189 * and Tcl_GetStringResult. See the SetResult man page for details.
190 */
191
192 char *result; /* If the last command returned a string
193 * result, this points to it. Should not be
194 * accessed directly; see comment above. */
195 Tcl_FreeProc *freeProc; /* Zero means a string result is statically
196 * allocated. TCL_DYNAMIC means string
197 * result was allocated with ckalloc and
198 * should be freed with ckfree. Other values
199 * give address of procedure to invoke to
200 * free the string result. Tcl_Eval must
201 * free it before executing next command. */
202 int errorLine; /* When TCL_ERROR is returned, this gives
203 * the line number in the command where the
204 * error occurred (1 means first line). */
205 Tcl_Obj *objResultPtr; /* If the last command returned an object
206 * result, this points to it. Should not be
207 * accessed directly; see comment above. */
208
209 TclHandle handle; /* Handle used to keep track of when this
210 * interp is deleted. */
211
212 Namespace *globalNsPtr; /* The interpreter's global namespace. */
213 Tcl_HashTable *hiddenCmdTablePtr;
214 /* Hash table used by tclBasic.c to keep
215 * track of hidden commands on a per-interp
216 * basis. */
217 ClientData interpInfo; /* Information used by tclInterp.c to keep
218 * track of master/slave interps on
219 * a per-interp basis. */
220 Tcl_HashTable mathFuncTable;/* Contains all the math functions currently
221 * defined for the interpreter. Indexed by
222 * strings (function names); values have
223 * type (MathFunc *). */
224
225
226
227 /*
228 * Information related to procedures and variables. See tclProc.c
229 * and tclvar.c for usage.
230 */
231
232 int numLevels; /* Keeps track of how many nested calls to
233 * Tcl_Eval are in progress for this
234 * interpreter. It's used to delay deletion
235 * of the table until all Tcl_Eval
236 * invocations are completed. */
237 int maxNestingDepth; /* If numLevels exceeds this value then Tcl
238 * assumes that infinite recursion has
239 * occurred and it generates an error. */
240 CallFrame *framePtr; /* Points to top-most in stack of all nested
241 * procedure invocations. NULL means there
242 * are no active procedures. */
243 CallFrame *varFramePtr; /* Points to the call frame whose variables
244 * are currently in use (same as framePtr
245 * unless an "uplevel" command is
246 * executing). NULL means no procedure is
247 * active or "uplevel 0" is executing. */
248 ActiveVarTrace *activeTracePtr;
249 /* First in list of active traces for
250 * interp, or NULL if no active traces. */
251 int returnCode; /* Completion code to return if current
252 * procedure exits with TCL_RETURN code. */
253 char *errorInfo; /* Value to store in errorInfo if returnCode
254 * is TCL_ERROR. Malloc'ed, may be NULL */
255 char *errorCode; /* Value to store in errorCode if returnCode
256 * is TCL_ERROR. Malloc'ed, may be NULL */
257
258 /*
259 * Information used by Tcl_AppendResult to keep track of partial
260 * results. See Tcl_AppendResult code for details.
261 */
262
263 char *appendResult; /* Storage space for results generated
264 * by Tcl_AppendResult. Malloc-ed. NULL
265 * means not yet allocated. */
266 int appendAvl; /* Total amount of space available at
267 * partialResult. */
268 int appendUsed; /* Number of non-null bytes currently
269 * stored at partialResult. */
270
271 /*
272 * A cache of compiled regular expressions. See Tcl_RegExpCompile
273 * in tclUtil.c for details. THIS CACHE IS OBSOLETE and is only
274 * retained for backward compatibility with Tcl_RegExpCompile.
275 * New code should use the object interface so the Tcl_Obj caches
276 * the compiled expression.
277 */
278
279#define NUM_REGEXPS 5
280 char *patterns[NUM_REGEXPS];/* Strings corresponding to compiled
281 * regular expression patterns. NULL
282 * means that this slot isn't used.
283 * Malloc-ed. */
284 int patLengths[NUM_REGEXPS];/* Number of non-null characters in
285 * corresponding entry in patterns.
286 * -1 means entry isn't used. */
287 TclRegexp *regexps[NUM_REGEXPS];
288 /* Compiled forms of above strings. Also
289 * malloc-ed, or NULL if not in use yet. */
290
291 /*
292 * Information about packages. Used only in tclPkg.c.
293 */
294
295 Tcl_HashTable packageTable; /* Describes all of the packages loaded
296 * in or available to this interpreter.
297 * Keys are package names, values are
298 * (Package *) pointers. */
299 char *packageUnknown; /* Command to invoke during "package
300 * require" commands for packages that
301 * aren't described in packageTable.
302 * Malloc'ed, may be NULL. */
303
304 /*
305 * Miscellaneous information:
306 */
307
308 int cmdCount; /* Total number of times a command procedure
309 * has been called for this interpreter. */
310 int evalFlags; /* Flags to control next call to Tcl_Eval.
311 * Normally zero, but may be set before
312 * calling Tcl_Eval. See below for valid
313 * values. */
314 int termOffset; /* Offset of character just after last one
315 * compiled or executed by Tcl_EvalObj. */
316 LiteralTable literalTable; /* Contains LiteralEntry's describing all
317 * Tcl objects holding literals of scripts
318 * compiled by the interpreter. Indexed by
319 * the string representations of literals.
320 * Used to avoid creating duplicate
321 * objects. */
322 int compileEpoch; /* Holds the current "compilation epoch"
323 * for this interpreter. This is
324 * incremented to invalidate existing
325 * ByteCodes when, e.g., a command with a
326 * compile procedure is redefined. */
327 Proc *compiledProcPtr; /* If a procedure is being compiled, a
328 * pointer to its Proc structure; otherwise,
329 * this is NULL. Set by ObjInterpProc in
330 * tclProc.c and used by tclCompile.c to
331 * process local variables appropriately. */
332 char *scriptFile; /* NULL means there is no nested source
333 * command active; otherwise this points to
334 * the name of the file being sourced (it's
335 * not malloc-ed: it points to an argument
336 * to Tcl_EvalFile. */
337 int flags; /* Various flag bits. See below. */
338 long randSeed; /* Seed used for rand() function. */
339 Trace *tracePtr; /* List of traces for this interpreter. */
340 Tcl_HashTable *assocData; /* Hash table for associating data with
341 * this interpreter. Cleaned up when
342 * this interpreter is deleted. */
343 ExecEnv *execEnvPtr; /* Execution environment for Tcl bytecode
344 * execution. Contains a pointer to the
345 * Tcl evaluation stack. */
346 Tcl_Obj *emptyObjPtr; /* Points to an object holding an empty
347 * string. Returned by Tcl_ObjSetVar2 when
348 * variable traces change a variable in a
349 * gross way. */
350 char resultSpace[TCL_RESULT_SIZE + 1];
351 /* Static space holding small results. */
352 Tcl_ThreadId threadId; /* ID of thread that owns the interpreter */
353
354 /*
355 * Statistical information about the bytecode compiler and interpreter's
356 * operation.
357 */
358
359#ifdef TCL_COMPILE_STATS
360 ByteCodeStats stats; /* Holds compilation and execution
361 * statistics for this interpreter. */
362#endif /* TCL_COMPILE_STATS */
363} Interp;
364
365/*
366 * EvalFlag bits for Interp structures:
367 *
368 * TCL_BRACKET_TERM 1 means that the current script is terminated by
369 * a close bracket rather than the end of the string.
370 * TCL_ALLOW_EXCEPTIONS 1 means it's OK for the script to terminate with
371 * a code other than TCL_OK or TCL_ERROR; 0 means
372 * codes other than these should be turned into errors.
373 */
374
375#define TCL_BRACKET_TERM 1
376#define TCL_ALLOW_EXCEPTIONS 4
Note: See TracBrowser for help on using the repository browser.