Add compilation for TIP#90-style [catch] requiring a new opcode [Bug1219112]

1 files changed, 285 insertions, 294 deletions

diff --git a/generic/tclCompile.h b/generic/tclCompile.h
index ab34f81..74c2091 100644
--- a/generic/tclCompile.h
+++ b/generic/tclCompile.h
@@ -8,7 +8,7 @@
  * 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.55 2005/05/10 18:34:27 kennykb Exp $
+ * RCS: @(#) $Id: tclCompile.h,v 1.56 2005/06/20 21:27:12 dkf Exp $
  */
 
 #ifndef _TCLCOMPILATION
@@ -34,9 +34,7 @@
  */
 
 MODULE_SCOPE int 	tclTraceCompile;
-#endif
 
-#ifdef TCL_COMPILE_DEBUG
 /*
  * Variable that controls whether execution tracing is enabled and, if so,
  * what level of tracing is desired:
@@ -49,7 +47,7 @@ MODULE_SCOPE int 	tclTraceCompile;
 
 MODULE_SCOPE int 	tclTraceExec;
 #endif
-
+
 /*
  *------------------------------------------------------------------------
  * Data structures related to compilation.
@@ -57,54 +55,55 @@ MODULE_SCOPE int 	tclTraceExec;
  */
 
 /*
- * 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.
+ * 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. */
+    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 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. */
+				 * 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.
+ * 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 {
@@ -115,19 +114,18 @@ typedef struct CmdLocation {
 } CmdLocation;
 
 /*
- * 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.
+ * 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.
+ * objects are duplicated and freed. Pointers to these procedures are kept in
+ * the AuxData structure.
  */
 
 typedef ClientData (AuxDataDupProc)  _ANSI_ARGS_((ClientData clientData));
@@ -136,22 +134,22 @@ 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.
+ * 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. */
+    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;
 
 /*
@@ -180,70 +178,68 @@ typedef struct AuxData {
 
 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. */
+				 * 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. */
+    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
+    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. */
+    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.*/
+    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. */
+    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. */
+				 * 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. */
+				 * 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. */
+				 * 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. */
@@ -260,11 +256,11 @@ typedef struct CompileEnv {
 } 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.
+ * 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.
  */
 
 /*
@@ -273,13 +269,12 @@ typedef struct CompileEnv {
  */
 #define TCL_BYTECODE_PRECOMPILED		0x0001
 
-
 /*
  * When a bytecode is compiled, interp or namespace resolvers have not been
  * applied yet: this is indicated by the TCL_BYTECODE_RESOLVE_VARS flag.
  */
 
-#define TCL_BYTECODE_RESOLVE_VARS               0x0002
+#define TCL_BYTECODE_RESOLVE_VARS		0x0002
 
 typedef struct ByteCode {
     TclHandle interpHandle;	/* Handle for interpreter containing the
@@ -291,25 +286,25 @@ typedef struct ByteCode {
 				 * 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
+    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. */
+    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. */
+    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
@@ -325,71 +320,69 @@ typedef struct ByteCode {
     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 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. */
+    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. */
+				 * 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. */
+				 * 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. */
+				/* 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. */
+				/* 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. */
+				/* 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. */
+				/* 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 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 */
@@ -533,9 +526,9 @@ typedef struct ByteCode {
 
 /* TIP #157 - {expand}... language syntax support. */
 
-#define INST_EXPAND_START             100
-#define INST_EXPAND_STKTOP            101
-#define INST_INVOKE_EXPANDED          102
+#define INST_EXPAND_START		100
+#define INST_EXPAND_STKTOP		101
+#define INST_INVOKE_EXPANDED		102
 
 /*
  * TIP #57 - 'lassign' command.  Code generation requires immediate
@@ -545,21 +538,23 @@ typedef struct ByteCode {
 #define INST_LIST_INDEX_IMM		103
 #define INST_LIST_RANGE_IMM		104
 
-#define INST_START_CMD                  105
+#define INST_START_CMD			105
 
 #define INST_LIST_IN			106
 #define INST_LIST_NOT_IN		107
 
-/* The last opcode */
-#define LAST_INST_OPCODE		107
+#define INST_PUSH_RETURN_OPTIONS	108
 
+/* The last opcode */
+#define LAST_INST_OPCODE		108
+
 /*
- * 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.
+ * 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
@@ -577,11 +572,11 @@ typedef enum 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 
+    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).
+				 * that the instruction's worst case effect is
+				 * (1-opnd1).
 				 */
     int numOperands;		/* Number of operands. */
     InstOperandType opTypes[MAX_INSTRUCTION_OPERANDS];
@@ -592,15 +587,15 @@ MODULE_SCOPE InstructionDesc tclInstructionTable[];
 
 /*
  * 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.
+ * (||) 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 {
@@ -619,9 +614,9 @@ typedef struct JumpFixup {
 				 * 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
+				 * 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;
@@ -639,21 +634,21 @@ typedef struct JumpFixupArray {
 } 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,
+ * 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! */
+				 * 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;
 
 /*
@@ -665,22 +660,21 @@ typedef struct ForeachVarList {
 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. */
+    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! */
+				 * enough to numVars indexes. THIS MUST BE THE
+				 * LAST FIELD IN THE STRUCTURE! */
 } ForeachInfo;
 
 MODULE_SCOPE AuxDataType		tclForeachInfoType;
-
-
+
 /*
  *----------------------------------------------------------------
  * Procedures exported by tclBasic.c to be used within the engine.
@@ -702,7 +696,7 @@ MODULE_SCOPE int	TclEvalObjvInternal _ANSI_ARGS_((Tcl_Interp *interp,
  *
 MODULE_SCOPE int	TclCompEvalObj _ANSI_ARGS_((Tcl_Interp *interp,
 			    Tcl_Obj *objPtr));
-*/
+ */
 
 /*
  *----------------------------------------------------------------
@@ -759,8 +753,7 @@ MODULE_SCOPE void	TclInitByteCodeObj _ANSI_ARGS_((Tcl_Obj *objPtr,
 			    CompileEnv *envPtr));
 MODULE_SCOPE void	TclInitCompilation _ANSI_ARGS_((void));
 MODULE_SCOPE void	TclInitCompileEnv _ANSI_ARGS_((Tcl_Interp *interp,
-			    CompileEnv *envPtr, char *string,
-			    int numBytes));
+			    CompileEnv *envPtr, char *string, int numBytes));
 MODULE_SCOPE void	TclInitJumpFixupArray _ANSI_ARGS_((
 			    JumpFixupArray *fixupArrayPtr));
 MODULE_SCOPE void	TclInitLiteralTable _ANSI_ARGS_((
@@ -780,7 +773,8 @@ MODULE_SCOPE void	TclPrintObject _ANSI_ARGS_((FILE *outFile,
 			    Tcl_Obj *objPtr, int maxChars));
 MODULE_SCOPE void	TclPrintSource _ANSI_ARGS_((FILE *outFile,
 			    CONST char *string, int maxChars));
-MODULE_SCOPE void	TclRegisterAuxDataType _ANSI_ARGS_((AuxDataType *typePtr));
+MODULE_SCOPE void	TclRegisterAuxDataType _ANSI_ARGS_((
+			    AuxDataType *typePtr));
 MODULE_SCOPE int	TclRegisterLiteral _ANSI_ARGS_((CompileEnv *envPtr,
 			    char *bytes, int length, int flags));
 MODULE_SCOPE void	TclReleaseLiteral _ANSI_ARGS_((Tcl_Interp *interp,
@@ -793,11 +787,11 @@ MODULE_SCOPE void	TclVerifyGlobalLiteralTable _ANSI_ARGS_((
 MODULE_SCOPE void	TclVerifyLocalLiteralTable _ANSI_ARGS_((
 			    CompileEnv *envPtr));
 #endif
-MODULE_SCOPE int	TclCompileVariableCmd _ANSI_ARGS_((
-			    Tcl_Interp *interp, Tcl_Parse *parsePtr, CompileEnv *envPtr));
+MODULE_SCOPE int	TclCompileVariableCmd _ANSI_ARGS_((Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, CompileEnv *envPtr));
 MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
 			    Tcl_Token *tokenPtr, Tcl_Obj *valuePtr));
-
+
 /*
  *----------------------------------------------------------------
  * Macros and flag values used by Tcl bytecode compilation and execution
@@ -808,31 +802,34 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
 #define LITERAL_ON_HEAP    0x01
 #define LITERAL_NS_SCOPE   0x02
 /*
- * 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.
+ * 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.
+ *
+ * int TclRegisterNewLiteral(CompileEnv *envPtr, const char *bytes,
+ *			     int length);
  */
 
 #define TclRegisterNewLiteral(envPtr, bytes, length) \
-	TclRegisterLiteral(envPtr, (char *)(bytes), length, \
-                /*flags*/ 0)
+	TclRegisterLiteral(envPtr, (char *)(bytes), length, /*flags*/ 0)
 
 /*
- * Form of TclRegisterNSLiteral 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.
+ * Form of TclRegisterNSLiteral 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.
+ *
+ * int TclRegisterNewNSLiteral(CompileEnv *envPtr, const char *bytes,
+ *			       int length);
  */
 
 #define TclRegisterNewNSLiteral(envPtr, bytes, length) \
 	TclRegisterLiteral(envPtr, (char *)(bytes), length, \
-                /*flags*/ LITERAL_NS_SCOPE)
-
+		/*flags*/ LITERAL_NS_SCOPE)
 
 /*
- * Macro used to manually adjust the stack requirements; used
- * in cases where the stack effect cannot be computed from
- * the opcode and its operands, but is still known at
- * compile time.
+ * Macro used to manually adjust the stack requirements; used in cases where
+ * the stack effect cannot be computed from the opcode and its operands, but
+ * is still known at compile time.
+ *
+ * void TclAdjustStackDepth(int delta, CompileEnv *envPtr);
  */
 
 #define TclAdjustStackDepth(delta, envPtr) \
@@ -844,12 +841,13 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
     (envPtr)->currStackDepth += (delta)
 
 /*
- * 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.
+ * 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.
+ *
+ * void TclUpdateStackReqs(unsigned char op, int i, CompileEnv *envPtr);
  */
 
 #define TclUpdateStackReqs(op, i, envPtr) \
@@ -859,16 +857,15 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
 	    if (delta == INT_MIN) {\
 		delta = 1 - (i);\
 	    }\
-            TclAdjustStackDepth(delta, envPtr);\
-        }\
+	    TclAdjustStackDepth(delta, envPtr);\
+	}\
     }
 
 /*
- * Macro to emit an opcode byte into a CompileEnv's code array.
- * The ANSI C "prototype" for this macro is:
+ * Macro to emit an opcode byte into a CompileEnv's code array.  The ANSI C
+ * "prototype" for this macro is:
  *
- * MODULE_SCOPE void	TclEmitOpcode _ANSI_ARGS_((unsigned char op,
- *		    CompileEnv *envPtr));
+ * void TclEmitOpcode(unsigned char op, CompileEnv *envPtr);
  */
 
 #define TclEmitOpcode(op, envPtr) \
