/*

 * tclCompile.h --

 *

 * Copyright (c) 1996-1998 Sun Microsystems, Inc.

 * Copyright (c) 1998-2000 by Scriptics Corporation.

 * Copyright (c) 2001 by Kevin B. Kenny.  All rights reserved.

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * RCS: @(#) $Id: tclCompile.h,v 1.33.2.1 2006/11/28 22:20:00 andreas_kupries Exp $

 */

#ifndef _TCLCOMPILATION

#define _TCLCOMPILATION 1

#ifndef _TCLINT

#include "tclInt.h"

#endif /* _TCLINT */

#ifdef BUILD_tcl

# undef TCL_STORAGE_CLASS

# define TCL_STORAGE_CLASS DLLEXPORT

#endif

/*

 *------------------------------------------------------------------------

 * Variables related to compilation. These are used in tclCompile.c,

 * tclExecute.c, tclBasic.c, and their clients.

 *------------------------------------------------------------------------

 */

#ifdef TCL_COMPILE_DEBUG

/*

 * Variable that controls whether compilation tracing is enabled and, if so,

 * what level of tracing is desired:

 *    0: no compilation tracing

 *    1: summarize compilation of top level cmds and proc bodies

 *    2: display all instructions of each ByteCode compiled

 * This variable is linked to the Tcl variable "tcl_traceCompile".

 */

extern int 		tclTraceCompile;

#endif

#ifdef TCL_COMPILE_DEBUG

/*

 * Variable that controls whether execution tracing is enabled and, if so,

 * what level of tracing is desired:

 *    0: no execution tracing

 *    1: trace invocations of Tcl procs only

 *    2: trace invocations of all (not compiled away) commands

 *    3: display each instruction executed

 * This variable is linked to the Tcl variable "tcl_traceExec".

 */

extern int 		tclTraceExec;

#endif

/*

 *------------------------------------------------------------------------

 * Data structures related to compilation.

 *------------------------------------------------------------------------

 */

/*

 * The structure used to implement Tcl "exceptions" (exceptional returns):

 * for example, those generated in loops by the break and continue commands,

 * and those generated by scripts and caught by the catch command. This

 * ExceptionRange structure describes a range of code (e.g., a loop body),

 * the kind of exceptions (e.g., a break or continue) that might occur, and

 * the PC offsets to jump to if a matching exception does occur. Exception

 * ranges can nest so this structure includes a nesting level that is used

 * at runtime to find the closest exception range surrounding a PC. For

 * example, when a break command is executed, the ExceptionRange structure

 * for the most deeply nested loop, if any, is found and used. These

 * structures are also generated for the "next" subcommands of for loops

 * since a break there terminates the for command. This means a for command

 * actually generates two LoopInfo structures.

 */

typedef enum {

    LOOP_EXCEPTION_RANGE,	/* Exception's range is part of a loop.

				 * Break and continue "exceptions" cause

				 * jumps to appropriate PC offsets. */

    CATCH_EXCEPTION_RANGE	/* Exception's range is controlled by a

				 * catch command. Errors in the range cause

				 * a jump to a catch PC offset. */

} ExceptionRangeType;

typedef struct ExceptionRange {

    ExceptionRangeType type;	/* The kind of ExceptionRange. */

    int nestingLevel;		/* Static depth of the exception range.

				 * Used to find the most deeply-nested

				 * range surrounding a PC at runtime. */

    int codeOffset;		/* Offset of the first instruction byte of

				 * the code range. */

    int numCodeBytes;		/* Number of bytes in the code range. */

    int breakOffset;		/* If LOOP_EXCEPTION_RANGE, the target PC

				 * offset for a break command in the range. */

    int continueOffset;		/* If LOOP_EXCEPTION_RANGE and not -1, the

				 * target PC offset for a continue command in

				 * the code range. Otherwise, ignore this range

				 * when processing a continue command. */

    int catchOffset;		/* If a CATCH_EXCEPTION_RANGE, the target PC

				 * offset for any "exception" in range. */

} ExceptionRange;

/*

 * Structure used to map between instruction pc and source locations. It

 * defines for each compiled Tcl command its code's starting offset and 

 * its source's starting offset and length. Note that the code offset

 * increases monotonically: that is, the table is sorted in code offset

 * order. The source offset is not monotonic.

 */

typedef struct CmdLocation {

    int codeOffset;		/* Offset of first byte of command code. */

    int numCodeBytes;		/* Number of bytes for command's code. */

    int srcOffset;		/* Offset of first char of the command. */

    int numSrcBytes;		/* Number of command source chars. */

} CmdLocation;

#ifdef TCL_TIP280

/*

 * TIP #280

 * Structure to record additional location information for byte code.

 * This information is internal and not saved. I.e. tbcload'ed code

 * will not have this information. It records the lines for all words

 * of all commands found in the byte code. The association with a

 * ByteCode structure BC is done through the 'lineBCPtr' HashTable in

 * Interp, keyed by the address of BC. Also recorded is information

 * coming from the context, i.e. type of the frame and associated

 * information, like the path of a sourced file.

 */

typedef struct ECL {

  int  srcOffset; /* cmd location to find the entry */

  int  nline;

  int* line;      /* line information for all words in the command */

} ECL;

