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