@@ -878,11 +875,11 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
     TclUpdateStackReqs(op, 0, envPtr)
 
 /*
- * Macros to emit an integer operand.
- * The ANSI C "prototype" for these macros are:
+ * Macros to emit an integer operand.  The ANSI C "prototype" for these macros
+ * are:
  *
- * MODULE_SCOPE void	TclEmitInt1 _ANSI_ARGS_((int i, CompileEnv *envPtr));
- * MODULE_SCOPE void	TclEmitInt4 _ANSI_ARGS_((int i, CompileEnv *envPtr));
+ * void TclEmitInt1(int i, CompileEnv *envPtr);
+ * void TclEmitInt4(int i, CompileEnv *envPtr);
  */
 
 #define TclEmitInt1(i, envPtr) \
@@ -906,16 +903,13 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
 /*
  * 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:
+ * byte stored at the lowest address.  The ANSI C "prototypes" for these
+ * macros are:
  *
- * MODULE_SCOPE void	TclEmitInstInt1 _ANSI_ARGS_((unsigned char op, int i, 
- *		    CompileEnv *envPtr));
- * MODULE_SCOPE void	TclEmitInstInt4 _ANSI_ARGS_((unsigned char op, int i, 
- *		    CompileEnv *envPtr));
+ * void TclEmitInstInt1(unsigned char op, int i, CompileEnv *envPtr);
+ * void TclEmitInstInt4(unsigned char op, int i, CompileEnv *envPtr);
  */
 
