开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
tclCompile.h
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：44k
源码类别：

通讯编程

开发平台：

Visual C++

tclCompile.h：源码内容
  1. /*
  2.  * tclCompile.h --
  3.  *
  4.  * Copyright (c) 1996-1998 Sun Microsystems, Inc.
  5.  * Copyright (c) 1998-2000 by Scriptics Corporation.
  6.  * Copyright (c) 2001 by Kevin B. Kenny.  All rights reserved.
  7.  * Copyright (c) 2007 Daniel A. Steffen <das@users.sourceforge.net>
  8.  *
  9.  * See the file "license.terms" for information on usage and redistribution
  10.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  11.  *
  12.  * RCS: @(#) $Id: tclCompile.h,v 1.33.2.2 2007/09/13 15:28:11 das Exp $
  13.  */
  15. #ifndef _TCLCOMPILATION
  16. #define _TCLCOMPILATION 1
  18. #ifndef _TCLINT
  19. #include "tclInt.h"
  20. #endif /* _TCLINT */
  22. #ifdef BUILD_tcl
  23. # undef TCL_STORAGE_CLASS
  24. # define TCL_STORAGE_CLASS DLLEXPORT
  25. #endif
  27. /*
  28.  *------------------------------------------------------------------------
  29.  * Variables related to compilation. These are used in tclCompile.c,
  30.  * tclExecute.c, tclBasic.c, and their clients.
  31.  *------------------------------------------------------------------------
  32.  */
  34. #ifdef TCL_COMPILE_DEBUG
  35. /*
  36.  * Variable that controls whether compilation tracing is enabled and, if so,
  37.  * what level of tracing is desired:
  38.  *    0: no compilation tracing
  39.  *    1: summarize compilation of top level cmds and proc bodies
  40.  *    2: display all instructions of each ByteCode compiled
  41.  * This variable is linked to the Tcl variable "tcl_traceCompile".
  42.  */
  44. extern int  tclTraceCompile;
  45. #endif
  47. #ifdef TCL_COMPILE_DEBUG
  48. /*
  49.  * Variable that controls whether execution tracing is enabled and, if so,
  50.  * what level of tracing is desired:
  51.  *    0: no execution tracing
  52.  *    1: trace invocations of Tcl procs only
  53.  *    2: trace invocations of all (not compiled away) commands
  54.  *    3: display each instruction executed
  55.  * This variable is linked to the Tcl variable "tcl_traceExec".
  56.  */
  58. extern int  tclTraceExec;
  59. #endif
  61. /*
  62.  *------------------------------------------------------------------------
  63.  * Data structures related to compilation.
  64.  *------------------------------------------------------------------------
  65.  */
  67. /*
  68.  * The structure used to implement Tcl "exceptions" (exceptional returns):
  69.  * for example, those generated in loops by the break and continue commands,
  70.  * and those generated by scripts and caught by the catch command. This
  71.  * ExceptionRange structure describes a range of code (e.g., a loop body),
  72.  * the kind of exceptions (e.g., a break or continue) that might occur, and
  73.  * the PC offsets to jump to if a matching exception does occur. Exception
  74.  * ranges can nest so this structure includes a nesting level that is used
  75.  * at runtime to find the closest exception range surrounding a PC. For
  76.  * example, when a break command is executed, the ExceptionRange structure
  77.  * for the most deeply nested loop, if any, is found and used. These
  78.  * structures are also generated for the "next" subcommands of for loops
  79.  * since a break there terminates the for command. This means a for command
  80.  * actually generates two LoopInfo structures.
  81.  */
  83. typedef enum {
  84.     LOOP_EXCEPTION_RANGE, /* Exception's range is part of a loop.
  85.  * Break and continue "exceptions" cause
  86.  * jumps to appropriate PC offsets. */
  87.     CATCH_EXCEPTION_RANGE /* Exception's range is controlled by a
  88.  * catch command. Errors in the range cause
  89.  * a jump to a catch PC offset. */
  90. } ExceptionRangeType;
  92. typedef struct ExceptionRange {
  93.     ExceptionRangeType type; /* The kind of ExceptionRange. */
  94.     int nestingLevel; /* Static depth of the exception range.
  95.  * Used to find the most deeply-nested
  96.  * range surrounding a PC at runtime. */
  97.     int codeOffset; /* Offset of the first instruction byte of
  98.  * the code range. */
  99.     int numCodeBytes; /* Number of bytes in the code range. */
  100.     int breakOffset; /* If LOOP_EXCEPTION_RANGE, the target PC
  101.  * offset for a break command in the range. */
  102.     int continueOffset; /* If LOOP_EXCEPTION_RANGE and not -1, the
  103.  * target PC offset for a continue command in
  104.  * the code range. Otherwise, ignore this range
  105.  * when processing a continue command. */
  106.     int catchOffset; /* If a CATCH_EXCEPTION_RANGE, the target PC
  107.  * offset for any "exception" in range. */
  108. } ExceptionRange;
  110. /*
  111.  * Structure used to map between instruction pc and source locations. It
  112.  * defines for each compiled Tcl command its code's starting offset and 
  113.  * its source's starting offset and length. Note that the code offset
  114.  * increases monotonically: that is, the table is sorted in code offset
  115.  * order. The source offset is not monotonic.
  116.  */
  118. typedef struct CmdLocation {
  119.     int codeOffset; /* Offset of first byte of command code. */
  120.     int numCodeBytes; /* Number of bytes for command's code. */
  121.     int srcOffset; /* Offset of first char of the command. */
  122.     int numSrcBytes; /* Number of command source chars. */
  123. } CmdLocation;
  125. #ifdef TCL_TIP280
  126. /*
  127.  * TIP #280
  128.  * Structure to record additional location information for byte code.
  129.  * This information is internal and not saved. I.e. tbcload'ed code
  130.  * will not have this information. It records the lines for all words
  131.  * of all commands found in the byte code. The association with a
  132.  * ByteCode structure BC is done through the 'lineBCPtr' HashTable in
  133.  * Interp, keyed by the address of BC. Also recorded is information
  134.  * coming from the context, i.e. type of the frame and associated
  135.  * information, like the path of a sourced file.
  136.  */
  138. typedef struct ECL {
  139.   int  srcOffset; /* cmd location to find the entry */
  140.   int  nline;
  141.   int* line;      /* line information for all words in the command */
  142. } ECL;
  143. typedef struct ExtCmdLoc {
  144.   int      type;  /* Context type */
  145.   Tcl_Obj* path;  /* Path of the sourced file the command is in */
  146.   ECL*     loc;   /* Command word locations (lines) */
  147.   int      nloc;  /* Number of allocated entries in 'loc' */
  148.   int      nuloc; /* Number of used entries in 'loc' */
  149. } ExtCmdLoc;
  150. #endif
  152. /*
  153.  * CompileProcs need the ability to record information during compilation
  154.  * that can be used by bytecode instructions during execution. The AuxData
  155.  * structure provides this "auxiliary data" mechanism. An arbitrary number
  156.  * of these structures can be stored in the ByteCode record (during
  157.  * compilation they are stored in a CompileEnv structure). Each AuxData
  158.  * record holds one word of client-specified data (often a pointer) and is
  159.  * given an index that instructions can later use to look up the structure
  160.  * and its data.
  161.  *
  162.  * The following definitions declare the types of procedures that are called
  163.  * to duplicate or free this auxiliary data when the containing ByteCode
  164.  * objects are duplicated and freed. Pointers to these procedures are kept
  165.  * in the AuxData structure.
  166.  */
  168. typedef ClientData (AuxDataDupProc)  _ANSI_ARGS_((ClientData clientData));
  169. typedef void       (AuxDataFreeProc) _ANSI_ARGS_((ClientData clientData));
  171. /*
  172.  * We define a separate AuxDataType struct to hold type-related information
  173.  * for the AuxData structure. This separation makes it possible for clients
  174.  * outside of the TCL core to manipulate (in a limited fashion!) AuxData;
  175.  * for example, it makes it possible to pickle and unpickle AuxData structs.
  176.  */
  178. typedef struct AuxDataType {
  179.     char *name; /* the name of the type. Types can be
  180.                                  * registered and found by name */
  181.     AuxDataDupProc *dupProc; /* Callback procedure to invoke when the
  182.                                  * aux data is duplicated (e.g., when the
  183.                                  * ByteCode structure containing the aux
  184.                                  * data is duplicated). NULL means just
  185.                                  * copy the source clientData bits; no
  186.                                  * proc need be called. */
  187.     AuxDataFreeProc *freeProc; /* Callback procedure to invoke when the
  188.                                  * aux data is freed. NULL means no
  189.                                  * proc need be called. */
  190. } AuxDataType;
  192. /*
  193.  * The definition of the AuxData structure that holds information created
  194.  * during compilation by CompileProcs and used by instructions during
  195.  * execution.
  196.  */
  198. typedef struct AuxData {
  199.     AuxDataType *type; /* pointer to the AuxData type associated with
  200.                              * this ClientData. */
  201.     ClientData clientData; /* The compilation data itself. */
  202. } AuxData;
  204. /*
  205.  * Structure defining the compilation environment. After compilation, fields
  206.  * describing bytecode instructions are copied out into the more compact
  207.  * ByteCode structure defined below.
  208.  */
  210. #define COMPILEENV_INIT_CODE_BYTES    250
  211. #define COMPILEENV_INIT_NUM_OBJECTS    60
  212. #define COMPILEENV_INIT_EXCEPT_RANGES   5
  213. #define COMPILEENV_INIT_CMD_MAP_SIZE   40
  214. #define COMPILEENV_INIT_AUX_DATA_SIZE   5
  216. typedef struct CompileEnv {
  217.     Interp *iPtr; /* Interpreter containing the code being
  218.  * compiled. Commands and their compile
  219.  * procs are specific to an interpreter so
  220.  * the code emitted will depend on the
  221.  * interpreter. */
  222.     char *source; /* The source string being compiled by
  223.  * SetByteCodeFromAny. This pointer is not
  224.  * owned by the CompileEnv and must not be
  225.  * freed or changed by it. */
  226.     int numSrcBytes; /* Number of bytes in source. */
  227.     Proc *procPtr; /* If a procedure is being compiled, a
  228.  * pointer to its Proc structure; otherwise
  229.  * NULL. Used to compile local variables.
  230.  * Set from information provided by
  231.  * ObjInterpProc in tclProc.c. */
  232.     int numCommands; /* Number of commands compiled. */
  233.     int exceptDepth; /* Current exception range nesting level;
  234.  * -1 if not in any range currently. */
  235.     int maxExceptDepth; /* Max nesting level of exception ranges;
  236.  * -1 if no ranges have been compiled. */
  237.     int maxStackDepth; /* Maximum number of stack elements needed
  238.  * to execute the code. Set by compilation
  239.  * procedures before returning. */
  240.     int currStackDepth;         /* Current stack depth. */
  241.     LiteralTable localLitTable; /* Contains LiteralEntry's describing
  242.  * all Tcl objects referenced by this
  243.  * compiled code. Indexed by the string
  244.  * representations of the literals. Used to
  245.  * avoid creating duplicate objects. */
  246.     unsigned char *codeStart; /* Points to the first byte of the code. */
  247.     unsigned char *codeNext; /* Points to next code array byte to use. */
  248.     unsigned char *codeEnd; /* Points just after the last allocated
  249.  * code array byte. */
  250.     int mallocedCodeArray;      /* Set 1 if code array was expanded 
  251.  * and codeStart points into the heap.*/
  252.     LiteralEntry *literalArrayPtr;
  253.      /* Points to start of LiteralEntry array. */
  254.     int literalArrayNext; /* Index of next free object array entry. */
  255.     int literalArrayEnd; /* Index just after last obj array entry. */
  256.     int mallocedLiteralArray;   /* 1 if object array was expanded and
  257.                                  * objArray points into the heap, else 0. */
  258.     ExceptionRange *exceptArrayPtr;
  259.      /* Points to start of the ExceptionRange
  260.  * array. */
  261.     int exceptArrayNext; /* Next free ExceptionRange array index.
  262.  * exceptArrayNext is the number of ranges
  263.  * and (exceptArrayNext-1) is the index of
  264.  * the current range's array entry. */
  265.     int exceptArrayEnd; /* Index after the last ExceptionRange
  266.  * array entry. */
  267.     int mallocedExceptArray; /* 1 if ExceptionRange array was expanded
  268.  * and exceptArrayPtr points in heap,
  269.  * else 0. */
  270.     CmdLocation *cmdMapPtr; /* Points to start of CmdLocation array.
  271.  * numCommands is the index of the next
  272.  * entry to use; (numCommands-1) is the
  273.  * entry index for the last command. */
  274.     int cmdMapEnd; /* Index after last CmdLocation entry. */
  275.     int mallocedCmdMap; /* 1 if command map array was expanded and
  276.  * cmdMapPtr points in the heap, else 0. */
  277.     AuxData *auxDataArrayPtr;   /* Points to auxiliary data array start. */
  278.     int auxDataArrayNext; /* Next free compile aux data array index.
  279.  * auxDataArrayNext is the number of aux
  280.  * data items and (auxDataArrayNext-1) is
  281.  * index of current aux data array entry. */
  282.     int auxDataArrayEnd; /* Index after last aux data array entry. */
  283.     int mallocedAuxDataArray; /* 1 if aux data array was expanded and
  284.  * auxDataArrayPtr points in heap else 0. */
  285.     unsigned char staticCodeSpace[COMPILEENV_INIT_CODE_BYTES];
  286.                                 /* Initial storage for code. */
  287.     LiteralEntry staticLiteralSpace[COMPILEENV_INIT_NUM_OBJECTS];
  288.                                 /* Initial storage of LiteralEntry array. */
  289.     ExceptionRange staticExceptArraySpace[COMPILEENV_INIT_EXCEPT_RANGES];
  290.                                 /* Initial ExceptionRange array storage. */
  291.     CmdLocation staticCmdMapSpace[COMPILEENV_INIT_CMD_MAP_SIZE];
  292.                                 /* Initial storage for cmd location map. */
  293.     AuxData staticAuxDataArraySpace[COMPILEENV_INIT_AUX_DATA_SIZE];
  294.                                 /* Initial storage for aux data array. */
  295. #ifdef TCL_TIP280
  296.     /* TIP #280 */
  297.     ExtCmdLoc* extCmdMapPtr;    /* Extended command location information
  298.  * for 'info frame'. */
  299.     int        line;            /* First line of the script, based on the
  300.  * invoking context, then the line of the
  301.  * command currently compiled. */
  302. #endif
  303. } CompileEnv;
  305. /*
  306.  * The structure defining the bytecode instructions resulting from compiling
  307.  * a Tcl script. Note that this structure is variable length: a single heap
  308.  * object is allocated to hold the ByteCode structure immediately followed
  309.  * by the code bytes, the literal object array, the ExceptionRange array,
  310.  * the CmdLocation map, and the compilation AuxData array.
  311.  */
  313. /*
  314.  * A PRECOMPILED bytecode struct is one that was generated from a compiled
  315.  * image rather than implicitly compiled from source
  316.  */
  317. #define TCL_BYTECODE_PRECOMPILED 0x0001
  319. typedef struct ByteCode {
  320.     TclHandle interpHandle; /* Handle for interpreter containing the
  321.  * compiled code.  Commands and their compile
  322.  * procs are specific to an interpreter so the
  323.  * code emitted will depend on the
  324.  * interpreter. */
  325.     int compileEpoch; /* Value of iPtr->compileEpoch when this
  326.  * ByteCode was compiled. Used to invalidate
  327.  * code when, e.g., commands with compile
  328.  * procs are redefined. */
  329.     Namespace *nsPtr; /* Namespace context in which this code
  330.  * was compiled. If the code is executed
  331.  * if a different namespace, it must be
  332.  * recompiled. */
  333.     int nsEpoch; /* Value of nsPtr->resolverEpoch when this
  334.  * ByteCode was compiled. Used to invalidate
  335.  * code when new namespace resolution rules
  336.  * are put into effect. */
  337.     int refCount; /* Reference count: set 1 when created
  338.  * plus 1 for each execution of the code
  339.  * currently active. This structure can be
  340.  * freed when refCount becomes zero. */
  341.     unsigned int flags; /* flags describing state for the codebyte.
  342.                                  * this variable holds ORed values from the
  343.                                  * TCL_BYTECODE_ masks defined above */
  344.     char *source; /* The source string from which this
  345.  * ByteCode was compiled. Note that this
  346.  * pointer is not owned by the ByteCode and
  347.  * must not be freed or modified by it. */
  348.     Proc *procPtr; /* If the ByteCode was compiled from a
  349.  * procedure body, this is a pointer to its
  350.  * Proc structure; otherwise NULL. This
  351.  * pointer is also not owned by the ByteCode
  352.  * and must not be freed by it. */
  353.     size_t structureSize; /* Number of bytes in the ByteCode structure
  354.  * itself. Does not include heap space for
  355.  * literal Tcl objects or storage referenced
  356.  * by AuxData entries. */
  357.     int numCommands; /* Number of commands compiled. */
  358.     int numSrcBytes; /* Number of source bytes compiled. */
  359.     int numCodeBytes; /* Number of code bytes. */
  360.     int numLitObjects; /* Number of objects in literal array. */
  361.     int numExceptRanges; /* Number of ExceptionRange array elems. */
  362.     int numAuxDataItems; /* Number of AuxData items. */
  363.     int numCmdLocBytes; /* Number of bytes needed for encoded
  364.  * command location information. */
  365.     int maxExceptDepth; /* Maximum nesting level of ExceptionRanges;
  366.  * -1 if no ranges were compiled. */
  367.     int maxStackDepth; /* Maximum number of stack elements needed
  368.  * to execute the code. */
  369.     unsigned char *codeStart; /* Points to the first byte of the code.
  370.  * This is just after the final ByteCode
  371.  * member cmdMapPtr. */
  372.     Tcl_Obj **objArrayPtr; /* Points to the start of the literal
  373.  * object array. This is just after the
  374.  * last code byte. */
  375.     ExceptionRange *exceptArrayPtr;
  376.      /* Points to the start of the ExceptionRange
  377.  * array. This is just after the last
  378.  * object in the object array. */
  379.     AuxData *auxDataArrayPtr;   /* Points to the start of the auxiliary data
  380.  * array. This is just after the last entry
  381.  * in the ExceptionRange array. */
  382.     unsigned char *codeDeltaStart;
  383. /* Points to the first of a sequence of
  384.  * bytes that encode the change in the
  385.  * starting offset of each command's code.
  386.  * If -127<=delta<=127, it is encoded as 1
  387.  * byte, otherwise 0xFF (128) appears and
  388.  * the delta is encoded by the next 4 bytes.
  389.  * Code deltas are always positive. This
  390.  * sequence is just after the last entry in
  391.  * the AuxData array. */
  392.     unsigned char *codeLengthStart;
  393. /* Points to the first of a sequence of
  394.  * bytes that encode the length of each
  395.  * command's code. The encoding is the same
  396.  * as for code deltas. Code lengths are
  397.  * always positive. This sequence is just
  398.  * after the last entry in the code delta
  399.  * sequence. */
  400.     unsigned char *srcDeltaStart;
  401. /* Points to the first of a sequence of
  402.  * bytes that encode the change in the
  403.  * starting offset of each command's source.
  404.  * The encoding is the same as for code
  405.  * deltas. Source deltas can be negative.
  406.  * This sequence is just after the last byte
  407.  * in the code length sequence. */
  408.     unsigned char *srcLengthStart;
  409. /* Points to the first of a sequence of
  410.  * bytes that encode the length of each
  411.  * command's source. The encoding is the
  412.  * same as for code deltas. Source lengths
  413.  * are always positive. This sequence is
  414.  * just after the last byte in the source
  415.  * delta sequence. */
  416. #ifdef TCL_COMPILE_STATS
  417.     Tcl_Time createTime; /* Absolute time when the ByteCode was
  418.  * created. */
  419. #endif /* TCL_COMPILE_STATS */
  420. } ByteCode;
  422. /*
  423.  * Opcodes for the Tcl bytecode instructions. These must correspond to
  424.  * the entries in the table of instruction descriptions,
  425.  * tclInstructionTable, in tclCompile.c. Also, the order and number of
  426.  * the expression opcodes (e.g., INST_LOR) must match the entries in
  427.  * the array operatorStrings in tclExecute.c.
  428.  */
  430. /* Opcodes 0 to 9 */
  431. #define INST_DONE 0
  432. #define INST_PUSH1 1
  433. #define INST_PUSH4 2
  434. #define INST_POP 3
  435. #define INST_DUP 4
  436. #define INST_CONCAT1 5
  437. #define INST_INVOKE_STK1 6
  438. #define INST_INVOKE_STK4 7
  439. #define INST_EVAL_STK 8
  440. #define INST_EXPR_STK 9
  442. /* Opcodes 10 to 23 */
  443. #define INST_LOAD_SCALAR1 10
  444. #define INST_LOAD_SCALAR4 11
  445. #define INST_LOAD_SCALAR_STK 12
  446. #define INST_LOAD_ARRAY1 13
  447. #define INST_LOAD_ARRAY4 14
  448. #define INST_LOAD_ARRAY_STK 15
  449. #define INST_LOAD_STK 16
  450. #define INST_STORE_SCALAR1 17
  451. #define INST_STORE_SCALAR4 18
  452. #define INST_STORE_SCALAR_STK 19
  453. #define INST_STORE_ARRAY1 20
  454. #define INST_STORE_ARRAY4 21
  455. #define INST_STORE_ARRAY_STK 22
  456. #define INST_STORE_STK 23
  458. /* Opcodes 24 to 33 */
  459. #define INST_INCR_SCALAR1 24
  460. #define INST_INCR_SCALAR_STK 25
  461. #define INST_INCR_ARRAY1 26
  462. #define INST_INCR_ARRAY_STK 27
  463. #define INST_INCR_STK 28
  464. #define INST_INCR_SCALAR1_IMM 29
  465. #define INST_INCR_SCALAR_STK_IMM 30
  466. #define INST_INCR_ARRAY1_IMM 31
  467. #define INST_INCR_ARRAY_STK_IMM 32
  468. #define INST_INCR_STK_IMM 33
  470. /* Opcodes 34 to 39 */
  471. #define INST_JUMP1 34
  472. #define INST_JUMP4 35
  473. #define INST_JUMP_TRUE1 36
  474. #define INST_JUMP_TRUE4 37
  475. #define INST_JUMP_FALSE1 38
  476. #define INST_JUMP_FALSE4         39
  478. /* Opcodes 40 to 64 */
  479. #define INST_LOR 40
  480. #define INST_LAND 41
  481. #define INST_BITOR 42
  482. #define INST_BITXOR 43
  483. #define INST_BITAND 44
  484. #define INST_EQ 45
  485. #define INST_NEQ 46
  486. #define INST_LT 47
  487. #define INST_GT 48
  488. #define INST_LE 49
  489. #define INST_GE 50
  490. #define INST_LSHIFT 51
  491. #define INST_RSHIFT 52
  492. #define INST_ADD 53
  493. #define INST_SUB 54
  494. #define INST_MULT 55
  495. #define INST_DIV 56
  496. #define INST_MOD 57
  497. #define INST_UPLUS 58
  498. #define INST_UMINUS 59
  499. #define INST_BITNOT 60
  500. #define INST_LNOT 61
  501. #define INST_CALL_BUILTIN_FUNC1 62
  502. #define INST_CALL_FUNC1 63
  503. #define INST_TRY_CVT_TO_NUMERIC 64
  505. /* Opcodes 65 to 66 */
  506. #define INST_BREAK 65
  507. #define INST_CONTINUE 66
  509. /* Opcodes 67 to 68 */
  510. #define INST_FOREACH_START4 67
  511. #define INST_FOREACH_STEP4 68
  513. /* Opcodes 69 to 72 */
  514. #define INST_BEGIN_CATCH4 69
  515. #define INST_END_CATCH 70
  516. #define INST_PUSH_RESULT 71
  517. #define INST_PUSH_RETURN_CODE 72
  519. /* Opcodes 73 to 78 */
  520. #define INST_STR_EQ 73
  521. #define INST_STR_NEQ 74
  522. #define INST_STR_CMP 75
  523. #define INST_STR_LEN 76
  524. #define INST_STR_INDEX 77
  525. #define INST_STR_MATCH 78
  527. /* Opcodes 78 to 81 */
  528. #define INST_LIST 79
  529. #define INST_LIST_INDEX 80
  530. #define INST_LIST_LENGTH 81
  532. /* Opcodes 82 to 87 */
  533. #define INST_APPEND_SCALAR1 82
  534. #define INST_APPEND_SCALAR4 83
  535. #define INST_APPEND_ARRAY1 84
  536. #define INST_APPEND_ARRAY4 85
  537. #define INST_APPEND_ARRAY_STK 86
  538. #define INST_APPEND_STK 87
  540. /* Opcodes 88 to 93 */
  541. #define INST_LAPPEND_SCALAR1 88
  542. #define INST_LAPPEND_SCALAR4 89
  543. #define INST_LAPPEND_ARRAY1 90
  544. #define INST_LAPPEND_ARRAY4 91
  545. #define INST_LAPPEND_ARRAY_STK 92
  546. #define INST_LAPPEND_STK 93
  548. /* TIP #22 - LINDEX operator with flat arg list */
  550. #define INST_LIST_INDEX_MULTI 94
  552. /*
  553.  * TIP #33 - 'lset' command.  Code gen also required a Forth-like
  554.  *           OVER operation.
  555.  */
  557. #define INST_OVER                       95
  558. #define INST_LSET_LIST 96
  559. #define INST_LSET_FLAT                  97
  561. /* The last opcode */
  562. #define LAST_INST_OPCODE         97
  564. /*
  565.  * Table describing the Tcl bytecode instructions: their name (for
  566.  * displaying code), total number of code bytes required (including
  567.  * operand bytes), and a description of the type of each operand.
  568.  * These operand types include signed and unsigned integers of length
  569.  * one and four bytes. The unsigned integers are used for indexes or
  570.  * for, e.g., the count of objects to push in a "push" instruction.
  571.  */
  573. #define MAX_INSTRUCTION_OPERANDS 2
  575. typedef enum InstOperandType {
  576.     OPERAND_NONE,
  577.     OPERAND_INT1, /* One byte signed integer. */
  578.     OPERAND_INT4, /* Four byte signed integer. */
  579.     OPERAND_UINT1, /* One byte unsigned integer. */
  580.     OPERAND_UINT4 /* Four byte unsigned integer. */
  581. } InstOperandType;
  583. typedef struct InstructionDesc {
  584.     char *name; /* Name of instruction. */
  585.     int numBytes; /* Total number of bytes for instruction. */
  586.     int stackEffect;            /* The worst-case balance stack effect of the 
  587.  * instruction, used for stack requirements 
  588.  * computations. The value INT_MIN signals
  589.  * that the instruction's worst case effect
  590.  * is (1-opnd1).
  591.  */
  592.     int numOperands; /* Number of operands. */
  593.     InstOperandType opTypes[MAX_INSTRUCTION_OPERANDS];
  594. /* The type of each operand. */
  595. } InstructionDesc;
  597. extern InstructionDesc tclInstructionTable[];
  599. /*
  600.  * Definitions of the values of the INST_CALL_BUILTIN_FUNC instruction's
  601.  * operand byte. Each value denotes a builtin Tcl math function. These
  602.  * values must correspond to the entries in the tclBuiltinFuncTable array
  603.  * below and to the values stored in the tclInt.h MathFunc structure's
  604.  * builtinFuncIndex field.
  605.  */
  607. #define BUILTIN_FUNC_ACOS 0
  608. #define BUILTIN_FUNC_ASIN 1
  609. #define BUILTIN_FUNC_ATAN 2
  610. #define BUILTIN_FUNC_ATAN2 3
  611. #define BUILTIN_FUNC_CEIL 4
  612. #define BUILTIN_FUNC_COS 5
  613. #define BUILTIN_FUNC_COSH 6
  614. #define BUILTIN_FUNC_EXP 7
  615. #define BUILTIN_FUNC_FLOOR 8
  616. #define BUILTIN_FUNC_FMOD 9
  617. #define BUILTIN_FUNC_HYPOT 10
  618. #define BUILTIN_FUNC_LOG 11
  619. #define BUILTIN_FUNC_LOG10 12
  620. #define BUILTIN_FUNC_POW 13
  621. #define BUILTIN_FUNC_SIN 14
  622. #define BUILTIN_FUNC_SINH 15
  623. #define BUILTIN_FUNC_SQRT 16
  624. #define BUILTIN_FUNC_TAN 17
  625. #define BUILTIN_FUNC_TANH 18
  626. #define BUILTIN_FUNC_ABS 19
  627. #define BUILTIN_FUNC_DOUBLE 20
  628. #define BUILTIN_FUNC_INT 21
  629. #define BUILTIN_FUNC_RAND 22
  630. #define BUILTIN_FUNC_ROUND 23
  631. #define BUILTIN_FUNC_SRAND 24
  632. #define BUILTIN_FUNC_WIDE 25
  634. #define LAST_BUILTIN_FUNC         25
  636. /*
  637.  * Table describing the built-in math functions. Entries in this table are
  638.  * indexed by the values of the INST_CALL_BUILTIN_FUNC instruction's
  639.  * operand byte.
  640.  */
  642. typedef int (CallBuiltinFuncProc) _ANSI_ARGS_((Tcl_Interp *interp,
  643.         ExecEnv *eePtr, ClientData clientData));
  645. typedef struct {
  646.     char *name; /* Name of function. */
  647.     int numArgs; /* Number of arguments for function. */
  648.     Tcl_ValueType argTypes[MAX_MATH_ARGS];
  649. /* Acceptable types for each argument. */
  650.     CallBuiltinFuncProc *proc; /* Procedure implementing this function. */
  651.     ClientData clientData; /* Additional argument to pass to the
  652.  * function when invoking it. */
  653. } BuiltinFunc;
  655. extern BuiltinFunc tclBuiltinFuncTable[];
  657. /*
  658.  * Compilation of some Tcl constructs such as if commands and the logical or
  659.  * (||) and logical and (&&) operators in expressions requires the
  660.  * generation of forward jumps. Since the PC target of these jumps isn't
  661.  * known when the jumps are emitted, we record the offset of each jump in an
  662.  * array of JumpFixup structures. There is one array for each sequence of
  663.  * jumps to one target PC. When we learn the target PC, we update the jumps
  664.  * with the correct distance. Also, if the distance is too great (> 127
  665.  * bytes), we replace the single-byte jump with a four byte jump
  666.  * instruction, move the instructions after the jump down, and update the
  667.  * code offsets for any commands between the jump and the target.
  668.  */
  670. typedef enum {
  671.     TCL_UNCONDITIONAL_JUMP,
  672.     TCL_TRUE_JUMP,
  673.     TCL_FALSE_JUMP
  674. } TclJumpType;
  676. typedef struct JumpFixup {
  677.     TclJumpType jumpType; /* Indicates the kind of jump. */
  678.     int codeOffset; /* Offset of the first byte of the one-byte
  679.  * forward jump's code. */
  680.     int cmdIndex; /* Index of the first command after the one
  681.  * for which the jump was emitted. Used to
  682.  * update the code offsets for subsequent
  683.  * commands if the two-byte jump at jumpPc
  684.  * must be replaced with a five-byte one. */
  685.     int exceptIndex; /* Index of the first range entry in the
  686.  * ExceptionRange array after the current
  687.  * one. This field is used to adjust the
  688.  * code offsets in subsequent ExceptionRange
  689.  * records when a jump is grown from 2 bytes
  690.  * to 5 bytes. */
  691. } JumpFixup;
  693. #define JUMPFIXUP_INIT_ENTRIES    10
  695. typedef struct JumpFixupArray {
  696.     JumpFixup *fixup; /* Points to start of jump fixup array. */
  697.     int next; /* Index of next free array entry. */
  698.     int end; /* Index of last usable entry in array. */
  699.     int mallocedArray; /* 1 if array was expanded and fixups points
  700.  * into the heap, else 0. */
  701.     JumpFixup staticFixupSpace[JUMPFIXUP_INIT_ENTRIES];
  702. /* Initial storage for jump fixup array. */
  703. } JumpFixupArray;
  705. /*
  706.  * The structure describing one variable list of a foreach command. Note
  707.  * that only foreach commands inside procedure bodies are compiled inline so
  708.  * a ForeachVarList structure always describes local variables. Furthermore,
  709.  * only scalar variables are supported for inline-compiled foreach loops.
  710.  */
  712. typedef struct ForeachVarList {
  713.     int numVars; /* The number of variables in the list. */
  714.     int varIndexes[1]; /* An array of the indexes ("slot numbers")
  715.  * for each variable in the procedure's
  716.  * array of local variables. Only scalar
  717.  * variables are supported. The actual
  718.  * size of this field will be large enough
  719.  * to numVars indexes. THIS MUST BE THE
  720.  * LAST FIELD IN THE STRUCTURE! */
  721. } ForeachVarList;
  723. /*
  724.  * Structure used to hold information about a foreach command that is needed
  725.  * during program execution. These structures are stored in CompileEnv and
  726.  * ByteCode structures as auxiliary data.
  727.  */
  729. typedef struct ForeachInfo {
  730.     int numLists; /* The number of both the variable and value
  731.  * lists of the foreach command. */
  732.     int firstValueTemp; /* Index of the first temp var in a proc
  733.  * frame used to point to a value list. */
  734.     int loopCtTemp; /* Index of temp var in a proc frame
  735.  * holding the loop's iteration count. Used
  736.  * to determine next value list element to
  737.  * assign each loop var. */
  738.     ForeachVarList *varLists[1];/* An array of pointers to ForeachVarList
  739.  * structures describing each var list. The
  740.  * actual size of this field will be large
  741.  * enough to numVars indexes. THIS MUST BE
  742.  * THE LAST FIELD IN THE STRUCTURE! */
  743. } ForeachInfo;
  745. extern AuxDataType tclForeachInfoType;
  748. /*
  749.  *----------------------------------------------------------------
  750.  * Procedures exported by tclBasic.c to be used within the engine.
  751.  *----------------------------------------------------------------
  752.  */
  754. EXTERN int TclEvalObjvInternal _ANSI_ARGS_((Tcl_Interp *interp, int objc,
  755.     Tcl_Obj *CONST objv[], CONST char *command, int length,
  756.     int flags));
  757. EXTERN int              TclInterpReady _ANSI_ARGS_((Tcl_Interp *interp));
  760. /*
  761.  *----------------------------------------------------------------
  762.  * Procedures exported by the engine to be used by tclBasic.c
  763.  *----------------------------------------------------------------
  764.  */
  766. #ifndef TCL_TIP280
  767. EXTERN int TclCompEvalObj _ANSI_ARGS_((Tcl_Interp *interp,
  768.     Tcl_Obj *objPtr));
  769. #else
  770. EXTERN int TclCompEvalObj _ANSI_ARGS_((Tcl_Interp *interp,
  771.     Tcl_Obj *objPtr, CONST CmdFrame* invoker,
  772.     int word));
  773. #endif
  775. /*
  776.  *----------------------------------------------------------------
  777.  * Procedures shared among Tcl bytecode compilation and execution
  778.  * modules but not used outside:
  779.  *----------------------------------------------------------------
  780.  */
  782. EXTERN void TclCleanupByteCode _ANSI_ARGS_((ByteCode *codePtr));
  783. EXTERN int TclCompileCmdWord _ANSI_ARGS_((Tcl_Interp *interp,
  784.     Tcl_Token *tokenPtr, int count,
  785.     CompileEnv *envPtr));
  786. EXTERN int TclCompileExpr _ANSI_ARGS_((Tcl_Interp *interp,
  787.     CONST char *script, int numBytes,
  788.     CompileEnv *envPtr));
  789. EXTERN int TclCompileExprWords _ANSI_ARGS_((Tcl_Interp *interp,
  790.     Tcl_Token *tokenPtr, int numWords,
  791.     CompileEnv *envPtr));
  792. EXTERN int TclCompileScript _ANSI_ARGS_((Tcl_Interp *interp,
  793.     CONST char *script, int numBytes, int nested,
  794.     CompileEnv *envPtr));
  795. EXTERN int TclCompileTokens _ANSI_ARGS_((Tcl_Interp *interp,
  796.     Tcl_Token *tokenPtr, int count,
  797.     CompileEnv *envPtr));
  798. EXTERN int TclCreateAuxData _ANSI_ARGS_((ClientData clientData,
  799.     AuxDataType *typePtr, CompileEnv *envPtr));
  800. EXTERN int TclCreateExceptRange _ANSI_ARGS_((
  801.     ExceptionRangeType type, CompileEnv *envPtr));
  802. EXTERN ExecEnv * TclCreateExecEnv _ANSI_ARGS_((Tcl_Interp *interp));
  803. EXTERN void TclDeleteExecEnv _ANSI_ARGS_((ExecEnv *eePtr));
  804. EXTERN void TclDeleteLiteralTable _ANSI_ARGS_((
  805.     Tcl_Interp *interp, LiteralTable *tablePtr));
  806. EXTERN void TclEmitForwardJump _ANSI_ARGS_((CompileEnv *envPtr,
  807.     TclJumpType jumpType, JumpFixup *jumpFixupPtr));
  808. EXTERN ExceptionRange * TclGetExceptionRangeForPc _ANSI_ARGS_((
  809.     unsigned char *pc, int catchOnly,
  810.     ByteCode* codePtr));
  811. EXTERN void TclExpandJumpFixupArray _ANSI_ARGS_((
  812.                             JumpFixupArray *fixupArrayPtr));
  813. EXTERN void TclFinalizeAuxDataTypeTable _ANSI_ARGS_((void));
  814. EXTERN int TclFindCompiledLocal _ANSI_ARGS_((CONST char *name, 
  815.              int nameChars, int create, int flags,
  816.     Proc *procPtr));
  817. EXTERN LiteralEntry * TclLookupLiteralEntry _ANSI_ARGS_((
  818.     Tcl_Interp *interp, Tcl_Obj *objPtr));
  819. EXTERN int TclFixupForwardJump _ANSI_ARGS_((
  820.     CompileEnv *envPtr, JumpFixup *jumpFixupPtr,
  821.     int jumpDist, int distThreshold));
  822. EXTERN void TclFreeCompileEnv _ANSI_ARGS_((CompileEnv *envPtr));
  823. EXTERN void TclFreeJumpFixupArray _ANSI_ARGS_((
  824.        JumpFixupArray *fixupArrayPtr));
  825. EXTERN void TclInitAuxDataTypeTable _ANSI_ARGS_((void));
  826. EXTERN void TclInitByteCodeObj _ANSI_ARGS_((Tcl_Obj *objPtr,
  827.     CompileEnv *envPtr));
  828. EXTERN void TclInitCompilation _ANSI_ARGS_((void));
  829. #ifndef TCL_TIP280
  830. EXTERN void TclInitCompileEnv _ANSI_ARGS_((Tcl_Interp *interp,
  831.     CompileEnv *envPtr, char *string,
  832.     int numBytes));
  833. #else
  834. EXTERN void TclInitCompileEnv _ANSI_ARGS_((Tcl_Interp *interp,
  835.     CompileEnv *envPtr, char *string,
  836.     int numBytes, CONST CmdFrame* invoker, int word));
  837. #endif
  838. EXTERN void TclInitJumpFixupArray _ANSI_ARGS_((
  839.     JumpFixupArray *fixupArrayPtr));
  840. EXTERN void TclInitLiteralTable _ANSI_ARGS_((
  841.     LiteralTable *tablePtr));
  842. #ifdef TCL_COMPILE_STATS
  843. EXTERN char * TclLiteralStats _ANSI_ARGS_((
  844.     LiteralTable *tablePtr));
  845. EXTERN int TclLog2 _ANSI_ARGS_((int value));
  846. #endif
  847. #ifdef TCL_COMPILE_DEBUG
  848. EXTERN void TclPrintByteCodeObj _ANSI_ARGS_((Tcl_Interp *interp,
  849.             Tcl_Obj *objPtr));
  850. #endif
  851. EXTERN int TclPrintInstruction _ANSI_ARGS_((ByteCode* codePtr,
  852.     unsigned char *pc));
  853. EXTERN void TclPrintObject _ANSI_ARGS_((FILE *outFile,
  854.     Tcl_Obj *objPtr, int maxChars));
  855. EXTERN void TclPrintSource _ANSI_ARGS_((FILE *outFile,
  856.     CONST char *string, int maxChars));
  857. EXTERN void TclRegisterAuxDataType _ANSI_ARGS_((AuxDataType *typePtr));
  858. EXTERN int TclRegisterLiteral _ANSI_ARGS_((CompileEnv *envPtr,
  859.     char *bytes, int length, int onHeap));
  860. EXTERN void TclReleaseLiteral _ANSI_ARGS_((Tcl_Interp *interp,
  861.     Tcl_Obj *objPtr));
  862. EXTERN void TclSetCmdNameObj _ANSI_ARGS_((Tcl_Interp *interp,
  863.     Tcl_Obj *objPtr, Command *cmdPtr));
  864. #ifdef TCL_COMPILE_DEBUG
  865. EXTERN void TclVerifyGlobalLiteralTable _ANSI_ARGS_((
  866.     Interp *iPtr));
  867. EXTERN void TclVerifyLocalLiteralTable _ANSI_ARGS_((
  868.     CompileEnv *envPtr));
  869. #endif
  870. EXTERN int TclCompileVariableCmd _ANSI_ARGS_((
  871.     Tcl_Interp *interp, Tcl_Parse *parsePtr, CompileEnv *envPtr));
  873. /*
  874.  *----------------------------------------------------------------
  875.  * Macros used by Tcl bytecode compilation and execution modules
  876.  * inside the Tcl core but not used outside.
  877.  *----------------------------------------------------------------
  878.  */
  880. /*
  881.  * Form of TclRegisterLiteral with onHeap == 0.
  882.  * In that case, it is safe to cast away CONSTness, and it
  883.  * is cleanest to do that here, all in one place.
  884.  */
  886. #define TclRegisterNewLiteral(envPtr, bytes, length) 
  887. TclRegisterLiteral(envPtr, (char *)(bytes), length, /*onHeap*/ 0)
  889. /*
  890.  * Macro used to update the stack requirements.
  891.  * It is called by the macros TclEmitOpCode, TclEmitInst1 and
  892.  * TclEmitInst4.
  893.  * Remark that the very last instruction of a bytecode always
  894.  * reduces the stack level: INST_DONE or INST_POP, so that the 
  895.  * maxStackdepth is always updated.
  896.  */
  898. #define TclUpdateStackReqs(op, i, envPtr) 
  899.     {
  900. int delta = tclInstructionTable[(op)].stackEffect;
  901. if (delta) {
  902.     if (delta < 0) {
  903. if((envPtr)->maxStackDepth < (envPtr)->currStackDepth) {
  904.     (envPtr)->maxStackDepth = (envPtr)->currStackDepth;
  905. }
  906. if (delta == INT_MIN) {
  907.     delta = 1 - (i);
  908. }
  909.     }
  910.     (envPtr)->currStackDepth += delta;
  911. }
  912.     }
  914. /*
  915.  * Macro to emit an opcode byte into a CompileEnv's code array.
  916.  * The ANSI C "prototype" for this macro is:
  917.  *
  918.  * EXTERN void TclEmitOpcode _ANSI_ARGS_((unsigned char op,
  919.  *     CompileEnv *envPtr));
  920.  */
  922. #define TclEmitOpcode(op, envPtr) 
  923.     if ((envPtr)->codeNext == (envPtr)->codeEnd) 
  924.         TclExpandCodeArray(envPtr); 
  925.     *(envPtr)->codeNext++ = (unsigned char) (op);
  926.     TclUpdateStackReqs(op, 0, envPtr)
  928. /*
  929.  * Macro to emit an integer operand.
  930.  * The ANSI C "prototype" for this macro is:
  931.  *
  932.  * EXTERN void TclEmitInt1 _ANSI_ARGS_((int i, CompileEnv *envPtr));
  933.  */
  935. #define TclEmitInt1(i, envPtr) 
  936.     if ((envPtr)->codeNext == (envPtr)->codeEnd) 
  937.         TclExpandCodeArray(envPtr); 
  938.     *(envPtr)->codeNext++ = (unsigned char) ((unsigned int) (i))
  940. /*
  941.  * Macros to emit an instruction with signed or unsigned integer operands.
  942.  * Four byte integers are stored in "big-endian" order with the high order
  943.  * byte stored at the lowest address.
  944.  * The ANSI C "prototypes" for these macros are:
  945.  *
  946.  * EXTERN void TclEmitInstInt1 _ANSI_ARGS_((unsigned char op, int i, 
  947.  *     CompileEnv *envPtr));
  948.  * EXTERN void TclEmitInstInt4 _ANSI_ARGS_((unsigned char op, int i, 
  949.  *     CompileEnv *envPtr));
  950.  */
  953. #define TclEmitInstInt1(op, i, envPtr) 
  954.     if (((envPtr)->codeNext + 2) > (envPtr)->codeEnd) { 
  955.         TclExpandCodeArray(envPtr); 
  956.     } 
  957.     *(envPtr)->codeNext++ = (unsigned char) (op); 
  958.     *(envPtr)->codeNext++ = (unsigned char) ((unsigned int) (i));
  959.     TclUpdateStackReqs(op, i, envPtr)
  961. #define TclEmitInstInt4(op, i, envPtr) 
  962.     if (((envPtr)->codeNext + 5) > (envPtr)->codeEnd) { 
  963.         TclExpandCodeArray(envPtr); 
  964.     } 
  965.     *(envPtr)->codeNext++ = (unsigned char) (op); 
  966.     *(envPtr)->codeNext++ = 
  967.         (unsigned char) ((unsigned int) (i) >> 24); 
  968.     *(envPtr)->codeNext++ = 
  969.         (unsigned char) ((unsigned int) (i) >> 16); 
  970.     *(envPtr)->codeNext++ = 
  971.         (unsigned char) ((unsigned int) (i) >>  8); 
  972.     *(envPtr)->codeNext++ = 
  973.         (unsigned char) ((unsigned int) (i)      );
  974.     TclUpdateStackReqs(op, i, envPtr)
  975.     
  976. /*
  977.  * Macro to push a Tcl object onto the Tcl evaluation stack. It emits the
  978.  * object's one or four byte array index into the CompileEnv's code
  979.  * array. These support, respectively, a maximum of 256 (2**8) and 2**32
  980.  * objects in a CompileEnv. The ANSI C "prototype" for this macro is:
  981.  *
  982.  * EXTERN void TclEmitPush _ANSI_ARGS_((int objIndex, CompileEnv *envPtr));
  983.  */
  985. #define TclEmitPush(objIndex, envPtr) 
  986.     {
  987.         register int objIndexCopy = (objIndex);
  988.         if (objIndexCopy <= 255) { 
  989.     TclEmitInstInt1(INST_PUSH1, objIndexCopy, (envPtr)); 
  990.         } else { 
  991.     TclEmitInstInt4(INST_PUSH4, objIndexCopy, (envPtr)); 
  992. }
  993.     }
  995. /*
  996.  * Macros to update a (signed or unsigned) integer starting at a pointer.
  997.  * The two variants depend on the number of bytes. The ANSI C "prototypes"
  998.  * for these macros are:
  999.  *
  1000.  * EXTERN void TclStoreInt1AtPtr _ANSI_ARGS_((int i, unsigned char *p));
  1001.  * EXTERN void TclStoreInt4AtPtr _ANSI_ARGS_((int i, unsigned char *p));
  1002.  */
  1003.     
  1004. #define TclStoreInt1AtPtr(i, p) 
  1005.     *(p)   = (unsigned char) ((unsigned int) (i))
  1006.     
  1007. #define TclStoreInt4AtPtr(i, p) 
  1008.     *(p)   = (unsigned char) ((unsigned int) (i) >> 24); 
  1009.     *(p+1) = (unsigned char) ((unsigned int) (i) >> 16); 
  1010.     *(p+2) = (unsigned char) ((unsigned int) (i) >>  8); 
  1011.     *(p+3) = (unsigned char) ((unsigned int) (i)      )
  1013. /*
  1014.  * Macros to update instructions at a particular pc with a new op code
  1015.  * and a (signed or unsigned) int operand. The ANSI C "prototypes" for
  1016.  * these macros are:
  1017.  *
  1018.  * EXTERN void TclUpdateInstInt1AtPc _ANSI_ARGS_((unsigned char op, int i,
  1019.  *     unsigned char *pc));
  1020.  * EXTERN void TclUpdateInstInt4AtPc _ANSI_ARGS_((unsigned char op, int i,
  1021.  *     unsigned char *pc));
  1022.  */
  1024. #define TclUpdateInstInt1AtPc(op, i, pc) 
  1025.     *(pc) = (unsigned char) (op); 
  1026.     TclStoreInt1AtPtr((i), ((pc)+1))
  1028. #define TclUpdateInstInt4AtPc(op, i, pc) 
  1029.     *(pc) = (unsigned char) (op); 
  1030.     TclStoreInt4AtPtr((i), ((pc)+1))
  1031.     
  1032. /*
  1033.  * Macros to get a signed integer (GET_INT{1,2}) or an unsigned int
  1034.  * (GET_UINT{1,2}) from a pointer. There are two variants for each
  1035.  * return type that depend on the number of bytes fetched.
  1036.  * The ANSI C "prototypes" for these macros are:
  1037.  *
  1038.  * EXTERN int         TclGetInt1AtPtr  _ANSI_ARGS_((unsigned char *p));
  1039.  * EXTERN int         TclGetInt4AtPtr  _ANSI_ARGS_((unsigned char *p));
  1040.  * EXTERN unsigned int TclGetUInt1AtPtr _ANSI_ARGS_((unsigned char *p));
  1041.  * EXTERN unsigned int TclGetUInt4AtPtr _ANSI_ARGS_((unsigned char *p));
  1042.  */
  1044. /*
  1045.  * The TclGetInt1AtPtr macro is tricky because we want to do sign
  1046.  * extension on the 1-byte value. Unfortunately the "char" type isn't
  1047.  * signed on all platforms so sign-extension doesn't always happen
  1048.  * automatically. Sometimes we can explicitly declare the pointer to be
  1049.  * signed, but other times we have to explicitly sign-extend the value
  1050.  * in software.
  1051.  */
  1053. #ifndef __CHAR_UNSIGNED__
  1054. #   define TclGetInt1AtPtr(p) ((int) *((char *) p))
  1055. #else
  1056. #   ifdef HAVE_SIGNED_CHAR
  1057. # define TclGetInt1AtPtr(p) ((int) *((signed char *) p))
  1058. #    else
  1059. # define TclGetInt1AtPtr(p) (((int) *((char *) p)) 
  1060. | ((*(p) & 0200) ? (-256) : 0))
  1061. #    endif
  1062. #endif
  1064. #define TclGetInt4AtPtr(p) (((int) TclGetInt1AtPtr(p) << 24) | 
  1065.                        (*((p)+1) << 16) | 
  1066.        (*((p)+2) <<  8) | 
  1067.        (*((p)+3)))
  1069. #define TclGetUInt1AtPtr(p) ((unsigned int) *(p))
  1070. #define TclGetUInt4AtPtr(p) ((unsigned int) (*(p)     << 24) | 
  1071.                             (*((p)+1) << 16) | 
  1072.             (*((p)+2) <<  8) | 
  1073.             (*((p)+3)))
  1075. /*
  1076.  * Macros used to compute the minimum and maximum of two integers.
  1077.  * The ANSI C "prototypes" for these macros are:
  1078.  *
  1079.  * EXTERN int  TclMin _ANSI_ARGS_((int i, int j));
  1080.  * EXTERN int  TclMax _ANSI_ARGS_((int i, int j));
  1081.  */
  1083. #define TclMin(i, j)   ((((int) i) < ((int) j))? (i) : (j))
  1084. #define TclMax(i, j)   ((((int) i) > ((int) j))? (i) : (j))
  1086. /*
  1087.  * DTrace probe macros (NOPs if DTrace support is not enabled).
  1088.  */
  1090. #ifdef USE_DTRACE
  1092. #include "tclDTrace.h"
  1094. #if defined(__GNUC__ ) && __GNUC__ > 2
  1095. /* Use gcc branch prediction hint to minimize cost of DTrace ENABLED checks. */
  1096. #define unlikely(x) (__builtin_expect((x), 0))
  1097. #else
  1098. #define unlikely(x) (x)
  1099. #endif
  1101. #define TCL_DTRACE_PROC_ENTRY_ENABLED()     unlikely(TCL_PROC_ENTRY_ENABLED())
  1102. #define TCL_DTRACE_PROC_RETURN_ENABLED()    unlikely(TCL_PROC_RETURN_ENABLED())
  1103. #define TCL_DTRACE_PROC_RESULT_ENABLED()    unlikely(TCL_PROC_RESULT_ENABLED())
  1104. #define TCL_DTRACE_PROC_ARGS_ENABLED()     unlikely(TCL_PROC_ARGS_ENABLED())
  1105. #define TCL_DTRACE_PROC_ENTRY(a0, a1, a2)   TCL_PROC_ENTRY(a0, a1, a2)
  1106. #define TCL_DTRACE_PROC_RETURN(a0, a1)     TCL_PROC_RETURN(a0, a1)
  1107. #define TCL_DTRACE_PROC_RESULT(a0, a1, a2, a3) TCL_PROC_RESULT(a0, a1, a2, a3)
  1108. #define TCL_DTRACE_PROC_ARGS(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) 
  1109. TCL_PROC_ARGS(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
  1111. #define TCL_DTRACE_CMD_ENTRY_ENABLED()     unlikely(TCL_CMD_ENTRY_ENABLED())
  1112. #define TCL_DTRACE_CMD_RETURN_ENABLED()     unlikely(TCL_CMD_RETURN_ENABLED())
  1113. #define TCL_DTRACE_CMD_RESULT_ENABLED()     unlikely(TCL_CMD_RESULT_ENABLED())
  1114. #define TCL_DTRACE_CMD_ARGS_ENABLED()     unlikely(TCL_CMD_ARGS_ENABLED())
  1115. #define TCL_DTRACE_CMD_ENTRY(a0, a1, a2)    TCL_CMD_ENTRY(a0, a1, a2)
  1116. #define TCL_DTRACE_CMD_RETURN(a0, a1)     TCL_CMD_RETURN(a0, a1)
  1117. #define TCL_DTRACE_CMD_RESULT(a0, a1, a2, a3) TCL_CMD_RESULT(a0, a1, a2, a3)
  1118. #define TCL_DTRACE_CMD_ARGS(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) 
  1119. TCL_CMD_ARGS(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
  1121. #define TCL_DTRACE_INST_START_ENABLED()     unlikely(TCL_INST_START_ENABLED())
  1122. #define TCL_DTRACE_INST_DONE_ENABLED()     unlikely(TCL_INST_DONE_ENABLED())
  1123. #define TCL_DTRACE_INST_START(a0, a1, a2)   TCL_INST_START(a0, a1, a2)
  1124. #define TCL_DTRACE_INST_DONE(a0, a1, a2)    TCL_INST_DONE(a0, a1, a2)
  1126. #define TCL_DTRACE_TCL_PROBE_ENABLED()     unlikely(TCL_TCL_PROBE_ENABLED())
  1127. #define TCL_DTRACE_TCL_PROBE(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) 
  1128. TCL_TCL_PROBE(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
  1130. #else /* USE_DTRACE */
  1132. #define TCL_DTRACE_PROC_ENTRY_ENABLED()     0
  1133. #define TCL_DTRACE_PROC_RETURN_ENABLED()    0
  1134. #define TCL_DTRACE_PROC_RESULT_ENABLED()    0
  1135. #define TCL_DTRACE_PROC_ARGS_ENABLED()     0
  1136. #define TCL_DTRACE_PROC_ENTRY(a0, a1, a2)   {}
  1137. #define TCL_DTRACE_PROC_RETURN(a0, a1)     {}
  1138. #define TCL_DTRACE_PROC_RESULT(a0, a1, a2, a3) {}
  1139. #define TCL_DTRACE_PROC_ARGS(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
  1141. #define TCL_DTRACE_CMD_ENTRY_ENABLED()     0
  1142. #define TCL_DTRACE_CMD_RETURN_ENABLED()     0
  1143. #define TCL_DTRACE_CMD_RESULT_ENABLED()     0
  1144. #define TCL_DTRACE_CMD_ARGS_ENABLED()     0
  1145. #define TCL_DTRACE_CMD_ENTRY(a0, a1, a2)    {}
  1146. #define TCL_DTRACE_CMD_RETURN(a0, a1)     {}
  1147. #define TCL_DTRACE_CMD_RESULT(a0, a1, a2, a3) {}
  1148. #define TCL_DTRACE_CMD_ARGS(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
  1150. #define TCL_DTRACE_INST_START_ENABLED()     0
  1151. #define TCL_DTRACE_INST_DONE_ENABLED()     0
  1152. #define TCL_DTRACE_INST_START(a0, a1, a2)   {}
  1153. #define TCL_DTRACE_INST_DONE(a0, a1, a2)    {}
  1155. #define TCL_DTRACE_TCL_PROBE_ENABLED()     0
  1156. #define TCL_DTRACE_TCL_PROBE(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
  1158. #endif /* USE_DTRACE */
  1160. # undef TCL_STORAGE_CLASS
  1161. # define TCL_STORAGE_CLASS DLLIMPORT
  1163. #endif /* _TCLCOMPILATION */