![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tclint.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / tcl|
Return to tclint.h CVS log | Up to [Micropolis - Activity] / micropolis / src / tcl |
1.1 root 1: /*
2: * tclInt.h --
3: *
4: * Declarations of things used internally by the Tcl interpreter.
5: *
6: * Copyright 1987-1991 Regents of the University of California
7: * Permission to use, copy, modify, and distribute this
8: * software and its documentation for any purpose and without
9: * fee is hereby granted, provided that the above copyright
10: * notice appear in all copies. The University of California
11: * makes no representations about the suitability of this
12: * software for any purpose. It is provided "as is" without
13: * express or implied warranty.
14: *
15: * $Header: /user6/ouster/tcl/RCS/tclInt.h,v 1.69 92/06/21 14:09:23 ouster Exp $ SPRITE (Berkeley)
16: */
17:
18: #ifndef _TCLINT
19: #define _TCLINT
20:
21: /*
22: * Common include files needed by most of the Tcl source files are
23: * included here, so that system-dependent personalizations for the
24: * include files only have to be made in once place. This results
25: * in a few extra includes, but greater modularity. The order of
26: * the three groups of #includes is important. For example, stdio.h
27: * is needed by tcl.h, and the _ANSI_ARGS_ declaration in tcl.h is
28: * needed by stdlib.h in some configurations.
29: */
30:
31: #include <stdio.h>
32: #include <unistd.h>
33:
34: #ifndef _TCL
35: #include "tcl.h"
36: #endif
37: #ifndef _TCLHASH
38: #include "tclhash.h"
39: #endif
40: #ifndef _REGEXP
41: #include "regexp.h"
42: #endif
43:
44: /*
45: * Macro to use instead of "void" for arguments that must have
46: * type "void *" in ANSI C; maps them to type "char *" in
47: * non-ANSI systems. This macro may be used in some of the include
48: * files below, which is why it is defined here.
49: */
50:
51: #ifndef VOID
52: # ifdef __STDC__
53: # define VOID void
54: # else
55: # define VOID char
56: # endif
57: #endif
58:
59: #include <ctype.h>
60: #include <stdlib.h>
61: #include <string.h>
62: //#include <varargs.h>
63: #include <stdarg.h>
64:
65: /*
66: * At present (12/91) not all stdlib.h implementations declare strtod.
67: * The declaration below is here to ensure that it's declared, so that
68: * the compiler won't take the default approach of assuming it returns
69: * an int. There's no ANSI prototype for it because there would end
70: * up being too many conflicts with slightly-different prototypes.
71: */
72:
73: extern double strtod();
74:
75: /*
76: *----------------------------------------------------------------
77: * Data structures related to variables. These are used primarily
78: * in tclVar.c
79: *----------------------------------------------------------------
80: */
81:
82: /*
83: * The following structure defines a variable trace, which is used to
84: * invoke a specific C procedure whenever certain operations are performed
85: * on a variable.
86: */
87:
88: typedef struct VarTrace {
89: Tcl_VarTraceProc *traceProc;/* Procedure to call when operations given
90: * by flags are performed on variable. */
91: ClientData clientData; /* Argument to pass to proc. */
92: int flags; /* What events the trace procedure is
93: * interested in: OR-ed combination of
94: * TCL_TRACE_READS, TCL_TRACE_WRITES, and
95: * TCL_TRACE_UNSETS. */
96: struct VarTrace *nextPtr; /* Next in list of traces associated with
97: * a particular variable. */
98: } VarTrace;
99:
100: /*
101: * When a variable trace is active (i.e. its associated procedure is
102: * executing), one of the following structures is linked into a list
103: * associated with the variable's interpreter. The information in
104: * the structure is needed in order for Tcl to behave reasonably
105: * if traces are deleted while traces are active.
106: */
107:
108: typedef struct ActiveVarTrace {
109: struct ActiveVarTrace *nextPtr;
110: /* Next in list of all active variable
111: * traces for the interpreter, or NULL
112: * if no more. */
113: VarTrace *nextTracePtr; /* Next trace to check after current
114: * trace procedure returns; if this
115: * trace gets deleted, must update pointer
116: * to avoid using free'd memory. */
117: } ActiveVarTrace;
118:
119: /*
120: * The following structure describes an enumerative search in progress on
121: * an array variable; this are invoked with options to the "array"
122: * command.
123: */
124:
125: typedef struct ArraySearch {
126: int id; /* Integer id used to distinguish among
127: * multiple concurrent searches for the
128: * same array. */
129: struct Var *varPtr; /* Pointer to array variable that's being
130: * searched. */
131: Tcl_HashSearch search; /* Info kept by the hash module about
132: * progress through the array. */
133: Tcl_HashEntry *nextEntry; /* Non-null means this is the next element
134: * to be enumerated (it's leftover from
135: * the Tcl_FirstHashEntry call or from
136: * an "array anymore" command). NULL
137: * means must call Tcl_NextHashEntry
138: * to get value to return. */
139: struct ArraySearch *nextPtr;/* Next in list of all active searches
140: * for this variable, or NULL if this is
141: * the last one. */
142: } ArraySearch;
143:
144: /*
145: * The structure below defines a variable, which associates a string name
146: * with a string value. Pointers to these structures are kept as the
147: * values of hash table entries, and the name of each variable is stored
148: * in the hash entry.
149: */
150:
151: typedef struct Var {
152: int valueLength; /* Holds the number of non-null bytes
153: * actually occupied by the variable's
154: * current value in value.string (extra
155: * space is sometimes left for expansion).
156: * For array and global variables this is
157: * meaningless. */
158: int valueSpace; /* Total number of bytes of space allocated
159: * at value. */
160: int upvarUses; /* Counts number of times variable is
161: * is referenced via global or upvar variables
162: * (i.e. how many variables have "upvarPtr"
163: * pointing to this variable). Variable
164: * can't be deleted until this count reaches
165: * 0. */
166: VarTrace *tracePtr; /* First in list of all traces set for this
167: * variable. */
168: ArraySearch *searchPtr; /* First in list of all searches active
169: * for this variable, or NULL if none. */
170: int flags; /* Miscellaneous bits of information about
171: * variable. See below for definitions. */
172: union {
173: char string[4]; /* String value of variable. The actual
174: * length of this field is given by the
175: * valueSpace field above. */
176: Tcl_HashTable *tablePtr;/* For array variables, this points to
177: * information about the hash table used
178: * to implement the associative array.
179: * Points to malloc-ed data. */
180: Tcl_HashEntry *upvarPtr;
181: /* If this is a global variable being
182: * referred to in a procedure, or a variable
183: * created by "upvar", this field points to
184: * the hash table entry for the higher-level
185: * variable. */
186: } value; /* MUST BE LAST FIELD IN STRUCTURE!!! */
187: } Var;
188:
189: /*
190: * Flag bits for variables:
191: *
192: * VAR_ARRAY - 1 means this is an array variable rather
193: * than a scalar variable.
194: * VAR_UPVAR - 1 means this variable just contains a
195: * pointer to another variable that has the
196: * real value. Variables like this come
197: * about through the "upvar" and "global"
198: * commands.
199: * VAR_UNDEFINED - 1 means that the variable is currently
200: * undefined. Undefined variables usually
201: * go away completely, but if an undefined
202: * variable has a trace on it, or if it is
203: * a global variable being used by a procedure,
204: * then it stays around even when undefined.
205: * VAR_ELEMENT_ACTIVE - Used only in array variables; 1 means that
206: * an element of the array is currently being
207: * manipulated in some way, so that it isn't
208: * safe to delete the whole array.
209: * VAR_TRACE_ACTIVE - 1 means that trace processing is currently
210: * underway for a read or write access, so
211: * new read or write accesses should not cause
212: * trace procedures to be called and the
213: * variable can't be deleted.
214: */
215:
216: #define VAR_ARRAY 1
217: #define VAR_UPVAR 2
218: #define VAR_UNDEFINED 4
219: #define VAR_ELEMENT_ACTIVE 0x10
220: #define VAR_TRACE_ACTIVE 0x20
221: #define VAR_SEARCHES_POSSIBLE 0x40
222:
223: /*
224: *----------------------------------------------------------------
225: * Data structures related to procedures. These are used primarily
226: * in tclProc.c
227: *----------------------------------------------------------------
228: */
229:
230: /*
231: * The structure below defines an argument to a procedure, which
232: * consists of a name and an (optional) default value.
233: */
234:
235: typedef struct Arg {
236: struct Arg *nextPtr; /* Next argument for this procedure,
237: * or NULL if this is the last argument. */
238: char *defValue; /* Pointer to arg's default value, or NULL
239: * if no default value. */
240: char name[4]; /* Name of argument starts here. The name
241: * is followed by space for the default,
242: * if there is one. The actual size of this
243: * field will be as large as necessary to
244: * hold both name and default value. THIS
245: * MUST BE THE LAST FIELD IN THE STRUCTURE!! */
246: } Arg;
247:
248: /*
249: * The structure below defines a command procedure, which consists of
250: * a collection of Tcl commands plus information about arguments and
251: * variables.
252: */
253:
254: typedef struct Proc {
255: struct Interp *iPtr; /* Interpreter for which this command
256: * is defined. */
257: char *command; /* Command that constitutes the body of
258: * the procedure (dynamically allocated). */
259: Arg *argPtr; /* Pointer to first of procedure's formal
260: * arguments, or NULL if none. */
261: } Proc;
262:
263: /*
264: * The structure below defines a command trace. This is used to allow Tcl
265: * clients to find out whenever a command is about to be executed.
266: */
267:
268: typedef struct Trace {
269: int level; /* Only trace commands at nesting level
270: * less than or equal to this. */
271: Tcl_CmdTraceProc *proc; /* Procedure to call to trace command. */
272: ClientData clientData; /* Arbitrary value to pass to proc. */
273: struct Trace *nextPtr; /* Next in list of traces for this interp. */
274: } Trace;
275:
276: /*
277: * The structure below defines a frame, which is a procedure invocation.
278: * These structures exist only while procedures are being executed, and
279: * provide a sort of call stack.
280: */
281:
282: typedef struct CallFrame {
283: Tcl_HashTable varTable; /* Hash table containing all of procedure's
284: * local variables. */
285: int level; /* Level of this procedure, for "uplevel"
286: * purposes (i.e. corresponds to nesting of
287: * callerVarPtr's, not callerPtr's). 1 means
288: * outer-most procedure, 0 means top-level. */
289: int argc; /* This and argv below describe name and
290: * arguments for this procedure invocation. */
291: char **argv; /* Array of arguments. */
292: struct CallFrame *callerPtr;
293: /* Value of interp->framePtr when this
294: * procedure was invoked (i.e. next in
295: * stack of all active procedures). */
296: struct CallFrame *callerVarPtr;
297: /* Value of interp->varFramePtr when this
298: * procedure was invoked (i.e. determines
299: * variable scoping within caller; same
300: * as callerPtr unless an "uplevel" command
301: * or something equivalent was active in
302: * the caller). */
303: } CallFrame;
304:
305: /*
306: * The structure below defines one history event (a previously-executed
307: * command that can be re-executed in whole or in part).
308: */
309:
310: typedef struct {
311: char *command; /* String containing previously-executed
312: * command. */
313: int bytesAvl; /* Total # of bytes available at *event (not
314: * all are necessarily in use now). */
315: } HistoryEvent;
316:
317: /*
318: *----------------------------------------------------------------
319: * Data structures related to history. These are used primarily
320: * in tclHistory.c
321: *----------------------------------------------------------------
322: */
323:
324: /*
325: * The structure below defines a pending revision to the most recent
326: * history event. Changes are linked together into a list and applied
327: * during the next call to Tcl_RecordHistory. See the comments at the
328: * beginning of tclHistory.c for information on revisions.
329: */
330:
331: typedef struct HistoryRev {
332: int firstIndex; /* Index of the first byte to replace in
333: * current history event. */
334: int lastIndex; /* Index of last byte to replace in
335: * current history event. */
336: int newSize; /* Number of bytes in newBytes. */
337: char *newBytes; /* Replacement for the range given by
338: * firstIndex and lastIndex. */
339: struct HistoryRev *nextPtr; /* Next in chain of revisions to apply, or
340: * NULL for end of list. */
341: } HistoryRev;
342:
343: /*
344: *----------------------------------------------------------------
345: * Data structures related to files. These are used primarily in
346: * tclUnixUtil.c and tclUnixAZ.c.
347: *----------------------------------------------------------------
348: */
349:
350: /*
351: * The data structure below defines an open file (or connection to
352: * a process pipeline) as returned by the "open" command.
353: */
354:
355: typedef struct OpenFile {
356: FILE *f; /* Stdio file to use for reading and/or
357: * writing. */
358: FILE *f2; /* Normally NULL. In the special case of
359: * a command pipeline with pipes for both
360: * input and output, this is a stdio file
361: * to use for writing to the pipeline. */
362: int readable; /* Non-zero means file may be read. */
363: int writable; /* Non-zero means file may be written. */
364: int numPids; /* If this is a connection to a process
365: * pipeline, gives number of processes
366: * in pidPtr array below; otherwise it
367: * is 0. */
368: int *pidPtr; /* Pointer to malloc-ed array of child
369: * process ids (numPids of them), or NULL
370: * if this isn't a connection to a process
371: * pipeline. */
372: int errorId; /* File id of file that receives error
373: * output from pipeline. -1 means not
374: * used (i.e. this is a normal file). */
375: } OpenFile;
376:
377: /*
378: *----------------------------------------------------------------
379: * This structure defines an interpreter, which is a collection of
380: * commands plus other state information related to interpreting
381: * commands, such as variable storage. Primary responsibility for
382: * this data structure is in tclBasic.c, but almost every Tcl
383: * source file uses something in here.
384: *----------------------------------------------------------------
385: */
386:
387: typedef struct Command {
388: Tcl_CmdProc *proc; /* Procedure to process command. */
389: ClientData clientData; /* Arbitrary value to pass to proc. */
390: Tcl_CmdDeleteProc *deleteProc;
391: /* Procedure to invoke when deleting
392: * command. */
393: } Command;
394:
395: #define CMD_SIZE(nameLength) ((unsigned) sizeof(Command) + nameLength - 3)
396:
397: typedef struct Interp {
398:
399: /*
400: * Note: the first three fields must match exactly the fields in
401: * a Tcl_Interp struct (see tcl.h). If you change one, be sure to
402: * change the other.
403: */
404:
405: char *result; /* Points to result returned by last
406: * command. */
407: Tcl_FreeProc *freeProc; /* Zero means result is statically allocated.
408: * If non-zero, gives address of procedure
409: * to invoke to free the result. Must be
410: * freed by Tcl_Eval before executing next
411: * command. */
412: int errorLine; /* When TCL_ERROR is returned, this gives
413: * the line number within the command where
414: * the error occurred (1 means first line). */
415: Tcl_HashTable commandTable; /* Contains all of the commands currently
416: * registered in this interpreter. Indexed
417: * by strings; values have type (Command *). */
418:
419: /*
420: * Information related to procedures and variables. See tclProc.c
421: * and tclvar.c for usage.
422: */
423:
424: Tcl_HashTable globalTable; /* Contains all global variables for
425: * interpreter. */
426: int numLevels; /* Keeps track of how many nested calls to
427: * Tcl_Eval are in progress for this
428: * interpreter. It's used to delay deletion
429: * of the table until all Tcl_Eval invocations
430: * are completed. */
431: CallFrame *framePtr; /* Points to top-most in stack of all nested
432: * procedure invocations. NULL means there
433: * are no active procedures. */
434: CallFrame *varFramePtr; /* Points to the call frame whose variables
435: * are currently in use (same as framePtr
436: * unless an "uplevel" command is being
437: * executed). NULL means no procedure is
438: * active or "uplevel 0" is being exec'ed. */
439: ActiveVarTrace *activeTracePtr;
440: /* First in list of active traces for interp,
441: * or NULL if no active traces. */
442:
443: /*
444: * Information related to history:
445: */
446:
447: int numEvents; /* Number of previously-executed commands
448: * to retain. */
449: HistoryEvent *events; /* Array containing numEvents entries
450: * (dynamically allocated). */
451: int curEvent; /* Index into events of place where current
452: * (or most recent) command is recorded. */
453: int curEventNum; /* Event number associated with the slot
454: * given by curEvent. */
455: HistoryRev *revPtr; /* First in list of pending revisions. */
456: char *historyFirst; /* First char. of current command executed
457: * from history module or NULL if none. */
458: int revDisables; /* 0 means history revision OK; > 0 gives
459: * a count of number of times revision has
460: * been disabled. */
461: char *evalFirst; /* If TCL_RECORD_BOUNDS flag set, Tcl_Eval
462: * sets this field to point to the first
463: * char. of text from which the current
464: * command came. Otherwise Tcl_Eval sets
465: * this to NULL. */
466: char *evalLast; /* Similar to evalFirst, except points to
467: * last character of current command. */
468:
469: /*
470: * Information used by Tcl_AppendResult to keep track of partial
471: * results. See Tcl_AppendResult code for details.
472: */
473:
474: char *appendResult; /* Storage space for results generated
475: * by Tcl_AppendResult. Malloc-ed. NULL
476: * means not yet allocated. */
477: int appendAvl; /* Total amount of space available at
478: * partialResult. */
479: int appendUsed; /* Number of non-null bytes currently
480: * stored at partialResult. */
481:
482: /*
483: * Information related to files. See tclUnixAZ.c and tclUnixUtil.c
484: * for details.
485: */
486:
487: int numFiles; /* Number of entries in filePtrArray
488: * below. 0 means array hasn't been
489: * created yet. */
490: OpenFile **filePtrArray; /* Pointer to malloc-ed array of pointers
491: * to information about open files. Entry
492: * N corresponds to the file with fileno N.
493: * If an entry is NULL then the corresponding
494: * file isn't open. If filePtrArray is NULL
495: * it means no files have been used, so even
496: * stdin/stdout/stderr entries haven't been
497: * setup yet. */
498: /*
499: * A cache of compiled regular expressions. See TclCompileRegexp
500: * in tclUtil.c for details.
501: */
502:
503: #define NUM_REGEXPS 5
504: char *patterns[NUM_REGEXPS];/* Strings corresponding to compiled
505: * regular expression patterns. NULL
506: * means that this slot isn't used.
507: * Malloc-ed. */
508: int patLengths[NUM_REGEXPS];/* Number of non-null characters in
509: * corresponding entry in patterns.
510: * -1 means entry isn't used. */
511: regexp *regexps[NUM_REGEXPS];
512: /* Compiled forms of above strings. Also
513: * malloc-ed, or NULL if not in use yet. */
514:
515:
516: /*
517: * Miscellaneous information:
518: */
519:
520: int cmdCount; /* Total number of times a command procedure
521: * has been called for this interpreter. */
522: int noEval; /* Non-zero means no commands should actually
523: * be executed: just parse only. Used in
524: * expressions when the result is already
525: * determined. */
526: char *scriptFile; /* NULL means there is no nested source
527: * command active; otherwise this points to
528: * the name of the file being sourced (it's
529: * not malloc-ed: it points to an argument
530: * to Tcl_EvalFile. */
531: int flags; /* Various flag bits. See below. */
532: Trace *tracePtr; /* List of traces for this interpreter. */
533: char resultSpace[TCL_RESULT_SIZE+1];
534: /* Static space for storing small results. */
535: } Interp;
536:
537: /*
538: * Flag bits for Interp structures:
539: *
540: * DELETED: Non-zero means the interpreter has been deleted:
541: * don't process any more commands for it, and destroy
542: * the structure as soon as all nested invocations of
543: * Tcl_Eval are done.
544: * ERR_IN_PROGRESS: Non-zero means an error unwind is already in progress.
545: * Zero means a command proc has been invoked since last
546: * error occured.
547: * ERR_ALREADY_LOGGED: Non-zero means information has already been logged
548: * in $errorInfo for the current Tcl_Eval instance,
549: * so Tcl_Eval needn't log it (used to implement the
550: * "error message log" command).
551: * ERROR_CODE_SET: Non-zero means that Tcl_SetErrorCode has been
552: * called to record information for the current
553: * error. Zero means Tcl_Eval must clear the
554: * errorCode variable if an error is returned.
555: */
556:
557: #define DELETED 1
558: #define ERR_IN_PROGRESS 2
559: #define ERR_ALREADY_LOGGED 4
560: #define ERROR_CODE_SET 8
561:
562: /*
563: *----------------------------------------------------------------
564: * Data structures related to command parsing. These are used in
565: * tclParse.c and its clients.
566: *----------------------------------------------------------------
567: */
568:
569: /*
570: * The following data structure is used by various parsing procedures
571: * to hold information about where to store the results of parsing
572: * (e.g. the substituted contents of a quoted argument, or the result
573: * of a nested command). At any given time, the space available
574: * for output is fixed, but a procedure may be called to expand the
575: * space available if the current space runs out.
576: */
577:
578: typedef struct ParseValue {
579: char *buffer; /* Address of first character in
580: * output buffer. */
581: char *next; /* Place to store next character in
582: * output buffer. */
583: char *end; /* Address of the last usable character
584: * in the buffer. */
585: void (*expandProc) _ANSI_ARGS_((struct ParseValue *pvPtr, int needed));
586: /* Procedure to call when space runs out;
587: * it will make more space. */
588: ClientData clientData; /* Arbitrary information for use of
589: * expandProc. */
590: } ParseValue;
591:
592: /*
593: * A table used to classify input characters to assist in parsing
594: * Tcl commands. The table should be indexed with a signed character
595: * using the CHAR_TYPE macro. The character may have a negative
596: * value.
597: */
598:
599: extern char tclTypeTable[];
600: #define CHAR_TYPE(c) (tclTypeTable+128)[c]
601:
602: /*
603: * Possible values returned by CHAR_TYPE:
604: *
605: * TCL_NORMAL - All characters that don't have special significance
606: * to the Tcl language.
607: * TCL_SPACE - Character is space, tab, or return.
608: * TCL_COMMAND_END - Character is newline or null or semicolon or
609: * close-bracket.
610: * TCL_QUOTE - Character is a double-quote.
611: * TCL_OPEN_BRACKET - Character is a "[".
612: * TCL_OPEN_BRACE - Character is a "{".
613: * TCL_CLOSE_BRACE - Character is a "}".
614: * TCL_BACKSLASH - Character is a "\".
615: * TCL_DOLLAR - Character is a "$".
616: */
617:
618: #define TCL_NORMAL 0
619: #define TCL_SPACE 1
620: #define TCL_COMMAND_END 2
621: #define TCL_QUOTE 3
622: #define TCL_OPEN_BRACKET 4
623: #define TCL_OPEN_BRACE 5
624: #define TCL_CLOSE_BRACE 6
625: #define TCL_BACKSLASH 7
626: #define TCL_DOLLAR 8
627:
628: /*
629: * Additional flags passed to Tcl_Eval. See tcl.h for other flags to
630: * Tcl_Eval; these ones are only used internally by Tcl.
631: *
632: * TCL_RECORD_BOUNDS Tells Tcl_Eval to record information in the
633: * evalFirst and evalLast fields for each command
634: * executed directly from the string (top-level
635: * commands and those from command substitution).
636: */
637:
638: #define TCL_RECORD_BOUNDS 0x100
639:
640: /*
641: * Maximum number of levels of nesting permitted in Tcl commands.
642: */
643:
644: #define MAX_NESTING_DEPTH 100
645:
646: /*
647: * Variables shared among Tcl modules but not used by the outside
648: * world:
649: */
650:
651: extern char * tclRegexpError;
652:
653: /*
654: *----------------------------------------------------------------
655: * Procedures shared among Tcl modules but not used by the outside
656: * world:
657: *----------------------------------------------------------------
658: */
659:
660: extern void panic();
661: extern regexp * TclCompileRegexp _ANSI_ARGS_((Tcl_Interp *interp,
662: char *string));
663: extern void TclCopyAndCollapse _ANSI_ARGS_((int count, char *src,
664: char *dst));
665: extern void TclDeleteVars _ANSI_ARGS_((Interp *iPtr,
666: Tcl_HashTable *tablePtr));
667: extern void TclExpandParseValue _ANSI_ARGS_((ParseValue *pvPtr,
668: int needed));
669: extern int TclFindElement _ANSI_ARGS_((Tcl_Interp *interp,
670: char *list, char **elementPtr, char **nextPtr,
671: int *sizePtr, int *bracePtr));
672: extern Proc * TclFindProc _ANSI_ARGS_((Interp *iPtr,
673: char *procName));
674: extern int TclGetFrame _ANSI_ARGS_((Tcl_Interp *interp,
675: char *string, CallFrame **framePtrPtr));
676: extern int TclGetListIndex _ANSI_ARGS_((Tcl_Interp *interp,
677: char *string, int *indexPtr));
678: extern int TclGetOpenFile _ANSI_ARGS_((Tcl_Interp *interp,
679: char *string, OpenFile **filePtrPtr));
680: extern Proc * TclIsProc _ANSI_ARGS_((Command *cmdPtr));
681: extern void TclMakeFileTable _ANSI_ARGS_((Interp *iPtr,
682: int index));
683: extern int TclParseBraces _ANSI_ARGS_((Tcl_Interp *interp,
684: char *string, char **termPtr, ParseValue *pvPtr));
685: extern int TclParseNestedCmd _ANSI_ARGS_((Tcl_Interp *interp,
686: char *string, int flags, char **termPtr,
687: ParseValue *pvPtr));
688: extern int TclParseQuotes _ANSI_ARGS_((Tcl_Interp *interp,
689: char *string, int termChar, int flags,
690: char **termPtr, ParseValue *pvPtr));
691: extern int TclParseWords _ANSI_ARGS_((Tcl_Interp *interp,
692: char *string, int flags, int maxWords,
693: char **termPtr, int *argcPtr, char **argv,
694: ParseValue *pvPtr));
695: extern void TclSetupEnv _ANSI_ARGS_((Tcl_Interp *interp));
696: extern char * TclWordEnd _ANSI_ARGS_((char *start, int nested));
697:
698: /*
699: *----------------------------------------------------------------
700: * Command procedures in the generic core:
701: *----------------------------------------------------------------
702: */
703:
704: extern int Tcl_AppendCmd _ANSI_ARGS_((ClientData clientData,
705: Tcl_Interp *interp, int argc, char **argv));
706: extern int Tcl_ArrayCmd _ANSI_ARGS_((ClientData clientData,
707: Tcl_Interp *interp, int argc, char **argv));
708: extern int Tcl_BreakCmd _ANSI_ARGS_((ClientData clientData,
709: Tcl_Interp *interp, int argc, char **argv));
710: extern int Tcl_CaseCmd _ANSI_ARGS_((ClientData clientData,
711: Tcl_Interp *interp, int argc, char **argv));
712: extern int Tcl_CatchCmd _ANSI_ARGS_((ClientData clientData,
713: Tcl_Interp *interp, int argc, char **argv));
714: extern int Tcl_ConcatCmd _ANSI_ARGS_((ClientData clientData,
715: Tcl_Interp *interp, int argc, char **argv));
716: extern int Tcl_ContinueCmd _ANSI_ARGS_((ClientData clientData,
717: Tcl_Interp *interp, int argc, char **argv));
718: extern int Tcl_ErrorCmd _ANSI_ARGS_((ClientData clientData,
719: Tcl_Interp *interp, int argc, char **argv));
720: extern int Tcl_EvalCmd _ANSI_ARGS_((ClientData clientData,
721: Tcl_Interp *interp, int argc, char **argv));
722: extern int Tcl_ExprCmd _ANSI_ARGS_((ClientData clientData,
723: Tcl_Interp *interp, int argc, char **argv));
724: extern int Tcl_ForCmd _ANSI_ARGS_((ClientData clientData,
725: Tcl_Interp *interp, int argc, char **argv));
726: extern int Tcl_ForeachCmd _ANSI_ARGS_((ClientData clientData,
727: Tcl_Interp *interp, int argc, char **argv));
728: extern int Tcl_FormatCmd _ANSI_ARGS_((ClientData clientData,
729: Tcl_Interp *interp, int argc, char **argv));
730: extern int Tcl_GlobalCmd _ANSI_ARGS_((ClientData clientData,
731: Tcl_Interp *interp, int argc, char **argv));
732: extern int Tcl_HistoryCmd _ANSI_ARGS_((ClientData clientData,
733: Tcl_Interp *interp, int argc, char **argv));
734: extern int Tcl_IfCmd _ANSI_ARGS_((ClientData clientData,
735: Tcl_Interp *interp, int argc, char **argv));
736: extern int Tcl_IncrCmd _ANSI_ARGS_((ClientData clientData,
737: Tcl_Interp *interp, int argc, char **argv));
738: extern int Tcl_InfoCmd _ANSI_ARGS_((ClientData clientData,
739: Tcl_Interp *interp, int argc, char **argv));
740: extern int Tcl_JoinCmd _ANSI_ARGS_((ClientData clientData,
741: Tcl_Interp *interp, int argc, char **argv));
742: extern int Tcl_LappendCmd _ANSI_ARGS_((ClientData clientData,
743: Tcl_Interp *interp, int argc, char **argv));
744: extern int Tcl_LindexCmd _ANSI_ARGS_((ClientData clientData,
745: Tcl_Interp *interp, int argc, char **argv));
746: extern int Tcl_LinsertCmd _ANSI_ARGS_((ClientData clientData,
747: Tcl_Interp *interp, int argc, char **argv));
748: extern int Tcl_LlengthCmd _ANSI_ARGS_((ClientData clientData,
749: Tcl_Interp *interp, int argc, char **argv));
750: extern int Tcl_ListCmd _ANSI_ARGS_((ClientData clientData,
751: Tcl_Interp *interp, int argc, char **argv));
752: extern int Tcl_LrangeCmd _ANSI_ARGS_((ClientData clientData,
753: Tcl_Interp *interp, int argc, char **argv));
754: extern int Tcl_LreplaceCmd _ANSI_ARGS_((ClientData clientData,
755: Tcl_Interp *interp, int argc, char **argv));
756: extern int Tcl_LsearchCmd _ANSI_ARGS_((ClientData clientData,
757: Tcl_Interp *interp, int argc, char **argv));
758: extern int Tcl_LsortCmd _ANSI_ARGS_((ClientData clientData,
759: Tcl_Interp *interp, int argc, char **argv));
760: extern int Tcl_ProcCmd _ANSI_ARGS_((ClientData clientData,
761: Tcl_Interp *interp, int argc, char **argv));
762: extern int Tcl_RegexpCmd _ANSI_ARGS_((ClientData clientData,
763: Tcl_Interp *interp, int argc, char **argv));
764: extern int Tcl_RegsubCmd _ANSI_ARGS_((ClientData clientData,
765: Tcl_Interp *interp, int argc, char **argv));
766: extern int Tcl_RenameCmd _ANSI_ARGS_((ClientData clientData,
767: Tcl_Interp *interp, int argc, char **argv));
768: extern int Tcl_ReturnCmd _ANSI_ARGS_((ClientData clientData,
769: Tcl_Interp *interp, int argc, char **argv));
770: extern int Tcl_ScanCmd _ANSI_ARGS_((ClientData clientData,
771: Tcl_Interp *interp, int argc, char **argv));
772: extern int Tcl_SetCmd _ANSI_ARGS_((ClientData clientData,
773: Tcl_Interp *interp, int argc, char **argv));
774: extern int Tcl_SplitCmd _ANSI_ARGS_((ClientData clientData,
775: Tcl_Interp *interp, int argc, char **argv));
776: extern int Tcl_StringCmd _ANSI_ARGS_((ClientData clientData,
777: Tcl_Interp *interp, int argc, char **argv));
778: extern int Tcl_TraceCmd _ANSI_ARGS_((ClientData clientData,
779: Tcl_Interp *interp, int argc, char **argv));
780: extern int Tcl_UnsetCmd _ANSI_ARGS_((ClientData clientData,
781: Tcl_Interp *interp, int argc, char **argv));
782: extern int Tcl_UplevelCmd _ANSI_ARGS_((ClientData clientData,
783: Tcl_Interp *interp, int argc, char **argv));
784: extern int Tcl_UpvarCmd _ANSI_ARGS_((ClientData clientData,
785: Tcl_Interp *interp, int argc, char **argv));
786: extern int Tcl_WhileCmd _ANSI_ARGS_((ClientData clientData,
787: Tcl_Interp *interp, int argc, char **argv));
788: extern int Tcl_Cmd _ANSI_ARGS_((ClientData clientData,
789: Tcl_Interp *interp, int argc, char **argv));
790: extern int Tcl_Cmd _ANSI_ARGS_((ClientData clientData,
791: Tcl_Interp *interp, int argc, char **argv));
792:
793: /*
794: *----------------------------------------------------------------
795: * Command procedures in the UNIX core:
796: *----------------------------------------------------------------
797: */
798:
799: extern int Tcl_CdCmd _ANSI_ARGS_((ClientData clientData,
800: Tcl_Interp *interp, int argc, char **argv));
801: extern int Tcl_CloseCmd _ANSI_ARGS_((ClientData clientData,
802: Tcl_Interp *interp, int argc, char **argv));
803: extern int Tcl_EofCmd _ANSI_ARGS_((ClientData clientData,
804: Tcl_Interp *interp, int argc, char **argv));
805: extern int Tcl_ExecCmd _ANSI_ARGS_((ClientData clientData,
806: Tcl_Interp *interp, int argc, char **argv));
807: extern int Tcl_ExitCmd _ANSI_ARGS_((ClientData clientData,
808: Tcl_Interp *interp, int argc, char **argv));
809: extern int Tcl_FileCmd _ANSI_ARGS_((ClientData clientData,
810: Tcl_Interp *interp, int argc, char **argv));
811: extern int Tcl_FlushCmd _ANSI_ARGS_((ClientData clientData,
812: Tcl_Interp *interp, int argc, char **argv));
813: extern int Tcl_GetsCmd _ANSI_ARGS_((ClientData clientData,
814: Tcl_Interp *interp, int argc, char **argv));
815: extern int Tcl_GlobCmd _ANSI_ARGS_((ClientData clientData,
816: Tcl_Interp *interp, int argc, char **argv));
817: extern int Tcl_OpenCmd _ANSI_ARGS_((ClientData clientData,
818: Tcl_Interp *interp, int argc, char **argv));
819: extern int Tcl_PutsCmd _ANSI_ARGS_((ClientData clientData,
820: Tcl_Interp *interp, int argc, char **argv));
821: extern int Tcl_PwdCmd _ANSI_ARGS_((ClientData clientData,
822: Tcl_Interp *interp, int argc, char **argv));
823: extern int Tcl_ReadCmd _ANSI_ARGS_((ClientData clientData,
824: Tcl_Interp *interp, int argc, char **argv));
825: extern int Tcl_SeekCmd _ANSI_ARGS_((ClientData clientData,
826: Tcl_Interp *interp, int argc, char **argv));
827: extern int Tcl_SourceCmd _ANSI_ARGS_((ClientData clientData,
828: Tcl_Interp *interp, int argc, char **argv));
829: extern int Tcl_TellCmd _ANSI_ARGS_((ClientData clientData,
830: Tcl_Interp *interp, int argc, char **argv));
831: extern int Tcl_TimeCmd _ANSI_ARGS_((ClientData clientData,
832: Tcl_Interp *interp, int argc, char **argv));
833:
834: #endif /* _TCLINT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.