-
 #define TclEmitInstInt1(op, i, envPtr) \
     if (((envPtr)->codeNext + 2) > (envPtr)->codeEnd) { \
 	TclExpandCodeArray(envPtr); \
@@ -941,11 +935,11 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
 
 /*
  * 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:
+ * 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:
  *
- * MODULE_SCOPE void	TclEmitPush _ANSI_ARGS_((int objIndex, CompileEnv *envPtr));
+ * void	TclEmitPush(int objIndex, CompileEnv *envPtr);
  */
 
 #define TclEmitPush(objIndex, envPtr) \
@@ -959,12 +953,12 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
     }
 
 /*
- * Macros to update a (signed or unsigned) integer starting at a pointer.
- * The two variants depend on the number of bytes. The ANSI C "prototypes"
- * for these macros are:
+ * Macros to update a (signed or unsigned) integer starting at a pointer.  The
+ * two variants depend on the number of bytes. The ANSI C "prototypes" for
+ * these macros are:
  *
- * MODULE_SCOPE void	TclStoreInt1AtPtr _ANSI_ARGS_((int i, unsigned char *p));
- * MODULE_SCOPE void	TclStoreInt4AtPtr _ANSI_ARGS_((int i, unsigned char *p));
+ * void TclStoreInt1AtPtr(int i, unsigned char *p);
+ * void TclStoreInt4AtPtr(int i, unsigned char *p);
  */
 
 #define TclStoreInt1AtPtr(i, p) \