typedef struct ExtCmdLoc {

  int      type;  /* Context type */

  Tcl_Obj* path;  /* Path of the sourced file the command is in */

  ECL*     loc;   /* Command word locations (lines) */

  int      nloc;  /* Number of allocated entries in 'loc' */

  int      nuloc; /* Number of used entries in 'loc' */

} ExtCmdLoc;

#endif

/*

 * CompileProcs need the ability to record information during compilation

 * that can be used by bytecode instructions during execution. The AuxData

 * structure provides this "auxiliary data" mechanism. An arbitrary number

 * of these structures can be stored in the ByteCode record (during

 * compilation they are stored in a CompileEnv structure). Each AuxData

 * record holds one word of client-specified data (often a pointer) and is

 * given an index that instructions can later use to look up the structure

 * and its data.

 *

 * The following definitions declare the types of procedures that are called

 * to duplicate or free this auxiliary data when the containing ByteCode

 * objects are duplicated and freed. Pointers to these procedures are kept

 * in the AuxData structure.

 */

typedef ClientData (AuxDataDupProc)  _ANSI_ARGS_((ClientData clientData));

typedef void       (AuxDataFreeProc) _ANSI_ARGS_((ClientData clientData));

/*

 * We define a separate AuxDataType struct to hold type-related information

 * for the AuxData structure. This separation makes it possible for clients

 * outside of the TCL core to manipulate (in a limited fashion!) AuxData;

 * for example, it makes it possible to pickle and unpickle AuxData structs.

 */

typedef struct AuxDataType {

    char *name;					/* the name of the type. Types can be

                                 * registered and found by name */

    AuxDataDupProc *dupProc;	/* Callback procedure to invoke when the

                                 * aux data is duplicated (e.g., when the

                                 * ByteCode structure containing the aux

                                 * data is duplicated). NULL means just

                                 * copy the source clientData bits; no

                                 * proc need be called. */

    AuxDataFreeProc *freeProc;	/* Callback procedure to invoke when the

                                 * aux data is freed. NULL means no

                                 * proc need be called. */

} AuxDataType;

/*

 * The definition of the AuxData structure that holds information created

 * during compilation by CompileProcs and used by instructions during

 * execution.

 */

typedef struct AuxData {

    AuxDataType *type;		/* pointer to the AuxData type associated with

                             * this ClientData. */

    ClientData clientData;	/* The compilation data itself. */

} AuxData;

/*

 * Structure defining the compilation environment. After compilation, fields

 * describing bytecode instructions are copied out into the more compact

 * ByteCode structure defined below.

 */

#define COMPILEENV_INIT_CODE_BYTES    250

#define COMPILEENV_INIT_NUM_OBJECTS    60

#define COMPILEENV_INIT_EXCEPT_RANGES   5

#define COMPILEENV_INIT_CMD_MAP_SIZE   40

#define COMPILEENV_INIT_AUX_DATA_SIZE   5

typedef struct CompileEnv {

    Interp *iPtr;		/* Interpreter containing the code being

				 * compiled. Commands and their compile

				 * procs are specific to an interpreter so

				 * the code emitted will depend on the

				 * interpreter. */

    char *source;		/* The source string being compiled by

				 * SetByteCodeFromAny. This pointer is not

				 * owned by the CompileEnv and must not be

				 * freed or changed by it. */

    int numSrcBytes;		/* Number of bytes in source. */

    Proc *procPtr;		/* If a procedure is being compiled, a

				 * pointer to its Proc structure; otherwise

				 * NULL. Used to compile local variables.

				 * Set from information provided by

				 * ObjInterpProc in tclProc.c. */

    int numCommands;		/* Number of commands compiled. */

    int exceptDepth;		/* Current exception range nesting level;

				 * -1 if not in any range currently. */

    int maxExceptDepth;		/* Max nesting level of exception ranges;

				 * -1 if no ranges have been compiled. */

    int maxStackDepth;		/* Maximum number of stack elements needed

				 * to execute the code. Set by compilation

				 * procedures before returning. */

    int currStackDepth;         /* Current stack depth. */

    LiteralTable localLitTable;	/* Contains LiteralEntry's describing

				 * all Tcl objects referenced by this

				 * compiled code. Indexed by the string

				 * representations of the literals. Used to

				 * avoid creating duplicate objects. */

    unsigned char *codeStart;	/* Points to the first byte of the code. */

    unsigned char *codeNext;	/* Points to next code array byte to use. */

    unsigned char *codeEnd;	/* Points just after the last allocated

				 * code array byte. */

    int mallocedCodeArray;      /* Set 1 if code array was expanded 

				 * and codeStart points into the heap.*/

    LiteralEntry *literalArrayPtr;

    				/* Points to start of LiteralEntry array. */

    int literalArrayNext;	/* Index of next free object array entry. */

    int literalArrayEnd;	/* Index just after last obj array entry. */

    int mallocedLiteralArray;   /* 1 if object array was expanded and

                                 * objArray points into the heap, else 0. */

    ExceptionRange *exceptArrayPtr;

    				/* Points to start of the ExceptionRange

				 * array. */

    int exceptArrayNext;	/* Next free ExceptionRange array index.

				 * exceptArrayNext is the number of ranges

				 * and (exceptArrayNext-1) is the index of

				 * the current range's array entry. */

    int exceptArrayEnd;		/* Index after the last ExceptionRange

				 * array entry. */

    int mallocedExceptArray;	/* 1 if ExceptionRange array was expanded

				 * and exceptArrayPtr points in heap,

				 * else 0. */

    CmdLocation *cmdMapPtr;	/* Points to start of CmdLocation array.

				 * numCommands is the index of the next

				 * entry to use; (numCommands-1) is the

				 * entry index for the last command. */

    int cmdMapEnd;		/* Index after last CmdLocation entry. */

    int mallocedCmdMap;		/* 1 if command map array was expanded and

				 * cmdMapPtr points in the heap, else 0. */

    AuxData *auxDataArrayPtr;   /* Points to auxiliary data array start. */

    int auxDataArrayNext;	/* Next free compile aux data array index.

				 * auxDataArrayNext is the number of aux

				 * data items and (auxDataArrayNext-1) is

				 * index of current aux data array entry. */

    int auxDataArrayEnd;	/* Index after last aux data array entry. */

    int mallocedAuxDataArray;	/* 1 if aux data array was expanded and

				 * auxDataArrayPtr points in heap else 0. */

    unsigned char staticCodeSpace[COMPILEENV_INIT_CODE_BYTES];

                                /* Initial storage for code. */

    LiteralEntry staticLiteralSpace[COMPILEENV_INIT_NUM_OBJECTS];

                                /* Initial storage of LiteralEntry array. */

    ExceptionRange staticExceptArraySpace[COMPILEENV_INIT_EXCEPT_RANGES];

                                /* Initial ExceptionRange array storage. */

    CmdLocation staticCmdMapSpace[COMPILEENV_INIT_CMD_MAP_SIZE];

                                /* Initial storage for cmd location map. */

    AuxData staticAuxDataArraySpace[COMPILEENV_INIT_AUX_DATA_SIZE];

                                /* Initial storage for aux data array. */

#ifdef TCL_TIP280

    /* TIP #280 */

    ExtCmdLoc* extCmdMapPtr;    /* Extended command location information

				 * for 'info frame'. */

    int        line;            /* First line of the script, based on the

				 * invoking context, then the line of the

				 * command currently compiled. */

#endif

} CompileEnv;

