![[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.