@@ -977,14 +971,12 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
     *(p+3) = (unsigned char) ((unsigned int) (i)      )
 
 /*
- * Macros to update instructions at a particular pc with a new op code
- * and a (signed or unsigned) int operand. The ANSI C "prototypes" for
- * these macros are:
+ * Macros to update instructions at a particular pc with a new op code and a
+ * (signed or unsigned) int operand. The ANSI C "prototypes" for these macros
+ * are:
  *
- * MODULE_SCOPE void	TclUpdateInstInt1AtPc _ANSI_ARGS_((unsigned char op, int i,
- *		    unsigned char *pc));
- * MODULE_SCOPE void	TclUpdateInstInt4AtPc _ANSI_ARGS_((unsigned char op, int i,
- *		    unsigned char *pc));
+ * void TclUpdateInstInt1AtPc(unsigned char op, int i, unsigned char *pc);
+ * void TclUpdateInstInt4AtPc(unsigned char op, int i, unsigned char *pc);
  */
 
 #define TclUpdateInstInt1AtPc(op, i, pc) \
@@ -996,12 +988,12 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
     TclStoreInt4AtPtr((i), ((pc)+1))
 
 /*
- * Macro to fix up a forward jump to point to the current
- * code-generation position in the bytecode being created (the most
- * common case). The ANSI C "prototypes" for this macro is:
+ * Macro to fix up a forward jump to point to the current code-generation
+ * position in the bytecode being created (the most common case). The ANSI C
+ * "prototypes" for this macro is:
  *
- * MODULE_SCOPE int	TclFixupForwardJumpToHere _ANSI_ARGS_((CompileEnv *envPtr,
- *		    JumpFixup *fixupPtr, int threshold));
+ * int TclFixupForwardJumpToHere(CompileEnv *envPtr, JumpFixup *fixupPtr,
+ *				 int threshold);
  */
 
 #define TclFixupForwardJumpToHere(envPtr, fixupPtr, threshold) \