/*

 * The structure defining the bytecode instructions resulting from compiling

 * a Tcl script. Note that this structure is variable length: a single heap

 * object is allocated to hold the ByteCode structure immediately followed

 * by the code bytes, the literal object array, the ExceptionRange array,

 * the CmdLocation map, and the compilation AuxData array.

 */

/*

 * A PRECOMPILED bytecode struct is one that was generated from a compiled

 * image rather than implicitly compiled from source

 */

#define TCL_BYTECODE_PRECOMPILED		0x0001

typedef struct ByteCode {

    TclHandle interpHandle;	/* Handle for interpreter containing the

				 * compiled code.  Commands and their compile

				 * procs are specific to an interpreter so the

				 * code emitted will depend on the

				 * interpreter. */

    int compileEpoch;		/* Value of iPtr->compileEpoch when this

				 * ByteCode was compiled. Used to invalidate

				 * code when, e.g., commands with compile

				 * procs are redefined. */

    Namespace *nsPtr;		/* Namespace context in which this code

				 * was compiled. If the code is executed

				 * if a different namespace, it must be

				 * recompiled. */

    int nsEpoch;		/* Value of nsPtr->resolverEpoch when this

				 * ByteCode was compiled. Used to invalidate

				 * code when new namespace resolution rules

				 * are put into effect. */

    int refCount;		/* Reference count: set 1 when created

				 * plus 1 for each execution of the code

				 * currently active. This structure can be

				 * freed when refCount becomes zero. */

    unsigned int flags;		/* flags describing state for the codebyte.

                                 * this variable holds ORed values from the

                                 * TCL_BYTECODE_ masks defined above */

    char *source;		/* The source string from which this

				 * ByteCode was compiled. Note that this

				 * pointer is not owned by the ByteCode and

				 * must not be freed or modified by it. */

    Proc *procPtr;		/* If the ByteCode was compiled from a

				 * procedure body, this is a pointer to its

				 * Proc structure; otherwise NULL. This

				 * pointer is also not owned by the ByteCode

				 * and must not be freed by it. */

    size_t structureSize;	/* Number of bytes in the ByteCode structure

				 * itself. Does not include heap space for

				 * literal Tcl objects or storage referenced

				 * by AuxData entries. */

    int numCommands;		/* Number of commands compiled. */

    int numSrcBytes;		/* Number of source bytes compiled. */

    int numCodeBytes;		/* Number of code bytes. */

    int numLitObjects;		/* Number of objects in literal array. */

    int numExceptRanges;	/* Number of ExceptionRange array elems. */

    int numAuxDataItems;	/* Number of AuxData items. */

    int numCmdLocBytes;		/* Number of bytes needed for encoded

				 * command location information. */

    int maxExceptDepth;		/* Maximum nesting level of ExceptionRanges;

				 * -1 if no ranges were compiled. */

    int maxStackDepth;		/* Maximum number of stack elements needed

				 * to execute the code. */

    unsigned char *codeStart;	/* Points to the first byte of the code.

				 * This is just after the final ByteCode

				 * member cmdMapPtr. */

    Tcl_Obj **objArrayPtr;	/* Points to the start of the literal

				 * object array. This is just after the

				 * last code byte. */

    ExceptionRange *exceptArrayPtr;

    				/* Points to the start of the ExceptionRange

				 * array. This is just after the last

				 * object in the object array. */

    AuxData *auxDataArrayPtr;   /* Points to the start of the auxiliary data

				 * array. This is just after the last entry

				 * in the ExceptionRange array. */

    unsigned char *codeDeltaStart;

				/* Points to the first of a sequence of

				 * bytes that encode the change in the

				 * starting offset of each command's code.

				 * If -127<=delta<=127, it is encoded as 1

				 * byte, otherwise 0xFF (128) appears and

				 * the delta is encoded by the next 4 bytes.

				 * Code deltas are always positive. This

				 * sequence is just after the last entry in

				 * the AuxData array. */

    unsigned char *codeLengthStart;

				/* Points to the first of a sequence of

				 * bytes that encode the length of each

				 * command's code. The encoding is the same

				 * as for code deltas. Code lengths are

				 * always positive. This sequence is just

				 * after the last entry in the code delta

				 * sequence. */

    unsigned char *srcDeltaStart;

				/* Points to the first of a sequence of

				 * bytes that encode the change in the

				 * starting offset of each command's source.

				 * The encoding is the same as for code

				 * deltas. Source deltas can be negative.

				 * This sequence is just after the last byte

				 * in the code length sequence. */

    unsigned char *srcLengthStart;

				/* Points to the first of a sequence of

				 * bytes that encode the length of each

				 * command's source. The encoding is the

				 * same as for code deltas. Source lengths

				 * are always positive. This sequence is

				 * just after the last byte in the source

				 * delta sequence. */

#ifdef TCL_COMPILE_STATS

    Tcl_Time createTime;	/* Absolute time when the ByteCode was

				 * created. */

#endif /* TCL_COMPILE_STATS */

} ByteCode;

