OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [tcl/] [generic/] [tclCompile.h] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.