[25] | 1 | /* |
---|
| 2 | * tcl.h -- |
---|
| 3 | * |
---|
| 4 | * This header file describes the externally-visible facilities of the |
---|
| 5 | * Tcl interpreter. |
---|
| 6 | * |
---|
| 7 | * Copyright (c) 1987-1994 The Regents of the University of California. |
---|
| 8 | * Copyright (c) 1993-1996 Lucent Technologies. |
---|
| 9 | * Copyright (c) 1994-1998 Sun Microsystems, Inc. |
---|
| 10 | * Copyright (c) 1998-2000 by Scriptics Corporation. |
---|
| 11 | * Copyright (c) 2002 by Kevin B. Kenny. All rights reserved. |
---|
| 12 | * |
---|
| 13 | * See the file "license.terms" for information on usage and redistribution of |
---|
| 14 | * this file, and for a DISCLAIMER OF ALL WARRANTIES. |
---|
| 15 | * |
---|
| 16 | * RCS: @(#) $Id: tcl.h,v 1.254 2008/03/28 17:31:44 dgp Exp $ |
---|
| 17 | */ |
---|
| 18 | |
---|
| 19 | #ifndef _TCL |
---|
| 20 | #define _TCL |
---|
| 21 | |
---|
| 22 | /* |
---|
| 23 | * For C++ compilers, use extern "C" |
---|
| 24 | */ |
---|
| 25 | |
---|
| 26 | #ifdef __cplusplus |
---|
| 27 | extern "C" { |
---|
| 28 | #endif |
---|
| 29 | |
---|
| 30 | /* |
---|
| 31 | * The following defines are used to indicate the various release levels. |
---|
| 32 | */ |
---|
| 33 | |
---|
| 34 | #define TCL_ALPHA_RELEASE 0 |
---|
| 35 | #define TCL_BETA_RELEASE 1 |
---|
| 36 | #define TCL_FINAL_RELEASE 2 |
---|
| 37 | |
---|
| 38 | /* |
---|
| 39 | * When version numbers change here, must also go into the following files and |
---|
| 40 | * update the version numbers: |
---|
| 41 | * |
---|
| 42 | * library/init.tcl (1 LOC patch) |
---|
| 43 | * unix/configure.in (2 LOC Major, 2 LOC minor, 1 LOC patch) |
---|
| 44 | * win/configure.in (as above) |
---|
| 45 | * win/tcl.m4 (not patchlevel) |
---|
| 46 | * win/makefile.bc (not patchlevel) 2 LOC |
---|
| 47 | * README (sections 0 and 2, with and without separator) |
---|
| 48 | * macosx/Tcl.pbproj/project.pbxproj (not patchlevel) 1 LOC |
---|
| 49 | * macosx/Tcl.pbproj/default.pbxuser (not patchlevel) 1 LOC |
---|
| 50 | * macosx/Tcl.xcode/project.pbxproj (not patchlevel) 2 LOC |
---|
| 51 | * macosx/Tcl.xcode/default.pbxuser (not patchlevel) 1 LOC |
---|
| 52 | * macosx/Tcl-Common.xcconfig (not patchlevel) 1 LOC |
---|
| 53 | * win/README (not patchlevel) (sections 0 and 2) |
---|
| 54 | * unix/tcl.spec (1 LOC patch) |
---|
| 55 | * tools/tcl.hpj.in (not patchlevel, for windows installer) |
---|
| 56 | * tools/tcl.wse.in (for windows installer) |
---|
| 57 | * tools/tclSplash.bmp (not patchlevel) |
---|
| 58 | */ |
---|
| 59 | |
---|
| 60 | #define TCL_MAJOR_VERSION 8 |
---|
| 61 | #define TCL_MINOR_VERSION 5 |
---|
| 62 | #define TCL_RELEASE_LEVEL TCL_FINAL_RELEASE |
---|
| 63 | #define TCL_RELEASE_SERIAL 2 |
---|
| 64 | |
---|
| 65 | #define TCL_VERSION "8.5" |
---|
| 66 | #define TCL_PATCH_LEVEL "8.5.2" |
---|
| 67 | |
---|
| 68 | /* |
---|
| 69 | * The following definitions set up the proper options for Windows compilers. |
---|
| 70 | * We use this method because there is no autoconf equivalent. |
---|
| 71 | */ |
---|
| 72 | |
---|
| 73 | #ifndef __WIN32__ |
---|
| 74 | # if defined(_WIN32) || defined(WIN32) || defined(__MINGW32__) || defined(__BORLANDC__) || (defined(__WATCOMC__) && defined(__WINDOWS_386__)) |
---|
| 75 | # define __WIN32__ |
---|
| 76 | # ifndef WIN32 |
---|
| 77 | # define WIN32 |
---|
| 78 | # endif |
---|
| 79 | # ifndef _WIN32 |
---|
| 80 | # define _WIN32 |
---|
| 81 | # endif |
---|
| 82 | # endif |
---|
| 83 | #endif |
---|
| 84 | |
---|
| 85 | /* |
---|
| 86 | * STRICT: See MSDN Article Q83456 |
---|
| 87 | */ |
---|
| 88 | |
---|
| 89 | #ifdef __WIN32__ |
---|
| 90 | # ifndef STRICT |
---|
| 91 | # define STRICT |
---|
| 92 | # endif |
---|
| 93 | #endif /* __WIN32__ */ |
---|
| 94 | |
---|
| 95 | /* |
---|
| 96 | * Utility macros: STRINGIFY takes an argument and wraps it in "" (double |
---|
| 97 | * quotation marks), JOIN joins two arguments. |
---|
| 98 | */ |
---|
| 99 | |
---|
| 100 | #ifndef STRINGIFY |
---|
| 101 | # define STRINGIFY(x) STRINGIFY1(x) |
---|
| 102 | # define STRINGIFY1(x) #x |
---|
| 103 | #endif |
---|
| 104 | #ifndef JOIN |
---|
| 105 | # define JOIN(a,b) JOIN1(a,b) |
---|
| 106 | # define JOIN1(a,b) a##b |
---|
| 107 | #endif |
---|
| 108 | |
---|
| 109 | /* |
---|
| 110 | * A special definition used to allow this header file to be included from |
---|
| 111 | * windows resource files so that they can obtain version information. |
---|
| 112 | * RC_INVOKED is defined by default by the windows RC tool. |
---|
| 113 | * |
---|
| 114 | * Resource compilers don't like all the C stuff, like typedefs and function |
---|
| 115 | * declarations, that occur below, so block them out. |
---|
| 116 | */ |
---|
| 117 | |
---|
| 118 | #ifndef RC_INVOKED |
---|
| 119 | |
---|
| 120 | /* |
---|
| 121 | * Special macro to define mutexes, that doesn't do anything if we are not |
---|
| 122 | * using threads. |
---|
| 123 | */ |
---|
| 124 | |
---|
| 125 | #ifdef TCL_THREADS |
---|
| 126 | #define TCL_DECLARE_MUTEX(name) static Tcl_Mutex name; |
---|
| 127 | #else |
---|
| 128 | #define TCL_DECLARE_MUTEX(name) |
---|
| 129 | #endif |
---|
| 130 | |
---|
| 131 | /* |
---|
| 132 | * Tcl's public routine Tcl_FSSeek() uses the values SEEK_SET, SEEK_CUR, and |
---|
| 133 | * SEEK_END, all #define'd by stdio.h . |
---|
| 134 | * |
---|
| 135 | * Also, many extensions need stdio.h, and they've grown accustomed to tcl.h |
---|
| 136 | * providing it for them rather than #include-ing it themselves as they |
---|
| 137 | * should, so also for their sake, we keep the #include to be consistent with |
---|
| 138 | * prior Tcl releases. |
---|
| 139 | */ |
---|
| 140 | |
---|
| 141 | #include <stdio.h> |
---|
| 142 | |
---|
| 143 | /* |
---|
| 144 | * Support for functions with a variable number of arguments. |
---|
| 145 | * |
---|
| 146 | * The following TCL_VARARGS* macros are to support old extensions |
---|
| 147 | * written for older versions of Tcl where the macros permitted |
---|
| 148 | * support for the varargs.h system as well as stdarg.h . |
---|
| 149 | * |
---|
| 150 | * New code should just directly be written to use stdarg.h conventions. |
---|
| 151 | */ |
---|
| 152 | |
---|
| 153 | #include <stdarg.h> |
---|
| 154 | #ifndef TCL_NO_DEPRECATED |
---|
| 155 | # define TCL_VARARGS(type, name) (type name, ...) |
---|
| 156 | # define TCL_VARARGS_DEF(type, name) (type name, ...) |
---|
| 157 | # define TCL_VARARGS_START(type, name, list) (va_start(list, name), name) |
---|
| 158 | #endif |
---|
| 159 | |
---|
| 160 | /* |
---|
| 161 | * Macros used to declare a function to be exported by a DLL. Used by Windows, |
---|
| 162 | * maps to no-op declarations on non-Windows systems. The default build on |
---|
| 163 | * windows is for a DLL, which causes the DLLIMPORT and DLLEXPORT macros to be |
---|
| 164 | * nonempty. To build a static library, the macro STATIC_BUILD should be |
---|
| 165 | * defined. |
---|
| 166 | * |
---|
| 167 | * Note: when building static but linking dynamically to MSVCRT we must still |
---|
| 168 | * correctly decorate the C library imported function. Use CRTIMPORT |
---|
| 169 | * for this purpose. _DLL is defined by the compiler when linking to |
---|
| 170 | * MSVCRT. |
---|
| 171 | */ |
---|
| 172 | |
---|
| 173 | #if (defined(__WIN32__) && (defined(_MSC_VER) || (__BORLANDC__ >= 0x0550) || defined(__LCC__) || defined(__WATCOMC__) || (defined(__GNUC__) && defined(__declspec)))) |
---|
| 174 | # define HAVE_DECLSPEC 1 |
---|
| 175 | #endif |
---|
| 176 | |
---|
| 177 | #ifdef STATIC_BUILD |
---|
| 178 | # define DLLIMPORT |
---|
| 179 | # define DLLEXPORT |
---|
| 180 | # if HAVE_DECLSPEC && defined(_DLL) |
---|
| 181 | # define CRTIMPORT __declspec(dllimport) |
---|
| 182 | # else |
---|
| 183 | # define CRTIMPORT |
---|
| 184 | # endif |
---|
| 185 | #else |
---|
| 186 | # if HAVE_DECLSPEC |
---|
| 187 | # define DLLIMPORT __declspec(dllimport) |
---|
| 188 | # define DLLEXPORT __declspec(dllexport) |
---|
| 189 | # define CRTIMPORT __declspec(dllimport) |
---|
| 190 | # else |
---|
| 191 | # define DLLIMPORT |
---|
| 192 | # define DLLEXPORT |
---|
| 193 | # define CRTIMPORT |
---|
| 194 | # endif |
---|
| 195 | #endif |
---|
| 196 | |
---|
| 197 | /* |
---|
| 198 | * These macros are used to control whether functions are being declared for |
---|
| 199 | * import or export. If a function is being declared while it is being built |
---|
| 200 | * to be included in a shared library, then it should have the DLLEXPORT |
---|
| 201 | * storage class. If is being declared for use by a module that is going to |
---|
| 202 | * link against the shared library, then it should have the DLLIMPORT storage |
---|
| 203 | * class. If the symbol is beind declared for a static build or for use from a |
---|
| 204 | * stub library, then the storage class should be empty. |
---|
| 205 | * |
---|
| 206 | * The convention is that a macro called BUILD_xxxx, where xxxx is the name of |
---|
| 207 | * a library we are building, is set on the compile line for sources that are |
---|
| 208 | * to be placed in the library. When this macro is set, the storage class will |
---|
| 209 | * be set to DLLEXPORT. At the end of the header file, the storage class will |
---|
| 210 | * be reset to DLLIMPORT. |
---|
| 211 | */ |
---|
| 212 | |
---|
| 213 | #undef TCL_STORAGE_CLASS |
---|
| 214 | #ifdef BUILD_tcl |
---|
| 215 | # define TCL_STORAGE_CLASS DLLEXPORT |
---|
| 216 | #else |
---|
| 217 | # ifdef USE_TCL_STUBS |
---|
| 218 | # define TCL_STORAGE_CLASS |
---|
| 219 | # else |
---|
| 220 | # define TCL_STORAGE_CLASS DLLIMPORT |
---|
| 221 | # endif |
---|
| 222 | #endif |
---|
| 223 | |
---|
| 224 | /* |
---|
| 225 | * Definitions that allow this header file to be used either with or without |
---|
| 226 | * ANSI C features like function prototypes. |
---|
| 227 | */ |
---|
| 228 | |
---|
| 229 | #undef _ANSI_ARGS_ |
---|
| 230 | #undef CONST |
---|
| 231 | #ifndef INLINE |
---|
| 232 | # define INLINE |
---|
| 233 | #endif |
---|
| 234 | |
---|
| 235 | #ifndef NO_CONST |
---|
| 236 | # define CONST const |
---|
| 237 | #else |
---|
| 238 | # define CONST |
---|
| 239 | #endif |
---|
| 240 | |
---|
| 241 | #ifndef NO_PROTOTYPES |
---|
| 242 | # define _ANSI_ARGS_(x) x |
---|
| 243 | #else |
---|
| 244 | # define _ANSI_ARGS_(x) () |
---|
| 245 | #endif |
---|
| 246 | |
---|
| 247 | #ifdef USE_NON_CONST |
---|
| 248 | # ifdef USE_COMPAT_CONST |
---|
| 249 | # error define at most one of USE_NON_CONST and USE_COMPAT_CONST |
---|
| 250 | # endif |
---|
| 251 | # define CONST84 |
---|
| 252 | # define CONST84_RETURN |
---|
| 253 | #else |
---|
| 254 | # ifdef USE_COMPAT_CONST |
---|
| 255 | # define CONST84 |
---|
| 256 | # define CONST84_RETURN CONST |
---|
| 257 | # else |
---|
| 258 | # define CONST84 CONST |
---|
| 259 | # define CONST84_RETURN CONST |
---|
| 260 | # endif |
---|
| 261 | #endif |
---|
| 262 | |
---|
| 263 | /* |
---|
| 264 | * Make sure EXTERN isn't defined elsewhere |
---|
| 265 | */ |
---|
| 266 | |
---|
| 267 | #ifdef EXTERN |
---|
| 268 | # undef EXTERN |
---|
| 269 | #endif /* EXTERN */ |
---|
| 270 | |
---|
| 271 | #ifdef __cplusplus |
---|
| 272 | # define EXTERN extern "C" TCL_STORAGE_CLASS |
---|
| 273 | #else |
---|
| 274 | # define EXTERN extern TCL_STORAGE_CLASS |
---|
| 275 | #endif |
---|
| 276 | |
---|
| 277 | /* |
---|
| 278 | * The following code is copied from winnt.h. If we don't replicate it here, |
---|
| 279 | * then <windows.h> can't be included after tcl.h, since tcl.h also defines |
---|
| 280 | * VOID. This block is skipped under Cygwin and Mingw. |
---|
| 281 | */ |
---|
| 282 | |
---|
| 283 | #if defined(__WIN32__) && !defined(HAVE_WINNT_IGNORE_VOID) |
---|
| 284 | #ifndef VOID |
---|
| 285 | #define VOID void |
---|
| 286 | typedef char CHAR; |
---|
| 287 | typedef short SHORT; |
---|
| 288 | typedef long LONG; |
---|
| 289 | #endif |
---|
| 290 | #endif /* __WIN32__ && !HAVE_WINNT_IGNORE_VOID */ |
---|
| 291 | |
---|
| 292 | /* |
---|
| 293 | * Macro to use instead of "void" for arguments that must have type "void *" |
---|
| 294 | * in ANSI C; maps them to type "char *" in non-ANSI systems. |
---|
| 295 | */ |
---|
| 296 | |
---|
| 297 | #ifndef NO_VOID |
---|
| 298 | #define VOID void |
---|
| 299 | #else |
---|
| 300 | #define VOID char |
---|
| 301 | #endif |
---|
| 302 | |
---|
| 303 | /* |
---|
| 304 | * Miscellaneous declarations. |
---|
| 305 | */ |
---|
| 306 | |
---|
| 307 | #ifndef _CLIENTDATA |
---|
| 308 | # ifndef NO_VOID |
---|
| 309 | typedef void *ClientData; |
---|
| 310 | # else |
---|
| 311 | typedef int *ClientData; |
---|
| 312 | # endif |
---|
| 313 | # define _CLIENTDATA |
---|
| 314 | #endif |
---|
| 315 | |
---|
| 316 | /* |
---|
| 317 | * Darwin specifc configure overrides (to support fat compiles, where |
---|
| 318 | * configure runs only once for multiple architectures): |
---|
| 319 | */ |
---|
| 320 | |
---|
| 321 | #ifdef __APPLE__ |
---|
| 322 | # ifdef __LP64__ |
---|
| 323 | # undef TCL_WIDE_INT_TYPE |
---|
| 324 | # define TCL_WIDE_INT_IS_LONG 1 |
---|
| 325 | # define TCL_CFG_DO64BIT 1 |
---|
| 326 | # else /* !__LP64__ */ |
---|
| 327 | # define TCL_WIDE_INT_TYPE long long |
---|
| 328 | # undef TCL_WIDE_INT_IS_LONG |
---|
| 329 | # undef TCL_CFG_DO64BIT |
---|
| 330 | # endif /* __LP64__ */ |
---|
| 331 | # undef HAVE_STRUCT_STAT64 |
---|
| 332 | #endif /* __APPLE__ */ |
---|
| 333 | |
---|
| 334 | /* |
---|
| 335 | * Define Tcl_WideInt to be a type that is (at least) 64-bits wide, and define |
---|
| 336 | * Tcl_WideUInt to be the unsigned variant of that type (assuming that where |
---|
| 337 | * we have one, we can have the other.) |
---|
| 338 | * |
---|
| 339 | * Also defines the following macros: |
---|
| 340 | * TCL_WIDE_INT_IS_LONG - if wide ints are really longs (i.e. we're on a real |
---|
| 341 | * 64-bit system.) |
---|
| 342 | * Tcl_WideAsLong - forgetful converter from wideInt to long. |
---|
| 343 | * Tcl_LongAsWide - sign-extending converter from long to wideInt. |
---|
| 344 | * Tcl_WideAsDouble - converter from wideInt to double. |
---|
| 345 | * Tcl_DoubleAsWide - converter from double to wideInt. |
---|
| 346 | * |
---|
| 347 | * The following invariant should hold for any long value 'longVal': |
---|
| 348 | * longVal == Tcl_WideAsLong(Tcl_LongAsWide(longVal)) |
---|
| 349 | * |
---|
| 350 | * Note on converting between Tcl_WideInt and strings. This implementation (in |
---|
| 351 | * tclObj.c) depends on the function |
---|
| 352 | * sprintf(...,"%" TCL_LL_MODIFIER "d",...). |
---|
| 353 | */ |
---|
| 354 | |
---|
| 355 | #if !defined(TCL_WIDE_INT_TYPE)&&!defined(TCL_WIDE_INT_IS_LONG) |
---|
| 356 | # if defined(__GNUC__) |
---|
| 357 | # define TCL_WIDE_INT_TYPE long long |
---|
| 358 | # if defined(__WIN32__) && !defined(__CYGWIN__) |
---|
| 359 | # define TCL_LL_MODIFIER "I64" |
---|
| 360 | # else |
---|
| 361 | # define TCL_LL_MODIFIER "L" |
---|
| 362 | # endif |
---|
| 363 | typedef struct stat Tcl_StatBuf; |
---|
| 364 | # elif defined(__WIN32__) |
---|
| 365 | # define TCL_WIDE_INT_TYPE __int64 |
---|
| 366 | # ifdef __BORLANDC__ |
---|
| 367 | typedef struct stati64 Tcl_StatBuf; |
---|
| 368 | # define TCL_LL_MODIFIER "L" |
---|
| 369 | # else /* __BORLANDC__ */ |
---|
| 370 | # if _MSC_VER < 1400 || !defined(_M_IX86) |
---|
| 371 | typedef struct _stati64 Tcl_StatBuf; |
---|
| 372 | # else |
---|
| 373 | typedef struct _stat64 Tcl_StatBuf; |
---|
| 374 | # endif /* _MSC_VER < 1400 */ |
---|
| 375 | # define TCL_LL_MODIFIER "I64" |
---|
| 376 | # endif /* __BORLANDC__ */ |
---|
| 377 | # else /* __WIN32__ */ |
---|
| 378 | /* |
---|
| 379 | * Don't know what platform it is and configure hasn't discovered what is |
---|
| 380 | * going on for us. Try to guess... |
---|
| 381 | */ |
---|
| 382 | # ifdef NO_LIMITS_H |
---|
| 383 | # error please define either TCL_WIDE_INT_TYPE or TCL_WIDE_INT_IS_LONG |
---|
| 384 | # else /* !NO_LIMITS_H */ |
---|
| 385 | # include <limits.h> |
---|
| 386 | # if (INT_MAX < LONG_MAX) |
---|
| 387 | # define TCL_WIDE_INT_IS_LONG 1 |
---|
| 388 | # else |
---|
| 389 | # define TCL_WIDE_INT_TYPE long long |
---|
| 390 | # endif |
---|
| 391 | # endif /* NO_LIMITS_H */ |
---|
| 392 | # endif /* __WIN32__ */ |
---|
| 393 | #endif /* !TCL_WIDE_INT_TYPE & !TCL_WIDE_INT_IS_LONG */ |
---|
| 394 | #ifdef TCL_WIDE_INT_IS_LONG |
---|
| 395 | # undef TCL_WIDE_INT_TYPE |
---|
| 396 | # define TCL_WIDE_INT_TYPE long |
---|
| 397 | #endif /* TCL_WIDE_INT_IS_LONG */ |
---|
| 398 | |
---|
| 399 | typedef TCL_WIDE_INT_TYPE Tcl_WideInt; |
---|
| 400 | typedef unsigned TCL_WIDE_INT_TYPE Tcl_WideUInt; |
---|
| 401 | |
---|
| 402 | #ifdef TCL_WIDE_INT_IS_LONG |
---|
| 403 | typedef struct stat Tcl_StatBuf; |
---|
| 404 | # define Tcl_WideAsLong(val) ((long)(val)) |
---|
| 405 | # define Tcl_LongAsWide(val) ((long)(val)) |
---|
| 406 | # define Tcl_WideAsDouble(val) ((double)((long)(val))) |
---|
| 407 | # define Tcl_DoubleAsWide(val) ((long)((double)(val))) |
---|
| 408 | # ifndef TCL_LL_MODIFIER |
---|
| 409 | # define TCL_LL_MODIFIER "l" |
---|
| 410 | # endif /* !TCL_LL_MODIFIER */ |
---|
| 411 | #else /* TCL_WIDE_INT_IS_LONG */ |
---|
| 412 | /* |
---|
| 413 | * The next short section of defines are only done when not running on Windows |
---|
| 414 | * or some other strange platform. |
---|
| 415 | */ |
---|
| 416 | # ifndef TCL_LL_MODIFIER |
---|
| 417 | # ifdef HAVE_STRUCT_STAT64 |
---|
| 418 | typedef struct stat64 Tcl_StatBuf; |
---|
| 419 | # else |
---|
| 420 | typedef struct stat Tcl_StatBuf; |
---|
| 421 | # endif /* HAVE_STRUCT_STAT64 */ |
---|
| 422 | # define TCL_LL_MODIFIER "ll" |
---|
| 423 | # endif /* !TCL_LL_MODIFIER */ |
---|
| 424 | # define Tcl_WideAsLong(val) ((long)((Tcl_WideInt)(val))) |
---|
| 425 | # define Tcl_LongAsWide(val) ((Tcl_WideInt)((long)(val))) |
---|
| 426 | # define Tcl_WideAsDouble(val) ((double)((Tcl_WideInt)(val))) |
---|
| 427 | # define Tcl_DoubleAsWide(val) ((Tcl_WideInt)((double)(val))) |
---|
| 428 | #endif /* TCL_WIDE_INT_IS_LONG */ |
---|
| 429 | |
---|
| 430 | /* |
---|
| 431 | * Data structures defined opaquely in this module. The definitions below just |
---|
| 432 | * provide dummy types. A few fields are made visible in Tcl_Interp |
---|
| 433 | * structures, namely those used for returning a string result from commands. |
---|
| 434 | * Direct access to the result field is discouraged in Tcl 8.0. The |
---|
| 435 | * interpreter result is either an object or a string, and the two values are |
---|
| 436 | * kept consistent unless some C code sets interp->result directly. |
---|
| 437 | * Programmers should use either the function Tcl_GetObjResult() or |
---|
| 438 | * Tcl_GetStringResult() to read the interpreter's result. See the SetResult |
---|
| 439 | * man page for details. |
---|
| 440 | * |
---|
| 441 | * Note: any change to the Tcl_Interp definition below must be mirrored in the |
---|
| 442 | * "real" definition in tclInt.h. |
---|
| 443 | * |
---|
| 444 | * Note: Tcl_ObjCmdProc functions do not directly set result and freeProc. |
---|
| 445 | * Instead, they set a Tcl_Obj member in the "real" structure that can be |
---|
| 446 | * accessed with Tcl_GetObjResult() and Tcl_SetObjResult(). |
---|
| 447 | */ |
---|
| 448 | |
---|
| 449 | typedef struct Tcl_Interp { |
---|
| 450 | char *result; /* If the last command returned a string |
---|
| 451 | * result, this points to it. */ |
---|
| 452 | void (*freeProc) _ANSI_ARGS_((char *blockPtr)); |
---|
| 453 | /* Zero means the string result is statically |
---|
| 454 | * allocated. TCL_DYNAMIC means it was |
---|
| 455 | * allocated with ckalloc and should be freed |
---|
| 456 | * with ckfree. Other values give the address |
---|
| 457 | * of function to invoke to free the result. |
---|
| 458 | * Tcl_Eval must free it before executing next |
---|
| 459 | * command. */ |
---|
| 460 | int errorLine; /* When TCL_ERROR is returned, this gives the |
---|
| 461 | * line number within the command where the |
---|
| 462 | * error occurred (1 if first line). */ |
---|
| 463 | } Tcl_Interp; |
---|
| 464 | |
---|
| 465 | typedef struct Tcl_AsyncHandler_ *Tcl_AsyncHandler; |
---|
| 466 | typedef struct Tcl_Channel_ *Tcl_Channel; |
---|
| 467 | typedef struct Tcl_ChannelTypeVersion_ *Tcl_ChannelTypeVersion; |
---|
| 468 | typedef struct Tcl_Command_ *Tcl_Command; |
---|
| 469 | typedef struct Tcl_Condition_ *Tcl_Condition; |
---|
| 470 | typedef struct Tcl_Dict_ *Tcl_Dict; |
---|
| 471 | typedef struct Tcl_EncodingState_ *Tcl_EncodingState; |
---|
| 472 | typedef struct Tcl_Encoding_ *Tcl_Encoding; |
---|
| 473 | typedef struct Tcl_Event Tcl_Event; |
---|
| 474 | typedef struct Tcl_InterpState_ *Tcl_InterpState; |
---|
| 475 | typedef struct Tcl_LoadHandle_ *Tcl_LoadHandle; |
---|
| 476 | typedef struct Tcl_Mutex_ *Tcl_Mutex; |
---|
| 477 | typedef struct Tcl_Pid_ *Tcl_Pid; |
---|
| 478 | typedef struct Tcl_RegExp_ *Tcl_RegExp; |
---|
| 479 | typedef struct Tcl_ThreadDataKey_ *Tcl_ThreadDataKey; |
---|
| 480 | typedef struct Tcl_ThreadId_ *Tcl_ThreadId; |
---|
| 481 | typedef struct Tcl_TimerToken_ *Tcl_TimerToken; |
---|
| 482 | typedef struct Tcl_Trace_ *Tcl_Trace; |
---|
| 483 | typedef struct Tcl_Var_ *Tcl_Var; |
---|
| 484 | |
---|
| 485 | /* |
---|
| 486 | * Definition of the interface to functions implementing threads. A function |
---|
| 487 | * following this definition is given to each call of 'Tcl_CreateThread' and |
---|
| 488 | * will be called as the main fuction of the new thread created by that call. |
---|
| 489 | */ |
---|
| 490 | |
---|
| 491 | #if defined __WIN32__ |
---|
| 492 | typedef unsigned (__stdcall Tcl_ThreadCreateProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 493 | #else |
---|
| 494 | typedef void (Tcl_ThreadCreateProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 495 | #endif |
---|
| 496 | |
---|
| 497 | /* |
---|
| 498 | * Threading function return types used for abstracting away platform |
---|
| 499 | * differences when writing a Tcl_ThreadCreateProc. See the NewThread function |
---|
| 500 | * in generic/tclThreadTest.c for it's usage. |
---|
| 501 | */ |
---|
| 502 | |
---|
| 503 | #if defined __WIN32__ |
---|
| 504 | # define Tcl_ThreadCreateType unsigned __stdcall |
---|
| 505 | # define TCL_THREAD_CREATE_RETURN return 0 |
---|
| 506 | #else |
---|
| 507 | # define Tcl_ThreadCreateType void |
---|
| 508 | # define TCL_THREAD_CREATE_RETURN |
---|
| 509 | #endif |
---|
| 510 | |
---|
| 511 | /* |
---|
| 512 | * Definition of values for default stacksize and the possible flags to be |
---|
| 513 | * given to Tcl_CreateThread. |
---|
| 514 | */ |
---|
| 515 | |
---|
| 516 | #define TCL_THREAD_STACK_DEFAULT (0) /* Use default size for stack */ |
---|
| 517 | #define TCL_THREAD_NOFLAGS (0000) /* Standard flags, default behaviour */ |
---|
| 518 | #define TCL_THREAD_JOINABLE (0001) /* Mark the thread as joinable */ |
---|
| 519 | |
---|
| 520 | /* |
---|
| 521 | * Flag values passed to Tcl_StringCaseMatch. |
---|
| 522 | */ |
---|
| 523 | |
---|
| 524 | #define TCL_MATCH_NOCASE (1<<0) |
---|
| 525 | |
---|
| 526 | /* |
---|
| 527 | * Flag values passed to Tcl_GetRegExpFromObj. |
---|
| 528 | */ |
---|
| 529 | |
---|
| 530 | #define TCL_REG_BASIC 000000 /* BREs (convenience) */ |
---|
| 531 | #define TCL_REG_EXTENDED 000001 /* EREs */ |
---|
| 532 | #define TCL_REG_ADVF 000002 /* advanced features in EREs */ |
---|
| 533 | #define TCL_REG_ADVANCED 000003 /* AREs (which are also EREs) */ |
---|
| 534 | #define TCL_REG_QUOTE 000004 /* no special characters, none */ |
---|
| 535 | #define TCL_REG_NOCASE 000010 /* ignore case */ |
---|
| 536 | #define TCL_REG_NOSUB 000020 /* don't care about subexpressions */ |
---|
| 537 | #define TCL_REG_EXPANDED 000040 /* expanded format, white space & |
---|
| 538 | * comments */ |
---|
| 539 | #define TCL_REG_NLSTOP 000100 /* \n doesn't match . or [^ ] */ |
---|
| 540 | #define TCL_REG_NLANCH 000200 /* ^ matches after \n, $ before */ |
---|
| 541 | #define TCL_REG_NEWLINE 000300 /* newlines are line terminators */ |
---|
| 542 | #define TCL_REG_CANMATCH 001000 /* report details on partial/limited |
---|
| 543 | * matches */ |
---|
| 544 | |
---|
| 545 | /* |
---|
| 546 | * Flags values passed to Tcl_RegExpExecObj. |
---|
| 547 | */ |
---|
| 548 | |
---|
| 549 | #define TCL_REG_NOTBOL 0001 /* Beginning of string does not match ^. */ |
---|
| 550 | #define TCL_REG_NOTEOL 0002 /* End of string does not match $. */ |
---|
| 551 | |
---|
| 552 | /* |
---|
| 553 | * Structures filled in by Tcl_RegExpInfo. Note that all offset values are |
---|
| 554 | * relative to the start of the match string, not the beginning of the entire |
---|
| 555 | * string. |
---|
| 556 | */ |
---|
| 557 | |
---|
| 558 | typedef struct Tcl_RegExpIndices { |
---|
| 559 | long start; /* Character offset of first character in |
---|
| 560 | * match. */ |
---|
| 561 | long end; /* Character offset of first character after |
---|
| 562 | * the match. */ |
---|
| 563 | } Tcl_RegExpIndices; |
---|
| 564 | |
---|
| 565 | typedef struct Tcl_RegExpInfo { |
---|
| 566 | int nsubs; /* Number of subexpressions in the compiled |
---|
| 567 | * expression. */ |
---|
| 568 | Tcl_RegExpIndices *matches; /* Array of nsubs match offset pairs. */ |
---|
| 569 | long extendStart; /* The offset at which a subsequent match |
---|
| 570 | * might begin. */ |
---|
| 571 | long reserved; /* Reserved for later use. */ |
---|
| 572 | } Tcl_RegExpInfo; |
---|
| 573 | |
---|
| 574 | /* |
---|
| 575 | * Picky compilers complain if this typdef doesn't appear before the struct's |
---|
| 576 | * reference in tclDecls.h. |
---|
| 577 | */ |
---|
| 578 | |
---|
| 579 | typedef Tcl_StatBuf *Tcl_Stat_; |
---|
| 580 | typedef struct stat *Tcl_OldStat_; |
---|
| 581 | |
---|
| 582 | /* |
---|
| 583 | * When a TCL command returns, the interpreter contains a result from the |
---|
| 584 | * command. Programmers are strongly encouraged to use one of the functions |
---|
| 585 | * Tcl_GetObjResult() or Tcl_GetStringResult() to read the interpreter's |
---|
| 586 | * result. See the SetResult man page for details. Besides this result, the |
---|
| 587 | * command function returns an integer code, which is one of the following: |
---|
| 588 | * |
---|
| 589 | * TCL_OK Command completed normally; the interpreter's result |
---|
| 590 | * contains the command's result. |
---|
| 591 | * TCL_ERROR The command couldn't be completed successfully; the |
---|
| 592 | * interpreter's result describes what went wrong. |
---|
| 593 | * TCL_RETURN The command requests that the current function return; |
---|
| 594 | * the interpreter's result contains the function's |
---|
| 595 | * return value. |
---|
| 596 | * TCL_BREAK The command requests that the innermost loop be |
---|
| 597 | * exited; the interpreter's result is meaningless. |
---|
| 598 | * TCL_CONTINUE Go on to the next iteration of the current loop; the |
---|
| 599 | * interpreter's result is meaningless. |
---|
| 600 | */ |
---|
| 601 | |
---|
| 602 | #define TCL_OK 0 |
---|
| 603 | #define TCL_ERROR 1 |
---|
| 604 | #define TCL_RETURN 2 |
---|
| 605 | #define TCL_BREAK 3 |
---|
| 606 | #define TCL_CONTINUE 4 |
---|
| 607 | |
---|
| 608 | #define TCL_RESULT_SIZE 200 |
---|
| 609 | |
---|
| 610 | /* |
---|
| 611 | * Flags to control what substitutions are performed by Tcl_SubstObj(): |
---|
| 612 | */ |
---|
| 613 | |
---|
| 614 | #define TCL_SUBST_COMMANDS 001 |
---|
| 615 | #define TCL_SUBST_VARIABLES 002 |
---|
| 616 | #define TCL_SUBST_BACKSLASHES 004 |
---|
| 617 | #define TCL_SUBST_ALL 007 |
---|
| 618 | |
---|
| 619 | /* |
---|
| 620 | * Argument descriptors for math function callbacks in expressions: |
---|
| 621 | */ |
---|
| 622 | |
---|
| 623 | typedef enum { |
---|
| 624 | TCL_INT, TCL_DOUBLE, TCL_EITHER, TCL_WIDE_INT |
---|
| 625 | } Tcl_ValueType; |
---|
| 626 | |
---|
| 627 | typedef struct Tcl_Value { |
---|
| 628 | Tcl_ValueType type; /* Indicates intValue or doubleValue is valid, |
---|
| 629 | * or both. */ |
---|
| 630 | long intValue; /* Integer value. */ |
---|
| 631 | double doubleValue; /* Double-precision floating value. */ |
---|
| 632 | Tcl_WideInt wideValue; /* Wide (min. 64-bit) integer value. */ |
---|
| 633 | } Tcl_Value; |
---|
| 634 | |
---|
| 635 | /* |
---|
| 636 | * Forward declaration of Tcl_Obj to prevent an error when the forward |
---|
| 637 | * reference to Tcl_Obj is encountered in the function types declared below. |
---|
| 638 | */ |
---|
| 639 | |
---|
| 640 | struct Tcl_Obj; |
---|
| 641 | |
---|
| 642 | /* |
---|
| 643 | * Function types defined by Tcl: |
---|
| 644 | */ |
---|
| 645 | |
---|
| 646 | typedef int (Tcl_AppInitProc) _ANSI_ARGS_((Tcl_Interp *interp)); |
---|
| 647 | typedef int (Tcl_AsyncProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 648 | Tcl_Interp *interp, int code)); |
---|
| 649 | typedef void (Tcl_ChannelProc) _ANSI_ARGS_((ClientData clientData, int mask)); |
---|
| 650 | typedef void (Tcl_CloseProc) _ANSI_ARGS_((ClientData data)); |
---|
| 651 | typedef void (Tcl_CmdDeleteProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 652 | typedef int (Tcl_CmdProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 653 | Tcl_Interp *interp, int argc, CONST84 char *argv[])); |
---|
| 654 | typedef void (Tcl_CmdTraceProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 655 | Tcl_Interp *interp, int level, char *command, Tcl_CmdProc *proc, |
---|
| 656 | ClientData cmdClientData, int argc, CONST84 char *argv[])); |
---|
| 657 | typedef int (Tcl_CmdObjTraceProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 658 | Tcl_Interp *interp, int level, CONST char *command, |
---|
| 659 | Tcl_Command commandInfo, int objc, struct Tcl_Obj * CONST * objv)); |
---|
| 660 | typedef void (Tcl_CmdObjTraceDeleteProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 661 | typedef void (Tcl_DupInternalRepProc) _ANSI_ARGS_((struct Tcl_Obj *srcPtr, |
---|
| 662 | struct Tcl_Obj *dupPtr)); |
---|
| 663 | typedef int (Tcl_EncodingConvertProc)_ANSI_ARGS_((ClientData clientData, |
---|
| 664 | CONST char *src, int srcLen, int flags, Tcl_EncodingState *statePtr, |
---|
| 665 | char *dst, int dstLen, int *srcReadPtr, int *dstWrotePtr, |
---|
| 666 | int *dstCharsPtr)); |
---|
| 667 | typedef void (Tcl_EncodingFreeProc)_ANSI_ARGS_((ClientData clientData)); |
---|
| 668 | typedef int (Tcl_EventProc) _ANSI_ARGS_((Tcl_Event *evPtr, int flags)); |
---|
| 669 | typedef void (Tcl_EventCheckProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 670 | int flags)); |
---|
| 671 | typedef int (Tcl_EventDeleteProc) _ANSI_ARGS_((Tcl_Event *evPtr, |
---|
| 672 | ClientData clientData)); |
---|
| 673 | typedef void (Tcl_EventSetupProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 674 | int flags)); |
---|
| 675 | typedef void (Tcl_ExitProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 676 | typedef void (Tcl_FileProc) _ANSI_ARGS_((ClientData clientData, int mask)); |
---|
| 677 | typedef void (Tcl_FileFreeProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 678 | typedef void (Tcl_FreeInternalRepProc) _ANSI_ARGS_((struct Tcl_Obj *objPtr)); |
---|
| 679 | typedef void (Tcl_FreeProc) _ANSI_ARGS_((char *blockPtr)); |
---|
| 680 | typedef void (Tcl_IdleProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 681 | typedef void (Tcl_InterpDeleteProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 682 | Tcl_Interp *interp)); |
---|
| 683 | typedef int (Tcl_MathProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 684 | Tcl_Interp *interp, Tcl_Value *args, Tcl_Value *resultPtr)); |
---|
| 685 | typedef void (Tcl_NamespaceDeleteProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 686 | typedef int (Tcl_ObjCmdProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 687 | Tcl_Interp *interp, int objc, struct Tcl_Obj * CONST * objv)); |
---|
| 688 | typedef int (Tcl_PackageInitProc) _ANSI_ARGS_((Tcl_Interp *interp)); |
---|
| 689 | typedef int (Tcl_PackageUnloadProc) _ANSI_ARGS_((Tcl_Interp *interp, |
---|
| 690 | int flags)); |
---|
| 691 | typedef void (Tcl_PanicProc) _ANSI_ARGS_((CONST char *format, ...)); |
---|
| 692 | typedef void (Tcl_TcpAcceptProc) _ANSI_ARGS_((ClientData callbackData, |
---|
| 693 | Tcl_Channel chan, char *address, int port)); |
---|
| 694 | typedef void (Tcl_TimerProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 695 | typedef int (Tcl_SetFromAnyProc) _ANSI_ARGS_((Tcl_Interp *interp, |
---|
| 696 | struct Tcl_Obj *objPtr)); |
---|
| 697 | typedef void (Tcl_UpdateStringProc) _ANSI_ARGS_((struct Tcl_Obj *objPtr)); |
---|
| 698 | typedef char *(Tcl_VarTraceProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 699 | Tcl_Interp *interp, CONST84 char *part1, CONST84 char *part2, |
---|
| 700 | int flags)); |
---|
| 701 | typedef void (Tcl_CommandTraceProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 702 | Tcl_Interp *interp, CONST char *oldName, CONST char *newName, |
---|
| 703 | int flags)); |
---|
| 704 | typedef void (Tcl_CreateFileHandlerProc) _ANSI_ARGS_((int fd, int mask, |
---|
| 705 | Tcl_FileProc *proc, ClientData clientData)); |
---|
| 706 | typedef void (Tcl_DeleteFileHandlerProc) _ANSI_ARGS_((int fd)); |
---|
| 707 | typedef void (Tcl_AlertNotifierProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 708 | typedef void (Tcl_ServiceModeHookProc) _ANSI_ARGS_((int mode)); |
---|
| 709 | typedef ClientData (Tcl_InitNotifierProc) _ANSI_ARGS_((VOID)); |
---|
| 710 | typedef void (Tcl_FinalizeNotifierProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 711 | typedef void (Tcl_MainLoopProc) _ANSI_ARGS_((void)); |
---|
| 712 | |
---|
| 713 | /* |
---|
| 714 | * The following structure represents a type of object, which is a particular |
---|
| 715 | * internal representation for an object plus a set of functions that provide |
---|
| 716 | * standard operations on objects of that type. |
---|
| 717 | */ |
---|
| 718 | |
---|
| 719 | typedef struct Tcl_ObjType { |
---|
| 720 | char *name; /* Name of the type, e.g. "int". */ |
---|
| 721 | Tcl_FreeInternalRepProc *freeIntRepProc; |
---|
| 722 | /* Called to free any storage for the type's |
---|
| 723 | * internal rep. NULL if the internal rep does |
---|
| 724 | * not need freeing. */ |
---|
| 725 | Tcl_DupInternalRepProc *dupIntRepProc; |
---|
| 726 | /* Called to create a new object as a copy of |
---|
| 727 | * an existing object. */ |
---|
| 728 | Tcl_UpdateStringProc *updateStringProc; |
---|
| 729 | /* Called to update the string rep from the |
---|
| 730 | * type's internal representation. */ |
---|
| 731 | Tcl_SetFromAnyProc *setFromAnyProc; |
---|
| 732 | /* Called to convert the object's internal rep |
---|
| 733 | * to this type. Frees the internal rep of the |
---|
| 734 | * old type. Returns TCL_ERROR on failure. */ |
---|
| 735 | } Tcl_ObjType; |
---|
| 736 | |
---|
| 737 | /* |
---|
| 738 | * One of the following structures exists for each object in the Tcl system. |
---|
| 739 | * An object stores a value as either a string, some internal representation, |
---|
| 740 | * or both. |
---|
| 741 | */ |
---|
| 742 | |
---|
| 743 | typedef struct Tcl_Obj { |
---|
| 744 | int refCount; /* When 0 the object will be freed. */ |
---|
| 745 | char *bytes; /* This points to the first byte of the |
---|
| 746 | * object's string representation. The array |
---|
| 747 | * must be followed by a null byte (i.e., at |
---|
| 748 | * offset length) but may also contain |
---|
| 749 | * embedded null characters. The array's |
---|
| 750 | * storage is allocated by ckalloc. NULL means |
---|
| 751 | * the string rep is invalid and must be |
---|
| 752 | * regenerated from the internal rep. Clients |
---|
| 753 | * should use Tcl_GetStringFromObj or |
---|
| 754 | * Tcl_GetString to get a pointer to the byte |
---|
| 755 | * array as a readonly value. */ |
---|
| 756 | int length; /* The number of bytes at *bytes, not |
---|
| 757 | * including the terminating null. */ |
---|
| 758 | Tcl_ObjType *typePtr; /* Denotes the object's type. Always |
---|
| 759 | * corresponds to the type of the object's |
---|
| 760 | * internal rep. NULL indicates the object has |
---|
| 761 | * no internal rep (has no type). */ |
---|
| 762 | union { /* The internal representation: */ |
---|
| 763 | long longValue; /* - an long integer value */ |
---|
| 764 | double doubleValue; /* - a double-precision floating value */ |
---|
| 765 | VOID *otherValuePtr; /* - another, type-specific value */ |
---|
| 766 | Tcl_WideInt wideValue; /* - a long long value */ |
---|
| 767 | struct { /* - internal rep as two pointers */ |
---|
| 768 | VOID *ptr1; |
---|
| 769 | VOID *ptr2; |
---|
| 770 | } twoPtrValue; |
---|
| 771 | struct { /* - internal rep as a wide int, tightly |
---|
| 772 | * packed fields */ |
---|
| 773 | VOID *ptr; /* Pointer to digits */ |
---|
| 774 | unsigned long value;/* Alloc, used, and signum packed into a |
---|
| 775 | * single word */ |
---|
| 776 | } ptrAndLongRep; |
---|
| 777 | } internalRep; |
---|
| 778 | } Tcl_Obj; |
---|
| 779 | |
---|
| 780 | /* |
---|
| 781 | * Macros to increment and decrement a Tcl_Obj's reference count, and to test |
---|
| 782 | * whether an object is shared (i.e. has reference count > 1). Note: clients |
---|
| 783 | * should use Tcl_DecrRefCount() when they are finished using an object, and |
---|
| 784 | * should never call TclFreeObj() directly. TclFreeObj() is only defined and |
---|
| 785 | * made public in tcl.h to support Tcl_DecrRefCount's macro definition. Note |
---|
| 786 | * also that Tcl_DecrRefCount() refers to the parameter "obj" twice. This |
---|
| 787 | * means that you should avoid calling it with an expression that is expensive |
---|
| 788 | * to compute or has side effects. |
---|
| 789 | */ |
---|
| 790 | |
---|
| 791 | void Tcl_IncrRefCount _ANSI_ARGS_((Tcl_Obj *objPtr)); |
---|
| 792 | void Tcl_DecrRefCount _ANSI_ARGS_((Tcl_Obj *objPtr)); |
---|
| 793 | int Tcl_IsShared _ANSI_ARGS_((Tcl_Obj *objPtr)); |
---|
| 794 | |
---|
| 795 | /* |
---|
| 796 | * The following structure contains the state needed by Tcl_SaveResult. No-one |
---|
| 797 | * outside of Tcl should access any of these fields. This structure is |
---|
| 798 | * typically allocated on the stack. |
---|
| 799 | */ |
---|
| 800 | |
---|
| 801 | typedef struct Tcl_SavedResult { |
---|
| 802 | char *result; |
---|
| 803 | Tcl_FreeProc *freeProc; |
---|
| 804 | Tcl_Obj *objResultPtr; |
---|
| 805 | char *appendResult; |
---|
| 806 | int appendAvl; |
---|
| 807 | int appendUsed; |
---|
| 808 | char resultSpace[TCL_RESULT_SIZE+1]; |
---|
| 809 | } Tcl_SavedResult; |
---|
| 810 | |
---|
| 811 | /* |
---|
| 812 | * The following definitions support Tcl's namespace facility. Note: the first |
---|
| 813 | * five fields must match exactly the fields in a Namespace structure (see |
---|
| 814 | * tclInt.h). |
---|
| 815 | */ |
---|
| 816 | |
---|
| 817 | typedef struct Tcl_Namespace { |
---|
| 818 | char *name; /* The namespace's name within its parent |
---|
| 819 | * namespace. This contains no ::'s. The name |
---|
| 820 | * of the global namespace is "" although "::" |
---|
| 821 | * is an synonym. */ |
---|
| 822 | char *fullName; /* The namespace's fully qualified name. This |
---|
| 823 | * starts with ::. */ |
---|
| 824 | ClientData clientData; /* Arbitrary value associated with this |
---|
| 825 | * namespace. */ |
---|
| 826 | Tcl_NamespaceDeleteProc *deleteProc; |
---|
| 827 | /* Function invoked when deleting the |
---|
| 828 | * namespace to, e.g., free clientData. */ |
---|
| 829 | struct Tcl_Namespace *parentPtr; |
---|
| 830 | /* Points to the namespace that contains this |
---|
| 831 | * one. NULL if this is the global |
---|
| 832 | * namespace. */ |
---|
| 833 | } Tcl_Namespace; |
---|
| 834 | |
---|
| 835 | /* |
---|
| 836 | * The following structure represents a call frame, or activation record. A |
---|
| 837 | * call frame defines a naming context for a procedure call: its local scope |
---|
| 838 | * (for local variables) and its namespace scope (used for non-local |
---|
| 839 | * variables; often the global :: namespace). A call frame can also define the |
---|
| 840 | * naming context for a namespace eval or namespace inscope command: the |
---|
| 841 | * namespace in which the command's code should execute. The Tcl_CallFrame |
---|
| 842 | * structures exist only while procedures or namespace eval/inscope's are |
---|
| 843 | * being executed, and provide a Tcl call stack. |
---|
| 844 | * |
---|
| 845 | * A call frame is initialized and pushed using Tcl_PushCallFrame and popped |
---|
| 846 | * using Tcl_PopCallFrame. Storage for a Tcl_CallFrame must be provided by the |
---|
| 847 | * Tcl_PushCallFrame caller, and callers typically allocate them on the C call |
---|
| 848 | * stack for efficiency. For this reason, Tcl_CallFrame is defined as a |
---|
| 849 | * structure and not as an opaque token. However, most Tcl_CallFrame fields |
---|
| 850 | * are hidden since applications should not access them directly; others are |
---|
| 851 | * declared as "dummyX". |
---|
| 852 | * |
---|
| 853 | * WARNING!! The structure definition must be kept consistent with the |
---|
| 854 | * CallFrame structure in tclInt.h. If you change one, change the other. |
---|
| 855 | */ |
---|
| 856 | |
---|
| 857 | typedef struct Tcl_CallFrame { |
---|
| 858 | Tcl_Namespace *nsPtr; |
---|
| 859 | int dummy1; |
---|
| 860 | int dummy2; |
---|
| 861 | char *dummy3; |
---|
| 862 | char *dummy4; |
---|
| 863 | char *dummy5; |
---|
| 864 | int dummy6; |
---|
| 865 | char *dummy7; |
---|
| 866 | char *dummy8; |
---|
| 867 | int dummy9; |
---|
| 868 | char *dummy10; |
---|
| 869 | char *dummy11; |
---|
| 870 | char *dummy12; |
---|
| 871 | } Tcl_CallFrame; |
---|
| 872 | |
---|
| 873 | /* |
---|
| 874 | * Information about commands that is returned by Tcl_GetCommandInfo and |
---|
| 875 | * passed to Tcl_SetCommandInfo. objProc is an objc/objv object-based command |
---|
| 876 | * function while proc is a traditional Tcl argc/argv string-based function. |
---|
| 877 | * Tcl_CreateObjCommand and Tcl_CreateCommand ensure that both objProc and |
---|
| 878 | * proc are non-NULL and can be called to execute the command. However, it may |
---|
| 879 | * be faster to call one instead of the other. The member isNativeObjectProc |
---|
| 880 | * is set to 1 if an object-based function was registered by |
---|
| 881 | * Tcl_CreateObjCommand, and to 0 if a string-based function was registered by |
---|
| 882 | * Tcl_CreateCommand. The other function is typically set to a compatibility |
---|
| 883 | * wrapper that does string-to-object or object-to-string argument conversions |
---|
| 884 | * then calls the other function. |
---|
| 885 | */ |
---|
| 886 | |
---|
| 887 | typedef struct Tcl_CmdInfo { |
---|
| 888 | int isNativeObjectProc; /* 1 if objProc was registered by a call to |
---|
| 889 | * Tcl_CreateObjCommand; 0 otherwise. |
---|
| 890 | * Tcl_SetCmdInfo does not modify this |
---|
| 891 | * field. */ |
---|
| 892 | Tcl_ObjCmdProc *objProc; /* Command's object-based function. */ |
---|
| 893 | ClientData objClientData; /* ClientData for object proc. */ |
---|
| 894 | Tcl_CmdProc *proc; /* Command's string-based function. */ |
---|
| 895 | ClientData clientData; /* ClientData for string proc. */ |
---|
| 896 | Tcl_CmdDeleteProc *deleteProc; |
---|
| 897 | /* Function to call when command is |
---|
| 898 | * deleted. */ |
---|
| 899 | ClientData deleteData; /* Value to pass to deleteProc (usually the |
---|
| 900 | * same as clientData). */ |
---|
| 901 | Tcl_Namespace *namespacePtr;/* Points to the namespace that contains this |
---|
| 902 | * command. Note that Tcl_SetCmdInfo will not |
---|
| 903 | * change a command's namespace; use |
---|
| 904 | * TclRenameCommand or Tcl_Eval (of 'rename') |
---|
| 905 | * to do that. */ |
---|
| 906 | } Tcl_CmdInfo; |
---|
| 907 | |
---|
| 908 | /* |
---|
| 909 | * The structure defined below is used to hold dynamic strings. The only |
---|
| 910 | * fields that clients should use are string and length, accessible via the |
---|
| 911 | * macros Tcl_DStringValue and Tcl_DStringLength. |
---|
| 912 | */ |
---|
| 913 | |
---|
| 914 | #define TCL_DSTRING_STATIC_SIZE 200 |
---|
| 915 | typedef struct Tcl_DString { |
---|
| 916 | char *string; /* Points to beginning of string: either |
---|
| 917 | * staticSpace below or a malloced array. */ |
---|
| 918 | int length; /* Number of non-NULL characters in the |
---|
| 919 | * string. */ |
---|
| 920 | int spaceAvl; /* Total number of bytes available for the |
---|
| 921 | * string and its terminating NULL char. */ |
---|
| 922 | char staticSpace[TCL_DSTRING_STATIC_SIZE]; |
---|
| 923 | /* Space to use in common case where string is |
---|
| 924 | * small. */ |
---|
| 925 | } Tcl_DString; |
---|
| 926 | |
---|
| 927 | #define Tcl_DStringLength(dsPtr) ((dsPtr)->length) |
---|
| 928 | #define Tcl_DStringValue(dsPtr) ((dsPtr)->string) |
---|
| 929 | #define Tcl_DStringTrunc Tcl_DStringSetLength |
---|
| 930 | |
---|
| 931 | /* |
---|
| 932 | * Definitions for the maximum number of digits of precision that may be |
---|
| 933 | * specified in the "tcl_precision" variable, and the number of bytes of |
---|
| 934 | * buffer space required by Tcl_PrintDouble. |
---|
| 935 | */ |
---|
| 936 | |
---|
| 937 | #define TCL_MAX_PREC 17 |
---|
| 938 | #define TCL_DOUBLE_SPACE (TCL_MAX_PREC+10) |
---|
| 939 | |
---|
| 940 | /* |
---|
| 941 | * Definition for a number of bytes of buffer space sufficient to hold the |
---|
| 942 | * string representation of an integer in base 10 (assuming the existence of |
---|
| 943 | * 64-bit integers). |
---|
| 944 | */ |
---|
| 945 | |
---|
| 946 | #define TCL_INTEGER_SPACE 24 |
---|
| 947 | |
---|
| 948 | /* |
---|
| 949 | * Flag values passed to Tcl_ConvertElement. |
---|
| 950 | * TCL_DONT_USE_BRACES forces it not to enclose the element in braces, but to |
---|
| 951 | * use backslash quoting instead. |
---|
| 952 | * TCL_DONT_QUOTE_HASH disables the default quoting of the '#' character. It |
---|
| 953 | * is safe to leave the hash unquoted when the element is not the first |
---|
| 954 | * element of a list, and this flag can be used by the caller to indicate |
---|
| 955 | * that condition. |
---|
| 956 | * (Careful! If you change these flag values be sure to change the definitions |
---|
| 957 | * at the front of tclUtil.c). |
---|
| 958 | */ |
---|
| 959 | |
---|
| 960 | #define TCL_DONT_USE_BRACES 1 |
---|
| 961 | #define TCL_DONT_QUOTE_HASH 8 |
---|
| 962 | |
---|
| 963 | /* |
---|
| 964 | * Flag that may be passed to Tcl_GetIndexFromObj to force it to disallow |
---|
| 965 | * abbreviated strings. |
---|
| 966 | */ |
---|
| 967 | |
---|
| 968 | #define TCL_EXACT 1 |
---|
| 969 | |
---|
| 970 | /* |
---|
| 971 | * Flag values passed to Tcl_RecordAndEval, Tcl_EvalObj, Tcl_EvalObjv. |
---|
| 972 | * WARNING: these bit choices must not conflict with the bit choices for |
---|
| 973 | * evalFlag bits in tclInt.h! |
---|
| 974 | * |
---|
| 975 | * Meanings: |
---|
| 976 | * TCL_NO_EVAL: Just record this command |
---|
| 977 | * TCL_EVAL_GLOBAL: Execute script in global namespace |
---|
| 978 | * TCL_EVAL_DIRECT: Do not compile this script |
---|
| 979 | * TCL_EVAL_INVOKE: Magical Tcl_EvalObjv mode for aliases/ensembles |
---|
| 980 | * o Run in iPtr->lookupNsPtr or global namespace |
---|
| 981 | * o Cut out of error traces |
---|
| 982 | * o Don't reset the flags controlling ensemble |
---|
| 983 | * error message rewriting. |
---|
| 984 | */ |
---|
| 985 | #define TCL_NO_EVAL 0x10000 |
---|
| 986 | #define TCL_EVAL_GLOBAL 0x20000 |
---|
| 987 | #define TCL_EVAL_DIRECT 0x40000 |
---|
| 988 | #define TCL_EVAL_INVOKE 0x80000 |
---|
| 989 | |
---|
| 990 | /* |
---|
| 991 | * Special freeProc values that may be passed to Tcl_SetResult (see the man |
---|
| 992 | * page for details): |
---|
| 993 | */ |
---|
| 994 | |
---|
| 995 | #define TCL_VOLATILE ((Tcl_FreeProc *) 1) |
---|
| 996 | #define TCL_STATIC ((Tcl_FreeProc *) 0) |
---|
| 997 | #define TCL_DYNAMIC ((Tcl_FreeProc *) 3) |
---|
| 998 | |
---|
| 999 | /* |
---|
| 1000 | * Flag values passed to variable-related functions. |
---|
| 1001 | */ |
---|
| 1002 | |
---|
| 1003 | #define TCL_GLOBAL_ONLY 1 |
---|
| 1004 | #define TCL_NAMESPACE_ONLY 2 |
---|
| 1005 | #define TCL_APPEND_VALUE 4 |
---|
| 1006 | #define TCL_LIST_ELEMENT 8 |
---|
| 1007 | #define TCL_TRACE_READS 0x10 |
---|
| 1008 | #define TCL_TRACE_WRITES 0x20 |
---|
| 1009 | #define TCL_TRACE_UNSETS 0x40 |
---|
| 1010 | #define TCL_TRACE_DESTROYED 0x80 |
---|
| 1011 | #define TCL_INTERP_DESTROYED 0x100 |
---|
| 1012 | #define TCL_LEAVE_ERR_MSG 0x200 |
---|
| 1013 | #define TCL_TRACE_ARRAY 0x800 |
---|
| 1014 | #ifndef TCL_REMOVE_OBSOLETE_TRACES |
---|
| 1015 | /* Required to support old variable/vdelete/vinfo traces */ |
---|
| 1016 | #define TCL_TRACE_OLD_STYLE 0x1000 |
---|
| 1017 | #endif |
---|
| 1018 | /* Indicate the semantics of the result of a trace */ |
---|
| 1019 | #define TCL_TRACE_RESULT_DYNAMIC 0x8000 |
---|
| 1020 | #define TCL_TRACE_RESULT_OBJECT 0x10000 |
---|
| 1021 | |
---|
| 1022 | /* |
---|
| 1023 | * Flag values for ensemble commands. |
---|
| 1024 | */ |
---|
| 1025 | |
---|
| 1026 | #define TCL_ENSEMBLE_PREFIX 0x02/* Flag value to say whether to allow |
---|
| 1027 | * unambiguous prefixes of commands or to |
---|
| 1028 | * require exact matches for command names. */ |
---|
| 1029 | |
---|
| 1030 | /* |
---|
| 1031 | * Flag values passed to command-related functions. |
---|
| 1032 | */ |
---|
| 1033 | |
---|
| 1034 | #define TCL_TRACE_RENAME 0x2000 |
---|
| 1035 | #define TCL_TRACE_DELETE 0x4000 |
---|
| 1036 | |
---|
| 1037 | #define TCL_ALLOW_INLINE_COMPILATION 0x20000 |
---|
| 1038 | |
---|
| 1039 | /* |
---|
| 1040 | * The TCL_PARSE_PART1 flag is deprecated and has no effect. The part1 is now |
---|
| 1041 | * always parsed whenever the part2 is NULL. (This is to avoid a common error |
---|
| 1042 | * when converting code to use the new object based APIs and forgetting to |
---|
| 1043 | * give the flag) |
---|
| 1044 | */ |
---|
| 1045 | |
---|
| 1046 | #ifndef TCL_NO_DEPRECATED |
---|
| 1047 | # define TCL_PARSE_PART1 0x400 |
---|
| 1048 | #endif |
---|
| 1049 | |
---|
| 1050 | /* |
---|
| 1051 | * Types for linked variables: |
---|
| 1052 | */ |
---|
| 1053 | |
---|
| 1054 | #define TCL_LINK_INT 1 |
---|
| 1055 | #define TCL_LINK_DOUBLE 2 |
---|
| 1056 | #define TCL_LINK_BOOLEAN 3 |
---|
| 1057 | #define TCL_LINK_STRING 4 |
---|
| 1058 | #define TCL_LINK_WIDE_INT 5 |
---|
| 1059 | #define TCL_LINK_CHAR 6 |
---|
| 1060 | #define TCL_LINK_UCHAR 7 |
---|
| 1061 | #define TCL_LINK_SHORT 8 |
---|
| 1062 | #define TCL_LINK_USHORT 9 |
---|
| 1063 | #define TCL_LINK_UINT 10 |
---|
| 1064 | #define TCL_LINK_LONG 11 |
---|
| 1065 | #define TCL_LINK_ULONG 12 |
---|
| 1066 | #define TCL_LINK_FLOAT 13 |
---|
| 1067 | #define TCL_LINK_WIDE_UINT 14 |
---|
| 1068 | #define TCL_LINK_READ_ONLY 0x80 |
---|
| 1069 | |
---|
| 1070 | /* |
---|
| 1071 | * Forward declarations of Tcl_HashTable and related types. |
---|
| 1072 | */ |
---|
| 1073 | |
---|
| 1074 | typedef struct Tcl_HashKeyType Tcl_HashKeyType; |
---|
| 1075 | typedef struct Tcl_HashTable Tcl_HashTable; |
---|
| 1076 | typedef struct Tcl_HashEntry Tcl_HashEntry; |
---|
| 1077 | |
---|
| 1078 | typedef unsigned int (Tcl_HashKeyProc) _ANSI_ARGS_((Tcl_HashTable *tablePtr, |
---|
| 1079 | VOID *keyPtr)); |
---|
| 1080 | typedef int (Tcl_CompareHashKeysProc) _ANSI_ARGS_((VOID *keyPtr, |
---|
| 1081 | Tcl_HashEntry *hPtr)); |
---|
| 1082 | typedef Tcl_HashEntry *(Tcl_AllocHashEntryProc) _ANSI_ARGS_(( |
---|
| 1083 | Tcl_HashTable *tablePtr, VOID *keyPtr)); |
---|
| 1084 | typedef void (Tcl_FreeHashEntryProc) _ANSI_ARGS_((Tcl_HashEntry *hPtr)); |
---|
| 1085 | |
---|
| 1086 | /* |
---|
| 1087 | * This flag controls whether the hash table stores the hash of a key, or |
---|
| 1088 | * recalculates it. There should be no reason for turning this flag off as it |
---|
| 1089 | * is completely binary and source compatible unless you directly access the |
---|
| 1090 | * bucketPtr member of the Tcl_HashTableEntry structure. This member has been |
---|
| 1091 | * removed and the space used to store the hash value. |
---|
| 1092 | */ |
---|
| 1093 | |
---|
| 1094 | #ifndef TCL_HASH_KEY_STORE_HASH |
---|
| 1095 | # define TCL_HASH_KEY_STORE_HASH 1 |
---|
| 1096 | #endif |
---|
| 1097 | |
---|
| 1098 | /* |
---|
| 1099 | * Structure definition for an entry in a hash table. No-one outside Tcl |
---|
| 1100 | * should access any of these fields directly; use the macros defined below. |
---|
| 1101 | */ |
---|
| 1102 | |
---|
| 1103 | struct Tcl_HashEntry { |
---|
| 1104 | Tcl_HashEntry *nextPtr; /* Pointer to next entry in this hash bucket, |
---|
| 1105 | * or NULL for end of chain. */ |
---|
| 1106 | Tcl_HashTable *tablePtr; /* Pointer to table containing entry. */ |
---|
| 1107 | #if TCL_HASH_KEY_STORE_HASH |
---|
| 1108 | VOID *hash; /* Hash value, stored as pointer to ensure |
---|
| 1109 | * that the offsets of the fields in this |
---|
| 1110 | * structure are not changed. */ |
---|
| 1111 | #else |
---|
| 1112 | Tcl_HashEntry **bucketPtr; /* Pointer to bucket that points to first |
---|
| 1113 | * entry in this entry's chain: used for |
---|
| 1114 | * deleting the entry. */ |
---|
| 1115 | #endif |
---|
| 1116 | ClientData clientData; /* Application stores something here with |
---|
| 1117 | * Tcl_SetHashValue. */ |
---|
| 1118 | union { /* Key has one of these forms: */ |
---|
| 1119 | char *oneWordValue; /* One-word value for key. */ |
---|
| 1120 | Tcl_Obj *objPtr; /* Tcl_Obj * key value. */ |
---|
| 1121 | int words[1]; /* Multiple integer words for key. The actual |
---|
| 1122 | * size will be as large as necessary for this |
---|
| 1123 | * table's keys. */ |
---|
| 1124 | char string[4]; /* String for key. The actual size will be as |
---|
| 1125 | * large as needed to hold the key. */ |
---|
| 1126 | } key; /* MUST BE LAST FIELD IN RECORD!! */ |
---|
| 1127 | }; |
---|
| 1128 | |
---|
| 1129 | /* |
---|
| 1130 | * Flags used in Tcl_HashKeyType. |
---|
| 1131 | * |
---|
| 1132 | * TCL_HASH_KEY_RANDOMIZE_HASH - |
---|
| 1133 | * There are some things, pointers for example |
---|
| 1134 | * which don't hash well because they do not use |
---|
| 1135 | * the lower bits. If this flag is set then the |
---|
| 1136 | * hash table will attempt to rectify this by |
---|
| 1137 | * randomising the bits and then using the upper |
---|
| 1138 | * N bits as the index into the table. |
---|
| 1139 | * TCL_HASH_KEY_SYSTEM_HASH - If this flag is set then all memory internally |
---|
| 1140 | * allocated for the hash table that is not for an |
---|
| 1141 | * entry will use the system heap. |
---|
| 1142 | */ |
---|
| 1143 | |
---|
| 1144 | #define TCL_HASH_KEY_RANDOMIZE_HASH 0x1 |
---|
| 1145 | #define TCL_HASH_KEY_SYSTEM_HASH 0x2 |
---|
| 1146 | |
---|
| 1147 | /* |
---|
| 1148 | * Structure definition for the methods associated with a hash table key type. |
---|
| 1149 | */ |
---|
| 1150 | |
---|
| 1151 | #define TCL_HASH_KEY_TYPE_VERSION 1 |
---|
| 1152 | struct Tcl_HashKeyType { |
---|
| 1153 | int version; /* Version of the table. If this structure is |
---|
| 1154 | * extended in future then the version can be |
---|
| 1155 | * used to distinguish between different |
---|
| 1156 | * structures. */ |
---|
| 1157 | int flags; /* Flags, see above for details. */ |
---|
| 1158 | Tcl_HashKeyProc *hashKeyProc; |
---|
| 1159 | /* Calculates a hash value for the key. If |
---|
| 1160 | * this is NULL then the pointer itself is |
---|
| 1161 | * used as a hash value. */ |
---|
| 1162 | Tcl_CompareHashKeysProc *compareKeysProc; |
---|
| 1163 | /* Compares two keys and returns zero if they |
---|
| 1164 | * do not match, and non-zero if they do. If |
---|
| 1165 | * this is NULL then the pointers are |
---|
| 1166 | * compared. */ |
---|
| 1167 | Tcl_AllocHashEntryProc *allocEntryProc; |
---|
| 1168 | /* Called to allocate memory for a new entry, |
---|
| 1169 | * i.e. if the key is a string then this could |
---|
| 1170 | * allocate a single block which contains |
---|
| 1171 | * enough space for both the entry and the |
---|
| 1172 | * string. Only the key field of the allocated |
---|
| 1173 | * Tcl_HashEntry structure needs to be filled |
---|
| 1174 | * in. If something else needs to be done to |
---|
| 1175 | * the key, i.e. incrementing a reference |
---|
| 1176 | * count then that should be done by this |
---|
| 1177 | * function. If this is NULL then Tcl_Alloc is |
---|
| 1178 | * used to allocate enough space for a |
---|
| 1179 | * Tcl_HashEntry and the key pointer is |
---|
| 1180 | * assigned to key.oneWordValue. */ |
---|
| 1181 | Tcl_FreeHashEntryProc *freeEntryProc; |
---|
| 1182 | /* Called to free memory associated with an |
---|
| 1183 | * entry. If something else needs to be done |
---|
| 1184 | * to the key, i.e. decrementing a reference |
---|
| 1185 | * count then that should be done by this |
---|
| 1186 | * function. If this is NULL then Tcl_Free is |
---|
| 1187 | * used to free the Tcl_HashEntry. */ |
---|
| 1188 | }; |
---|
| 1189 | |
---|
| 1190 | /* |
---|
| 1191 | * Structure definition for a hash table. Must be in tcl.h so clients can |
---|
| 1192 | * allocate space for these structures, but clients should never access any |
---|
| 1193 | * fields in this structure. |
---|
| 1194 | */ |
---|
| 1195 | |
---|
| 1196 | #define TCL_SMALL_HASH_TABLE 4 |
---|
| 1197 | struct Tcl_HashTable { |
---|
| 1198 | Tcl_HashEntry **buckets; /* Pointer to bucket array. Each element |
---|
| 1199 | * points to first entry in bucket's hash |
---|
| 1200 | * chain, or NULL. */ |
---|
| 1201 | Tcl_HashEntry *staticBuckets[TCL_SMALL_HASH_TABLE]; |
---|
| 1202 | /* Bucket array used for small tables (to |
---|
| 1203 | * avoid mallocs and frees). */ |
---|
| 1204 | int numBuckets; /* Total number of buckets allocated at |
---|
| 1205 | * **bucketPtr. */ |
---|
| 1206 | int numEntries; /* Total number of entries present in |
---|
| 1207 | * table. */ |
---|
| 1208 | int rebuildSize; /* Enlarge table when numEntries gets to be |
---|
| 1209 | * this large. */ |
---|
| 1210 | int downShift; /* Shift count used in hashing function. |
---|
| 1211 | * Designed to use high-order bits of |
---|
| 1212 | * randomized keys. */ |
---|
| 1213 | int mask; /* Mask value used in hashing function. */ |
---|
| 1214 | int keyType; /* Type of keys used in this table. It's |
---|
| 1215 | * either TCL_CUSTOM_KEYS, TCL_STRING_KEYS, |
---|
| 1216 | * TCL_ONE_WORD_KEYS, or an integer giving the |
---|
| 1217 | * number of ints that is the size of the |
---|
| 1218 | * key. */ |
---|
| 1219 | Tcl_HashEntry *(*findProc) _ANSI_ARGS_((Tcl_HashTable *tablePtr, |
---|
| 1220 | CONST char *key)); |
---|
| 1221 | Tcl_HashEntry *(*createProc) _ANSI_ARGS_((Tcl_HashTable *tablePtr, |
---|
| 1222 | CONST char *key, int *newPtr)); |
---|
| 1223 | Tcl_HashKeyType *typePtr; /* Type of the keys used in the |
---|
| 1224 | * Tcl_HashTable. */ |
---|
| 1225 | }; |
---|
| 1226 | |
---|
| 1227 | /* |
---|
| 1228 | * Structure definition for information used to keep track of searches through |
---|
| 1229 | * hash tables: |
---|
| 1230 | */ |
---|
| 1231 | |
---|
| 1232 | typedef struct Tcl_HashSearch { |
---|
| 1233 | Tcl_HashTable *tablePtr; /* Table being searched. */ |
---|
| 1234 | int nextIndex; /* Index of next bucket to be enumerated after |
---|
| 1235 | * present one. */ |
---|
| 1236 | Tcl_HashEntry *nextEntryPtr;/* Next entry to be enumerated in the current |
---|
| 1237 | * bucket. */ |
---|
| 1238 | } Tcl_HashSearch; |
---|
| 1239 | |
---|
| 1240 | /* |
---|
| 1241 | * Acceptable key types for hash tables: |
---|
| 1242 | * |
---|
| 1243 | * TCL_STRING_KEYS: The keys are strings, they are copied into the |
---|
| 1244 | * entry. |
---|
| 1245 | * TCL_ONE_WORD_KEYS: The keys are pointers, the pointer is stored |
---|
| 1246 | * in the entry. |
---|
| 1247 | * TCL_CUSTOM_TYPE_KEYS: The keys are arbitrary types which are copied |
---|
| 1248 | * into the entry. |
---|
| 1249 | * TCL_CUSTOM_PTR_KEYS: The keys are pointers to arbitrary types, the |
---|
| 1250 | * pointer is stored in the entry. |
---|
| 1251 | * |
---|
| 1252 | * While maintaining binary compatability the above have to be distinct values |
---|
| 1253 | * as they are used to differentiate between old versions of the hash table |
---|
| 1254 | * which don't have a typePtr and new ones which do. Once binary compatability |
---|
| 1255 | * is discarded in favour of making more wide spread changes TCL_STRING_KEYS |
---|
| 1256 | * can be the same as TCL_CUSTOM_TYPE_KEYS, and TCL_ONE_WORD_KEYS can be the |
---|
| 1257 | * same as TCL_CUSTOM_PTR_KEYS because they simply determine how the key is |
---|
| 1258 | * accessed from the entry and not the behaviour. |
---|
| 1259 | */ |
---|
| 1260 | |
---|
| 1261 | #define TCL_STRING_KEYS 0 |
---|
| 1262 | #define TCL_ONE_WORD_KEYS 1 |
---|
| 1263 | #define TCL_CUSTOM_TYPE_KEYS -2 |
---|
| 1264 | #define TCL_CUSTOM_PTR_KEYS -1 |
---|
| 1265 | |
---|
| 1266 | /* |
---|
| 1267 | * Structure definition for information used to keep track of searches through |
---|
| 1268 | * dictionaries. These fields should not be accessed by code outside |
---|
| 1269 | * tclDictObj.c |
---|
| 1270 | */ |
---|
| 1271 | |
---|
| 1272 | typedef struct { |
---|
| 1273 | void *next; /* Search position for underlying hash |
---|
| 1274 | * table. */ |
---|
| 1275 | int epoch; /* Epoch marker for dictionary being searched, |
---|
| 1276 | * or -1 if search has terminated. */ |
---|
| 1277 | Tcl_Dict dictionaryPtr; /* Reference to dictionary being searched. */ |
---|
| 1278 | } Tcl_DictSearch; |
---|
| 1279 | |
---|
| 1280 | /* |
---|
| 1281 | * Flag values to pass to Tcl_DoOneEvent to disable searches for some kinds of |
---|
| 1282 | * events: |
---|
| 1283 | */ |
---|
| 1284 | |
---|
| 1285 | #define TCL_DONT_WAIT (1<<1) |
---|
| 1286 | #define TCL_WINDOW_EVENTS (1<<2) |
---|
| 1287 | #define TCL_FILE_EVENTS (1<<3) |
---|
| 1288 | #define TCL_TIMER_EVENTS (1<<4) |
---|
| 1289 | #define TCL_IDLE_EVENTS (1<<5) /* WAS 0x10 ???? */ |
---|
| 1290 | #define TCL_ALL_EVENTS (~TCL_DONT_WAIT) |
---|
| 1291 | |
---|
| 1292 | /* |
---|
| 1293 | * The following structure defines a generic event for the Tcl event system. |
---|
| 1294 | * These are the things that are queued in calls to Tcl_QueueEvent and |
---|
| 1295 | * serviced later by Tcl_DoOneEvent. There can be many different kinds of |
---|
| 1296 | * events with different fields, corresponding to window events, timer events, |
---|
| 1297 | * etc. The structure for a particular event consists of a Tcl_Event header |
---|
| 1298 | * followed by additional information specific to that event. |
---|
| 1299 | */ |
---|
| 1300 | |
---|
| 1301 | struct Tcl_Event { |
---|
| 1302 | Tcl_EventProc *proc; /* Function to call to service this event. */ |
---|
| 1303 | struct Tcl_Event *nextPtr; /* Next in list of pending events, or NULL. */ |
---|
| 1304 | }; |
---|
| 1305 | |
---|
| 1306 | /* |
---|
| 1307 | * Positions to pass to Tcl_QueueEvent: |
---|
| 1308 | */ |
---|
| 1309 | |
---|
| 1310 | typedef enum { |
---|
| 1311 | TCL_QUEUE_TAIL, TCL_QUEUE_HEAD, TCL_QUEUE_MARK |
---|
| 1312 | } Tcl_QueuePosition; |
---|
| 1313 | |
---|
| 1314 | /* |
---|
| 1315 | * Values to pass to Tcl_SetServiceMode to specify the behavior of notifier |
---|
| 1316 | * event routines. |
---|
| 1317 | */ |
---|
| 1318 | |
---|
| 1319 | #define TCL_SERVICE_NONE 0 |
---|
| 1320 | #define TCL_SERVICE_ALL 1 |
---|
| 1321 | |
---|
| 1322 | /* |
---|
| 1323 | * The following structure keeps is used to hold a time value, either as an |
---|
| 1324 | * absolute time (the number of seconds from the epoch) or as an elapsed time. |
---|
| 1325 | * On Unix systems the epoch is Midnight Jan 1, 1970 GMT. |
---|
| 1326 | */ |
---|
| 1327 | |
---|
| 1328 | typedef struct Tcl_Time { |
---|
| 1329 | long sec; /* Seconds. */ |
---|
| 1330 | long usec; /* Microseconds. */ |
---|
| 1331 | } Tcl_Time; |
---|
| 1332 | |
---|
| 1333 | typedef void (Tcl_SetTimerProc) _ANSI_ARGS_((Tcl_Time *timePtr)); |
---|
| 1334 | typedef int (Tcl_WaitForEventProc) _ANSI_ARGS_((Tcl_Time *timePtr)); |
---|
| 1335 | |
---|
| 1336 | /* |
---|
| 1337 | * TIP #233 (Virtualized Time) |
---|
| 1338 | */ |
---|
| 1339 | |
---|
| 1340 | typedef void (Tcl_GetTimeProc) _ANSI_ARGS_((Tcl_Time *timebuf, |
---|
| 1341 | ClientData clientData)); |
---|
| 1342 | typedef void (Tcl_ScaleTimeProc) _ANSI_ARGS_((Tcl_Time *timebuf, |
---|
| 1343 | ClientData clientData)); |
---|
| 1344 | |
---|
| 1345 | /* |
---|
| 1346 | * Bits to pass to Tcl_CreateFileHandler and Tcl_CreateChannelHandler to |
---|
| 1347 | * indicate what sorts of events are of interest: |
---|
| 1348 | */ |
---|
| 1349 | |
---|
| 1350 | #define TCL_READABLE (1<<1) |
---|
| 1351 | #define TCL_WRITABLE (1<<2) |
---|
| 1352 | #define TCL_EXCEPTION (1<<3) |
---|
| 1353 | |
---|
| 1354 | /* |
---|
| 1355 | * Flag values to pass to Tcl_OpenCommandChannel to indicate the disposition |
---|
| 1356 | * of the stdio handles. TCL_STDIN, TCL_STDOUT, TCL_STDERR, are also used in |
---|
| 1357 | * Tcl_GetStdChannel. |
---|
| 1358 | */ |
---|
| 1359 | |
---|
| 1360 | #define TCL_STDIN (1<<1) |
---|
| 1361 | #define TCL_STDOUT (1<<2) |
---|
| 1362 | #define TCL_STDERR (1<<3) |
---|
| 1363 | #define TCL_ENFORCE_MODE (1<<4) |
---|
| 1364 | |
---|
| 1365 | /* |
---|
| 1366 | * Bits passed to Tcl_DriverClose2Proc to indicate which side of a channel |
---|
| 1367 | * should be closed. |
---|
| 1368 | */ |
---|
| 1369 | |
---|
| 1370 | #define TCL_CLOSE_READ (1<<1) |
---|
| 1371 | #define TCL_CLOSE_WRITE (1<<2) |
---|
| 1372 | |
---|
| 1373 | /* |
---|
| 1374 | * Value to use as the closeProc for a channel that supports the close2Proc |
---|
| 1375 | * interface. |
---|
| 1376 | */ |
---|
| 1377 | |
---|
| 1378 | #define TCL_CLOSE2PROC ((Tcl_DriverCloseProc *)1) |
---|
| 1379 | |
---|
| 1380 | /* |
---|
| 1381 | * Channel version tag. This was introduced in 8.3.2/8.4. |
---|
| 1382 | */ |
---|
| 1383 | |
---|
| 1384 | #define TCL_CHANNEL_VERSION_1 ((Tcl_ChannelTypeVersion) 0x1) |
---|
| 1385 | #define TCL_CHANNEL_VERSION_2 ((Tcl_ChannelTypeVersion) 0x2) |
---|
| 1386 | #define TCL_CHANNEL_VERSION_3 ((Tcl_ChannelTypeVersion) 0x3) |
---|
| 1387 | #define TCL_CHANNEL_VERSION_4 ((Tcl_ChannelTypeVersion) 0x4) |
---|
| 1388 | #define TCL_CHANNEL_VERSION_5 ((Tcl_ChannelTypeVersion) 0x5) |
---|
| 1389 | |
---|
| 1390 | /* |
---|
| 1391 | * TIP #218: Channel Actions, Ids for Tcl_DriverThreadActionProc |
---|
| 1392 | */ |
---|
| 1393 | |
---|
| 1394 | #define TCL_CHANNEL_THREAD_INSERT (0) |
---|
| 1395 | #define TCL_CHANNEL_THREAD_REMOVE (1) |
---|
| 1396 | |
---|
| 1397 | /* |
---|
| 1398 | * Typedefs for the various operations in a channel type: |
---|
| 1399 | */ |
---|
| 1400 | |
---|
| 1401 | typedef int (Tcl_DriverBlockModeProc) _ANSI_ARGS_(( |
---|
| 1402 | ClientData instanceData, int mode)); |
---|
| 1403 | typedef int (Tcl_DriverCloseProc) _ANSI_ARGS_((ClientData instanceData, |
---|
| 1404 | Tcl_Interp *interp)); |
---|
| 1405 | typedef int (Tcl_DriverClose2Proc) _ANSI_ARGS_((ClientData instanceData, |
---|
| 1406 | Tcl_Interp *interp, int flags)); |
---|
| 1407 | typedef int (Tcl_DriverInputProc) _ANSI_ARGS_((ClientData instanceData, |
---|
| 1408 | char *buf, int toRead, int *errorCodePtr)); |
---|
| 1409 | typedef int (Tcl_DriverOutputProc) _ANSI_ARGS_((ClientData instanceData, |
---|
| 1410 | CONST84 char *buf, int toWrite, int *errorCodePtr)); |
---|
| 1411 | typedef int (Tcl_DriverSeekProc) _ANSI_ARGS_((ClientData instanceData, |
---|
| 1412 | long offset, int mode, int *errorCodePtr)); |
---|
| 1413 | typedef int (Tcl_DriverSetOptionProc) _ANSI_ARGS_(( |
---|
| 1414 | ClientData instanceData, Tcl_Interp *interp, |
---|
| 1415 | CONST char *optionName, CONST char *value)); |
---|
| 1416 | typedef int (Tcl_DriverGetOptionProc) _ANSI_ARGS_(( |
---|
| 1417 | ClientData instanceData, Tcl_Interp *interp, |
---|
| 1418 | CONST84 char *optionName, Tcl_DString *dsPtr)); |
---|
| 1419 | typedef void (Tcl_DriverWatchProc) _ANSI_ARGS_(( |
---|
| 1420 | ClientData instanceData, int mask)); |
---|
| 1421 | typedef int (Tcl_DriverGetHandleProc) _ANSI_ARGS_(( |
---|
| 1422 | ClientData instanceData, int direction, |
---|
| 1423 | ClientData *handlePtr)); |
---|
| 1424 | typedef int (Tcl_DriverFlushProc) _ANSI_ARGS_((ClientData instanceData)); |
---|
| 1425 | typedef int (Tcl_DriverHandlerProc) _ANSI_ARGS_(( |
---|
| 1426 | ClientData instanceData, int interestMask)); |
---|
| 1427 | typedef Tcl_WideInt (Tcl_DriverWideSeekProc) _ANSI_ARGS_(( |
---|
| 1428 | ClientData instanceData, Tcl_WideInt offset, |
---|
| 1429 | int mode, int *errorCodePtr)); |
---|
| 1430 | /* |
---|
| 1431 | * TIP #218, Channel Thread Actions |
---|
| 1432 | */ |
---|
| 1433 | typedef void (Tcl_DriverThreadActionProc) _ANSI_ARGS_ (( |
---|
| 1434 | ClientData instanceData, int action)); |
---|
| 1435 | /* |
---|
| 1436 | * TIP #208, File Truncation (etc.) |
---|
| 1437 | */ |
---|
| 1438 | typedef int (Tcl_DriverTruncateProc) _ANSI_ARGS_(( |
---|
| 1439 | ClientData instanceData, Tcl_WideInt length)); |
---|
| 1440 | |
---|
| 1441 | /* |
---|
| 1442 | * struct Tcl_ChannelType: |
---|
| 1443 | * |
---|
| 1444 | * One such structure exists for each type (kind) of channel. It collects |
---|
| 1445 | * together in one place all the functions that are part of the specific |
---|
| 1446 | * channel type. |
---|
| 1447 | * |
---|
| 1448 | * It is recommend that the Tcl_Channel* functions are used to access elements |
---|
| 1449 | * of this structure, instead of direct accessing. |
---|
| 1450 | */ |
---|
| 1451 | |
---|
| 1452 | typedef struct Tcl_ChannelType { |
---|
| 1453 | char *typeName; /* The name of the channel type in Tcl |
---|
| 1454 | * commands. This storage is owned by channel |
---|
| 1455 | * type. */ |
---|
| 1456 | Tcl_ChannelTypeVersion version; |
---|
| 1457 | /* Version of the channel type. */ |
---|
| 1458 | Tcl_DriverCloseProc *closeProc; |
---|
| 1459 | /* Function to call to close the channel, or |
---|
| 1460 | * TCL_CLOSE2PROC if the close2Proc should be |
---|
| 1461 | * used instead. */ |
---|
| 1462 | Tcl_DriverInputProc *inputProc; |
---|
| 1463 | /* Function to call for input on channel. */ |
---|
| 1464 | Tcl_DriverOutputProc *outputProc; |
---|
| 1465 | /* Function to call for output on channel. */ |
---|
| 1466 | Tcl_DriverSeekProc *seekProc; |
---|
| 1467 | /* Function to call to seek on the channel. |
---|
| 1468 | * May be NULL. */ |
---|
| 1469 | Tcl_DriverSetOptionProc *setOptionProc; |
---|
| 1470 | /* Set an option on a channel. */ |
---|
| 1471 | Tcl_DriverGetOptionProc *getOptionProc; |
---|
| 1472 | /* Get an option from a channel. */ |
---|
| 1473 | Tcl_DriverWatchProc *watchProc; |
---|
| 1474 | /* Set up the notifier to watch for events on |
---|
| 1475 | * this channel. */ |
---|
| 1476 | Tcl_DriverGetHandleProc *getHandleProc; |
---|
| 1477 | /* Get an OS handle from the channel or NULL |
---|
| 1478 | * if not supported. */ |
---|
| 1479 | Tcl_DriverClose2Proc *close2Proc; |
---|
| 1480 | /* Function to call to close the channel if |
---|
| 1481 | * the device supports closing the read & |
---|
| 1482 | * write sides independently. */ |
---|
| 1483 | Tcl_DriverBlockModeProc *blockModeProc; |
---|
| 1484 | /* Set blocking mode for the raw channel. May |
---|
| 1485 | * be NULL. */ |
---|
| 1486 | /* |
---|
| 1487 | * Only valid in TCL_CHANNEL_VERSION_2 channels or later |
---|
| 1488 | */ |
---|
| 1489 | Tcl_DriverFlushProc *flushProc; |
---|
| 1490 | /* Function to call to flush a channel. May be |
---|
| 1491 | * NULL. */ |
---|
| 1492 | Tcl_DriverHandlerProc *handlerProc; |
---|
| 1493 | /* Function to call to handle a channel event. |
---|
| 1494 | * This will be passed up the stacked channel |
---|
| 1495 | * chain. */ |
---|
| 1496 | /* |
---|
| 1497 | * Only valid in TCL_CHANNEL_VERSION_3 channels or later |
---|
| 1498 | */ |
---|
| 1499 | Tcl_DriverWideSeekProc *wideSeekProc; |
---|
| 1500 | /* Function to call to seek on the channel |
---|
| 1501 | * which can handle 64-bit offsets. May be |
---|
| 1502 | * NULL, and must be NULL if seekProc is |
---|
| 1503 | * NULL. */ |
---|
| 1504 | /* |
---|
| 1505 | * Only valid in TCL_CHANNEL_VERSION_4 channels or later |
---|
| 1506 | * TIP #218, Channel Thread Actions |
---|
| 1507 | */ |
---|
| 1508 | Tcl_DriverThreadActionProc *threadActionProc; |
---|
| 1509 | /* Function to call to notify the driver of |
---|
| 1510 | * thread specific activity for a channel. May |
---|
| 1511 | * be NULL. */ |
---|
| 1512 | |
---|
| 1513 | /* |
---|
| 1514 | * Only valid in TCL_CHANNEL_VERSION_5 channels or later |
---|
| 1515 | * TIP #208, File Truncation |
---|
| 1516 | */ |
---|
| 1517 | Tcl_DriverTruncateProc *truncateProc; |
---|
| 1518 | /* Function to call to truncate the underlying |
---|
| 1519 | * file to a particular length. May be NULL if |
---|
| 1520 | * the channel does not support truncation. */ |
---|
| 1521 | } Tcl_ChannelType; |
---|
| 1522 | |
---|
| 1523 | /* |
---|
| 1524 | * The following flags determine whether the blockModeProc above should set |
---|
| 1525 | * the channel into blocking or nonblocking mode. They are passed as arguments |
---|
| 1526 | * to the blockModeProc function in the above structure. |
---|
| 1527 | */ |
---|
| 1528 | |
---|
| 1529 | #define TCL_MODE_BLOCKING 0 /* Put channel into blocking mode. */ |
---|
| 1530 | #define TCL_MODE_NONBLOCKING 1 /* Put channel into nonblocking |
---|
| 1531 | * mode. */ |
---|
| 1532 | |
---|
| 1533 | /* |
---|
| 1534 | * Enum for different types of file paths. |
---|
| 1535 | */ |
---|
| 1536 | |
---|
| 1537 | typedef enum Tcl_PathType { |
---|
| 1538 | TCL_PATH_ABSOLUTE, |
---|
| 1539 | TCL_PATH_RELATIVE, |
---|
| 1540 | TCL_PATH_VOLUME_RELATIVE |
---|
| 1541 | } Tcl_PathType; |
---|
| 1542 | |
---|
| 1543 | /* |
---|
| 1544 | * The following structure is used to pass glob type data amongst the various |
---|
| 1545 | * glob routines and Tcl_FSMatchInDirectory. |
---|
| 1546 | */ |
---|
| 1547 | |
---|
| 1548 | typedef struct Tcl_GlobTypeData { |
---|
| 1549 | int type; /* Corresponds to bcdpfls as in 'find -t' */ |
---|
| 1550 | int perm; /* Corresponds to file permissions */ |
---|
| 1551 | Tcl_Obj *macType; /* Acceptable mac type */ |
---|
| 1552 | Tcl_Obj *macCreator; /* Acceptable mac creator */ |
---|
| 1553 | } Tcl_GlobTypeData; |
---|
| 1554 | |
---|
| 1555 | /* |
---|
| 1556 | * Type and permission definitions for glob command |
---|
| 1557 | */ |
---|
| 1558 | |
---|
| 1559 | #define TCL_GLOB_TYPE_BLOCK (1<<0) |
---|
| 1560 | #define TCL_GLOB_TYPE_CHAR (1<<1) |
---|
| 1561 | #define TCL_GLOB_TYPE_DIR (1<<2) |
---|
| 1562 | #define TCL_GLOB_TYPE_PIPE (1<<3) |
---|
| 1563 | #define TCL_GLOB_TYPE_FILE (1<<4) |
---|
| 1564 | #define TCL_GLOB_TYPE_LINK (1<<5) |
---|
| 1565 | #define TCL_GLOB_TYPE_SOCK (1<<6) |
---|
| 1566 | #define TCL_GLOB_TYPE_MOUNT (1<<7) |
---|
| 1567 | |
---|
| 1568 | #define TCL_GLOB_PERM_RONLY (1<<0) |
---|
| 1569 | #define TCL_GLOB_PERM_HIDDEN (1<<1) |
---|
| 1570 | #define TCL_GLOB_PERM_R (1<<2) |
---|
| 1571 | #define TCL_GLOB_PERM_W (1<<3) |
---|
| 1572 | #define TCL_GLOB_PERM_X (1<<4) |
---|
| 1573 | |
---|
| 1574 | /* |
---|
| 1575 | * Flags for the unload callback function |
---|
| 1576 | */ |
---|
| 1577 | |
---|
| 1578 | #define TCL_UNLOAD_DETACH_FROM_INTERPRETER (1<<0) |
---|
| 1579 | #define TCL_UNLOAD_DETACH_FROM_PROCESS (1<<1) |
---|
| 1580 | |
---|
| 1581 | /* |
---|
| 1582 | * Typedefs for the various filesystem operations: |
---|
| 1583 | */ |
---|
| 1584 | |
---|
| 1585 | typedef int (Tcl_FSStatProc) _ANSI_ARGS_((Tcl_Obj *pathPtr, Tcl_StatBuf *buf)); |
---|
| 1586 | typedef int (Tcl_FSAccessProc) _ANSI_ARGS_((Tcl_Obj *pathPtr, int mode)); |
---|
| 1587 | typedef Tcl_Channel (Tcl_FSOpenFileChannelProc) _ANSI_ARGS_(( |
---|
| 1588 | Tcl_Interp *interp, Tcl_Obj *pathPtr, int mode, int permissions)); |
---|
| 1589 | typedef int (Tcl_FSMatchInDirectoryProc) _ANSI_ARGS_((Tcl_Interp *interp, |
---|
| 1590 | Tcl_Obj *result, Tcl_Obj *pathPtr, CONST char *pattern, |
---|
| 1591 | Tcl_GlobTypeData * types)); |
---|
| 1592 | typedef Tcl_Obj * (Tcl_FSGetCwdProc) _ANSI_ARGS_((Tcl_Interp *interp)); |
---|
| 1593 | typedef int (Tcl_FSChdirProc) _ANSI_ARGS_((Tcl_Obj *pathPtr)); |
---|
| 1594 | typedef int (Tcl_FSLstatProc) _ANSI_ARGS_((Tcl_Obj *pathPtr, |
---|
| 1595 | Tcl_StatBuf *buf)); |
---|
| 1596 | typedef int (Tcl_FSCreateDirectoryProc) _ANSI_ARGS_((Tcl_Obj *pathPtr)); |
---|
| 1597 | typedef int (Tcl_FSDeleteFileProc) _ANSI_ARGS_((Tcl_Obj *pathPtr)); |
---|
| 1598 | typedef int (Tcl_FSCopyDirectoryProc) _ANSI_ARGS_((Tcl_Obj *srcPathPtr, |
---|
| 1599 | Tcl_Obj *destPathPtr, Tcl_Obj **errorPtr)); |
---|
| 1600 | typedef int (Tcl_FSCopyFileProc) _ANSI_ARGS_((Tcl_Obj *srcPathPtr, |
---|
| 1601 | Tcl_Obj *destPathPtr)); |
---|
| 1602 | typedef int (Tcl_FSRemoveDirectoryProc) _ANSI_ARGS_((Tcl_Obj *pathPtr, |
---|
| 1603 | int recursive, Tcl_Obj **errorPtr)); |
---|
| 1604 | typedef int (Tcl_FSRenameFileProc) _ANSI_ARGS_((Tcl_Obj *srcPathPtr, |
---|
| 1605 | Tcl_Obj *destPathPtr)); |
---|
| 1606 | typedef void (Tcl_FSUnloadFileProc) _ANSI_ARGS_((Tcl_LoadHandle loadHandle)); |
---|
| 1607 | typedef Tcl_Obj * (Tcl_FSListVolumesProc) _ANSI_ARGS_((void)); |
---|
| 1608 | /* We have to declare the utime structure here. */ |
---|
| 1609 | struct utimbuf; |
---|
| 1610 | typedef int (Tcl_FSUtimeProc) _ANSI_ARGS_((Tcl_Obj *pathPtr, |
---|
| 1611 | struct utimbuf *tval)); |
---|
| 1612 | typedef int (Tcl_FSNormalizePathProc) _ANSI_ARGS_((Tcl_Interp *interp, |
---|
| 1613 | Tcl_Obj *pathPtr, int nextCheckpoint)); |
---|
| 1614 | typedef int (Tcl_FSFileAttrsGetProc) _ANSI_ARGS_((Tcl_Interp *interp, |
---|
| 1615 | int index, Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef)); |
---|
| 1616 | typedef CONST char ** (Tcl_FSFileAttrStringsProc) _ANSI_ARGS_(( |
---|
| 1617 | Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef)); |
---|
| 1618 | typedef int (Tcl_FSFileAttrsSetProc) _ANSI_ARGS_((Tcl_Interp *interp, |
---|
| 1619 | int index, Tcl_Obj *pathPtr, Tcl_Obj *objPtr)); |
---|
| 1620 | typedef Tcl_Obj * (Tcl_FSLinkProc) _ANSI_ARGS_((Tcl_Obj *pathPtr, |
---|
| 1621 | Tcl_Obj *toPtr, int linkType)); |
---|
| 1622 | typedef int (Tcl_FSLoadFileProc) _ANSI_ARGS_((Tcl_Interp * interp, |
---|
| 1623 | Tcl_Obj *pathPtr, Tcl_LoadHandle *handlePtr, |
---|
| 1624 | Tcl_FSUnloadFileProc **unloadProcPtr)); |
---|
| 1625 | typedef int (Tcl_FSPathInFilesystemProc) _ANSI_ARGS_((Tcl_Obj *pathPtr, |
---|
| 1626 | ClientData *clientDataPtr)); |
---|
| 1627 | typedef Tcl_Obj * (Tcl_FSFilesystemPathTypeProc) _ANSI_ARGS_(( |
---|
| 1628 | Tcl_Obj *pathPtr)); |
---|
| 1629 | typedef Tcl_Obj * (Tcl_FSFilesystemSeparatorProc) _ANSI_ARGS_(( |
---|
| 1630 | Tcl_Obj *pathPtr)); |
---|
| 1631 | typedef void (Tcl_FSFreeInternalRepProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 1632 | typedef ClientData (Tcl_FSDupInternalRepProc) _ANSI_ARGS_(( |
---|
| 1633 | ClientData clientData)); |
---|
| 1634 | typedef Tcl_Obj * (Tcl_FSInternalToNormalizedProc) _ANSI_ARGS_(( |
---|
| 1635 | ClientData clientData)); |
---|
| 1636 | typedef ClientData (Tcl_FSCreateInternalRepProc) _ANSI_ARGS_(( |
---|
| 1637 | Tcl_Obj *pathPtr)); |
---|
| 1638 | |
---|
| 1639 | typedef struct Tcl_FSVersion_ *Tcl_FSVersion; |
---|
| 1640 | |
---|
| 1641 | /* |
---|
| 1642 | *---------------------------------------------------------------- |
---|
| 1643 | * Data structures related to hooking into the filesystem |
---|
| 1644 | *---------------------------------------------------------------- |
---|
| 1645 | */ |
---|
| 1646 | |
---|
| 1647 | /* |
---|
| 1648 | * Filesystem version tag. This was introduced in 8.4. |
---|
| 1649 | */ |
---|
| 1650 | #define TCL_FILESYSTEM_VERSION_1 ((Tcl_FSVersion) 0x1) |
---|
| 1651 | |
---|
| 1652 | /* |
---|
| 1653 | * struct Tcl_Filesystem: |
---|
| 1654 | * |
---|
| 1655 | * One such structure exists for each type (kind) of filesystem. It collects |
---|
| 1656 | * together in one place all the functions that are part of the specific |
---|
| 1657 | * filesystem. Tcl always accesses the filesystem through one of these |
---|
| 1658 | * structures. |
---|
| 1659 | * |
---|
| 1660 | * Not all entries need be non-NULL; any which are NULL are simply ignored. |
---|
| 1661 | * However, a complete filesystem should provide all of these functions. The |
---|
| 1662 | * explanations in the structure show the importance of each function. |
---|
| 1663 | */ |
---|
| 1664 | |
---|
| 1665 | typedef struct Tcl_Filesystem { |
---|
| 1666 | CONST char *typeName; /* The name of the filesystem. */ |
---|
| 1667 | int structureLength; /* Length of this structure, so future binary |
---|
| 1668 | * compatibility can be assured. */ |
---|
| 1669 | Tcl_FSVersion version; /* Version of the filesystem type. */ |
---|
| 1670 | Tcl_FSPathInFilesystemProc *pathInFilesystemProc; |
---|
| 1671 | /* Function to check whether a path is in this |
---|
| 1672 | * filesystem. This is the most important |
---|
| 1673 | * filesystem function. */ |
---|
| 1674 | Tcl_FSDupInternalRepProc *dupInternalRepProc; |
---|
| 1675 | /* Function to duplicate internal fs rep. May |
---|
| 1676 | * be NULL (but then fs is less efficient). */ |
---|
| 1677 | Tcl_FSFreeInternalRepProc *freeInternalRepProc; |
---|
| 1678 | /* Function to free internal fs rep. Must be |
---|
| 1679 | * implemented if internal representations |
---|
| 1680 | * need freeing, otherwise it can be NULL. */ |
---|
| 1681 | Tcl_FSInternalToNormalizedProc *internalToNormalizedProc; |
---|
| 1682 | /* Function to convert internal representation |
---|
| 1683 | * to a normalized path. Only required if the |
---|
| 1684 | * fs creates pure path objects with no |
---|
| 1685 | * string/path representation. */ |
---|
| 1686 | Tcl_FSCreateInternalRepProc *createInternalRepProc; |
---|
| 1687 | /* Function to create a filesystem-specific |
---|
| 1688 | * internal representation. May be NULL if |
---|
| 1689 | * paths have no internal representation, or |
---|
| 1690 | * if the Tcl_FSPathInFilesystemProc for this |
---|
| 1691 | * filesystem always immediately creates an |
---|
| 1692 | * internal representation for paths it |
---|
| 1693 | * accepts. */ |
---|
| 1694 | Tcl_FSNormalizePathProc *normalizePathProc; |
---|
| 1695 | /* Function to normalize a path. Should be |
---|
| 1696 | * implemented for all filesystems which can |
---|
| 1697 | * have multiple string representations for |
---|
| 1698 | * the same path object. */ |
---|
| 1699 | Tcl_FSFilesystemPathTypeProc *filesystemPathTypeProc; |
---|
| 1700 | /* Function to determine the type of a path in |
---|
| 1701 | * this filesystem. May be NULL. */ |
---|
| 1702 | Tcl_FSFilesystemSeparatorProc *filesystemSeparatorProc; |
---|
| 1703 | /* Function to return the separator |
---|
| 1704 | * character(s) for this filesystem. Must be |
---|
| 1705 | * implemented. */ |
---|
| 1706 | Tcl_FSStatProc *statProc; /* Function to process a 'Tcl_FSStat()' call. |
---|
| 1707 | * Must be implemented for any reasonable |
---|
| 1708 | * filesystem. */ |
---|
| 1709 | Tcl_FSAccessProc *accessProc; |
---|
| 1710 | /* Function to process a 'Tcl_FSAccess()' |
---|
| 1711 | * call. Must be implemented for any |
---|
| 1712 | * reasonable filesystem. */ |
---|
| 1713 | Tcl_FSOpenFileChannelProc *openFileChannelProc; |
---|
| 1714 | /* Function to process a |
---|
| 1715 | * 'Tcl_FSOpenFileChannel()' call. Must be |
---|
| 1716 | * implemented for any reasonable |
---|
| 1717 | * filesystem. */ |
---|
| 1718 | Tcl_FSMatchInDirectoryProc *matchInDirectoryProc; |
---|
| 1719 | /* Function to process a |
---|
| 1720 | * 'Tcl_FSMatchInDirectory()'. If not |
---|
| 1721 | * implemented, then glob and recursive copy |
---|
| 1722 | * functionality will be lacking in the |
---|
| 1723 | * filesystem. */ |
---|
| 1724 | Tcl_FSUtimeProc *utimeProc; /* Function to process a 'Tcl_FSUtime()' call. |
---|
| 1725 | * Required to allow setting (not reading) of |
---|
| 1726 | * times with 'file mtime', 'file atime' and |
---|
| 1727 | * the open-r/open-w/fcopy implementation of |
---|
| 1728 | * 'file copy'. */ |
---|
| 1729 | Tcl_FSLinkProc *linkProc; /* Function to process a 'Tcl_FSLink()' call. |
---|
| 1730 | * Should be implemented only if the |
---|
| 1731 | * filesystem supports links (reading or |
---|
| 1732 | * creating). */ |
---|
| 1733 | Tcl_FSListVolumesProc *listVolumesProc; |
---|
| 1734 | /* Function to list any filesystem volumes |
---|
| 1735 | * added by this filesystem. Should be |
---|
| 1736 | * implemented only if the filesystem adds |
---|
| 1737 | * volumes at the head of the filesystem. */ |
---|
| 1738 | Tcl_FSFileAttrStringsProc *fileAttrStringsProc; |
---|
| 1739 | /* Function to list all attributes strings |
---|
| 1740 | * which are valid for this filesystem. If not |
---|
| 1741 | * implemented the filesystem will not support |
---|
| 1742 | * the 'file attributes' command. This allows |
---|
| 1743 | * arbitrary additional information to be |
---|
| 1744 | * attached to files in the filesystem. */ |
---|
| 1745 | Tcl_FSFileAttrsGetProc *fileAttrsGetProc; |
---|
| 1746 | /* Function to process a |
---|
| 1747 | * 'Tcl_FSFileAttrsGet()' call, used by 'file |
---|
| 1748 | * attributes'. */ |
---|
| 1749 | Tcl_FSFileAttrsSetProc *fileAttrsSetProc; |
---|
| 1750 | /* Function to process a |
---|
| 1751 | * 'Tcl_FSFileAttrsSet()' call, used by 'file |
---|
| 1752 | * attributes'. */ |
---|
| 1753 | Tcl_FSCreateDirectoryProc *createDirectoryProc; |
---|
| 1754 | /* Function to process a |
---|
| 1755 | * 'Tcl_FSCreateDirectory()' call. Should be |
---|
| 1756 | * implemented unless the FS is read-only. */ |
---|
| 1757 | Tcl_FSRemoveDirectoryProc *removeDirectoryProc; |
---|
| 1758 | /* Function to process a |
---|
| 1759 | * 'Tcl_FSRemoveDirectory()' call. Should be |
---|
| 1760 | * implemented unless the FS is read-only. */ |
---|
| 1761 | Tcl_FSDeleteFileProc *deleteFileProc; |
---|
| 1762 | /* Function to process a 'Tcl_FSDeleteFile()' |
---|
| 1763 | * call. Should be implemented unless the FS |
---|
| 1764 | * is read-only. */ |
---|
| 1765 | Tcl_FSCopyFileProc *copyFileProc; |
---|
| 1766 | /* Function to process a 'Tcl_FSCopyFile()' |
---|
| 1767 | * call. If not implemented Tcl will fall back |
---|
| 1768 | * on open-r, open-w and fcopy as a copying |
---|
| 1769 | * mechanism, for copying actions initiated in |
---|
| 1770 | * Tcl (not C). */ |
---|
| 1771 | Tcl_FSRenameFileProc *renameFileProc; |
---|
| 1772 | /* Function to process a 'Tcl_FSRenameFile()' |
---|
| 1773 | * call. If not implemented, Tcl will fall |
---|
| 1774 | * back on a copy and delete mechanism, for |
---|
| 1775 | * rename actions initiated in Tcl (not C). */ |
---|
| 1776 | Tcl_FSCopyDirectoryProc *copyDirectoryProc; |
---|
| 1777 | /* Function to process a |
---|
| 1778 | * 'Tcl_FSCopyDirectory()' call. If not |
---|
| 1779 | * implemented, Tcl will fall back on a |
---|
| 1780 | * recursive create-dir, file copy mechanism, |
---|
| 1781 | * for copying actions initiated in Tcl (not |
---|
| 1782 | * C). */ |
---|
| 1783 | Tcl_FSLstatProc *lstatProc; /* Function to process a 'Tcl_FSLstat()' call. |
---|
| 1784 | * If not implemented, Tcl will attempt to use |
---|
| 1785 | * the 'statProc' defined above instead. */ |
---|
| 1786 | Tcl_FSLoadFileProc *loadFileProc; |
---|
| 1787 | /* Function to process a 'Tcl_FSLoadFile()' |
---|
| 1788 | * call. If not implemented, Tcl will fall |
---|
| 1789 | * back on a copy to native-temp followed by a |
---|
| 1790 | * Tcl_FSLoadFile on that temporary copy. */ |
---|
| 1791 | Tcl_FSGetCwdProc *getCwdProc; |
---|
| 1792 | /* Function to process a 'Tcl_FSGetCwd()' |
---|
| 1793 | * call. Most filesystems need not implement |
---|
| 1794 | * this. It will usually only be called once, |
---|
| 1795 | * if 'getcwd' is called before 'chdir'. May |
---|
| 1796 | * be NULL. */ |
---|
| 1797 | Tcl_FSChdirProc *chdirProc; /* Function to process a 'Tcl_FSChdir()' call. |
---|
| 1798 | * If filesystems do not implement this, it |
---|
| 1799 | * will be emulated by a series of directory |
---|
| 1800 | * access checks. Otherwise, virtual |
---|
| 1801 | * filesystems which do implement it need only |
---|
| 1802 | * respond with a positive return result if |
---|
| 1803 | * the dirName is a valid directory in their |
---|
| 1804 | * filesystem. They need not remember the |
---|
| 1805 | * result, since that will be automatically |
---|
| 1806 | * remembered for use by GetCwd. Real |
---|
| 1807 | * filesystems should carry out the correct |
---|
| 1808 | * action (i.e. call the correct system |
---|
| 1809 | * 'chdir' api). If not implemented, then 'cd' |
---|
| 1810 | * and 'pwd' will fail inside the |
---|
| 1811 | * filesystem. */ |
---|
| 1812 | } Tcl_Filesystem; |
---|
| 1813 | |
---|
| 1814 | /* |
---|
| 1815 | * The following definitions are used as values for the 'linkAction' flag to |
---|
| 1816 | * Tcl_FSLink, or the linkProc of any filesystem. Any combination of flags can |
---|
| 1817 | * be given. For link creation, the linkProc should create a link which |
---|
| 1818 | * matches any of the types given. |
---|
| 1819 | * |
---|
| 1820 | * TCL_CREATE_SYMBOLIC_LINK - Create a symbolic or soft link. |
---|
| 1821 | * TCL_CREATE_HARD_LINK - Create a hard link. |
---|
| 1822 | */ |
---|
| 1823 | |
---|
| 1824 | #define TCL_CREATE_SYMBOLIC_LINK 0x01 |
---|
| 1825 | #define TCL_CREATE_HARD_LINK 0x02 |
---|
| 1826 | |
---|
| 1827 | /* |
---|
| 1828 | * The following structure represents the Notifier functions that you can |
---|
| 1829 | * override with the Tcl_SetNotifier call. |
---|
| 1830 | */ |
---|
| 1831 | |
---|
| 1832 | typedef struct Tcl_NotifierProcs { |
---|
| 1833 | Tcl_SetTimerProc *setTimerProc; |
---|
| 1834 | Tcl_WaitForEventProc *waitForEventProc; |
---|
| 1835 | Tcl_CreateFileHandlerProc *createFileHandlerProc; |
---|
| 1836 | Tcl_DeleteFileHandlerProc *deleteFileHandlerProc; |
---|
| 1837 | Tcl_InitNotifierProc *initNotifierProc; |
---|
| 1838 | Tcl_FinalizeNotifierProc *finalizeNotifierProc; |
---|
| 1839 | Tcl_AlertNotifierProc *alertNotifierProc; |
---|
| 1840 | Tcl_ServiceModeHookProc *serviceModeHookProc; |
---|
| 1841 | } Tcl_NotifierProcs; |
---|
| 1842 | |
---|
| 1843 | /* |
---|
| 1844 | * The following structure represents a user-defined encoding. It collects |
---|
| 1845 | * together all the functions that are used by the specific encoding. |
---|
| 1846 | */ |
---|
| 1847 | |
---|
| 1848 | typedef struct Tcl_EncodingType { |
---|
| 1849 | CONST char *encodingName; /* The name of the encoding, e.g. "euc-jp". |
---|
| 1850 | * This name is the unique key for this |
---|
| 1851 | * encoding type. */ |
---|
| 1852 | Tcl_EncodingConvertProc *toUtfProc; |
---|
| 1853 | /* Function to convert from external encoding |
---|
| 1854 | * into UTF-8. */ |
---|
| 1855 | Tcl_EncodingConvertProc *fromUtfProc; |
---|
| 1856 | /* Function to convert from UTF-8 into |
---|
| 1857 | * external encoding. */ |
---|
| 1858 | Tcl_EncodingFreeProc *freeProc; |
---|
| 1859 | /* If non-NULL, function to call when this |
---|
| 1860 | * encoding is deleted. */ |
---|
| 1861 | ClientData clientData; /* Arbitrary value associated with encoding |
---|
| 1862 | * type. Passed to conversion functions. */ |
---|
| 1863 | int nullSize; /* Number of zero bytes that signify |
---|
| 1864 | * end-of-string in this encoding. This number |
---|
| 1865 | * is used to determine the source string |
---|
| 1866 | * length when the srcLen argument is |
---|
| 1867 | * negative. Must be 1 or 2. */ |
---|
| 1868 | } Tcl_EncodingType; |
---|
| 1869 | |
---|
| 1870 | /* |
---|
| 1871 | * The following definitions are used as values for the conversion control |
---|
| 1872 | * flags argument when converting text from one character set to another: |
---|
| 1873 | * |
---|
| 1874 | * TCL_ENCODING_START - Signifies that the source buffer is the first |
---|
| 1875 | * block in a (potentially multi-block) input |
---|
| 1876 | * stream. Tells the conversion function to reset |
---|
| 1877 | * to an initial state and perform any |
---|
| 1878 | * initialization that needs to occur before the |
---|
| 1879 | * first byte is converted. If the source buffer |
---|
| 1880 | * contains the entire input stream to be |
---|
| 1881 | * converted, this flag should be set. |
---|
| 1882 | * TCL_ENCODING_END - Signifies that the source buffer is the last |
---|
| 1883 | * block in a (potentially multi-block) input |
---|
| 1884 | * stream. Tells the conversion routine to |
---|
| 1885 | * perform any finalization that needs to occur |
---|
| 1886 | * after the last byte is converted and then to |
---|
| 1887 | * reset to an initial state. If the source |
---|
| 1888 | * buffer contains the entire input stream to be |
---|
| 1889 | * converted, this flag should be set. |
---|
| 1890 | * TCL_ENCODING_STOPONERROR - If set, then the converter will return |
---|
| 1891 | * immediately upon encountering an invalid byte |
---|
| 1892 | * sequence or a source character that has no |
---|
| 1893 | * mapping in the target encoding. If clear, then |
---|
| 1894 | * the converter will skip the problem, |
---|
| 1895 | * substituting one or more "close" characters in |
---|
| 1896 | * the destination buffer and then continue to |
---|
| 1897 | * convert the source. |
---|
| 1898 | */ |
---|
| 1899 | |
---|
| 1900 | #define TCL_ENCODING_START 0x01 |
---|
| 1901 | #define TCL_ENCODING_END 0x02 |
---|
| 1902 | #define TCL_ENCODING_STOPONERROR 0x04 |
---|
| 1903 | |
---|
| 1904 | /* |
---|
| 1905 | * The following data structures and declarations are for the new Tcl parser. |
---|
| 1906 | */ |
---|
| 1907 | |
---|
| 1908 | /* |
---|
| 1909 | * For each word of a command, and for each piece of a word such as a variable |
---|
| 1910 | * reference, one of the following structures is created to describe the |
---|
| 1911 | * token. |
---|
| 1912 | */ |
---|
| 1913 | |
---|
| 1914 | typedef struct Tcl_Token { |
---|
| 1915 | int type; /* Type of token, such as TCL_TOKEN_WORD; see |
---|
| 1916 | * below for valid types. */ |
---|
| 1917 | CONST char *start; /* First character in token. */ |
---|
| 1918 | int size; /* Number of bytes in token. */ |
---|
| 1919 | int numComponents; /* If this token is composed of other tokens, |
---|
| 1920 | * this field tells how many of them there are |
---|
| 1921 | * (including components of components, etc.). |
---|
| 1922 | * The component tokens immediately follow |
---|
| 1923 | * this one. */ |
---|
| 1924 | } Tcl_Token; |
---|
| 1925 | |
---|
| 1926 | /* |
---|
| 1927 | * Type values defined for Tcl_Token structures. These values are defined as |
---|
| 1928 | * mask bits so that it's easy to check for collections of types. |
---|
| 1929 | * |
---|
| 1930 | * TCL_TOKEN_WORD - The token describes one word of a command, |
---|
| 1931 | * from the first non-blank character of the word |
---|
| 1932 | * (which may be " or {) up to but not including |
---|
| 1933 | * the space, semicolon, or bracket that |
---|
| 1934 | * terminates the word. NumComponents counts the |
---|
| 1935 | * total number of sub-tokens that make up the |
---|
| 1936 | * word. This includes, for example, sub-tokens |
---|
| 1937 | * of TCL_TOKEN_VARIABLE tokens. |
---|
| 1938 | * TCL_TOKEN_SIMPLE_WORD - This token is just like TCL_TOKEN_WORD except |
---|
| 1939 | * that the word is guaranteed to consist of a |
---|
| 1940 | * single TCL_TOKEN_TEXT sub-token. |
---|
| 1941 | * TCL_TOKEN_TEXT - The token describes a range of literal text |
---|
| 1942 | * that is part of a word. NumComponents is |
---|
| 1943 | * always 0. |
---|
| 1944 | * TCL_TOKEN_BS - The token describes a backslash sequence that |
---|
| 1945 | * must be collapsed. NumComponents is always 0. |
---|
| 1946 | * TCL_TOKEN_COMMAND - The token describes a command whose result |
---|
| 1947 | * must be substituted into the word. The token |
---|
| 1948 | * includes the enclosing brackets. NumComponents |
---|
| 1949 | * is always 0. |
---|
| 1950 | * TCL_TOKEN_VARIABLE - The token describes a variable substitution, |
---|
| 1951 | * including the dollar sign, variable name, and |
---|
| 1952 | * array index (if there is one) up through the |
---|
| 1953 | * right parentheses. NumComponents tells how |
---|
| 1954 | * many additional tokens follow to represent the |
---|
| 1955 | * variable name. The first token will be a |
---|
| 1956 | * TCL_TOKEN_TEXT token that describes the |
---|
| 1957 | * variable name. If the variable is an array |
---|
| 1958 | * reference then there will be one or more |
---|
| 1959 | * additional tokens, of type TCL_TOKEN_TEXT, |
---|
| 1960 | * TCL_TOKEN_BS, TCL_TOKEN_COMMAND, and |
---|
| 1961 | * TCL_TOKEN_VARIABLE, that describe the array |
---|
| 1962 | * index; numComponents counts the total number |
---|
| 1963 | * of nested tokens that make up the variable |
---|
| 1964 | * reference, including sub-tokens of |
---|
| 1965 | * TCL_TOKEN_VARIABLE tokens. |
---|
| 1966 | * TCL_TOKEN_SUB_EXPR - The token describes one subexpression of an |
---|
| 1967 | * expression, from the first non-blank character |
---|
| 1968 | * of the subexpression up to but not including |
---|
| 1969 | * the space, brace, or bracket that terminates |
---|
| 1970 | * the subexpression. NumComponents counts the |
---|
| 1971 | * total number of following subtokens that make |
---|
| 1972 | * up the subexpression; this includes all |
---|
| 1973 | * subtokens for any nested TCL_TOKEN_SUB_EXPR |
---|
| 1974 | * tokens. For example, a numeric value used as a |
---|
| 1975 | * primitive operand is described by a |
---|
| 1976 | * TCL_TOKEN_SUB_EXPR token followed by a |
---|
| 1977 | * TCL_TOKEN_TEXT token. A binary subexpression |
---|
| 1978 | * is described by a TCL_TOKEN_SUB_EXPR token |
---|
| 1979 | * followed by the TCL_TOKEN_OPERATOR token for |
---|
| 1980 | * the operator, then TCL_TOKEN_SUB_EXPR tokens |
---|
| 1981 | * for the left then the right operands. |
---|
| 1982 | * TCL_TOKEN_OPERATOR - The token describes one expression operator. |
---|
| 1983 | * An operator might be the name of a math |
---|
| 1984 | * function such as "abs". A TCL_TOKEN_OPERATOR |
---|
| 1985 | * token is always preceeded by one |
---|
| 1986 | * TCL_TOKEN_SUB_EXPR token for the operator's |
---|
| 1987 | * subexpression, and is followed by zero or more |
---|
| 1988 | * TCL_TOKEN_SUB_EXPR tokens for the operator's |
---|
| 1989 | * operands. NumComponents is always 0. |
---|
| 1990 | * TCL_TOKEN_EXPAND_WORD - This token is just like TCL_TOKEN_WORD except |
---|
| 1991 | * that it marks a word that began with the |
---|
| 1992 | * literal character prefix "{*}". This word is |
---|
| 1993 | * marked to be expanded - that is, broken into |
---|
| 1994 | * words after substitution is complete. |
---|
| 1995 | */ |
---|
| 1996 | |
---|
| 1997 | #define TCL_TOKEN_WORD 1 |
---|
| 1998 | #define TCL_TOKEN_SIMPLE_WORD 2 |
---|
| 1999 | #define TCL_TOKEN_TEXT 4 |
---|
| 2000 | #define TCL_TOKEN_BS 8 |
---|
| 2001 | #define TCL_TOKEN_COMMAND 16 |
---|
| 2002 | #define TCL_TOKEN_VARIABLE 32 |
---|
| 2003 | #define TCL_TOKEN_SUB_EXPR 64 |
---|
| 2004 | #define TCL_TOKEN_OPERATOR 128 |
---|
| 2005 | #define TCL_TOKEN_EXPAND_WORD 256 |
---|
| 2006 | |
---|
| 2007 | /* |
---|
| 2008 | * Parsing error types. On any parsing error, one of these values will be |
---|
| 2009 | * stored in the error field of the Tcl_Parse structure defined below. |
---|
| 2010 | */ |
---|
| 2011 | |
---|
| 2012 | #define TCL_PARSE_SUCCESS 0 |
---|
| 2013 | #define TCL_PARSE_QUOTE_EXTRA 1 |
---|
| 2014 | #define TCL_PARSE_BRACE_EXTRA 2 |
---|
| 2015 | #define TCL_PARSE_MISSING_BRACE 3 |
---|
| 2016 | #define TCL_PARSE_MISSING_BRACKET 4 |
---|
| 2017 | #define TCL_PARSE_MISSING_PAREN 5 |
---|
| 2018 | #define TCL_PARSE_MISSING_QUOTE 6 |
---|
| 2019 | #define TCL_PARSE_MISSING_VAR_BRACE 7 |
---|
| 2020 | #define TCL_PARSE_SYNTAX 8 |
---|
| 2021 | #define TCL_PARSE_BAD_NUMBER 9 |
---|
| 2022 | |
---|
| 2023 | /* |
---|
| 2024 | * A structure of the following type is filled in by Tcl_ParseCommand. It |
---|
| 2025 | * describes a single command parsed from an input string. |
---|
| 2026 | */ |
---|
| 2027 | |
---|
| 2028 | #define NUM_STATIC_TOKENS 20 |
---|
| 2029 | |
---|
| 2030 | typedef struct Tcl_Parse { |
---|
| 2031 | CONST char *commentStart; /* Pointer to # that begins the first of one |
---|
| 2032 | * or more comments preceding the command. */ |
---|
| 2033 | int commentSize; /* Number of bytes in comments (up through |
---|
| 2034 | * newline character that terminates the last |
---|
| 2035 | * comment). If there were no comments, this |
---|
| 2036 | * field is 0. */ |
---|
| 2037 | CONST char *commandStart; /* First character in first word of |
---|
| 2038 | * command. */ |
---|
| 2039 | int commandSize; /* Number of bytes in command, including first |
---|
| 2040 | * character of first word, up through the |
---|
| 2041 | * terminating newline, close bracket, or |
---|
| 2042 | * semicolon. */ |
---|
| 2043 | int numWords; /* Total number of words in command. May be |
---|
| 2044 | * 0. */ |
---|
| 2045 | Tcl_Token *tokenPtr; /* Pointer to first token representing the |
---|
| 2046 | * words of the command. Initially points to |
---|
| 2047 | * staticTokens, but may change to point to |
---|
| 2048 | * malloc-ed space if command exceeds space in |
---|
| 2049 | * staticTokens. */ |
---|
| 2050 | int numTokens; /* Total number of tokens in command. */ |
---|
| 2051 | int tokensAvailable; /* Total number of tokens available at |
---|
| 2052 | * *tokenPtr. */ |
---|
| 2053 | int errorType; /* One of the parsing error types defined |
---|
| 2054 | * above. */ |
---|
| 2055 | |
---|
| 2056 | /* |
---|
| 2057 | * The fields below are intended only for the private use of the parser. |
---|
| 2058 | * They should not be used by functions that invoke Tcl_ParseCommand. |
---|
| 2059 | */ |
---|
| 2060 | |
---|
| 2061 | CONST char *string; /* The original command string passed to |
---|
| 2062 | * Tcl_ParseCommand. */ |
---|
| 2063 | CONST char *end; /* Points to the character just after the last |
---|
| 2064 | * one in the command string. */ |
---|
| 2065 | Tcl_Interp *interp; /* Interpreter to use for error reporting, or |
---|
| 2066 | * NULL. */ |
---|
| 2067 | CONST char *term; /* Points to character in string that |
---|
| 2068 | * terminated most recent token. Filled in by |
---|
| 2069 | * ParseTokens. If an error occurs, points to |
---|
| 2070 | * beginning of region where the error |
---|
| 2071 | * occurred (e.g. the open brace if the close |
---|
| 2072 | * brace is missing). */ |
---|
| 2073 | int incomplete; /* This field is set to 1 by Tcl_ParseCommand |
---|
| 2074 | * if the command appears to be incomplete. |
---|
| 2075 | * This information is used by |
---|
| 2076 | * Tcl_CommandComplete. */ |
---|
| 2077 | Tcl_Token staticTokens[NUM_STATIC_TOKENS]; |
---|
| 2078 | /* Initial space for tokens for command. This |
---|
| 2079 | * space should be large enough to accommodate |
---|
| 2080 | * most commands; dynamic space is allocated |
---|
| 2081 | * for very large commands that don't fit |
---|
| 2082 | * here. */ |
---|
| 2083 | } Tcl_Parse; |
---|
| 2084 | |
---|
| 2085 | /* |
---|
| 2086 | * The following definitions are the error codes returned by the conversion |
---|
| 2087 | * routines: |
---|
| 2088 | * |
---|
| 2089 | * TCL_OK - All characters were converted. |
---|
| 2090 | * TCL_CONVERT_NOSPACE - The output buffer would not have been large |
---|
| 2091 | * enough for all of the converted data; as many |
---|
| 2092 | * characters as could fit were converted though. |
---|
| 2093 | * TCL_CONVERT_MULTIBYTE - The last few bytes in the source string were |
---|
| 2094 | * the beginning of a multibyte sequence, but |
---|
| 2095 | * more bytes were needed to complete this |
---|
| 2096 | * sequence. A subsequent call to the conversion |
---|
| 2097 | * routine should pass the beginning of this |
---|
| 2098 | * unconverted sequence plus additional bytes |
---|
| 2099 | * from the source stream to properly convert the |
---|
| 2100 | * formerly split-up multibyte sequence. |
---|
| 2101 | * TCL_CONVERT_SYNTAX - The source stream contained an invalid |
---|
| 2102 | * character sequence. This may occur if the |
---|
| 2103 | * input stream has been damaged or if the input |
---|
| 2104 | * encoding method was misidentified. This error |
---|
| 2105 | * is reported only if TCL_ENCODING_STOPONERROR |
---|
| 2106 | * was specified. |
---|
| 2107 | * TCL_CONVERT_UNKNOWN - The source string contained a character that |
---|
| 2108 | * could not be represented in the target |
---|
| 2109 | * encoding. This error is reported only if |
---|
| 2110 | * TCL_ENCODING_STOPONERROR was specified. |
---|
| 2111 | */ |
---|
| 2112 | |
---|
| 2113 | #define TCL_CONVERT_MULTIBYTE -1 |
---|
| 2114 | #define TCL_CONVERT_SYNTAX -2 |
---|
| 2115 | #define TCL_CONVERT_UNKNOWN -3 |
---|
| 2116 | #define TCL_CONVERT_NOSPACE -4 |
---|
| 2117 | |
---|
| 2118 | /* |
---|
| 2119 | * The maximum number of bytes that are necessary to represent a single |
---|
| 2120 | * Unicode character in UTF-8. The valid values should be 3 or 6 (or perhaps 1 |
---|
| 2121 | * if we want to support a non-unicode enabled core). If 3, then Tcl_UniChar |
---|
| 2122 | * must be 2-bytes in size (UCS-2) (the default). If 6, then Tcl_UniChar must |
---|
| 2123 | * be 4-bytes in size (UCS-4). At this time UCS-2 mode is the default and |
---|
| 2124 | * recommended mode. UCS-4 is experimental and not recommended. It works for |
---|
| 2125 | * the core, but most extensions expect UCS-2. |
---|
| 2126 | */ |
---|
| 2127 | |
---|
| 2128 | #ifndef TCL_UTF_MAX |
---|
| 2129 | #define TCL_UTF_MAX 3 |
---|
| 2130 | #endif |
---|
| 2131 | |
---|
| 2132 | /* |
---|
| 2133 | * This represents a Unicode character. Any changes to this should also be |
---|
| 2134 | * reflected in regcustom.h. |
---|
| 2135 | */ |
---|
| 2136 | |
---|
| 2137 | #if TCL_UTF_MAX > 3 |
---|
| 2138 | /* |
---|
| 2139 | * unsigned int isn't 100% accurate as it should be a strict 4-byte value |
---|
| 2140 | * (perhaps wchar_t). 64-bit systems may have troubles. The size of this |
---|
| 2141 | * value must be reflected correctly in regcustom.h and |
---|
| 2142 | * in tclEncoding.c. |
---|
| 2143 | * XXX: Tcl is currently UCS-2 and planning UTF-16 for the Unicode |
---|
| 2144 | * XXX: string rep that Tcl_UniChar represents. Changing the size |
---|
| 2145 | * XXX: of Tcl_UniChar is /not/ supported. |
---|
| 2146 | */ |
---|
| 2147 | typedef unsigned int Tcl_UniChar; |
---|
| 2148 | #else |
---|
| 2149 | typedef unsigned short Tcl_UniChar; |
---|
| 2150 | #endif |
---|
| 2151 | |
---|
| 2152 | /* |
---|
| 2153 | * TIP #59: The following structure is used in calls 'Tcl_RegisterConfig' to |
---|
| 2154 | * provide the system with the embedded configuration data. |
---|
| 2155 | */ |
---|
| 2156 | |
---|
| 2157 | typedef struct Tcl_Config { |
---|
| 2158 | CONST char *key; /* Configuration key to register. ASCII |
---|
| 2159 | * encoded, thus UTF-8 */ |
---|
| 2160 | CONST char *value; /* The value associated with the key. System |
---|
| 2161 | * encoding */ |
---|
| 2162 | } Tcl_Config; |
---|
| 2163 | |
---|
| 2164 | /* |
---|
| 2165 | * Flags for TIP#143 limits, detailing which limits are active in an |
---|
| 2166 | * interpreter. Used for Tcl_{Add,Remove}LimitHandler type argument. |
---|
| 2167 | */ |
---|
| 2168 | |
---|
| 2169 | #define TCL_LIMIT_COMMANDS 0x01 |
---|
| 2170 | #define TCL_LIMIT_TIME 0x02 |
---|
| 2171 | |
---|
| 2172 | /* |
---|
| 2173 | * Structure containing information about a limit handler to be called when a |
---|
| 2174 | * command- or time-limit is exceeded by an interpreter. |
---|
| 2175 | */ |
---|
| 2176 | |
---|
| 2177 | typedef void (Tcl_LimitHandlerProc) _ANSI_ARGS_((ClientData clientData, |
---|
| 2178 | Tcl_Interp *interp)); |
---|
| 2179 | typedef void (Tcl_LimitHandlerDeleteProc) _ANSI_ARGS_((ClientData clientData)); |
---|
| 2180 | |
---|
| 2181 | #ifndef MP_INT_DECLARED |
---|
| 2182 | typedef struct mp_int mp_int; |
---|
| 2183 | #define MP_INT_DECLARED |
---|
| 2184 | #endif |
---|
| 2185 | #ifndef MP_DIGIT_DECLARED |
---|
| 2186 | typedef unsigned long mp_digit; |
---|
| 2187 | #define MP_DIGIT_DECLARED |
---|
| 2188 | #endif |
---|
| 2189 | |
---|
| 2190 | /* |
---|
| 2191 | * The following constant is used to test for older versions of Tcl in the |
---|
| 2192 | * stubs tables. |
---|
| 2193 | * |
---|
| 2194 | * Jan Nijtman's plus patch uses 0xFCA1BACF, so we need to pick a different |
---|
| 2195 | * value since the stubs tables don't match. |
---|
| 2196 | */ |
---|
| 2197 | |
---|
| 2198 | #define TCL_STUB_MAGIC ((int)0xFCA3BACF) |
---|
| 2199 | |
---|
| 2200 | /* |
---|
| 2201 | * The following function is required to be defined in all stubs aware |
---|
| 2202 | * extensions. The function is actually implemented in the stub library, not |
---|
| 2203 | * the main Tcl library, although there is a trivial implementation in the |
---|
| 2204 | * main library in case an extension is statically linked into an application. |
---|
| 2205 | */ |
---|
| 2206 | |
---|
| 2207 | EXTERN CONST char * Tcl_InitStubs _ANSI_ARGS_((Tcl_Interp *interp, |
---|
| 2208 | CONST char *version, int exact)); |
---|
| 2209 | EXTERN CONST char * TclTomMathInitializeStubs _ANSI_ARGS_(( |
---|
| 2210 | Tcl_Interp *interp, CONST char *version, |
---|
| 2211 | int epoch, int revision)); |
---|
| 2212 | |
---|
| 2213 | #ifndef USE_TCL_STUBS |
---|
| 2214 | |
---|
| 2215 | /* |
---|
| 2216 | * When not using stubs, make it a macro. |
---|
| 2217 | */ |
---|
| 2218 | |
---|
| 2219 | #define Tcl_InitStubs(interp, version, exact) \ |
---|
| 2220 | Tcl_PkgInitStubsCheck(interp, version, exact) |
---|
| 2221 | |
---|
| 2222 | #endif |
---|
| 2223 | |
---|
| 2224 | /* |
---|
| 2225 | * TODO - tommath stubs export goes here! |
---|
| 2226 | */ |
---|
| 2227 | |
---|
| 2228 | |
---|
| 2229 | /* |
---|
| 2230 | * Public functions that are not accessible via the stubs table. |
---|
| 2231 | * Tcl_GetMemoryInfo is needed for AOLserver. [Bug 1868171] |
---|
| 2232 | */ |
---|
| 2233 | |
---|
| 2234 | EXTERN void Tcl_Main _ANSI_ARGS_((int argc, char **argv, |
---|
| 2235 | Tcl_AppInitProc *appInitProc)); |
---|
| 2236 | EXTERN CONST char * Tcl_PkgInitStubsCheck _ANSI_ARGS_((Tcl_Interp *interp, |
---|
| 2237 | CONST char *version, int exact)); |
---|
| 2238 | #if defined(TCL_THREADS) && defined(USE_THREAD_ALLOC) |
---|
| 2239 | EXTERN void Tcl_GetMemoryInfo _ANSI_ARGS_((Tcl_DString *dsPtr)); |
---|
| 2240 | #endif |
---|
| 2241 | |
---|
| 2242 | /* |
---|
| 2243 | * Include the public function declarations that are accessible via the stubs |
---|
| 2244 | * table. |
---|
| 2245 | */ |
---|
| 2246 | |
---|
| 2247 | #include "tclDecls.h" |
---|
| 2248 | |
---|
| 2249 | /* |
---|
| 2250 | * Include platform specific public function declarations that are accessible |
---|
| 2251 | * via the stubs table. |
---|
| 2252 | */ |
---|
| 2253 | |
---|
| 2254 | #include "tclPlatDecls.h" |
---|
| 2255 | |
---|
| 2256 | /* |
---|
| 2257 | * The following declarations either map ckalloc and ckfree to malloc and |
---|
| 2258 | * free, or they map them to functions with all sorts of debugging hooks |
---|
| 2259 | * defined in tclCkalloc.c. |
---|
| 2260 | */ |
---|
| 2261 | |
---|
| 2262 | #ifdef TCL_MEM_DEBUG |
---|
| 2263 | |
---|
| 2264 | # define ckalloc(x) Tcl_DbCkalloc(x, __FILE__, __LINE__) |
---|
| 2265 | # define ckfree(x) Tcl_DbCkfree(x, __FILE__, __LINE__) |
---|
| 2266 | # define ckrealloc(x,y) Tcl_DbCkrealloc((x), (y),__FILE__, __LINE__) |
---|
| 2267 | # define attemptckalloc(x) Tcl_AttemptDbCkalloc(x, __FILE__, __LINE__) |
---|
| 2268 | # define attemptckrealloc(x,y) Tcl_AttemptDbCkrealloc((x), (y), __FILE__, __LINE__) |
---|
| 2269 | |
---|
| 2270 | #else /* !TCL_MEM_DEBUG */ |
---|
| 2271 | |
---|
| 2272 | /* |
---|
| 2273 | * If we are not using the debugging allocator, we should call the Tcl_Alloc, |
---|
| 2274 | * et al. routines in order to guarantee that every module is using the same |
---|
| 2275 | * memory allocator both inside and outside of the Tcl library. |
---|
| 2276 | */ |
---|
| 2277 | |
---|
| 2278 | # define ckalloc(x) Tcl_Alloc(x) |
---|
| 2279 | # define ckfree(x) Tcl_Free(x) |
---|
| 2280 | # define ckrealloc(x,y) Tcl_Realloc(x,y) |
---|
| 2281 | # define attemptckalloc(x) Tcl_AttemptAlloc(x) |
---|
| 2282 | # define attemptckrealloc(x,y) Tcl_AttemptRealloc(x,y) |
---|
| 2283 | # undef Tcl_InitMemory |
---|
| 2284 | # define Tcl_InitMemory(x) |
---|
| 2285 | # undef Tcl_DumpActiveMemory |
---|
| 2286 | # define Tcl_DumpActiveMemory(x) |
---|
| 2287 | # undef Tcl_ValidateAllMemory |
---|
| 2288 | # define Tcl_ValidateAllMemory(x,y) |
---|
| 2289 | |
---|
| 2290 | #endif /* !TCL_MEM_DEBUG */ |
---|
| 2291 | |
---|
| 2292 | #ifdef TCL_MEM_DEBUG |
---|
| 2293 | # define Tcl_IncrRefCount(objPtr) \ |
---|
| 2294 | Tcl_DbIncrRefCount(objPtr, __FILE__, __LINE__) |
---|
| 2295 | # define Tcl_DecrRefCount(objPtr) \ |
---|
| 2296 | Tcl_DbDecrRefCount(objPtr, __FILE__, __LINE__) |
---|
| 2297 | # define Tcl_IsShared(objPtr) \ |
---|
| 2298 | Tcl_DbIsShared(objPtr, __FILE__, __LINE__) |
---|
| 2299 | #else |
---|
| 2300 | # define Tcl_IncrRefCount(objPtr) \ |
---|
| 2301 | ++(objPtr)->refCount |
---|
| 2302 | /* |
---|
| 2303 | * Use do/while0 idiom for optimum correctness without compiler warnings |
---|
| 2304 | * http://c2.com/cgi/wiki?TrivialDoWhileLoop |
---|
| 2305 | */ |
---|
| 2306 | # define Tcl_DecrRefCount(objPtr) \ |
---|
| 2307 | do { if (--(objPtr)->refCount <= 0) TclFreeObj(objPtr); } while(0) |
---|
| 2308 | # define Tcl_IsShared(objPtr) \ |
---|
| 2309 | ((objPtr)->refCount > 1) |
---|
| 2310 | #endif |
---|
| 2311 | |
---|
| 2312 | /* |
---|
| 2313 | * Macros and definitions that help to debug the use of Tcl objects. When |
---|
| 2314 | * TCL_MEM_DEBUG is defined, the Tcl_New declarations are overridden to call |
---|
| 2315 | * debugging versions of the object creation functions. |
---|
| 2316 | */ |
---|
| 2317 | |
---|
| 2318 | #ifdef TCL_MEM_DEBUG |
---|
| 2319 | # undef Tcl_NewBignumObj |
---|
| 2320 | # define Tcl_NewBignumObj(val) \ |
---|
| 2321 | Tcl_DbNewBignumObj(val, __FILE__, __LINE__) |
---|
| 2322 | # undef Tcl_NewBooleanObj |
---|
| 2323 | # define Tcl_NewBooleanObj(val) \ |
---|
| 2324 | Tcl_DbNewBooleanObj(val, __FILE__, __LINE__) |
---|
| 2325 | # undef Tcl_NewByteArrayObj |
---|
| 2326 | # define Tcl_NewByteArrayObj(bytes, len) \ |
---|
| 2327 | Tcl_DbNewByteArrayObj(bytes, len, __FILE__, __LINE__) |
---|
| 2328 | # undef Tcl_NewDoubleObj |
---|
| 2329 | # define Tcl_NewDoubleObj(val) \ |
---|
| 2330 | Tcl_DbNewDoubleObj(val, __FILE__, __LINE__) |
---|
| 2331 | # undef Tcl_NewIntObj |
---|
| 2332 | # define Tcl_NewIntObj(val) \ |
---|
| 2333 | Tcl_DbNewLongObj(val, __FILE__, __LINE__) |
---|
| 2334 | # undef Tcl_NewListObj |
---|
| 2335 | # define Tcl_NewListObj(objc, objv) \ |
---|
| 2336 | Tcl_DbNewListObj(objc, objv, __FILE__, __LINE__) |
---|
| 2337 | # undef Tcl_NewLongObj |
---|
| 2338 | # define Tcl_NewLongObj(val) \ |
---|
| 2339 | Tcl_DbNewLongObj(val, __FILE__, __LINE__) |
---|
| 2340 | # undef Tcl_NewObj |
---|
| 2341 | # define Tcl_NewObj() \ |
---|
| 2342 | Tcl_DbNewObj(__FILE__, __LINE__) |
---|
| 2343 | # undef Tcl_NewStringObj |
---|
| 2344 | # define Tcl_NewStringObj(bytes, len) \ |
---|
| 2345 | Tcl_DbNewStringObj(bytes, len, __FILE__, __LINE__) |
---|
| 2346 | # undef Tcl_NewWideIntObj |
---|
| 2347 | # define Tcl_NewWideIntObj(val) \ |
---|
| 2348 | Tcl_DbNewWideIntObj(val, __FILE__, __LINE__) |
---|
| 2349 | #endif /* TCL_MEM_DEBUG */ |
---|
| 2350 | |
---|
| 2351 | /* |
---|
| 2352 | * Macros for clients to use to access fields of hash entries: |
---|
| 2353 | */ |
---|
| 2354 | |
---|
| 2355 | #define Tcl_GetHashValue(h) ((h)->clientData) |
---|
| 2356 | #define Tcl_SetHashValue(h, value) ((h)->clientData = (ClientData) (value)) |
---|
| 2357 | #define Tcl_GetHashKey(tablePtr, h) \ |
---|
| 2358 | ((char *) (((tablePtr)->keyType == TCL_ONE_WORD_KEYS || \ |
---|
| 2359 | (tablePtr)->keyType == TCL_CUSTOM_PTR_KEYS) \ |
---|
| 2360 | ? (h)->key.oneWordValue \ |
---|
| 2361 | : (h)->key.string)) |
---|
| 2362 | |
---|
| 2363 | /* |
---|
| 2364 | * Macros to use for clients to use to invoke find and create functions for |
---|
| 2365 | * hash tables: |
---|
| 2366 | */ |
---|
| 2367 | |
---|
| 2368 | #undef Tcl_FindHashEntry |
---|
| 2369 | #define Tcl_FindHashEntry(tablePtr, key) \ |
---|
| 2370 | (*((tablePtr)->findProc))(tablePtr, key) |
---|
| 2371 | #undef Tcl_CreateHashEntry |
---|
| 2372 | #define Tcl_CreateHashEntry(tablePtr, key, newPtr) \ |
---|
| 2373 | (*((tablePtr)->createProc))(tablePtr, key, newPtr) |
---|
| 2374 | |
---|
| 2375 | /* |
---|
| 2376 | * Macros that eliminate the overhead of the thread synchronization functions |
---|
| 2377 | * when compiling without thread support. |
---|
| 2378 | */ |
---|
| 2379 | |
---|
| 2380 | #ifndef TCL_THREADS |
---|
| 2381 | #undef Tcl_MutexLock |
---|
| 2382 | #define Tcl_MutexLock(mutexPtr) |
---|
| 2383 | #undef Tcl_MutexUnlock |
---|
| 2384 | #define Tcl_MutexUnlock(mutexPtr) |
---|
| 2385 | #undef Tcl_MutexFinalize |
---|
| 2386 | #define Tcl_MutexFinalize(mutexPtr) |
---|
| 2387 | #undef Tcl_ConditionNotify |
---|
| 2388 | #define Tcl_ConditionNotify(condPtr) |
---|
| 2389 | #undef Tcl_ConditionWait |
---|
| 2390 | #define Tcl_ConditionWait(condPtr, mutexPtr, timePtr) |
---|
| 2391 | #undef Tcl_ConditionFinalize |
---|
| 2392 | #define Tcl_ConditionFinalize(condPtr) |
---|
| 2393 | #endif /* TCL_THREADS */ |
---|
| 2394 | |
---|
| 2395 | #ifndef TCL_NO_DEPRECATED |
---|
| 2396 | /* |
---|
| 2397 | * Deprecated Tcl functions: |
---|
| 2398 | */ |
---|
| 2399 | |
---|
| 2400 | # undef Tcl_EvalObj |
---|
| 2401 | # define Tcl_EvalObj(interp,objPtr) \ |
---|
| 2402 | Tcl_EvalObjEx((interp),(objPtr),0) |
---|
| 2403 | # undef Tcl_GlobalEvalObj |
---|
| 2404 | # define Tcl_GlobalEvalObj(interp,objPtr) \ |
---|
| 2405 | Tcl_EvalObjEx((interp),(objPtr),TCL_EVAL_GLOBAL) |
---|
| 2406 | |
---|
| 2407 | /* |
---|
| 2408 | * These function have been renamed. The old names are deprecated, but we |
---|
| 2409 | * define these macros for backwards compatibilty. |
---|
| 2410 | */ |
---|
| 2411 | |
---|
| 2412 | # define Tcl_Ckalloc Tcl_Alloc |
---|
| 2413 | # define Tcl_Ckfree Tcl_Free |
---|
| 2414 | # define Tcl_Ckrealloc Tcl_Realloc |
---|
| 2415 | # define Tcl_Return Tcl_SetResult |
---|
| 2416 | # define Tcl_TildeSubst Tcl_TranslateFileName |
---|
| 2417 | # define panic Tcl_Panic |
---|
| 2418 | # define panicVA Tcl_PanicVA |
---|
| 2419 | #endif |
---|
| 2420 | |
---|
| 2421 | /* |
---|
| 2422 | * Convenience declaration of Tcl_AppInit for backwards compatibility. This |
---|
| 2423 | * function is not *implemented* by the tcl library, so the storage class is |
---|
| 2424 | * neither DLLEXPORT nor DLLIMPORT. |
---|
| 2425 | */ |
---|
| 2426 | |
---|
| 2427 | #undef TCL_STORAGE_CLASS |
---|
| 2428 | #define TCL_STORAGE_CLASS |
---|
| 2429 | |
---|
| 2430 | EXTERN int Tcl_AppInit _ANSI_ARGS_((Tcl_Interp *interp)); |
---|
| 2431 | |
---|
| 2432 | #undef TCL_STORAGE_CLASS |
---|
| 2433 | #define TCL_STORAGE_CLASS DLLIMPORT |
---|
| 2434 | |
---|
| 2435 | #endif /* RC_INVOKED */ |
---|
| 2436 | |
---|
| 2437 | /* |
---|
| 2438 | * end block for C++ |
---|
| 2439 | */ |
---|
| 2440 | |
---|
| 2441 | #ifdef __cplusplus |
---|
| 2442 | } |
---|
| 2443 | #endif |
---|
| 2444 | |
---|
| 2445 | #endif /* _TCL */ |
---|
| 2446 | |
---|
| 2447 | /* |
---|
| 2448 | * Local Variables: |
---|
| 2449 | * mode: c |
---|
| 2450 | * c-basic-offset: 4 |
---|
| 2451 | * fill-column: 78 |
---|
| 2452 | * End: |
---|
| 2453 | */ |
---|