/*

 * Opcodes for the Tcl bytecode instructions. These must correspond to

 * the entries in the table of instruction descriptions,

 * tclInstructionTable, in tclCompile.c. Also, the order and number of

 * the expression opcodes (e.g., INST_LOR) must match the entries in

 * the array operatorStrings in tclExecute.c.

 */

/* Opcodes 0 to 9 */

#define INST_DONE			0

#define INST_PUSH1			1

#define INST_PUSH4			2

#define INST_POP			3

#define INST_DUP			4

#define INST_CONCAT1			5

#define INST_INVOKE_STK1		6

#define INST_INVOKE_STK4		7

#define INST_EVAL_STK			8

#define INST_EXPR_STK			9

/* Opcodes 10 to 23 */

#define INST_LOAD_SCALAR1		10

#define INST_LOAD_SCALAR4		11

#define INST_LOAD_SCALAR_STK		12

#define INST_LOAD_ARRAY1		13

#define INST_LOAD_ARRAY4		14

#define INST_LOAD_ARRAY_STK		15

#define INST_LOAD_STK			16

#define INST_STORE_SCALAR1		17

#define INST_STORE_SCALAR4		18

#define INST_STORE_SCALAR_STK		19

#define INST_STORE_ARRAY1		20

#define INST_STORE_ARRAY4		21

#define INST_STORE_ARRAY_STK		22

#define INST_STORE_STK			23

/* Opcodes 24 to 33 */

#define INST_INCR_SCALAR1		24

#define INST_INCR_SCALAR_STK		25

#define INST_INCR_ARRAY1		26

#define INST_INCR_ARRAY_STK		27

#define INST_INCR_STK			28

#define INST_INCR_SCALAR1_IMM		29

#define INST_INCR_SCALAR_STK_IMM	30

#define INST_INCR_ARRAY1_IMM		31

#define INST_INCR_ARRAY_STK_IMM		32

#define INST_INCR_STK_IMM		33

/* Opcodes 34 to 39 */

#define INST_JUMP1			34

#define INST_JUMP4			35

#define INST_JUMP_TRUE1			36

#define INST_JUMP_TRUE4			37

#define INST_JUMP_FALSE1		38

#define INST_JUMP_FALSE4	        39

/* Opcodes 40 to 64 */

#define INST_LOR			40

#define INST_LAND			41

#define INST_BITOR			42

#define INST_BITXOR			43

#define INST_BITAND			44

#define INST_EQ				45

#define INST_NEQ			46

#define INST_LT				47

#define INST_GT				48

#define INST_LE				49

#define INST_GE				50

#define INST_LSHIFT			51

#define INST_RSHIFT			52

#define INST_ADD			53

#define INST_SUB			54

#define INST_MULT			55

#define INST_DIV			56

#define INST_MOD			57

#define INST_UPLUS			58

#define INST_UMINUS			59

#define INST_BITNOT			60

#define INST_LNOT			61

#define INST_CALL_BUILTIN_FUNC1		62

#define INST_CALL_FUNC1			63

#define INST_TRY_CVT_TO_NUMERIC		64

/* Opcodes 65 to 66 */

#define INST_BREAK			65

#define INST_CONTINUE			66

/* Opcodes 67 to 68 */

#define INST_FOREACH_START4		67

#define INST_FOREACH_STEP4		68

/* Opcodes 69 to 72 */

#define INST_BEGIN_CATCH4		69

#define INST_END_CATCH			70

#define INST_PUSH_RESULT		71

#define INST_PUSH_RETURN_CODE		72

/* Opcodes 73 to 78 */

#define INST_STR_EQ			73

#define INST_STR_NEQ			74

#define INST_STR_CMP			75

#define INST_STR_LEN			76

#define INST_STR_INDEX			77

#define INST_STR_MATCH			78

/* Opcodes 78 to 81 */

#define INST_LIST			79

#define INST_LIST_INDEX			80

#define INST_LIST_LENGTH		81

/* Opcodes 82 to 87 */

#define INST_APPEND_SCALAR1		82

#define INST_APPEND_SCALAR4		83

#define INST_APPEND_ARRAY1		84

#define INST_APPEND_ARRAY4		85

#define INST_APPEND_ARRAY_STK		86

#define INST_APPEND_STK			87

/* Opcodes 88 to 93 */

#define INST_LAPPEND_SCALAR1		88

#define INST_LAPPEND_SCALAR4		89

#define INST_LAPPEND_ARRAY1		90

#define INST_LAPPEND_ARRAY4		91

#define INST_LAPPEND_ARRAY_STK		92

#define INST_LAPPEND_STK		93

/* TIP #22 - LINDEX operator with flat arg list */

#define INST_LIST_INDEX_MULTI		94

/*

 * TIP #33 - 'lset' command.  Code gen also required a Forth-like

 *           OVER operation.

 */

#define INST_OVER                       95

#define INST_LSET_LIST			96

#define INST_LSET_FLAT                  97

/* The last opcode */

#define LAST_INST_OPCODE        	97

/*

 * Table describing the Tcl bytecode instructions: their name (for

 * displaying code), total number of code bytes required (including

 * operand bytes), and a description of the type of each operand.

 * These operand types include signed and unsigned integers of length

 * one and four bytes. The unsigned integers are used for indexes or

 * for, e.g., the count of objects to push in a "push" instruction.

 */

#define MAX_INSTRUCTION_OPERANDS 2

typedef enum InstOperandType {

    OPERAND_NONE,

    OPERAND_INT1,		/* One byte signed integer. */

    OPERAND_INT4,		/* Four byte signed integer. */

    OPERAND_UINT1,		/* One byte unsigned integer. */

    OPERAND_UINT4		/* Four byte unsigned integer. */

} InstOperandType;

typedef struct InstructionDesc {

    char *name;			/* Name of instruction. */

    int numBytes;		/* Total number of bytes for instruction. */

    int stackEffect;            /* The worst-case balance stack effect of the 

				 * instruction, used for stack requirements 

				 * computations. The value INT_MIN signals

				 * that the instruction's worst case effect

				 * is (1-opnd1).

				 */

    int numOperands;		/* Number of operands. */

    InstOperandType opTypes[MAX_INSTRUCTION_OPERANDS];

				/* The type of each operand. */

} InstructionDesc;

extern InstructionDesc tclInstructionTable[];

/*

 * Definitions of the values of the INST_CALL_BUILTIN_FUNC instruction's

 * operand byte. Each value denotes a builtin Tcl math function. These

 * values must correspond to the entries in the tclBuiltinFuncTable array

 * below and to the values stored in the tclInt.h MathFunc structure's

 * builtinFuncIndex field.

 */

#define BUILTIN_FUNC_ACOS		0

#define BUILTIN_FUNC_ASIN		1

#define BUILTIN_FUNC_ATAN		2

#define BUILTIN_FUNC_ATAN2		3

#define BUILTIN_FUNC_CEIL		4

#define BUILTIN_FUNC_COS		5

#define BUILTIN_FUNC_COSH		6

#define BUILTIN_FUNC_EXP		7

#define BUILTIN_FUNC_FLOOR		8

#define BUILTIN_FUNC_FMOD		9

#define BUILTIN_FUNC_HYPOT		10

#define BUILTIN_FUNC_LOG		11

#define BUILTIN_FUNC_LOG10		12

#define BUILTIN_FUNC_POW		13

#define BUILTIN_FUNC_SIN		14

#define BUILTIN_FUNC_SINH		15

#define BUILTIN_FUNC_SQRT		16

#define BUILTIN_FUNC_TAN		17

#define BUILTIN_FUNC_TANH		18

#define BUILTIN_FUNC_ABS		19

#define BUILTIN_FUNC_DOUBLE		20

#define BUILTIN_FUNC_INT		21

#define BUILTIN_FUNC_RAND		22

#define BUILTIN_FUNC_ROUND		23

#define BUILTIN_FUNC_SRAND		24

#define BUILTIN_FUNC_WIDE		25

#define LAST_BUILTIN_FUNC        	25

/*

 * Table describing the built-in math functions. Entries in this table are

 * indexed by the values of the INST_CALL_BUILTIN_FUNC instruction's

 * operand byte.

 */

typedef int (CallBuiltinFuncProc) _ANSI_ARGS_((Tcl_Interp *interp,

        ExecEnv *eePtr, ClientData clientData));

typedef struct {

    char *name;			/* Name of function. */

    int numArgs;		/* Number of arguments for function. */

    Tcl_ValueType argTypes[MAX_MATH_ARGS];

				/* Acceptable types for each argument. */

    CallBuiltinFuncProc *proc;	/* Procedure implementing this function. */

    ClientData clientData;	/* Additional argument to pass to the

				 * function when invoking it. */

} BuiltinFunc;

extern BuiltinFunc tclBuiltinFuncTable[];

/*

 * Compilation of some Tcl constructs such as if commands and the logical or

 * (||) and logical and (&&) operators in expressions requires the

 * generation of forward jumps. Since the PC target of these jumps isn't

 * known when the jumps are emitted, we record the offset of each jump in an

 * array of JumpFixup structures. There is one array for each sequence of

 * jumps to one target PC. When we learn the target PC, we update the jumps

 * with the correct distance. Also, if the distance is too great (> 127

 * bytes), we replace the single-byte jump with a four byte jump

 * instruction, move the instructions after the jump down, and update the

 * code offsets for any commands between the jump and the target.

 */

typedef enum {

    TCL_UNCONDITIONAL_JUMP,

    TCL_TRUE_JUMP,

    TCL_FALSE_JUMP

} TclJumpType;

typedef struct JumpFixup {

    TclJumpType jumpType;	/* Indicates the kind of jump. */

    int codeOffset;		/* Offset of the first byte of the one-byte

				 * forward jump's code. */

    int cmdIndex;		/* Index of the first command after the one

				 * for which the jump was emitted. Used to

				 * update the code offsets for subsequent

				 * commands if the two-byte jump at jumpPc

				 * must be replaced with a five-byte one. */

    int exceptIndex;		/* Index of the first range entry in the

				 * ExceptionRange array after the current

				 * one. This field is used to adjust the

				 * code offsets in subsequent ExceptionRange

				 * records when a jump is grown from 2 bytes

				 * to 5 bytes. */

} JumpFixup;

#define JUMPFIXUP_INIT_ENTRIES    10

typedef struct JumpFixupArray {

    JumpFixup *fixup;		/* Points to start of jump fixup array. */

    int next;			/* Index of next free array entry. */

    int end;			/* Index of last usable entry in array. */

    int mallocedArray;		/* 1 if array was expanded and fixups points

				 * into the heap, else 0. */

    JumpFixup staticFixupSpace[JUMPFIXUP_INIT_ENTRIES];

				/* Initial storage for jump fixup array. */

} JumpFixupArray;

/*

 * The structure describing one variable list of a foreach command. Note

 * that only foreach commands inside procedure bodies are compiled inline so

 * a ForeachVarList structure always describes local variables. Furthermore,

 * only scalar variables are supported for inline-compiled foreach loops.

 */

typedef struct ForeachVarList {

    int numVars;		/* The number of variables in the list. */

    int varIndexes[1];		/* An array of the indexes ("slot numbers")

				 * for each variable in the procedure's

				 * array of local variables. Only scalar

				 * variables are supported. The actual

				 * size of this field will be large enough

				 * to numVars indexes. THIS MUST BE THE

				 * LAST FIELD IN THE STRUCTURE! */

} ForeachVarList;

/*

 * Structure used to hold information about a foreach command that is needed

 * during program execution. These structures are stored in CompileEnv and

 * ByteCode structures as auxiliary data.

 */

typedef struct ForeachInfo {

    int numLists;		/* The number of both the variable and value

				 * lists of the foreach command. */

    int firstValueTemp;		/* Index of the first temp var in a proc

				 * frame used to point to a value list. */

    int loopCtTemp;		/* Index of temp var in a proc frame

				 * holding the loop's iteration count. Used

				 * to determine next value list element to

				 * assign each loop var. */

    ForeachVarList *varLists[1];/* An array of pointers to ForeachVarList

				 * structures describing each var list. The

				 * actual size of this field will be large

				 * enough to numVars indexes. THIS MUST BE

				 * THE LAST FIELD IN THE STRUCTURE! */

} ForeachInfo;

extern AuxDataType		tclForeachInfoType;

/*

 *----------------------------------------------------------------

 * Procedures exported by tclBasic.c to be used within the engine.

 *----------------------------------------------------------------

 */

EXTERN int		TclEvalObjvInternal _ANSI_ARGS_((Tcl_Interp *interp, int objc,

			    Tcl_Obj *CONST objv[], CONST char *command, int length,

			    int flags));

EXTERN int              TclInterpReady _ANSI_ARGS_((Tcl_Interp *interp));

/*

 *----------------------------------------------------------------

 * Procedures exported by the engine to be used by tclBasic.c

 *----------------------------------------------------------------

 */

#ifndef TCL_TIP280

EXTERN int		TclCompEvalObj _ANSI_ARGS_((Tcl_Interp *interp,

			    Tcl_Obj *objPtr));

#else

EXTERN int		TclCompEvalObj _ANSI_ARGS_((Tcl_Interp *interp,

			    Tcl_Obj *objPtr, CONST CmdFrame* invoker,

			    int word));

#endif

/*

 *----------------------------------------------------------------

 * Procedures shared among Tcl bytecode compilation and execution

 * modules but not used outside:

 *----------------------------------------------------------------

 */

EXTERN void		TclCleanupByteCode _ANSI_ARGS_((ByteCode *codePtr));

EXTERN int		TclCompileCmdWord _ANSI_ARGS_((Tcl_Interp *interp,

			    Tcl_Token *tokenPtr, int count,

			    CompileEnv *envPtr));

EXTERN int		TclCompileExpr _ANSI_ARGS_((Tcl_Interp *interp,

			    CONST char *script, int numBytes,

			    CompileEnv *envPtr));

EXTERN int		TclCompileExprWords _ANSI_ARGS_((Tcl_Interp *interp,

			    Tcl_Token *tokenPtr, int numWords,

			    CompileEnv *envPtr));

EXTERN int		TclCompileScript _ANSI_ARGS_((Tcl_Interp *interp,

			    CONST char *script, int numBytes, int nested,

			    CompileEnv *envPtr));

EXTERN int		TclCompileTokens _ANSI_ARGS_((Tcl_Interp *interp,

			    Tcl_Token *tokenPtr, int count,

			    CompileEnv *envPtr));

EXTERN int		TclCreateAuxData _ANSI_ARGS_((ClientData clientData,

			    AuxDataType *typePtr, CompileEnv *envPtr));

EXTERN int		TclCreateExceptRange _ANSI_ARGS_((

			    ExceptionRangeType type, CompileEnv *envPtr));

EXTERN ExecEnv *	TclCreateExecEnv _ANSI_ARGS_((Tcl_Interp *interp));

EXTERN void		TclDeleteExecEnv _ANSI_ARGS_((ExecEnv *eePtr));

EXTERN void		TclDeleteLiteralTable _ANSI_ARGS_((

			    Tcl_Interp *interp, LiteralTable *tablePtr));

EXTERN void		TclEmitForwardJump _ANSI_ARGS_((CompileEnv *envPtr,

			    TclJumpType jumpType, JumpFixup *jumpFixupPtr));

EXTERN ExceptionRange *	TclGetExceptionRangeForPc _ANSI_ARGS_((

			    unsigned char *pc, int catchOnly,

			    ByteCode* codePtr));

EXTERN void		TclExpandJumpFixupArray _ANSI_ARGS_((

                            JumpFixupArray *fixupArrayPtr));

EXTERN void		TclFinalizeAuxDataTypeTable _ANSI_ARGS_((void));

EXTERN int		TclFindCompiledLocal _ANSI_ARGS_((CONST char *name, 

        		    int nameChars, int create, int flags,

			    Proc *procPtr));

EXTERN LiteralEntry *	TclLookupLiteralEntry _ANSI_ARGS_((

			    Tcl_Interp *interp, Tcl_Obj *objPtr));

EXTERN int		TclFixupForwardJump _ANSI_ARGS_((

			    CompileEnv *envPtr, JumpFixup *jumpFixupPtr,

			    int jumpDist, int distThreshold));

EXTERN void		TclFreeCompileEnv _ANSI_ARGS_((CompileEnv *envPtr));

EXTERN void		TclFreeJumpFixupArray _ANSI_ARGS_((

  			    JumpFixupArray *fixupArrayPtr));

EXTERN void		TclInitAuxDataTypeTable _ANSI_ARGS_((void));

EXTERN void		TclInitByteCodeObj _ANSI_ARGS_((Tcl_Obj *objPtr,

			    CompileEnv *envPtr));

EXTERN void		TclInitCompilation _ANSI_ARGS_((void));

#ifndef TCL_TIP280

EXTERN void		TclInitCompileEnv _ANSI_ARGS_((Tcl_Interp *interp,

			    CompileEnv *envPtr, char *string,

			    int numBytes));

#else

EXTERN void		TclInitCompileEnv _ANSI_ARGS_((Tcl_Interp *interp,

			    CompileEnv *envPtr, char *string,

			    int numBytes, CONST CmdFrame* invoker, int word));

#endif

EXTERN void		TclInitJumpFixupArray _ANSI_ARGS_((

			    JumpFixupArray *fixupArrayPtr));

EXTERN void		TclInitLiteralTable _ANSI_ARGS_((

			    LiteralTable *tablePtr));

#ifdef TCL_COMPILE_STATS

EXTERN char *		TclLiteralStats _ANSI_ARGS_((

			    LiteralTable *tablePtr));

EXTERN int		TclLog2 _ANSI_ARGS_((int value));

#endif

#ifdef TCL_COMPILE_DEBUG

EXTERN void		TclPrintByteCodeObj _ANSI_ARGS_((Tcl_Interp *interp,

		            Tcl_Obj *objPtr));

#endif

EXTERN int		TclPrintInstruction _ANSI_ARGS_((ByteCode* codePtr,

			    unsigned char *pc));

EXTERN void		TclPrintObject _ANSI_ARGS_((FILE *outFile,

			    Tcl_Obj *objPtr, int maxChars));

EXTERN void		TclPrintSource _ANSI_ARGS_((FILE *outFile,

			    CONST char *string, int maxChars));

EXTERN void		TclRegisterAuxDataType _ANSI_ARGS_((AuxDataType *typePtr));

EXTERN int		TclRegisterLiteral _ANSI_ARGS_((CompileEnv *envPtr,

			    char *bytes, int length, int onHeap));

EXTERN void		TclReleaseLiteral _ANSI_ARGS_((Tcl_Interp *interp,

			    Tcl_Obj *objPtr));

EXTERN void		TclSetCmdNameObj _ANSI_ARGS_((Tcl_Interp *interp,

			    Tcl_Obj *objPtr, Command *cmdPtr));

#ifdef TCL_COMPILE_DEBUG

EXTERN void		TclVerifyGlobalLiteralTable _ANSI_ARGS_((

			    Interp *iPtr));

EXTERN void		TclVerifyLocalLiteralTable _ANSI_ARGS_((

			    CompileEnv *envPtr));

#endif

EXTERN int		TclCompileVariableCmd _ANSI_ARGS_((

			    Tcl_Interp *interp, Tcl_Parse *parsePtr, CompileEnv *envPtr));

/*

 *----------------------------------------------------------------

 * Macros used by Tcl bytecode compilation and execution modules

 * inside the Tcl core but not used outside.

 *----------------------------------------------------------------

 */

/*

 * Form of TclRegisterLiteral with onHeap == 0.

 * In that case, it is safe to cast away CONSTness, and it

 * is cleanest to do that here, all in one place.

 */

#define TclRegisterNewLiteral(envPtr, bytes, length) \

	TclRegisterLiteral(envPtr, (char *)(bytes), length, /*onHeap*/ 0)

/*

 * Macro used to update the stack requirements.

 * It is called by the macros TclEmitOpCode, TclEmitInst1 and

 * TclEmitInst4.

 * Remark that the very last instruction of a bytecode always

 * reduces the stack level: INST_DONE or INST_POP, so that the 

 * maxStackdepth is always updated.

 */

#define TclUpdateStackReqs(op, i, envPtr) \

    {\

	int delta = tclInstructionTable[(op)].stackEffect;\

	if (delta) {\

	    if (delta < 0) {\

		if((envPtr)->maxStackDepth < (envPtr)->currStackDepth) {\

		    (envPtr)->maxStackDepth = (envPtr)->currStackDepth;\

		}\

		if (delta == INT_MIN) {\

		    delta = 1 - (i);\

		}\

	    }\

	    (envPtr)->currStackDepth += delta;\

	}\

    }

/*

 * Macro to emit an opcode byte into a CompileEnv's code array.

 * The ANSI C "prototype" for this macro is:

 *

 * EXTERN void	TclEmitOpcode _ANSI_ARGS_((unsigned char op,

 *		    CompileEnv *envPtr));

 */

#define TclEmitOpcode(op, envPtr) \

    if ((envPtr)->codeNext == (envPtr)->codeEnd) \

        TclExpandCodeArray(envPtr); \

    *(envPtr)->codeNext++ = (unsigned char) (op);\

    TclUpdateStackReqs(op, 0, envPtr)

/*

 * Macro to emit an integer operand.

 * The ANSI C "prototype" for this macro is:

 *

 * EXTERN void	TclEmitInt1 _ANSI_ARGS_((int i, CompileEnv *envPtr));

 */

#define TclEmitInt1(i, envPtr) \

    if ((envPtr)->codeNext == (envPtr)->codeEnd) \

        TclExpandCodeArray(envPtr); \

    *(envPtr)->codeNext++ = (unsigned char) ((unsigned int) (i))

/*

 * Macros to emit an instruction with signed or unsigned integer operands.

 * Four byte integers are stored in "big-endian" order with the high order

 * byte stored at the lowest address.

 * The ANSI C "prototypes" for these macros are:

 *

 * EXTERN void	TclEmitInstInt1 _ANSI_ARGS_((unsigned char op, int i, 

 *		    CompileEnv *envPtr));

 * EXTERN void	TclEmitInstInt4 _ANSI_ARGS_((unsigned char op, int i, 

 *		    CompileEnv *envPtr));

 */

#define TclEmitInstInt1(op, i, envPtr) \

    if (((envPtr)->codeNext + 2) > (envPtr)->codeEnd) { \

        TclExpandCodeArray(envPtr); \

    } \

    *(envPtr)->codeNext++ = (unsigned char) (op); \

    *(envPtr)->codeNext++ = (unsigned char) ((unsigned int) (i));\

    TclUpdateStackReqs(op, i, envPtr)

#define TclEmitInstInt4(op, i, envPtr) \

    if (((envPtr)->codeNext + 5) > (envPtr)->codeEnd) { \

        TclExpandCodeArray(envPtr); \

    } \

    *(envPtr)->codeNext++ = (unsigned char) (op); \

    *(envPtr)->codeNext++ = \

        (unsigned char) ((unsigned int) (i) >> 24); \

    *(envPtr)->codeNext++ = \

        (unsigned char) ((unsigned int) (i) >> 16); \

    *(envPtr)->codeNext++ = \

        (unsigned char) ((unsigned int) (i) >>  8); \

    *(envPtr)->codeNext++ = \

        (unsigned char) ((unsigned int) (i)      );\

    TclUpdateStackReqs(op, i, envPtr)

/*

 * Macro to push a Tcl object onto the Tcl evaluation stack. It emits the

 * object's one or four byte array index into the CompileEnv's code

 * array. These support, respectively, a maximum of 256 (2**8) and 2**32

 * objects in a CompileEnv. The ANSI C "prototype" for this macro is:

 *

 * EXTERN void	TclEmitPush _ANSI_ARGS_((int objIndex, CompileEnv *envPtr));

 */

#define TclEmitPush(objIndex, envPtr) \

    {\

        register int objIndexCopy = (objIndex);\

        if (objIndexCopy <= 255) { \

	    TclEmitInstInt1(INST_PUSH1, objIndexCopy, (envPtr)); \

        } else { \

	    TclEmitInstInt4(INST_PUSH4, objIndexCopy, (envPtr)); \

	}\

    }

/*