@@ -1011,23 +1003,22 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
 
 /*
  * Macros to get a signed integer (GET_INT{1,2}) or an unsigned int
- * (GET_UINT{1,2}) from a pointer. There are two variants for each
- * return type that depend on the number of bytes fetched.
- * The ANSI C "prototypes" for these macros are:
+ * (GET_UINT{1,2}) from a pointer. There are two variants for each return type
+ * that depend on the number of bytes fetched.  The ANSI C "prototypes" for
+ * these macros are:
  *
- * MODULE_SCOPE int		TclGetInt1AtPtr  _ANSI_ARGS_((unsigned char *p));
- * MODULE_SCOPE int		TclGetInt4AtPtr  _ANSI_ARGS_((unsigned char *p));
- * MODULE_SCOPE unsigned int	TclGetUInt1AtPtr _ANSI_ARGS_((unsigned char *p));
- * MODULE_SCOPE unsigned int	TclGetUInt4AtPtr _ANSI_ARGS_((unsigned char *p));
+ * int TclGetInt1AtPtr(unsigned char *p);
+ * int TclGetInt4AtPtr(unsigned char *p);
+ * unsigned int TclGetUInt1AtPtr(unsigned char *p);
+ * unsigned int TclGetUInt4AtPtr(unsigned char *p);
  */
 
 /*
- * The TclGetInt1AtPtr macro is tricky because we want to do sign
- * extension on the 1-byte value. Unfortunately the "char" type isn't
- * signed on all platforms so sign-extension doesn't always happen
- * automatically. Sometimes we can explicitly declare the pointer to be
- * signed, but other times we have to explicitly sign-extend the value
- * in software.
+ * The TclGetInt1AtPtr macro is tricky because we want to do sign extension on
+ * the 1-byte value. Unfortunately the "char" type isn't signed on all
+ * platforms so sign-extension doesn't always happen automatically. Sometimes
+ * we can explicitly declare the pointer to be signed, but other times we have
+ * to explicitly sign-extend the value in software.
  */
 
 #ifndef __CHAR_UNSIGNED__
@@ -1035,10 +1026,10 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
 #else
 #   ifdef HAVE_SIGNED_CHAR
 #	define TclGetInt1AtPtr(p) ((int) *((signed char *) p))
-#    else
+#   else
 #	define TclGetInt1AtPtr(p) (((int) *((char *) p)) \
 		| ((*(p) & 0200) ? (-256) : 0))
-#    endif
+#   endif
 #endif
 
 #define TclGetInt4AtPtr(p) (((int) TclGetInt1AtPtr(p) << 24) | \
@@ -1053,11 +1044,11 @@ MODULE_SCOPE int	TclWordKnownAtCompileTime _ANSI_ARGS_((
 					    (*((p)+3)))
 
 /*
- * Macros used to compute the minimum and maximum of two integers.
- * The ANSI C "prototypes" for these macros are:
+ * Macros used to compute the minimum and maximum of two integers.  The ANSI C
+ * "prototypes" for these macros are:
  *
- * MODULE_SCOPE int  TclMin _ANSI_ARGS_((int i, int j));
- * MODULE_SCOPE int  TclMax _ANSI_ARGS_((int i, int j));
+ * int TclMin(int i, int j);
+ * int TclMax(int i, int j);
  */
 
 #define TclMin(i, j)   ((((int) i) < ((int) j))? (i) : (j))