Usenet 1994 January/usenetsourcesnewsgroupsinfomagicjanuary1994.iso/sources/misc/volume25/tcl/part23

Text File | 1991-11-15 | 33.9 KB | 872 lines

Newsgroups: comp.sources.misc
From: [e-mail] (Karl Lehenbauer)
Subject:  v25i091:  tcl - tool command language, version 6.1, Part23/33
Message-ID: <[e-mail]>
X-Md4-Signature: 3225074f3359ca069b6d40e733debb60
Date: Fri, 15 Nov 1991 22:53:57 GMT
Approved: [e-mail]

Submitted-by: [e-mail] (Karl Lehenbauer)
Posting-number: Volume 25, Issue 91
Archive-name: tcl/part23
Environment: UNIX

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 23 (of 33)."
# Contents:  tcl6.1/tclInt.h
# Wrapped by karl@one on Tue Nov 12 19:44:28 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'tcl6.1/tclInt.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'tcl6.1/tclInt.h'\"
else
echo shar: Extracting \"'tcl6.1/tclInt.h'\" \(31734 characters\)
sed "s/^X//" >'tcl6.1/tclInt.h' <<'END_OF_FILE'
X/*
X * tclInt.h --
X *
X *    Declarations of things used internally by the Tcl interpreter.
X *
X * Copyright 1987-1991 Regents of the University of California
X * Permission to use, copy, modify, and distribute this
X * software and its documentation for any purpose and without
X * fee is hereby granted, provided that the above copyright
X * notice appear in all copies.  The University of California
X * makes no representations about the suitability of this
X * software for any purpose.  It is provided "as is" without
X * express or implied warranty.
X *
X * $Header: /user6/ouster/tcl/RCS/tclInt.h,v 1.64 91/10/31 16:41:32 ouster Exp $ SPRITE (Berkeley)
X */
X
X#ifndef _TCLINT
X#define _TCLINT
X
X/*
X * Common include files needed by most of the Tcl source files are
X * included here, so that system-dependent personalizations for the
X * include files only have to be made in once place.  This results
X * in a few extra includes, but greater modularity.  The order of
X * the three groups of #includes is important.  For example, stdio.h
X * is needed by tcl.h, and the _ANSI_ARGS_ declaration in tcl.h is
X * needed by stdlib.h in some configurations.
X */
X
X#include <stdio.h>
X
X#ifndef _TCL
X#include "tcl.h"
X#endif
X#ifndef _TCLHASH
X#include "tclHash.h"
X#endif
X#ifndef _REGEXP
X#include "regexp.h"
X#endif
X
X#include <ctype.h>
X#include <stdlib.h>
X#include <string.h>
X#include <varargs.h>
X
X/*
X *----------------------------------------------------------------
X * Data structures related to variables.   These are used primarily
X * in tclVar.c
X *----------------------------------------------------------------
X */
X
X/*
X * The following structure defines a variable trace, which is used to
X * invoke a specific C procedure whenever certain operations are performed
X * on a variable.
X */
X
Xtypedef struct VarTrace {
X    Tcl_VarTraceProc *traceProc;/* Procedure to call when operations given
X                 * by flags are performed on variable. */
X    ClientData clientData;    /* Argument to pass to proc. */
X    int flags;            /* What events the trace procedure is
X                 * interested in:  OR-ed combination of
X                 * TCL_TRACE_READS, TCL_TRACE_WRITES, and
X                 * TCL_TRACE_UNSETS. */
X    struct VarTrace *nextPtr;    /* Next in list of traces associated with
X                 * a particular variable. */
X} VarTrace;
X
X/*
X * When a variable trace is active (i.e. its associated procedure is
X * executing), one of the following structures is linked into a list
X * associated with the variable's interpreter.  The information in
X * the structure is needed in order for Tcl to behave reasonably
X * if traces are deleted while traces are active.
X */
X
Xtypedef struct ActiveVarTrace {
X    struct ActiveVarTrace *nextPtr;
X                /* Next in list of all active variable
X                 * traces for the interpreter, or NULL
X                 * if no more. */
X    VarTrace *nextTracePtr;    /* Next trace to check after current
X                 * trace procedure returns;  if this
X                 * trace gets deleted, must update pointer
X                 * to avoid using free'd memory. */
X} ActiveVarTrace;
X
X/*
X * The following structure describes an enumerative search in progress on
X * an array variable;  this are invoked with options to the "array"
X * command.
X */
X
Xtypedef struct ArraySearch {
X    int id;            /* Integer id used to distinguish among
X                 * multiple concurrent searches for the
X                 * same array. */
X    struct Var *varPtr;        /* Pointer to array variable that's being
X                 * searched. */
X    Tcl_HashSearch search;    /* Info kept by the hash module about
X                 * progress through the array. */
X    Tcl_HashEntry *nextEntry;    /* Non-null means this is the next element
X                 * to be enumerated (it's leftover from
X                 * the Tcl_FirstHashEntry call or from
X                 * an "array anymore" command).  NULL
X                 * means must call Tcl_NextHashEntry
X                 * to get value to return. */
X    struct ArraySearch *nextPtr;/* Next in list of all active searches
X                 * for this variable, or NULL if this is
X                 * the last one. */
X} ArraySearch;
X
X/*
X * The structure below defines a variable, which associates a string name
X * with a string value.  Pointers to these structures are kept as the
X * values of hash table entries, and the name of each variable is stored
X * in the hash entry.
X */
X
Xtypedef struct Var {
X    int valueLength;        /* Holds the number of non-null bytes
X                 * actually occupied by the variable's
X                 * current value in value.string (extra
X                 * space is sometimes left for expansion).
X                 * For array and global variables this is
X                 * meaningless. */
X    int valueSpace;        /* Total number of bytes of space allocated
X                 * at value. */
X    int upvarUses;        /* Counts number of times variable is
X                 * is referenced via global or upvar variables
X                 * (i.e. how many variables have "upvarPtr"
X                 * pointing to this variable).  Variable
X                 * can't be deleted until this count reaches
X                 * 0. */
X    VarTrace *tracePtr;        /* First in list of all traces set for this
X                 * variable. */
X    ArraySearch *searchPtr;    /* First in list of all searches active
X                 * for this variable, or NULL if none. */
X    int flags;            /* Miscellaneous bits of information about
X                 * variable.  See below for definitions. */
X    union {
X    char string[4];        /* String value of variable.  The actual
X                 * length of this field is given by the
X                 * valueSpace field above. */
X    Tcl_HashTable *tablePtr;/* For array variables, this points to
X                 * information about the hash table used
X                 * to implement the associative array.
X                 * Points to malloc-ed data. */
X    Tcl_HashEntry *upvarPtr;
X                /* If this is a global variable being
X                 * referred to in a procedure, or a variable
X                 * created by "upvar", this field points to
X                 * the hash table entry for the higher-level
X                 * variable. */
X    } value;            /* MUST BE LAST FIELD IN STRUCTURE!!! */
X} Var;
X
X/*
X * Flag bits for variables:
X *
X * VAR_ARRAY    -        1 means this is an array variable rather
X *                than a scalar variable.
X * VAR_UPVAR -             1 means this variable just contains a
X *                pointer to another variable that has the
X *                real value.  Variables like this come
X *                about through the "upvar" and "global"
X *                commands.
X * VAR_UNDEFINED -        1 means that the variable is currently
X *                undefined.  Undefined variables usually
X *                go away completely, but if an undefined
X *                variable has a trace on it, or if it is
X *                a global variable being used by a procedure,
X *                then it stays around even when undefined.
X * VAR_ELEMENT_ACTIVE -        Used only in array variables;  1 means that
X *                an element of the array is currently being
X *                manipulated in some way, so that it isn't
X *                safe to delete the whole array.
X * VAR_TRACE_ACTIVE -        1 means that trace processing is currently
X *                underway for a read or write access, so
X *                new read or write accesses should not cause
X *                trace procedures to be called and the
X *                variable can't be deleted.
X */
X
X#define VAR_ARRAY        1
X#define VAR_UPVAR        2
X#define VAR_UNDEFINED        4
X#define VAR_ELEMENT_ACTIVE    0x10
X#define VAR_TRACE_ACTIVE    0x20
X#define VAR_SEARCHES_POSSIBLE    0x40
X
X/*
X *----------------------------------------------------------------
X * Data structures related to procedures.   These are used primarily
X * in tclProc.c
X *----------------------------------------------------------------
X */
X
X/*
X * The structure below defines an argument to a procedure, which
X * consists of a name and an (optional) default value.
X */
X
Xtypedef struct Arg {
X    struct Arg *nextPtr;    /* Next argument for this procedure,
X                 * or NULL if this is the last argument. */
X    char *defValue;        /* Pointer to arg's default value, or NULL
X                 * if no default value. */
X    char name[4];        /* Name of argument starts here.  The name
X                 * is followed by space for the default,
X                 * if there is one.  The actual size of this
X                 * field will be as large as necessary to
X                 * hold both name and default value.  THIS
X                 * MUST BE THE LAST FIELD IN THE STRUCTURE!! */
X} Arg;
X
X/*
X * The structure below defines a command procedure, which consists of
X * a collection of Tcl commands plus information about arguments and
X * variables.
X */
X
Xtypedef struct Proc {
X    struct Interp *iPtr;    /* Interpreter for which this command
X                 * is defined. */
X    char *command;        /* Command that constitutes the body of
X                 * the procedure (dynamically allocated). */
X    Arg *argPtr;        /* Pointer to first of procedure's formal
X                 * arguments, or NULL if none. */
X} Proc;
X
X/*
X * The structure below defines a command trace.  This is used to allow Tcl
X * clients to find out whenever a command is about to be executed.
X */
X
Xtypedef struct Trace {
X    int level;            /* Only trace commands at nesting level
X                 * less than or equal to this. */
X    Tcl_CmdTraceProc *proc;    /* Procedure to call to trace command. */
X    ClientData clientData;    /* Arbitrary value to pass to proc. */
X    struct Trace *nextPtr;    /* Next in list of traces for this interp. */
X} Trace;
X
X/*
X * The structure below defines a frame, which is a procedure invocation.
X * These structures exist only while procedures are being executed, and
X * provide a sort of call stack.
X */
X
Xtypedef struct CallFrame {
X    Tcl_HashTable varTable;    /* Hash table containing all of procedure's
X                 * local variables. */
X    int level;            /* Level of this procedure, for "uplevel"
X                 * purposes (i.e. corresponds to nesting of
X                 * callerVarPtr's, not callerPtr's).  1 means
X                 * outer-most procedure, 0 means top-level. */
X    int argc;            /* This and argv below describe name and
X                 * arguments for this procedure invocation. */
X    char **argv;        /* Array of arguments. */
X    struct CallFrame *callerPtr;
X                /* Frame of procedure that invoked this one
X                 * (NULL if level == 1). */
X    struct CallFrame *callerVarPtr;
X                /* Frame used by caller for accessing local
X                 * variables (same as callerPtr unless an
X                 * "uplevel" command was active in the
X                 * caller).  This field is used in the
X                 * implementation of "uplevel". */
X} CallFrame;
X
X/*
X * The structure below defines one history event (a previously-executed
X * command that can be re-executed in whole or in part).
X */
X
Xtypedef struct {
X    char *command;        /* String containing previously-executed
X                 * command. */
X    int bytesAvl;        /* Total # of bytes available at *event (not
X                 * all are necessarily in use now). */
X} HistoryEvent;
X
X/*
X *----------------------------------------------------------------
X * Data structures related to history.   These are used primarily
X * in tclHistory.c
X *----------------------------------------------------------------
X */
X
X/*
X * The structure below defines a pending revision to the most recent
X * history event.  Changes are linked together into a list and applied
X * during the next call to Tcl_RecordHistory.  See the comments at the
X * beginning of tclHistory.c for information on revisions.
X */
X
Xtypedef struct HistoryRev {
X    int firstIndex;        /* Index of the first byte to replace in
X                 * current history event. */
X    int lastIndex;        /* Index of last byte to replace in
X                 * current history event. */
X    int newSize;        /* Number of bytes in newBytes. */
X    char *newBytes;        /* Replacement for the range given by
X                 * firstIndex and lastIndex. */
X    struct HistoryRev *nextPtr;    /* Next in chain of revisions to apply, or
X                 * NULL for end of list. */
X} HistoryRev;
X
X/*
X *----------------------------------------------------------------
X * Data structures related to files.  These are used primarily in
X * tclUnixUtil.c and tclUnixAZ.c.
X *----------------------------------------------------------------
X */
X
X/*
X * The data structure below defines an open file (or connection to
X * a process pipeline) as returned by the "open" command.
X */
X
Xtypedef struct OpenFile {
X    FILE *f;            /* Stdio file to use for reading and/or
X                 * writing. */
X    FILE *f2;            /* Normally NULL.  In the special case of
X                 * a command pipeline with pipes for both
X                 * input and output, this is a stdio file
X                 * to use for writing to the pipeline. */
X    int readable;        /* Non-zero means file may be read. */
X    int writable;        /* Non-zero means file may be written. */
X    int numPids;        /* If this is a connection to a process
X                 * pipeline, gives number of processes
X                 * in pidPtr array below;  otherwise it
X                 * is 0. */
X    int *pidPtr;        /* Pointer to malloc-ed array of child
X                 * process ids (numPids of them), or NULL
X                 * if this isn't a connection to a process
X                 * pipeline. */
X    int errorId;        /* File id of file that receives error
X                 * output from pipeline.  -1 means not
X                 * used (i.e. this is a normal file). */
X} OpenFile;
X
X/*
X *----------------------------------------------------------------
X * This structure defines an interpreter, which is a collection of
X * commands plus other state information related to interpreting
X * commands, such as variable storage.  Primary responsibility for
X * this data structure is in tclBasic.c, but almost every Tcl
X * source file uses something in here.
X *----------------------------------------------------------------
X */
X
Xtypedef struct Command {
X    Tcl_CmdProc *proc;        /* Procedure to process command. */
X    ClientData clientData;    /* Arbitrary value to pass to proc. */
X    Tcl_CmdDeleteProc *deleteProc;
X                /* Procedure to invoke when deleting
X                 * command. */
X} Command;
X
X#define CMD_SIZE(nameLength) ((unsigned) sizeof(Command) + nameLength - 3)
X
Xtypedef struct Interp {
X
X    /*
X     * Note:  the first three fields must match exactly the fields in
X     * a Tcl_Interp struct (see tcl.h).  If you change one, be sure to
X     * change the other.
X     */
X
X    char *result;        /* Points to result returned by last
X                 * command. */
X    Tcl_FreeProc *freeProc;    /* Zero means result is statically allocated.
X                 * If non-zero, gives address of procedure
X                 * to invoke to free the result.  Must be
X                 * freed by Tcl_Eval before executing next
X                 * command. */
X    int errorLine;        /* When TCL_ERROR is returned, this gives
X                 * the line number within the command where
X                 * the error occurred (1 means first line). */
X    Tcl_HashTable commandTable;    /* Contains all of the commands currently
X                 * registered in this interpreter.  Indexed
X                 * by strings; values have type (Command *). */
X
X    /*
X     * Information related to procedures and variables.  See tclProc.c
X     * and tclvar.c for usage.
X     */
X
X    Tcl_HashTable globalTable;    /* Contains all global variables for
X                 * interpreter. */
X    int numLevels;        /* Keeps track of how many nested calls to
X                 * Tcl_Eval are in progress for this
X                 * interpreter.  It's used to delay deletion
X                 * of the table until all Tcl_Eval invocations
X                 * are completed. */
X    CallFrame *framePtr;    /* If a procedure is being executed, this
X                 * points to the call frame for the current
X                 * procedure (most recently-called).  NULL
X                 * means no procedure is active. */
X    CallFrame *varFramePtr;    /* Points to the call frame whose variables
X                 * are currently in use (same as framePtr
X                 * unless an "uplevel" command is being
X                 * executed).  NULL means no procedure is
X                 * active or "uplevel 0" is being exec'ed. */
X    ActiveVarTrace *activeTracePtr;
X                /* First in list of active traces for interp,
X                 * or NULL if no active traces. */
X
X    /*
X     * Information related to history:
X     */
X
X    int numEvents;        /* Number of previously-executed commands
X                 * to retain. */
X    HistoryEvent *events;    /* Array containing numEvents entries
X                 * (dynamically allocated). */
X    int curEvent;        /* Index into events of place where current
X                 * (or most recent) command is recorded. */
X    int curEventNum;        /* Event number associated with the slot
X                 * given by curEvent. */
X    HistoryRev *revPtr;        /* First in list of pending revisions. */
X    char *historyFirst;        /* First char. of current command executed
X                 * from history module or NULL if none. */
X    int revDisables;        /* 0 means history revision OK;  > 0 gives
X                 * a count of number of times revision has
X                 * been disabled. */
X    char *evalFirst;        /* If TCL_RECORD_BOUNDS flag set, Tcl_Eval
X                 * sets this field to point to the first
X                 * char. of text from which the current
X                 * command came.  Otherwise Tcl_Eval sets
X                 * this to NULL. */
X    char *evalLast;        /* Similar to evalFirst, except points to
X                 * last character of current command. */
X
X    /*
X     * Information used by Tcl_AppendResult to keep track of partial
X     * results.  See Tcl_AppendResult code for details.
X     */
X
X    char *appendResult;        /* Storage space for results generated
X                 * by Tcl_AppendResult.  Malloc-ed.  NULL
X                 * means not yet allocated. */
X    int appendAvl;        /* Total amount of space available at
X                 * partialResult. */
X    int appendUsed;        /* Number of non-null bytes currently
X                 * stored at partialResult. */
X
X    /*
X     * Information related to files.  See tclUnixAZ.c and tclUnixUtil.c
X     * for details.
X     */
X
X    int numFiles;        /* Number of entries in filePtrArray
X                 * below.  0 means array hasn't been
X                 * created yet. */
X    OpenFile **filePtrArray;    /* Pointer to malloc-ed array of pointers
X                 * to information about open files.  Entry
X                 * N corresponds to the file with fileno N.
X                 * If an entry is NULL then the corresponding
X                 * file isn't open.  If filePtrArray is NULL
X                 * it means no files have been used, so even
X                 * stdin/stdout/stderr entries haven't been
X                 * setup yet. */
X    /*
X     * A cache of compiled regular expressions.  See TclCompileRegexp
X     * in tclUtil.c for details.
X     */
X
X#define NUM_REGEXPS 5
X    char *patterns[NUM_REGEXPS];/* Strings corresponding to compiled
X                 * regular expression patterns.  NULL
X                 * means that this slot isn't used.
X                 * Malloc-ed. */
X    int patLengths[NUM_REGEXPS];/* Number of non-null characters in
X                 * corresponding entry in patterns. */
X    regexp *regexps[NUM_REGEXPS];
X                /* Compiled forms of above strings.  Also
X                 * malloc-ed, or NULL if not in use yet. */
X
X
X    /*
X     * Miscellaneous information:
X     */
X
X    int cmdCount;        /* Total number of times a command procedure
X                 * has been called for this interpreter. */
X    int noEval;            /* Non-zero means no commands should actually
X                 * be executed:  just parse only.  Used in
X                 * expressions when the result is already
X                 * determined. */
X    char *scriptFile;        /* NULL means there is no nested source
X                 * command active;  otherwise this points to
X                 * the name of the file being sourced (it's
X                 * not malloc-ed:  it points to an argument
X                 * to Tcl_EvalFile. */
X    int flags;            /* Various flag bits.  See below. */
X    Trace *tracePtr;        /* List of traces for this interpreter. */
X    char resultSpace[TCL_RESULT_SIZE+1];
X                /* Static space for storing small results. */
X} Interp;
X
X/*
X * Flag bits for Interp structures:
X *
X * DELETED:        Non-zero means the interpreter has been deleted:
X *            don't process any more commands for it, and destroy
X *            the structure as soon as all nested invocations of
X *            Tcl_Eval are done.
X * ERR_IN_PROGRESS:    Non-zero means an error unwind is already in progress.
X *            Zero means a command proc has been invoked since last
X *            error occured.
X * ERR_ALREADY_LOGGED:    Non-zero means information has already been logged
X *            in $errorInfo for the current Tcl_Eval instance,
X *            so Tcl_Eval needn't log it (used to implement the
X *            "error message log" command).
X * ERROR_CODE_SET:    Non-zero means that Tcl_SetErrorCode has been
X *            called to record information for the current
X *            error.  Zero means Tcl_Eval must clear the
X *            errorCode variable if an error is returned.
X */
X
X#define DELETED            1
X#define ERR_IN_PROGRESS        2
X#define ERR_ALREADY_LOGGED    4
X#define ERROR_CODE_SET        8
X
X/*
X *----------------------------------------------------------------
X * Data structures related to command parsing.   These are used in
X * tclParse.c and its clients.
X *----------------------------------------------------------------
X */
X
X/*
X * The following data structure is used by various parsing procedures
X * to hold information about where to store the results of parsing
X * (e.g. the substituted contents of a quoted argument, or the result
X * of a nested command).  At any given time, the space available
X * for output is fixed, but a procedure may be called to expand the
X * space available if the current space runs out.
X */
X
Xtypedef struct ParseValue {
X    char *buffer;        /* Address of first character in
X                 * output buffer. */
X    char *next;            /* Place to store next character in
X                 * output buffer. */
X    char *end;            /* Address of the last usable character
X                 * in the buffer. */
X    void (*expandProc) _ANSI_ARGS_((struct ParseValue *pvPtr, int needed));
X                /* Procedure to call when space runs out;
X                 * it will make more space. */
X    ClientData clientData;    /* Arbitrary information for use of
X                 * expandProc. */
X} ParseValue;
X
X/*
X * A table used to classify input characters to assist in parsing
X * Tcl commands.  The table should be indexed with a signed character
X * using the CHAR_TYPE macro.  The character may have a negative
X * value.
X */
X
Xextern char tclTypeTable[];
X#define CHAR_TYPE(c) (tclTypeTable+128)[c]
X
X/*
X * Possible values returned by CHAR_TYPE:
X *
X * TCL_NORMAL -        All characters that don't have special significance
X *            to the Tcl language.
X * TCL_SPACE -        Character is space, tab, or return.
X * TCL_COMMAND_END -    Character is newline or null or semicolon or
X *            close-bracket.
X * TCL_QUOTE -        Character is a double-quote.
X * TCL_OPEN_BRACKET -    Character is a "[".
X * TCL_OPEN_BRACE -    Character is a "{".
X * TCL_CLOSE_BRACE -    Character is a "}".
X * TCL_BACKSLASH -    Character is a "\".
X * TCL_DOLLAR -        Character is a "$".
X */
X
X#define TCL_NORMAL        0
X#define TCL_SPACE        1
X#define TCL_COMMAND_END        2
X#define TCL_QUOTE        3
X#define TCL_OPEN_BRACKET    4
X#define TCL_OPEN_BRACE        5
X#define TCL_CLOSE_BRACE        6
X#define TCL_BACKSLASH        7
X#define TCL_DOLLAR        8
X
X/*
X * Additional flags passed to Tcl_Eval.  See tcl.h for other flags to
X * Tcl_Eval;  these ones are only used internally by Tcl.
X *
X * TCL_RECORD_BOUNDS    Tells Tcl_Eval to record information in the
X *            evalFirst and evalLast fields for each command
X *            executed directly from the string (top-level
X *            commands and those from command substitution).
X */
X
X#define TCL_RECORD_BOUNDS    0x100
X
X/*
X * Maximum number of levels of nesting permitted in Tcl commands.
X */
X
X#define MAX_NESTING_DEPTH    100
X
X/*
X * Macro to use instead of "void" for arguments that must have
X * type "void *" in ANSI C;  maps them to type "char *" in
X * non-ANSI systems.
X */
X
X#define VOID char
X
X/*
X * Variables shared among Tcl modules but not used by the outside
X * world:
X */
X
Xextern char *        tclRegexpError;
X
X/*
X *----------------------------------------------------------------
X * Procedures shared among Tcl modules but not used by the outside
X * world:
X *----------------------------------------------------------------
X */
X
Xextern void        panic();
Xextern regexp *        TclCompileRegexp _ANSI_ARGS_((Tcl_Interp *interp,
X                char *string));
Xextern void        TclCopyAndCollapse _ANSI_ARGS_((int count, char *src,
X                char *dst));
Xextern void        TclDeleteVars _ANSI_ARGS_((Interp *iPtr,
X                Tcl_HashTable *tablePtr));
Xextern void        TclExpandParseValue _ANSI_ARGS_((ParseValue *pvPtr,
X                int needed));
Xextern int        TclFindElement _ANSI_ARGS_((Tcl_Interp *interp,
X                char *list, char **elementPtr, char **nextPtr,
X                int *sizePtr, int *bracePtr));
Xextern Proc *        TclFindProc _ANSI_ARGS_((Interp *iPtr,
X                char *procName));
Xextern int        TclGetFrame _ANSI_ARGS_((Tcl_Interp *interp,
X                char *string, CallFrame **framePtrPtr));
Xextern int        TclGetListIndex _ANSI_ARGS_((Tcl_Interp *interp,
X                char *string, int *indexPtr));
Xextern int        TclGetOpenFile _ANSI_ARGS_((Tcl_Interp *interp,
X                char *string, OpenFile **filePtrPtr));
Xextern Proc *        TclIsProc _ANSI_ARGS_((Command *cmdPtr));
Xextern void        TclMakeFileTable _ANSI_ARGS_((Interp *iPtr,
X                int index));
Xextern int        TclParseBraces _ANSI_ARGS_((Tcl_Interp *interp,
X                char *string, char **termPtr, ParseValue *pvPtr));
Xextern int        TclParseNestedCmd _ANSI_ARGS_((Tcl_Interp *interp,
X                char *string, int flags, char **termPtr,
X                ParseValue *pvPtr));
Xextern int        TclParseQuotes _ANSI_ARGS_((Tcl_Interp *interp,
X                char *string, int termChar, int flags,
X                char **termPtr, ParseValue *pvPtr));
Xextern int        TclParseWords _ANSI_ARGS_((Tcl_Interp *interp,
X                char *string, int flags, int maxWords,
X                char **termPtr, int *argcPtr, char **argv,
X                ParseValue *pvPtr));
Xextern void        TclSetupEnv _ANSI_ARGS_((Tcl_Interp *interp));
Xextern char *        TclWordEnd _ANSI_ARGS_((char *start, int nested));
X
X/*
X *----------------------------------------------------------------
X * Command procedures in the generic core:
X *----------------------------------------------------------------
X */
X
Xextern int    Tcl_AppendCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ArrayCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_BreakCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_CaseCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_CatchCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ConcatCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ContinueCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ErrorCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_EvalCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ExprCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ForCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ForeachCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_FormatCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_GlobalCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_HistoryCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_IfCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_IncrCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_InfoCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_JoinCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_LappendCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_LindexCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_LinsertCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_LlengthCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ListCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_LrangeCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_LreplaceCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_LsearchCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_LsortCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ProcCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_RegexpCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_RegsubCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_RenameCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ReturnCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ScanCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_SetCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_SplitCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_StringCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_TraceCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_UnsetCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_UplevelCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_UpvarCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_WhileCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_Cmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_Cmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
X
X/*
X *----------------------------------------------------------------
X * Command procedures in the UNIX core:
X *----------------------------------------------------------------
X */
X
Xextern int    Tcl_CdCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_CloseCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_EofCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ExecCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ExitCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_FileCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_FlushCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_GetsCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_GlobCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_OpenCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_PutsCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_PwdCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_ReadCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_SeekCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_SourceCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_TellCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
Xextern int    Tcl_TimeCmd _ANSI_ARGS_((ClientData clientData,
X            Tcl_Interp *interp, int argc, char **argv));
X
X#endif /* _TCLINT */
END_OF_FILE
if test 31734 -ne `wc -c <'tcl6.1/tclInt.h'`; then
    echo shar: \"'tcl6.1/tclInt.h'\" unpacked with wrong size!
fi
# end of 'tcl6.1/tclInt.h'
fi
echo shar: End of archive 23 \(of 33\).
cp /dev/null ark23isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 33 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0

exit 0 # Just in case...
--
Kent Landfield                   INTERNET: [e-mail]
Sterling Software, IMD           UUCP:     uunet!sparky!kent
Phone:    [phone]         FAX:      [phone]
Please send comp.sources.misc-related mail to [e-mail].