Fork me on GitHub

Context Navigation

source: git/external/tcl/tclCompile.h@ a0f5d71

Visit:

3.4.3pre03

Last change on this file since a0f5d71 was d4f8a8c, checked in by Pavel Demin <pavel-demin@…>, 5 years ago
add TclPrintSource to tclCompile.h
Property mode set to `100644`
File size: 40.0 KB

Line
1	/*
2	* tclCompile.h --
3	*
4	* Copyright (c) 1996-1997 Sun Microsystems, Inc.
5	*
6	* See the file "license.terms" for information on usage and redistribution
7	* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
8	*
9	* RCS: @(#) $Id: tclCompile.h,v 1.1 2008-06-04 13:58:05 demin Exp $
10	*/
11
12	#ifndef _TCLCOMPILATION
13	#define _TCLCOMPILATION 1
14
15	#ifndef _TCLINT
16	#include "tclInt.h"
17	#endif /* _TCLINT */
18
19	#ifdef BUILD_tcl
20	# undef TCL_STORAGE_CLASS
21	# define TCL_STORAGE_CLASS DLLEXPORT
22	#endif
23
24	/*
25	*------------------------------------------------------------------------
26	* Variables related to compilation. These are used in tclCompile.c,
27	* tclExecute.c, tclBasic.c, and their clients.
28	*------------------------------------------------------------------------
29	*/
30
31	/*
32	* Variable that denotes the command name Tcl object type. Objects of this
33	* type cache the Command pointer that results from looking up command names
34	* in the command hashtable.
35	*/
36
37	extern Tcl_ObjType tclCmdNameType;
38
39	/*
40	*------------------------------------------------------------------------
41	* Data structures related to compilation.
42	*------------------------------------------------------------------------
43	*/
44
45	/*
46	* The structure used to implement Tcl "exceptions" (exceptional returns):
47	* for example, those generated in loops by the break and continue commands,
48	* and those generated by scripts and caught by the catch command. This
49	* ExceptionRange structure describes a range of code (e.g., a loop body),
50	* the kind of exceptions (e.g., a break or continue) that might occur, and
51	* the PC offsets to jump to if a matching exception does occur. Exception
52	* ranges can nest so this structure includes a nesting level that is used
53	* at runtime to find the closest exception range surrounding a PC. For
54	* example, when a break command is executed, the ExceptionRange structure
55	* for the most deeply nested loop, if any, is found and used. These
56	* structures are also generated for the "next" subcommands of for loops
57	* since a break there terminates the for command. This means a for command
58	* actually generates two LoopInfo structures.
59	*/
60
61	typedef enum {
62	LOOP_EXCEPTION_RANGE, /* Code range is part of a loop command.
63	* break and continue "exceptions" cause
64	* jumps to appropriate PC offsets. */
65	CATCH_EXCEPTION_RANGE /* Code range is controlled by a catch
66	* command. Errors in the range cause a
67	* jump to a particular PC offset. */
68	} ExceptionRangeType;
69
70	typedef struct ExceptionRange {
71	ExceptionRangeType type; /* The kind of ExceptionRange. */
72	int nestingLevel; /* Static depth of the exception range.
73	* Used to find the most deeply-nested
74	* range surrounding a PC at runtime. */
75	int codeOffset; /* Offset of the first instruction byte of
76	* the code range. */
77	int numCodeBytes; /* Number of bytes in the code range. */
78	int breakOffset; /* If a LOOP_EXCEPTION_RANGE, the target
79	* PC offset for a break command in the
80	* range. */
81	int continueOffset; /* If a LOOP_EXCEPTION_RANGE and not -1,
82	* the target PC offset for a continue
83	* command in the code range. Otherwise,
84	* ignore this range when processing a
85	* continue command. */
86	int catchOffset; /* If a CATCH_EXCEPTION_RANGE, the target PC
87	* offset for an "exception" in range. */
88	} ExceptionRange;
89
90	/*
91	* Structure used to map between instruction pc and source locations. It
92	* defines for each compiled Tcl command its code's starting offset and
93	* its source's starting offset and length. Note that the code offset
94	* increases monotonically: that is, the table is sorted in code offset
95	* order. The source offset is not monotonic.
96	*/
97
98	typedef struct CmdLocation {
99	int codeOffset; /* Offset of first byte of command code. */
100	int numCodeBytes; /* Number of bytes for command's code. */
101	int srcOffset; /* Offset of first char of the command. */
102	int numSrcChars; /* Number of command source chars. */
103	} CmdLocation;
104
105	/*
106	* CompileProcs need the ability to record information during compilation
107	* that can be used by bytecode instructions during execution. The AuxData
108	* structure provides this "auxiliary data" mechanism. An arbitrary number
109	* of these structures can be stored in the ByteCode record (during
110	* compilation they are stored in a CompileEnv structure). Each AuxData
111	* record holds one word of client-specified data (often a pointer) and is
112	* given an index that instructions can later use to look up the structure
113	* and its data.
114	*
115	* The following definitions declare the types of procedures that are called
116	* to duplicate or free this auxiliary data when the containing ByteCode
117	* objects are duplicated and freed. Pointers to these procedures are kept
118	* in the AuxData structure.
119	*/
120
121	typedef ClientData (AuxDataDupProc) _ANSI_ARGS_((ClientData clientData));
122	typedef void (AuxDataFreeProc) _ANSI_ARGS_((ClientData clientData));
123
124	/*
125	* We define a separate AuxDataType struct to hold type-related information
126	* for the AuxData structure. This separation makes it possible for clients
127	* outside of the TCL core to manipulate (in a limited fashion!) AuxData;
128	* for example, it makes it possible to pickle and unpickle AuxData structs.
129	*/
130
131	typedef struct AuxDataType {
132	char name; / the name of the type. Types can be
133	* registered and found by name */
134	AuxDataDupProc dupProc; / Callback procedure to invoke when the
135	* aux data is duplicated (e.g., when the
136	* ByteCode structure containing the aux
137	* data is duplicated). NULL means just
138	* copy the source clientData bits; no
139	* proc need be called. */
140	AuxDataFreeProc freeProc; / Callback procedure to invoke when the
141	* aux data is freed. NULL means no
142	* proc need be called. */
143	} AuxDataType;
144
145	/*
146	* The definition of the AuxData structure that holds information created
147	* during compilation by CompileProcs and used by instructions during
148	* execution.
149	*/
150
151	typedef struct AuxData {
152	AuxDataType type; / pointer to the AuxData type associated with
153	* this ClientData. */
154	ClientData clientData; /* The compilation data itself. */
155	} AuxData;
156
157	/*
158	* Structure defining the compilation environment. After compilation, fields
159	* describing bytecode instructions are copied out into the more compact
160	* ByteCode structure defined below.
161	*/
162
163	#define COMPILEENV_INIT_CODE_BYTES 250
164	#define COMPILEENV_INIT_NUM_OBJECTS 40
165	#define COMPILEENV_INIT_EXCEPT_RANGES 5
166	#define COMPILEENV_INIT_CMD_MAP_SIZE 40
167	#define COMPILEENV_INIT_AUX_DATA_SIZE 5
168
169	typedef struct CompileEnv {
170	Interp iPtr; / Interpreter containing the code being
171	* compiled. Commands and their compile
172	* procs are specific to an interpreter so
173	* the code emitted will depend on the
174	* interpreter. */
175	char source; / The source string being compiled by
176	* SetByteCodeFromAny. This pointer is not
177	* owned by the CompileEnv and must not be
178	* freed or changed by it. */
179	Proc procPtr; / If a procedure is being compiled, a
180	* pointer to its Proc structure; otherwise
181	* NULL. Used to compile local variables.
182	* Set from information provided by
183	* ObjInterpProc in tclProc.c. */
184	int numCommands; /* Number of commands compiled. */
185	int excRangeDepth; /* Current exception range nesting level;
186	* -1 if not in any range currently. */
187	int maxExcRangeDepth; /* Max nesting level of exception ranges;
188	* -1 if no ranges have been compiled. */
189	int maxStackDepth; /* Maximum number of stack elements needed
190	* to execute the code. Set by compilation
191	* procedures before returning. */
192	Tcl_HashTable objTable; /* Contains all Tcl objects referenced by
193	* the compiled code. Indexed by the string
194	* representations of the objects. Used to
195	* avoid creating duplicate objects. */
196	int pushSimpleWords; /* Set 1 by callers of compilation routines
197	* if they should emit instructions to push
198	* "simple" command words (those that are
199	* just a sequence of characters). If 0, the
200	* callers are responsible for compiling
201	* simple words. */
202	int wordIsSimple; /* Set 1 by compilation procedures before
203	* returning if the previous command word
204	* was just a sequence of characters,
205	* otherwise 0. Used to help determine the
206	* command being compiled. */
207	int numSimpleWordChars; /* If wordIsSimple is 1 then the number of
208	* characters in the simple word, else 0. */
209	int exprIsJustVarRef; /* Set 1 if the expression last compiled by
210	* TclCompileExpr consisted of just a
211	* variable reference as in the expression
212	* of "if $b then...". Otherwise 0. Used
213	* to implement expr's 2 level substitution
214	* semantics properly. */
215	int exprIsComparison; /* Set 1 if the top-level operator in the
216	* expression last compiled is a comparison.
217	* Otherwise 0. If 1, since the operands
218	* might be strings, the expr is compiled
219	* out-of-line to implement expr's 2 level
220	* substitution semantics properly. */
221	int termOffset; /* Offset of character just after the last
222	* one compiled. Set by compilation
223	* procedures before returning. */
224	unsigned char codeStart; / Points to the first byte of the code. */
225	unsigned char codeNext; / Points to next code array byte to use. */
226	unsigned char codeEnd; / Points just after the last allocated
227	* code array byte. */
228	int mallocedCodeArray; /* Set 1 if code array was expanded
229	* and codeStart points into the heap.*/
230	Tcl_Obj *objArrayPtr; / Points to start of object array. */
231	int objArrayNext; /* Index of next free object array entry. */
232	int objArrayEnd; /* Index just after last obj array entry. */
233	int mallocedObjArray; /* 1 if object array was expanded and
234	* objArray points into the heap, else 0. */
235	ExceptionRange *excRangeArrayPtr;
236	/* Points to start of the ExceptionRange
237	* array. */
238	int excRangeArrayNext; /* Next free ExceptionRange array index.
239	* excRangeArrayNext is the number of ranges
240	* and (excRangeArrayNext-1) is the index of
241	* the current range's array entry. */
242	int excRangeArrayEnd; /* Index after the last ExceptionRange
243	* array entry. */
244	int mallocedExcRangeArray; /* 1 if ExceptionRange array was expanded
245	* and excRangeArrayPtr points in heap,
246	* else 0. */
247	CmdLocation cmdMapPtr; / Points to start of CmdLocation array.
248	* numCommands is the index of the next
249	* entry to use; (numCommands-1) is the
250	* entry index for the last command. */
251	int cmdMapEnd; /* Index after last CmdLocation entry. */
252	int mallocedCmdMap; /* 1 if command map array was expanded and
253	* cmdMapPtr points in the heap, else 0. */
254	AuxData auxDataArrayPtr; / Points to auxiliary data array start. */
255	int auxDataArrayNext; /* Next free compile aux data array index.
256	* auxDataArrayNext is the number of aux
257	* data items and (auxDataArrayNext-1) is
258	* index of current aux data array entry. */
259	int auxDataArrayEnd; /* Index after last aux data array entry. */
260	int mallocedAuxDataArray; /* 1 if aux data array was expanded and
261	* auxDataArrayPtr points in heap else 0. */
262	unsigned char staticCodeSpace[COMPILEENV_INIT_CODE_BYTES];
263	/* Initial storage for code. */
264	Tcl_Obj *staticObjArraySpace[COMPILEENV_INIT_NUM_OBJECTS];
265	/* Initial storage for object array. */
266	ExceptionRange staticExcRangeArraySpace[COMPILEENV_INIT_EXCEPT_RANGES];
267	/* Initial ExceptionRange array storage. */
268	CmdLocation staticCmdMapSpace[COMPILEENV_INIT_CMD_MAP_SIZE];
269	/* Initial storage for cmd location map. */
270	AuxData staticAuxDataArraySpace[COMPILEENV_INIT_AUX_DATA_SIZE];
271	/* Initial storage for aux data array. */
272	} CompileEnv;
273
274	/*
275	* The structure defining the bytecode instructions resulting from compiling
276	* a Tcl script. Note that this structure is variable length: a single heap
277	* object is allocated to hold the ByteCode structure immediately followed
278	* by the code bytes, the object array, the ExceptionRange array, the
279	* CmdLocation map, and the compilation AuxData array.
280	*/
281
282	/*
283	* A PRECOMPILED bytecode struct is one that was generated from a compiled
284	* image rather than implicitly compiled from source
285	*/
286	#define TCL_BYTECODE_PRECOMPILED 0x0001
287
288	typedef struct ByteCode {
289	Interp iPtr; / Interpreter containing the code being
290	* compiled. Commands and their compile
291	* procs are specific to an interpreter so
292	* the code emitted will depend on the
293	* interpreter. */
294	int compileEpoch; /* Value of iPtr->compileEpoch when this
295	* ByteCode was compiled. Used to invalidate
296	* code when, e.g., commands with compile
297	* procs are redefined. */
298	Namespace nsPtr; / Namespace context in which this code
299	* was compiled. If the code is executed
300	* if a different namespace, it must be
301	* recompiled. */
302	int nsEpoch; /* Value of nsPtr->resolverEpoch when this
303	* ByteCode was compiled. Used to invalidate
304	* code when new namespace resolution rules
305	* are put into effect. */
306	int refCount; /* Reference count: set 1 when created
307	* plus 1 for each execution of the code
308	* currently active. This structure can be
309	* freed when refCount becomes zero. */
310	unsigned int flags; /* flags describing state for the codebyte.
311	* this variable holds ORed values from the
312	* TCL_BYTECODE_ masks defined above */
313	char source; / The source string from which this
314	* ByteCode was compiled. Note that this
315	* pointer is not owned by the ByteCode and
316	* must not be freed or modified by it. */
317	Proc procPtr; / If the ByteCode was compiled from a
318	* procedure body, this is a pointer to its
319	* Proc structure; otherwise NULL. This
320	* pointer is also not owned by the ByteCode
321	* and must not be freed by it. Used for
322	* debugging. */
323	size_t totalSize; /* Total number of bytes required for this
324	* ByteCode structure including the storage
325	* for Tcl objects in its object array. */
326	int numCommands; /* Number of commands compiled. */
327	int numSrcChars; /* Number of source chars compiled. */
328	int numCodeBytes; /* Number of code bytes. */
329	int numObjects; /* Number of Tcl objects in object array. */
330	int numExcRanges; /* Number of ExceptionRange array elems. */
331	int numAuxDataItems; /* Number of AuxData items. */
332	int numCmdLocBytes; /* Number of bytes needed for encoded
333	* command location information. */
334	int maxExcRangeDepth; /* Maximum nesting level of ExceptionRanges;
335	* -1 if no ranges were compiled. */
336	int maxStackDepth; /* Maximum number of stack elements needed
337	* to execute the code. */
338	unsigned char codeStart; / Points to the first byte of the code.
339	* This is just after the final ByteCode
340	* member cmdMapPtr. */
341	Tcl_Obj *objArrayPtr; / Points to the start of the object array.
342	* This is just after the last code byte. */
343	ExceptionRange *excRangeArrayPtr;
344	/* Points to the start of the ExceptionRange
345	* array. This is just after the last
346	* object in the object array. */
347	AuxData auxDataArrayPtr; / Points to the start of the auxiliary data
348	* array. This is just after the last entry
349	* in the ExceptionRange array. */
350	unsigned char *codeDeltaStart;
351	/* Points to the first of a sequence of
352	* bytes that encode the change in the
353	* starting offset of each command's code.
354	* If -127<=delta<=127, it is encoded as 1
355	* byte, otherwise 0xFF (128) appears and
356	* the delta is encoded by the next 4 bytes.
357	* Code deltas are always positive. This
358	* sequence is just after the last entry in
359	* the AuxData array. */
360	unsigned char *codeLengthStart;
361	/* Points to the first of a sequence of
362	* bytes that encode the length of each
363	* command's code. The encoding is the same
364	* as for code deltas. Code lengths are
365	* always positive. This sequence is just
366	* after the last entry in the code delta
367	* sequence. */
368	unsigned char *srcDeltaStart;
369	/* Points to the first of a sequence of
370	* bytes that encode the change in the
371	* starting offset of each command's source.
372	* The encoding is the same as for code
373	* deltas. Source deltas can be negative.
374	* This sequence is just after the last byte
375	* in the code length sequence. */
376	unsigned char *srcLengthStart;
377	/* Points to the first of a sequence of
378	* bytes that encode the length of each
379	* command's source. The encoding is the
380	* same as for code deltas. Source lengths
381	* are always positive. This sequence is
382	* just after the last byte in the source
383	* delta sequence. */
384	} ByteCode;
385
386	/*
387	* Opcodes for the Tcl bytecode instructions. These opcodes must correspond
388	* to the entries in the table of instruction descriptions in tclCompile.c.
389	* Also, the order and number of the expression opcodes (e.g., INST_LOR)
390	* must match the entries in the array operatorStrings in tclExecute.c.
391	*/
392
393	/* Opcodes 0 to 9 */
394	#define INST_DONE 0
395	#define INST_PUSH1 (INST_DONE + 1)
396	#define INST_PUSH4 (INST_DONE + 2)
397	#define INST_POP (INST_DONE + 3)
398	#define INST_DUP (INST_DONE + 4)
399	#define INST_CONCAT1 (INST_DONE + 5)
400	#define INST_INVOKE_STK1 (INST_DONE + 6)
401	#define INST_INVOKE_STK4 (INST_DONE + 7)
402	#define INST_EVAL_STK (INST_DONE + 8)
403	#define INST_EXPR_STK (INST_DONE + 9)
404
405	/* Opcodes 10 to 23 */
406	#define INST_LOAD_SCALAR1 (INST_EXPR_STK + 1)
407	#define INST_LOAD_SCALAR4 (INST_LOAD_SCALAR1 + 1)
408	#define INST_LOAD_SCALAR_STK (INST_LOAD_SCALAR1 + 2)
409	#define INST_LOAD_ARRAY1 (INST_LOAD_SCALAR1 + 3)
410	#define INST_LOAD_ARRAY4 (INST_LOAD_SCALAR1 + 4)
411	#define INST_LOAD_ARRAY_STK (INST_LOAD_SCALAR1 + 5)
412	#define INST_LOAD_STK (INST_LOAD_SCALAR1 + 6)
413	#define INST_STORE_SCALAR1 (INST_LOAD_SCALAR1 + 7)
414	#define INST_STORE_SCALAR4 (INST_LOAD_SCALAR1 + 8)
415	#define INST_STORE_SCALAR_STK (INST_LOAD_SCALAR1 + 9)
416	#define INST_STORE_ARRAY1 (INST_LOAD_SCALAR1 + 10)
417	#define INST_STORE_ARRAY4 (INST_LOAD_SCALAR1 + 11)
418	#define INST_STORE_ARRAY_STK (INST_LOAD_SCALAR1 + 12)
419	#define INST_STORE_STK (INST_LOAD_SCALAR1 + 13)
420
421	/* Opcodes 24 to 33 */
422	#define INST_INCR_SCALAR1 (INST_STORE_STK + 1)
423	#define INST_INCR_SCALAR_STK (INST_INCR_SCALAR1 + 1)
424	#define INST_INCR_ARRAY1 (INST_INCR_SCALAR1 + 2)
425	#define INST_INCR_ARRAY_STK (INST_INCR_SCALAR1 + 3)
426	#define INST_INCR_STK (INST_INCR_SCALAR1 + 4)
427	#define INST_INCR_SCALAR1_IMM (INST_INCR_SCALAR1 + 5)
428	#define INST_INCR_SCALAR_STK_IMM (INST_INCR_SCALAR1 + 6)
429	#define INST_INCR_ARRAY1_IMM (INST_INCR_SCALAR1 + 7)
430	#define INST_INCR_ARRAY_STK_IMM (INST_INCR_SCALAR1 + 8)
431	#define INST_INCR_STK_IMM (INST_INCR_SCALAR1 + 9)
432
433	/* Opcodes 34 to 39 */
434	#define INST_JUMP1 (INST_INCR_STK_IMM + 1)
435	#define INST_JUMP4 (INST_JUMP1 + 1)
436	#define INST_JUMP_TRUE1 (INST_JUMP1 + 2)
437	#define INST_JUMP_TRUE4 (INST_JUMP1 + 3)
438	#define INST_JUMP_FALSE1 (INST_JUMP1 + 4)
439	#define INST_JUMP_FALSE4 (INST_JUMP1 + 5)
440
441	/* Opcodes 40 to 64 */
442	#define INST_LOR (INST_JUMP_FALSE4 + 1)
443	#define INST_LAND (INST_LOR + 1)
444	#define INST_BITOR (INST_LOR + 2)
445	#define INST_BITXOR (INST_LOR + 3)
446	#define INST_BITAND (INST_LOR + 4)
447	#define INST_EQ (INST_LOR + 5)
448	#define INST_NEQ (INST_LOR + 6)
449	#define INST_LT (INST_LOR + 7)
450	#define INST_GT (INST_LOR + 8)
451	#define INST_LE (INST_LOR + 9)
452	#define INST_GE (INST_LOR + 10)
453	#define INST_LSHIFT (INST_LOR + 11)
454	#define INST_RSHIFT (INST_LOR + 12)
455	#define INST_ADD (INST_LOR + 13)
456	#define INST_SUB (INST_LOR + 14)
457	#define INST_MULT (INST_LOR + 15)
458	#define INST_DIV (INST_LOR + 16)
459	#define INST_MOD (INST_LOR + 17)
460	#define INST_UPLUS (INST_LOR + 18)
461	#define INST_UMINUS (INST_LOR + 19)
462	#define INST_BITNOT (INST_LOR + 20)
463	#define INST_LNOT (INST_LOR + 21)
464	#define INST_CALL_BUILTIN_FUNC1 (INST_LOR + 22)
465	#define INST_CALL_FUNC1 (INST_LOR + 23)
466	#define INST_TRY_CVT_TO_NUMERIC (INST_LOR + 24)
467
468	/* Opcodes 65 to 66 */
469	#define INST_BREAK (INST_TRY_CVT_TO_NUMERIC + 1)
470	#define INST_CONTINUE (INST_BREAK + 1)
471
472	/* Opcodes 67 to 68 */
473	#define INST_FOREACH_START4 (INST_CONTINUE + 1)
474	#define INST_FOREACH_STEP4 (INST_FOREACH_START4 + 1)
475
476	/* Opcodes 69 to 72 */
477	#define INST_BEGIN_CATCH4 (INST_FOREACH_STEP4 + 1)
478	#define INST_END_CATCH (INST_BEGIN_CATCH4 + 1)
479	#define INST_PUSH_RESULT (INST_BEGIN_CATCH4 + 2)
480	#define INST_PUSH_RETURN_CODE (INST_BEGIN_CATCH4 + 3)
481
482	/* The last opcode */
483	#define LAST_INST_OPCODE INST_PUSH_RETURN_CODE
484
485	/*
486	* Table describing the Tcl bytecode instructions: their name (for
487	* displaying code), total number of code bytes required (including
488	* operand bytes), and a description of the type of each operand.
489	* These operand types include signed and unsigned integers of length
490	* one and four bytes. The unsigned integers are used for indexes or
491	* for, e.g., the count of objects to push in a "push" instruction.
492	*/
493
494	#define MAX_INSTRUCTION_OPERANDS 2
495
496	typedef enum InstOperandType {
497	OPERAND_NONE,
498	OPERAND_INT1, /* One byte signed integer. */
499	OPERAND_INT4, /* Four byte signed integer. */
500	OPERAND_UINT1, /* One byte unsigned integer. */
501	OPERAND_UINT4 /* Four byte unsigned integer. */
502	} InstOperandType;
503
504	typedef struct InstructionDesc {
505	char name; / Name of instruction. */
506	int numBytes; /* Total number of bytes for instruction. */
507	int numOperands; /* Number of operands. */
508	InstOperandType opTypes[MAX_INSTRUCTION_OPERANDS];
509	/* The type of each operand. */
510	} InstructionDesc;
511
512	extern InstructionDesc instructionTable[];
513
514	/*
515	* Definitions of the values of the INST_CALL_BUILTIN_FUNC instruction's
516	* operand byte. Each value denotes a builtin Tcl math function. These
517	* values must correspond to the entries in the builtinFuncTable array
518	* below and to the values stored in the tclInt.h MathFunc structure's
519	* builtinFuncIndex field.
520	*/
521
522	#define BUILTIN_FUNC_ACOS 0
523	#define BUILTIN_FUNC_ASIN 1
524	#define BUILTIN_FUNC_ATAN 2
525	#define BUILTIN_FUNC_ATAN2 3
526	#define BUILTIN_FUNC_CEIL 4
527	#define BUILTIN_FUNC_COS 5
528	#define BUILTIN_FUNC_COSH 6
529	#define BUILTIN_FUNC_EXP 7
530	#define BUILTIN_FUNC_FLOOR 8
531	#define BUILTIN_FUNC_FMOD 9
532	#define BUILTIN_FUNC_HYPOT 10
533	#define BUILTIN_FUNC_LOG 11
534	#define BUILTIN_FUNC_LOG10 12
535	#define BUILTIN_FUNC_POW 13
536	#define BUILTIN_FUNC_SIN 14
537	#define BUILTIN_FUNC_SINH 15
538	#define BUILTIN_FUNC_SQRT 16
539	#define BUILTIN_FUNC_TAN 17
540	#define BUILTIN_FUNC_TANH 18
541	#define BUILTIN_FUNC_ABS 19
542	#define BUILTIN_FUNC_DOUBLE 20
543	#define BUILTIN_FUNC_INT 21
544	#define BUILTIN_FUNC_RAND 22
545	#define BUILTIN_FUNC_ROUND 23
546	#define BUILTIN_FUNC_SRAND 24
547
548	#define LAST_BUILTIN_FUNC BUILTIN_FUNC_SRAND
549
550	/*
551	* Table describing the built-in math functions. Entries in this table are
552	* indexed by the values of the INST_CALL_BUILTIN_FUNC instruction's
553	* operand byte.
554	*/
555
556	typedef int (CallBuiltinFuncProc) _ANSI_ARGS_((Tcl_Interp *interp,
557	ExecEnv *eePtr, ClientData clientData));
558
559	typedef struct {
560	char name; / Name of function. */
561	int numArgs; /* Number of arguments for function. */
562	Tcl_ValueType argTypes[MAX_MATH_ARGS];
563	/* Acceptable types for each argument. */
564	CallBuiltinFuncProc proc; / Procedure implementing this function. */
565	ClientData clientData; /* Additional argument to pass to the
566	* function when invoking it. */
567	} BuiltinFunc;
568
569	extern BuiltinFunc builtinFuncTable[];
570
571	/*
572	* The structure used to hold information about the start and end of each
573	* argument word in a command.
574	*/
575
576	#define ARGINFO_INIT_ENTRIES 5
577
578	typedef struct ArgInfo {
579	int numArgs; /* Number of argument words in command. */
580	char *startArray; / Array of pointers to the first character
581	* of each argument word. */
582	char *endArray; / Array of pointers to the last character
583	* of each argument word. */
584	int allocArgs; /* Number of array entries currently
585	* allocated. */
586	int mallocedArrays; /* 1 if the arrays were expanded and
587	* wordStartArray/wordEndArray point into
588	* the heap, else 0. */
589	char *staticStartSpace[ARGINFO_INIT_ENTRIES];
590	/* Initial storage for word start array. */
591	char *staticEndSpace[ARGINFO_INIT_ENTRIES];
592	/* Initial storage for word end array. */
593	} ArgInfo;
594
595	/*
596	* Compilation of some Tcl constructs such as if commands and the logical or
597	* (\|\|) and logical and (&&) operators in expressions requires the
598	* generation of forward jumps. Since the PC target of these jumps isn't
599	* known when the jumps are emitted, we record the offset of each jump in an
600	* array of JumpFixup structures. There is one array for each sequence of
601	* jumps to one target PC. When we learn the target PC, we update the jumps
602	* with the correct distance. Also, if the distance is too great (> 127
603	* bytes), we replace the single-byte jump with a four byte jump
604	* instruction, move the instructions after the jump down, and update the
605	* code offsets for any commands between the jump and the target.
606	*/
607
608	typedef enum {
609	TCL_UNCONDITIONAL_JUMP,
610	TCL_TRUE_JUMP,
611	TCL_FALSE_JUMP
612	} TclJumpType;
613
614	typedef struct JumpFixup {
615	TclJumpType jumpType; /* Indicates the kind of jump. */
616	int codeOffset; /* Offset of the first byte of the one-byte
617	* forward jump's code. */
618	int cmdIndex; /* Index of the first command after the one
619	* for which the jump was emitted. Used to
620	* update the code offsets for subsequent
621	* commands if the two-byte jump at jumpPc
622	* must be replaced with a five-byte one. */
623	int excRangeIndex; /* Index of the first range entry in the
624	* ExceptionRange array after the current
625	* one. This field is used to adjust the
626	* code offsets in subsequent ExceptionRange
627	* records when a jump is grown from 2 bytes
628	* to 5 bytes. */
629	} JumpFixup;
630
631	#define JUMPFIXUP_INIT_ENTRIES 10
632
633	typedef struct JumpFixupArray {
634	JumpFixup fixup; / Points to start of jump fixup array. */
635	int next; /* Index of next free array entry. */
636	int end; /* Index of last usable entry in array. */
637	int mallocedArray; /* 1 if array was expanded and fixups points
638	* into the heap, else 0. */
639	JumpFixup staticFixupSpace[JUMPFIXUP_INIT_ENTRIES];
640	/* Initial storage for jump fixup array. */
641	} JumpFixupArray;
642
643	/*
644	* The structure describing one variable list of a foreach command. Note
645	* that only foreach commands inside procedure bodies are compiled inline so
646	* a ForeachVarList structure always describes local variables. Furthermore,
647	* only scalar variables are supported for inline-compiled foreach loops.
648	*/
649
650	typedef struct ForeachVarList {
651	int numVars; /* The number of variables in the list. */
652	int varIndexes[1]; /* An array of the indexes ("slot numbers")
653	* for each variable in the procedure's
654	* array of local variables. Only scalar
655	* variables are supported. The actual
656	* size of this field will be large enough
657	* to numVars indexes. THIS MUST BE THE
658	* LAST FIELD IN THE STRUCTURE! */
659	} ForeachVarList;
660
661	/*
662	* Structure used to hold information about a foreach command that is needed
663	* during program execution. These structures are stored in CompileEnv and
664	* ByteCode structures as auxiliary data.
665	*/
666
667	typedef struct ForeachInfo {
668	int numLists; /* The number of both the variable and value
669	* lists of the foreach command. */
670	int firstListTmp; /* The slot number of the first temporary
671	* variable holding the lists themselves. */
672	int loopIterNumTmp; /* The slot number of the temp var holding
673	* the count of times the loop body has been
674	* executed. This is used to determine which
675	* list element to assign each loop var. */
676	ForeachVarList varLists[1];/ An array of pointers to ForeachVarList
677	* structures describing each var list. The
678	* actual size of this field will be large
679	* enough to numVars indexes. THIS MUST BE
680	* THE LAST FIELD IN THE STRUCTURE! */
681	} ForeachInfo;
682
683	/*
684	* Structure containing a cached pointer to a command that is the result
685	* of resolving the command's name in some namespace. It is the internal
686	* representation for a cmdName object. It contains the pointer along
687	* with some information that is used to check the pointer's validity.
688	*/
689
690	typedef struct ResolvedCmdName {
691	Command cmdPtr; / A cached Command pointer. */
692	Namespace refNsPtr; / Points to the namespace containing the
693	* reference (not the namespace that
694	* contains the referenced command). */
695	long refNsId; /* refNsPtr's unique namespace id. Used to
696	* verify that refNsPtr is still valid
697	* (e.g., it's possible that the cmd's
698	* containing namespace was deleted and a
699	* new one created at the same address). */
700	int refNsCmdEpoch; /* Value of the referencing namespace's
701	* cmdRefEpoch when the pointer was cached.
702	* Before using the cached pointer, we check
703	* if the namespace's epoch was incremented;
704	* if so, this cached pointer is invalid. */
705	int cmdEpoch; /* Value of the command's cmdEpoch when this
706	* pointer was cached. Before using the
707	* cached pointer, we check if the cmd's
708	* epoch was incremented; if so, the cmd was
709	* renamed, deleted, hidden, or exposed, and
710	* so the pointer is invalid. */
711	int refCount; /* Reference count: 1 for each cmdName
712	* object that has a pointer to this
713	* ResolvedCmdName structure as its internal
714	* rep. This structure can be freed when
715	* refCount becomes zero. */
716	} ResolvedCmdName;
717
718	/*
719	*----------------------------------------------------------------
720	* Procedures shared among Tcl bytecode compilation and execution
721	* modules but not used outside:
722	*----------------------------------------------------------------
723	*/
724
725	EXTERN void TclCleanupByteCode _ANSI_ARGS_((ByteCode *codePtr));
726	EXTERN int TclCompileExpr _ANSI_ARGS_((Tcl_Interp *interp,
727	char string, char lastChar, int flags,
728	CompileEnv *envPtr));
729	EXTERN int TclCompileQuotes _ANSI_ARGS_((Tcl_Interp *interp,
730	char string, char lastChar, int termChar,
731	int flags, CompileEnv *envPtr));
732	EXTERN int TclCompileString _ANSI_ARGS_((Tcl_Interp *interp,
733	char string, char lastChar, int flags,
734	CompileEnv *envPtr));
735	EXTERN int TclCompileDollarVar _ANSI_ARGS_((Tcl_Interp *interp,
736	char string, char lastChar, int flags,
737	CompileEnv *envPtr));
738	EXTERN int TclCreateAuxData _ANSI_ARGS_((ClientData clientData,
739	AuxDataType typePtr, CompileEnv envPtr));
740	EXTERN ExecEnv * TclCreateExecEnv _ANSI_ARGS_((Tcl_Interp *interp));
741	EXTERN void TclDeleteExecEnv _ANSI_ARGS_((ExecEnv *eePtr));
742	EXTERN void TclEmitForwardJump _ANSI_ARGS_((CompileEnv *envPtr,
743	TclJumpType jumpType, JumpFixup *jumpFixupPtr));
744	EXTERN AuxDataType TclGetAuxDataType _ANSI_ARGS_((char typeName));
745	EXTERN ExceptionRange * TclGetExceptionRangeForPc _ANSI_ARGS_((
746	unsigned char *pc, int catchOnly,
747	ByteCode* codePtr));
748	EXTERN InstructionDesc * TclGetInstructionTable _ANSI_ARGS_(());
749	EXTERN int TclExecuteByteCode _ANSI_ARGS_((Tcl_Interp *interp,
750	ByteCode *codePtr));
751	EXTERN void TclExpandCodeArray _ANSI_ARGS_((
752	CompileEnv *envPtr));
753	EXTERN void TclExpandJumpFixupArray _ANSI_ARGS_((
754	JumpFixupArray *fixupArrayPtr));
755	EXTERN void TclFinalizeAuxDataTypeTable _ANSI_ARGS_((void));
756	EXTERN int TclFixupForwardJump _ANSI_ARGS_((
757	CompileEnv envPtr, JumpFixup jumpFixupPtr,
758	int jumpDist, int distThreshold));
759	EXTERN void TclFreeCompileEnv _ANSI_ARGS_((CompileEnv *envPtr));
760	EXTERN void TclFreeJumpFixupArray _ANSI_ARGS_((
761	JumpFixupArray *fixupArrayPtr));
762	EXTERN void TclInitAuxDataTypeTable _ANSI_ARGS_((void));
763	EXTERN void TclInitByteCodeObj _ANSI_ARGS_((Tcl_Obj *objPtr,
764	CompileEnv *envPtr));
765	EXTERN void TclInitCompileEnv _ANSI_ARGS_((Tcl_Interp *interp,
766	CompileEnv envPtr, char string));
767	EXTERN void TclInitJumpFixupArray _ANSI_ARGS_((
768	JumpFixupArray *fixupArrayPtr));
769	EXTERN int TclObjIndexForString _ANSI_ARGS_((char *start,
770	int length, int allocStrRep, int inHeap,
771	CompileEnv *envPtr));
772	EXTERN void TclPrintSource _ANSI_ARGS_((FILE *outFile,
773	char *string, int maxChars));
774	EXTERN void TclRegisterAuxDataType _ANSI_ARGS_((AuxDataType *typePtr));
775
776	/*
777	*----------------------------------------------------------------
778	* Macros used by Tcl bytecode compilation and execution modules
779	* inside the Tcl core but not used outside.
780	*----------------------------------------------------------------
781	*/
782
783	/*
784	* Macros to ensure there is enough room in a CompileEnv's code array.
785	* The ANSI C "prototypes" for these macros are:
786	*
787	* EXTERN void TclEnsureCodeSpace1 _ANSI_ARGS_((CompileEnv *envPtr));
788	* EXTERN void TclEnsureCodeSpace _ANSI_ARGS_((int nBytes,
789	* CompileEnv *envPtr));
790	*/
791
792	#define TclEnsureCodeSpace1(envPtr) \
793	if ((envPtr)->codeNext == (envPtr)->codeEnd) \
794	TclExpandCodeArray(envPtr)
795
796	#define TclEnsureCodeSpace(nBytes, envPtr) \
797	if (((envPtr)->codeNext + nBytes) > (envPtr)->codeEnd) \
798	TclExpandCodeArray(envPtr)
799
800	/*
801	* Macro to emit an opcode byte into a CompileEnv's code array.
802	* The ANSI C "prototype" for this macro is:
803	*
804	* EXTERN void TclEmitOpcode _ANSI_ARGS_((unsigned char op,
805	* CompileEnv *envPtr));
806	*/
807
808	#define TclEmitOpcode(op, envPtr) \
809	TclEnsureCodeSpace1(envPtr); \
810	*(envPtr)->codeNext++ = (unsigned char) (op)
811
812	/*
813	* Macros to emit a (signed or unsigned) int operand. The two variants
814	* depend on the number of bytes needed for the int. Four byte integers
815	* are stored in "big-endian" order with the high order byte stored at
816	* the lowest address. The ANSI C "prototypes" for these macros are:
817	*
818	* EXTERN void TclEmitInt1 _ANSI_ARGS_((int i, CompileEnv *envPtr));
819	* EXTERN void TclEmitInt4 _ANSI_ARGS_((int i, CompileEnv *envPtr));
820	*/
821
822	#define TclEmitInt1(i, envPtr) \
823	TclEnsureCodeSpace(1, (envPtr)); \
824	*(envPtr)->codeNext++ = (unsigned char) ((unsigned int) (i))
825
826	#define TclEmitInt4(i, envPtr) \
827	TclEnsureCodeSpace(4, (envPtr)); \
828	*(envPtr)->codeNext++ = \
829	(unsigned char) ((unsigned int) (i) >> 24); \
830	*(envPtr)->codeNext++ = \
831	(unsigned char) ((unsigned int) (i) >> 16); \
832	*(envPtr)->codeNext++ = \
833	(unsigned char) ((unsigned int) (i) >> 8); \
834	*(envPtr)->codeNext++ = \
835	(unsigned char) ((unsigned int) (i) )
836
837	/*
838	* Macros to emit an instruction with signed or unsigned int operands.
839	* The ANSI C "prototypes" for these macros are:
840	*
841	* EXTERN void TclEmitInstInt1 _ANSI_ARGS_((unsigned char op, int i,
842	* CompileEnv *envPtr));
843	* EXTERN void TclEmitInstInt4 _ANSI_ARGS_((unsigned char op, int i,
844	* CompileEnv *envPtr));
845	* EXTERN void TclEmitInstUInt1 _ANSI_ARGS_((unsigned char op,
846	* unsigned int i, CompileEnv *envPtr));
847	* EXTERN void TclEmitInstUInt4 _ANSI_ARGS_((unsigned char op,
848	* unsigned int i, CompileEnv *envPtr));
849	*/
850
851	#define TclEmitInstInt1(op, i, envPtr) \
852	TclEnsureCodeSpace(2, (envPtr)); \
853	*(envPtr)->codeNext++ = (unsigned char) (op); \
854	*(envPtr)->codeNext++ = (unsigned char) ((unsigned int) (i))
855
856	#define TclEmitInstInt4(op, i, envPtr) \
857	TclEnsureCodeSpace(5, (envPtr)); \
858	*(envPtr)->codeNext++ = (unsigned char) (op); \
859	*(envPtr)->codeNext++ = \
860	(unsigned char) ((unsigned int) (i) >> 24); \
861	*(envPtr)->codeNext++ = \
862	(unsigned char) ((unsigned int) (i) >> 16); \
863	*(envPtr)->codeNext++ = \
864	(unsigned char) ((unsigned int) (i) >> 8); \
865	*(envPtr)->codeNext++ = \
866	(unsigned char) ((unsigned int) (i) )
867
868	#define TclEmitInstUInt1(op, i, envPtr) \
869	TclEmitInstInt1((op), (i), (envPtr))
870
871	#define TclEmitInstUInt4(op, i, envPtr) \
872	TclEmitInstInt4((op), (i), (envPtr))
873
874	/*
875	* Macro to push a Tcl object onto the Tcl evaluation stack. It emits the
876	* object's one or four byte array index into the CompileEnv's code
877	* array. These support, respectively, a maximum of 256 (28) and 232
878	* objects in a CompileEnv. The ANSI C "prototype" for this macro is:
879	*
880	* EXTERN void TclEmitPush _ANSI_ARGS_((int objIndex, CompileEnv *envPtr));
881	*/
882
883	#define TclEmitPush(objIndex, envPtr) \
884	if ((objIndex) <= 255) { \
885	TclEmitInstUInt1(INST_PUSH1, (objIndex), (envPtr)); \
886	} else { \
887	TclEmitInstUInt4(INST_PUSH4, (objIndex), (envPtr)); \
888	}
889
890	/*
891	* Macros to update a (signed or unsigned) integer starting at a pointer.
892	* The two variants depend on the number of bytes. The ANSI C "prototypes"
893	* for these macros are:
894	*
895	* EXTERN void TclStoreInt1AtPtr _ANSI_ARGS_((int i, unsigned char *p));
896	* EXTERN void TclStoreInt4AtPtr _ANSI_ARGS_((int i, unsigned char *p));
897	*/
898
899	#define TclStoreInt1AtPtr(i, p) \
900	*(p) = (unsigned char) ((unsigned int) (i))
901
902	#define TclStoreInt4AtPtr(i, p) \
903	*(p) = (unsigned char) ((unsigned int) (i) >> 24); \
904	*(p+1) = (unsigned char) ((unsigned int) (i) >> 16); \
905	*(p+2) = (unsigned char) ((unsigned int) (i) >> 8); \
906	*(p+3) = (unsigned char) ((unsigned int) (i) )
907
908	/*
909	* Macros to update instructions at a particular pc with a new op code
910	* and a (signed or unsigned) int operand. The ANSI C "prototypes" for
911	* these macros are:
912	*
913	* EXTERN void TclUpdateInstInt1AtPc _ANSI_ARGS_((unsigned char op, int i,
914	* unsigned char *pc));
915	* EXTERN void TclUpdateInstInt4AtPc _ANSI_ARGS_((unsigned char op, int i,
916	* unsigned char *pc));
917	*/
918
919	#define TclUpdateInstInt1AtPc(op, i, pc) \
920	*(pc) = (unsigned char) (op); \
921	TclStoreInt1AtPtr((i), ((pc)+1))
922
923	#define TclUpdateInstInt4AtPc(op, i, pc) \
924	*(pc) = (unsigned char) (op); \
925	TclStoreInt4AtPtr((i), ((pc)+1))
926
927	/*
928	* Macros to get a signed integer (GET_INT{1,2}) or an unsigned int
929	* (GET_UINT{1,2}) from a pointer. There are two variants for each
930	* return type that depend on the number of bytes fetched.
931	* The ANSI C "prototypes" for these macros are:
932	*
933	* EXTERN int TclGetInt1AtPtr _ANSI_ARGS_((unsigned char *p));
934	* EXTERN int TclGetInt4AtPtr _ANSI_ARGS_((unsigned char *p));
935	* EXTERN unsigned int TclGetUInt1AtPtr _ANSI_ARGS_((unsigned char *p));
936	* EXTERN unsigned int TclGetUInt4AtPtr _ANSI_ARGS_((unsigned char *p));
937	*/
938
939	/*
940	* The TclGetInt1AtPtr macro is tricky because we want to do sign
941	* extension on the 1-byte value. Unfortunately the "char" type isn't
942	* signed on all platforms so sign-extension doesn't always happen
943	* automatically. Sometimes we can explicitly declare the pointer to be
944	* signed, but other times we have to explicitly sign-extend the value
945	* in software.
946	*/
947
948	#ifndef __CHAR_UNSIGNED__
949	# define TclGetInt1AtPtr(p) ((int) ((char ) p))
950	#else
951	# ifdef HAVE_SIGNED_CHAR
952	# define TclGetInt1AtPtr(p) ((int) ((signed char ) p))
953	# else
954	# define TclGetInt1AtPtr(p) (((int) ((char ) p)) \
955	\| ((*(p) & 0200) ? (-256) : 0))
956	# endif
957	#endif
958
959	#define TclGetInt4AtPtr(p) (((int) TclGetInt1AtPtr(p) << 24) \| \
960	(*((p)+1) << 16) \| \
961	(*((p)+2) << 8) \| \
962	(*((p)+3)))
963
964	#define TclGetUInt1AtPtr(p) ((unsigned int) *(p))
965	#define TclGetUInt4AtPtr(p) ((unsigned int) (*(p) << 24) \| \
966	(*((p)+1) << 16) \| \
967	(*((p)+2) << 8) \| \
968	(*((p)+3)))
969
970	/*
971	* Macros used to compute the minimum and maximum of two integers.
972	* The ANSI C "prototypes" for these macros are:
973	*
974	* EXTERN int TclMin _ANSI_ARGS_((int i, int j));
975	* EXTERN int TclMax _ANSI_ARGS_((int i, int j));
976	*/
977
978	#define TclMin(i, j) ((((int) i) < ((int) j))? (i) : (j))
979	#define TclMax(i, j) ((((int) i) > ((int) j))? (i) : (j))
980
981	/*
982	* Macro used to compute the offset of the current instruction in the
983	* bytecode instruction stream. The ANSI C "prototypes" for this macro is:
984	*
985	* EXTERN int TclCurrCodeOffset _ANSI_ARGS_((void));
986	*/
987
988	#define TclCurrCodeOffset() ((envPtr)->codeNext - (envPtr)->codeStart)
989
990	/*
991	* Upper bound for legal jump distances. Checked during compilation if
992	* debugging.
993	*/
994
995	#define MAX_JUMP_DIST 5000
996
997	# undef TCL_STORAGE_CLASS
998	# define TCL_STORAGE_CLASS DLLIMPORT
999
1000	#endif /* _TCLCOMPILATION */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: