Fossil with Commonmark

Check-in [a44b4aa5ac]
Login

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:merge trunk
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | undo-clean
Files: files | file ages | folders
SHA1:a44b4aa5ac323392f58ccf10938dd6ba1fab0654
User & Date: jan.nijtmans 2014-07-10 09:25:42
Context
2015-06-26
18:48
Merge trunk. check-in: f3daf39355 user: andygoth tags: undo-clean
2014-07-10
09:25
merge trunk check-in: a44b4aa5ac user: jan.nijtmans tags: undo-clean
08:21
c/--force/--allow-fork/ check-in: 604a355811 user: jan.nijtmans tags: trunk
2013-05-03
13:50
Prompt before cleaning files > 10M. Those file deletions are not undo-able. check-in: 8e74f0fe40 user: jan.nijtmans tags: undo-clean
Changes
Hide Diffs Side-by-Side Diffs Show Whitespace Changes Patch

Added .fossil-settings/clean-glob.

            1  +*.a
            2  +*.lib
            3  +*.manifest
            4  +*.o
            5  +*.obj
            6  +*.pdb
            7  +*.res
            8  +Makefile
            9  +bld/*
           10  +wbld/*
           11  +win/*.c
           12  +win/*.h
           13  +win/*.exe
           14  +win/headers
           15  +win/linkopts
           16  +autoconfig.h
           17  +config.log

Added .fossil-settings/encoding-glob.

            1  +compat/zlib/contrib/dotzlib/DotZLib/*.cs
            2  +win/fossil.rc

Added .fossil-settings/ignore-glob.

            1  +compat/openssl*
            2  +compat/tcl*
            3  +fossil
            4  +fossil.exe
            5  +win/fossil.exe

Added .fossil-settings/keep-glob.

            1  +compat/openssl*
            2  +compat/tcl*
            3  +fossil
            4  +fossil.exe
            5  +win/fossil.exe

Changes to BUILD.txt.

whitespace changes only

Changes to COPYRIGHT-BSD2.txt.

whitespace changes only

Changes to Makefile.in.

    35     35   
    36     36   #### Tcl shell for use in running the fossil testsuite.  If you do not
    37     37   #    care about testing the end result, this can be blank.
    38     38   #
    39     39   TCLSH = tclsh
    40     40   
    41     41   LIB =	@LDFLAGS@ @EXTRA_LDFLAGS@ @LIBS@
    42         -TCC +=	@EXTRA_CFLAGS@ @CPPFLAGS@ @CFLAGS@ -DHAVE_AUTOCONFIG_H
           42  +TCC +=	@EXTRA_CFLAGS@ @CPPFLAGS@ @CFLAGS@ -DHAVE_AUTOCONFIG_H -D_HAVE_SQLITE_CONFIG_H
    43     43   INSTALLDIR = $(DESTDIR)@prefix@/bin
    44     44   USE_SYSTEM_SQLITE = @USE_SYSTEM_SQLITE@
    45         -FOSSIL_ENABLE_TCL = @FOSSIL_ENABLE_TCL@
    46         -FOSSIL_ENABLE_TCL_STUBS = @FOSSIL_ENABLE_TCL_STUBS@
    47     45   
    48     46   include $(SRCDIR)/main.mk
    49     47   
    50     48   distclean: clean
    51     49   	rm -f autoconfig.h config.log Makefile

Changes to VERSION.

     1         -1.25
            1  +1.30

Changes to ajax/i-test/rhino-test.js.

   181    181           },
   182    182           {
   183    183               onResponse:function(resp,req){
   184    184                   rs = resp;
   185    185               }
   186    186           });
   187    187       assertResponseOK(rs);
   188         -    assert(3 == rs.payload.artifact.parents.length, 'Got 3 parent artifacts.');
          188  +    assert(3 == rs.payload.parents.length, 'Got 3 parent artifacts.');
   189    189   }
   190    190   testFetchCheckinArtifact.description = '/json/artifact/CHECKIN';
   191    191   
   192    192   function testAnonLogout(){
   193    193       var rs;
   194    194       TestApp.fossil.logout({
   195    195           onResponse:function(resp,req){

Changes to auto.def.

     2      2   
     3      3   use cc cc-lib
     4      4   
     5      5   options {
     6      6       with-openssl:path|auto|none
     7      7                            => {Look for openssl in the given path, or auto or none}
     8      8       with-zlib:path       => {Look for zlib in the given path}
            9  +    with-th1-hooks=0     => {Enable TH1 hooks for commands and web pages}
     9     10       with-tcl:path        => {Enable Tcl integration, with Tcl in the specified path}
    10         -    with-tcl-stubs=0     => {Enable Tcl integration via stubs mechanism}
    11         -    internal-sqlite=1    => {Don't use the internal sqlite, use the system one}
           11  +    with-tcl-stubs=0     => {Enable Tcl integration via stubs library mechanism}
           12  +    with-tcl-private-stubs=0
           13  +                         => {Enable Tcl integration via private stubs mechanism}
           14  +    internal-sqlite=1    => {Don't use the internal SQLite, use the system one}
    12     15       static=0             => {Link a static executable}
    13     16       lineedit=1           => {Disable line editing}
           17  +    fusefs=1             => {Disable the Fuse Filesystem}
    14     18       fossil-debug=0       => {Build with fossil debugging enabled}
    15     19       json=0               => {Build with fossil JSON API enabled}
    16     20   }
    17     21   
    18     22   # sqlite wants these types if possible
    19     23   cc-with {-includes {stdint.h inttypes.h}} {
    20     24       cc-check-types uint32_t uint16_t int16_t uint8_t
................................................................................
    24     28   define USE_PREAD [cc-check-functions pread]
    25     29   
    26     30   # Find tclsh for the test suite. Can't yet use jimsh for this.
    27     31   cc-check-progs tclsh
    28     32   
    29     33   define EXTRA_CFLAGS ""
    30     34   define EXTRA_LDFLAGS ""
    31         -define USE_SYSTEM_SQLITE ""
           35  +define USE_SYSTEM_SQLITE 0
    32     36   
    33     37   if {![opt-bool internal-sqlite]} {
    34     38     proc find_internal_sqlite {} {
    35     39   
    36     40       # On some systems (slackware), libsqlite3 requires -ldl to link. So
    37     41       # search for the system SQLite once with -ldl, and once without. If
    38     42       # the library can only be found with $extralibs set to -ldl, then
    39     43       # the code below will append -ldl to LIBS.
    40     44       #
    41     45       foreach extralibs {{} {-ldl}} {
    42     46   
    43     47         # Locate the system SQLite by searching for sqlite3_open(). Then check
    44         -      # if sqlite3_wal_checkpoint() can be found as well. If we can find
    45         -      # open() but not wal_checkpoint(), then the system SQLite is too old
    46         -      # to link against fossil.
           48  +      # if sqlite3_strglob() can be found as well. If we can find open() but
           49  +      # not strglob(), then the system SQLite is too old to link against
           50  +      # fossil.
    47     51         #
    48     52         if {[cc-check-function-in-lib sqlite3_open sqlite3 $extralibs]} {
    49         -        if {![cc-check-function-in-lib sqlite3_wal_checkpoint sqlite3 $extralibs]} {
    50         -          user-error "system sqlite3 too old (require >= 3.7.0)"
           53  +        if {![cc-check-function-in-lib sqlite3_strglob sqlite3 $extralibs]} {
           54  +          user-error "system sqlite3 too old (require >= 3.7.17)"
    51     55           }
    52     56   
    53     57           # Success. Update symbols and return.
    54     58           #
    55     59           define USE_SYSTEM_SQLITE 1
    56     60           define-append LIBS $extralibs
    57     61           return
................................................................................
    58     62         }
    59     63       }
    60     64       user-error "system sqlite3 not found"
    61     65     }
    62     66   
    63     67     find_internal_sqlite
    64     68   }
           69  +
           70  +if {[string match *-solaris* [get-define host]]} {
           71  +    define-append EXTRA_CFLAGS -D_XOPEN_SOURCE=500
           72  +}
    65     73   
    66     74   if {[opt-bool fossil-debug]} {
    67     75       define-append EXTRA_CFLAGS -DFOSSIL_DEBUG
           76  +    msg-result "Debugging support enabled"
    68     77   }
    69     78   
    70     79   if {[opt-bool json]} {
    71     80       # Reminder/FIXME (stephan): FOSSIL_ENABLE_JSON
    72     81       # is required in the CFLAGS because json*.c
    73     82       # have #ifdef guards around the whole file without
    74     83       # reading config.h first.
    75     84       define-append EXTRA_CFLAGS -DFOSSIL_ENABLE_JSON
    76     85       define FOSSIL_ENABLE_JSON
           86  +    msg-result "JSON support enabled"
           87  +}
           88  +
           89  +if {[opt-bool with-th1-hooks]} {
           90  +    define-append EXTRA_CFLAGS -DFOSSIL_ENABLE_TH1_HOOKS
           91  +    define FOSSIL_ENABLE_TH1_HOOKS
           92  +    msg-result "TH1 hooks support enabled"
    77     93   }
    78     94   
    79     95   #if {[opt-bool markdown]} {
    80     96   #    # no-op.  Markdown is now enabled by default.
           97  +#    msg-result "Markdown support enabled"
    81     98   #}
    82     99   
    83    100   if {[opt-bool static]} {
    84    101       # XXX: This will not work on all systems.
    85    102       define-append EXTRA_LDFLAGS -static
    86         -}
    87         -
    88         -# Check for zlib, using the given location if specified
    89         -set zlibpath [opt-val with-zlib]
    90         -if {$zlibpath ne ""} {
    91         -    cc-with [list -cflags "-I$zlibpath -L$zlibpath"]
    92         -    define-append EXTRA_CFLAGS -I$zlibpath
    93         -    define-append EXTRA_LDFLAGS -L$zlibpath
    94         -}
    95         -if {![cc-check-includes zlib.h] || ![cc-check-function-in-lib inflateEnd z]} {
    96         -    user-error "zlib not found please install it or specify the location with --with-zlib"
          103  +    msg-result "Trying to link statically"
    97    104   }
    98    105   
    99    106   set tclpath [opt-val with-tcl]
   100    107   if {$tclpath ne ""} {
          108  +    set tclprivatestubs [opt-bool with-tcl-private-stubs]
   101    109       # Note parse-tclconfig-sh is in autosetup/local.tcl
   102    110       if {$tclpath eq "1"} {
          111  +        if {$tclprivatestubs} {
          112  +            set tclconfig(TCL_INCLUDE_SPEC) -Icompat/tcl-8.6/generic
          113  +            set tclconfig(TCL_VERSION) {Private Stubs}
          114  +            set tclconfig(TCL_PATCH_LEVEL) {}
          115  +            set tclconfig(TCL_PREFIX) {compat/tcl-8.6}
          116  +            set tclconfig(TCL_LD_FLAGS) { }
          117  +        } else {
   103    118           # Use the system Tcl. Look in some likely places.
   104    119           array set tclconfig [parse-tclconfig-sh \
          120  +                compat/tcl-8.6/unix compat/tcl-8.6/win \
   105    121               /usr /usr/local /usr/share /opt/local]
   106    122           set msg "on your system"
          123  +        }
   107    124       } else {
   108    125           array set tclconfig [parse-tclconfig-sh $tclpath]
   109    126           set msg "at $tclpath"
   110    127       }
   111    128       if {![info exists tclconfig(TCL_INCLUDE_SPEC)]} {
   112    129           user-error "Cannot find Tcl $msg"
   113    130       }
   114    131       set tclstubs [opt-bool with-tcl-stubs]
   115         -    if {$tclstubs && $tclconfig(TCL_SUPPORTS_STUBS)} {
          132  +    if {$tclprivatestubs} {
          133  +        define FOSSIL_ENABLE_TCL_PRIVATE_STUBS
          134  +        define USE_TCL_STUBS
          135  +    } elseif {$tclstubs && $tclconfig(TCL_SUPPORTS_STUBS)} {
   116    136           set libs "$tclconfig(TCL_STUB_LIB_SPEC)"
   117    137           define FOSSIL_ENABLE_TCL_STUBS
   118    138           define USE_TCL_STUBS
   119    139       } else {
   120    140           set libs "$tclconfig(TCL_LIB_SPEC) $tclconfig(TCL_LIBS)"
   121    141       }
   122    142       set cflags $tclconfig(TCL_INCLUDE_SPEC)
          143  +    if {!$tclprivatestubs} {
   123    144       cc-with [list -cflags $cflags -libs $libs] {
   124    145           if {$tclstubs} {
   125    146               if {![cc-check-functions Tcl_InitStubs]} {
   126    147                   user-error "Cannot find a usable Tcl stubs library $msg"
   127    148               }
   128    149           } else {
   129    150               if {![cc-check-functions Tcl_CreateInterp]} {
   130    151                   user-error "Cannot find a usable Tcl library $msg"
   131    152               }
   132    153           }
   133    154       }
          155  +    }
   134    156       set version $tclconfig(TCL_VERSION)$tclconfig(TCL_PATCH_LEVEL)
   135    157       msg-result "Found Tcl $version at $tclconfig(TCL_PREFIX)"
          158  +    if {!$tclprivatestubs} {
   136    159       define-append LIBS $libs
          160  +    }
   137    161       define-append EXTRA_CFLAGS $cflags
   138    162       define-append EXTRA_LDFLAGS $tclconfig(TCL_LD_FLAGS)
   139    163       define FOSSIL_ENABLE_TCL
   140    164   }
   141    165   
   142    166   # Helper for openssl checking
   143    167   proc check-for-openssl {msg {cflags {}}} {
................................................................................
   201    225                   define-append EXTRA_CFLAGS -Wdeprecated-declarations
   202    226               }
   203    227           }
   204    228       } else {
   205    229           user-error "OpenSSL not found. Consider --with-openssl=none to disable HTTPS support"
   206    230       }
   207    231   }
          232  +
          233  +# Check for zlib, using the given location if specified
          234  +set zlibpath [opt-val with-zlib]
          235  +if {$zlibpath ne ""} {
          236  +    cc-with [list -cflags "-I$zlibpath -L$zlibpath"]
          237  +    define-append EXTRA_CFLAGS -I$zlibpath
          238  +    define-append EXTRA_LDFLAGS -L$zlibpath
          239  +    msg-result "Using zlib from $zlibpath"
          240  +}
          241  +if {![cc-check-includes zlib.h] || ![cc-check-function-in-lib inflateEnd z]} {
          242  +    user-error "zlib not found please install it or specify the location with --with-zlib"
          243  +}
   208    244   
   209    245   if {[opt-bool lineedit]} {
   210    246       # Need readline-compatible line editing
   211    247       cc-with {-includes stdio.h} {
   212    248           if {[cc-check-includes readline/readline.h] && [cc-check-function-in-lib readline readline]} {
   213    249               msg-result "Using readline for line editing"
   214    250           } elseif {[cc-check-includes editline/readline.h] && [cc-check-function-in-lib readline edit]} {
................................................................................
   223    259   if {![cc-check-function-in-lib socket {socket network}]} {
   224    260       # Last resort, may be Windows
   225    261       if {[string match *mingw* [get-define host]]} {
   226    262           define-append LIBS -lwsock32
   227    263       }
   228    264   }
   229    265   cc-check-function-in-lib iconv iconv
          266  +cc-check-functions utime
          267  +cc-check-functions usleep
          268  +
          269  +# Check for getloadavg(), and if it doesn't exist, define FOSSIL_OMIT_LOAD_AVERAGE
          270  +if {![cc-check-functions getloadavg]} {
          271  +  define FOSSIL_OMIT_LOAD_AVERAGE 1
          272  +  msg-result "Load average support unavailable"
          273  +}
   230    274   
   231    275   # Check for getpassphrase() for Solaris 10 where getpass() truncates to 10 chars
   232    276   if {![cc-check-functions getpassphrase]} {
   233    277       # Haiku needs this
   234    278       cc-check-function-in-lib getpass bsd
   235    279   }
   236    280   cc-check-function-in-lib dlopen dl
          281  +
          282  +# Check for the FuseFS library
          283  +if {[opt-bool fusefs]} {
          284  +  if {[cc-check-function-in-lib fuse_mount fuse]} {
          285  +     define FOSSIL_HAVE_FUSEFS 1
          286  +     define-append LIBS -lfuse
          287  +     msg-result "FuseFS support enabled"
          288  +  }
          289  +}
   237    290   
   238    291   make-template Makefile.in
   239    292   make-config-header autoconfig.h -auto {USE_* FOSSIL_*}

Changes to autosetup/autosetup.

   923    923   		}
   924    924   	}
   925    925   }
   926    926   
   927    927   # Load module source in the global scope by executing the given command
   928    928   proc automf_load {args} {
   929    929   	if {[catch [list uplevel #0 $args] msg opts] ni {0 2 3}} {
   930         -		autosetup-full-error [error-dump $msg $opts]
          930  +		autosetup-full-error [error-dump $msg $opts $::autosetup(debug)]
   931    931   	}
   932    932   }
   933    933   
   934    934   # Initial settings
   935    935   set autosetup(exe) $::argv0
   936    936   set autosetup(istcl) 1
   937    937   set autosetup(start) [clock millis]
................................................................................
  1704   1704   		#puts "Skipping $info(file):$info(line)"
  1705   1705   	}
  1706   1706   	return $msg
  1707   1707   }
  1708   1708   
  1709   1709   # Given the return from [catch {...} msg opts], returns an appropriate
  1710   1710   # error message. A nice one for Jim and a less-nice one for Tcl.
         1711  +# If 'fulltrace' is set, a full stack trace is provided.
         1712  +# Otherwise a simple message is provided.
  1711   1713   #
  1712         -# This is designed for developer errors, e.g. in module code
         1714  +# This is designed for developer errors, e.g. in module code or auto.def code
         1715  +#
  1713   1716   #
  1714         -proc error-dump {msg opts} {
         1717  +proc error-dump {msg opts fulltrace} {
  1715   1718   	if {$::autosetup(istcl)} {
         1719  +		if {$fulltrace} {
  1716   1720   		return "Error: [dict get $opts -errorinfo]"
  1717   1721   	} else {
  1718         -		return "Error: $msg\n[stackdump $opts(-errorinfo)]"
         1722  +			return "Error: $msg"
         1723  +		}
         1724  +	} else {
         1725  +		lassign $opts(-errorinfo) p f l
         1726  +		if {$f ne ""} {
         1727  +			set result "$f:$l: Error: "
         1728  +		}
         1729  +		append result "$msg\n"
         1730  +		if {$fulltrace} {
         1731  +			append result [stackdump $opts(-errorinfo)]
         1732  +		}
         1733  +
         1734  +		# Remove the trailing newline
         1735  +		string trim $result
  1719   1736   	}
  1720   1737   }
  1721   1738   }
  1722   1739   
  1723   1740   # ----- module text-formatting -----
  1724   1741   
  1725   1742   set modsource(text-formatting) {
................................................................................
  1884   1901   ##################################################################
  1885   1902   #
  1886   1903   # Entry/Exit
  1887   1904   #
  1888   1905   if {$autosetup(debug)} {
  1889   1906   	main $argv
  1890   1907   }
  1891         -if {[catch {main $argv} msg] == 1} {
         1908  +if {[catch {main $argv} msg opts] == 1} {
  1892   1909   	show-notices
  1893         -	puts stderr [error-stacktrace $msg]
  1894         -	if {!$autosetup(debug) && !$autosetup(istcl)} {
         1910  +	autosetup-full-error [error-dump $msg $opts $::autosetup(debug)]
         1911  +	if {!$autosetup(debug)} {
  1895   1912   		puts stderr "Try: '[file tail $autosetup(exe)] --debug' for a full stack trace"
  1896   1913   	}
  1897   1914   	exit 1
  1898   1915   }

Changes to autosetup/cc-shared.tcl.

    92     92   		# XXX: These haven't been tested
    93     93   		define SHOBJ_CFLAGS "+O3 +z"
    94     94   		define SHOBJ_LDFLAGS -b
    95     95   		define SH_CFLAGS +z
    96     96   		define SH_LINKFLAGS -Wl,+s
    97     97   		define LD_LIBRARY_PATH SHLIB_PATH
    98     98   	}
           99  +	*-*-haiku {
          100  +		define SHOBJ_CFLAGS ""
          101  +		define SHOBJ_LDFLAGS -shared
          102  +		define SH_CFLAGS ""
          103  +		define SH_LDFLAGS -shared
          104  +		define SH_LINKFLAGS ""
          105  +		define SH_SOPREFIX ""
          106  +		define LD_LIBRARY_PATH LIBRARY_PATH
          107  +	}
    99    108   }
   100    109   
   101    110   if {![is-defined SHOBJ_LDFLAGS_R]} {
   102    111   	define SHOBJ_LDFLAGS_R [get-define SHOBJ_LDFLAGS]
   103    112   }

Changes to autosetup/cc.tcl.

   331    331   			-declare {
   332    332   				lappend new($name) $value
   333    333   			}
   334    334   			-libs {
   335    335   				# Note that new libraries are added before previous libraries
   336    336   				set new($name) [list {*}$value {*}$new($name)]
   337    337   			}
   338         -			-link - -lang {
          338  +			-link - -lang - -nooutput {
   339    339   				set new($name) $value
   340    340   			}
   341    341   			-source - -sourcefile - -code {
   342    342   				# XXX: These probably are only valid directly from cctest
   343    343   				set new($name) $value
   344    344   			}
   345    345   			default {
................................................................................
   426    426   ## -declare code       Code to declare before main()
   427    427   ## -link 1             Don't just compile, link too
   428    428   ## -lang c|c++         Use the C (default) or C++ compiler
   429    429   ## -libs liblist       List of libraries to link, e.g. {-ldl -lm}
   430    430   ## -code code          Code to compile in the body of main()
   431    431   ## -source code        Compile a complete program. Ignore -includes, -declare and -code
   432    432   ## -sourcefile file    Shorthand for -source [readfile [get-define srcdir]/$file]
          433  +## -nooutput 1         Treat any compiler output (e.g. a warning) as an error
   433    434   #
   434    435   # Unless -source or -sourcefile is specified, the C program looks like:
   435    436   #
   436    437   ## #include <firstinclude>   /* same for remaining includes in the list */
   437    438   ##
   438    439   ## declare-code              /* any code in -declare, verbatim */
   439    440   ##
................................................................................
   519    520   		}
   520    521   		return $ok
   521    522   	}
   522    523   
   523    524   	writefile $src $lines\n
   524    525   
   525    526   	set ok 1
   526         -	if {[catch {exec-with-stderr {*}$cmdline} result errinfo]} {
          527  +	set err [catch {exec-with-stderr {*}$cmdline} result errinfo]
          528  +	if {$err || ($opts(-nooutput) && [string length $result])} {
   527    529   		configlog "Failed: [join $cmdline]"
   528    530   		configlog $result
   529    531   		configlog "============"
   530    532   		configlog "The failed code was:"
   531    533   		configlog $lines
   532    534   		configlog "============"
   533    535   		set ok 0
................................................................................
   669    671   if {[get-define CC] eq ""} {
   670    672   	user-error "Could not find a C compiler. Tried: [join $try ", "]"
   671    673   }
   672    674   
   673    675   define CCACHE [find-an-executable [get-env CCACHE ccache]]
   674    676   
   675    677   # Initial cctest settings
   676         -cc-store-settings {-cflags {} -includes {} -declare {} -link 0 -lang c -libs {} -code {}}
          678  +cc-store-settings {-cflags {} -includes {} -declare {} -link 0 -lang c -libs {} -code {} -nooutput 0}
   677    679   set autosetup(cc-include-deps) {}
   678    680   
   679    681   msg-result "C compiler...[get-define CCACHE] [get-define CC] [get-define CFLAGS]"
   680    682   if {[get-define CXX] ne "false"} {
   681    683   	msg-result "C++ compiler...[get-define CCACHE] [get-define CXX] [get-define CXXFLAGS]"
   682    684   }
   683    685   msg-result "Build C compiler...[get-define CC_FOR_BUILD]"
   684    686   
   685         -# On Darwin, we prefer to use -gstabs to avoid creating .dSYM directories
   686         -# but some compilers don't support -gstabs, so test for it here.
          687  +# On Darwin, we prefer to use -g0 to avoid creating .dSYM directories
          688  +# but some compilers may not support it, so test here.
   687    689   switch -glob -- [get-define host] {
   688    690   	*-*-darwin* {
   689         -		if {[cctest -cflags {-gstabs}]} {
   690         -			define cc-default-debug -gstabs
          691  +		if {[cctest -cflags {-g0}]} {
          692  +			define cc-default-debug -g0
   691    693   		}
   692    694   	}
   693    695   }
   694    696   
   695    697   if {![cc-check-includes stdlib.h]} {
   696    698   	user-error "Compiler does not work. See config.log"
   697    699   }

Changes to autosetup/jimsh0.c.

    40     40   #define HAVE_VFORK
    41     41   #define HAVE_WAITPID
    42     42   #define HAVE_ISATTY
    43     43   #define HAVE_SYS_TIME_H
    44     44   #define HAVE_DIRENT_H
    45     45   #define HAVE_UNISTD_H
    46     46   #endif
           47  +#define JIM_VERSION 75
    47     48   #ifndef JIM_WIN32COMPAT_H
    48     49   #define JIM_WIN32COMPAT_H
    49     50   
    50     51   
    51     52   
    52     53   
    53     54   #if defined(_WIN32) || defined(WIN32)
................................................................................
   183    184   #    define strtoull strtoul
   184    185   #  endif
   185    186   #endif
   186    187   
   187    188   #define UCHAR(c) ((unsigned char)(c))
   188    189   
   189    190   
   190         -#define JIM_VERSION 73
   191         -
   192    191   #define JIM_OK 0
   193    192   #define JIM_ERR 1
   194    193   #define JIM_RETURN 2
   195    194   #define JIM_BREAK 3
   196    195   #define JIM_CONTINUE 4
   197    196   #define JIM_SIGNAL 5
   198    197   #define JIM_EXIT 6
................................................................................
   319    318   #define Jim_GetHashEntryVal(he) ((he)->val)
   320    319   #define Jim_GetHashTableCollisions(ht) ((ht)->collisions)
   321    320   #define Jim_GetHashTableSize(ht) ((ht)->size)
   322    321   #define Jim_GetHashTableUsed(ht) ((ht)->used)
   323    322   
   324    323   
   325    324   typedef struct Jim_Obj {
   326         -    int refCount; 
   327    325       char *bytes; 
   328         -    int length; 
   329    326       const struct Jim_ObjType *typePtr; 
          327  +    int refCount; 
          328  +    int length; 
   330    329       
   331    330       union {
   332    331           
   333    332           jim_wide wideValue;
   334    333           
   335    334           int intValue;
   336    335           
................................................................................
   663    662   JIM_EXPORT Jim_HashEntry * Jim_NextHashEntry
   664    663           (Jim_HashTableIterator *iter);
   665    664   
   666    665   
   667    666   JIM_EXPORT Jim_Obj * Jim_NewObj (Jim_Interp *interp);
   668    667   JIM_EXPORT void Jim_FreeObj (Jim_Interp *interp, Jim_Obj *objPtr);
   669    668   JIM_EXPORT void Jim_InvalidateStringRep (Jim_Obj *objPtr);
   670         -JIM_EXPORT void Jim_InitStringRep (Jim_Obj *objPtr, const char *bytes,
   671         -        int length);
   672    669   JIM_EXPORT Jim_Obj * Jim_DuplicateObj (Jim_Interp *interp,
   673    670           Jim_Obj *objPtr);
   674    671   JIM_EXPORT const char * Jim_GetString(Jim_Obj *objPtr,
   675    672           int *lenPtr);
   676    673   JIM_EXPORT const char *Jim_String(Jim_Obj *objPtr);
   677    674   JIM_EXPORT int Jim_Length(Jim_Obj *objPtr);
   678    675   
................................................................................
   832    829   
   833    830   JIM_EXPORT int Jim_GetDouble(Jim_Interp *interp, Jim_Obj *objPtr,
   834    831           double *doublePtr);
   835    832   JIM_EXPORT void Jim_SetDouble(Jim_Interp *interp, Jim_Obj *objPtr,
   836    833           double doubleValue);
   837    834   JIM_EXPORT Jim_Obj * Jim_NewDoubleObj(Jim_Interp *interp, double doubleValue);
   838    835   
   839         -
   840         -JIM_EXPORT const char * Jim_GetSharedString (Jim_Interp *interp,
   841         -        const char *str);
   842         -JIM_EXPORT void Jim_ReleaseSharedString (Jim_Interp *interp,
   843         -        const char *str);
   844         -
   845    836   
   846    837   JIM_EXPORT void Jim_WrongNumArgs (Jim_Interp *interp, int argc,
   847    838           Jim_Obj *const *argv, const char *msg);
   848    839   JIM_EXPORT int Jim_GetEnum (Jim_Interp *interp, Jim_Obj *objPtr,
   849    840           const char * const *tablePtr, int *indexPtr, const char *name, int flags);
   850    841   JIM_EXPORT int Jim_ScriptIsComplete (const char *s, int len,
   851    842           char *stateCharPtr);
................................................................................
   875    866   JIM_EXPORT char *Jim_HistoryGetline(const char *prompt);
   876    867   JIM_EXPORT void Jim_HistoryAdd(const char *line);
   877    868   JIM_EXPORT void Jim_HistoryShow(void);
   878    869   
   879    870   
   880    871   JIM_EXPORT int Jim_InitStaticExtensions(Jim_Interp *interp);
   881    872   JIM_EXPORT int Jim_StringToWide(const char *str, jim_wide *widePtr, int base);
          873  +JIM_EXPORT int Jim_IsBigEndian(void);
          874  +#define Jim_CheckSignal(i) ((i)->signal_level && (i)->sigmask)
   882    875   
   883    876   
   884    877   JIM_EXPORT int Jim_LoadLibrary(Jim_Interp *interp, const char *pathName);
   885    878   JIM_EXPORT void Jim_FreeLoadHandles(Jim_Interp *interp);
   886    879   
   887    880   
   888    881   JIM_EXPORT FILE *Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *command);
................................................................................
  1773   1766           fclose(af->fp);
  1774   1767       }
  1775   1768   
  1776   1769       Jim_DecrRefCount(interp, af->filename);
  1777   1770   
  1778   1771   #ifdef jim_ext_eventloop
  1779   1772       
  1780         -    if (af->rEvent) {
  1781         -        Jim_DeleteFileHandler(interp, af->fp);
  1782         -    }
  1783         -    if (af->wEvent) {
  1784         -        Jim_DeleteFileHandler(interp, af->fp);
  1785         -    }
  1786         -    if (af->eEvent) {
  1787         -        Jim_DeleteFileHandler(interp, af->fp);
  1788         -    }
         1773  +    Jim_DeleteFileHandler(interp, af->fp, JIM_EVENT_READABLE | JIM_EVENT_WRITABLE | JIM_EVENT_EXCEPTION);
  1789   1774   #endif
  1790   1775       Jim_Free(af);
  1791   1776   }
  1792   1777   
  1793   1778   static int JimCheckStreamError(Jim_Interp *interp, AioFile *af)
  1794   1779   {
  1795   1780       if (!ferror(af->fp)) {
................................................................................
  2145   2130       }
  2146   2131       return JIM_OK;
  2147   2132   }
  2148   2133   
  2149   2134   #ifdef jim_ext_eventloop
  2150   2135   static void JimAioFileEventFinalizer(Jim_Interp *interp, void *clientData)
  2151   2136   {
  2152         -    Jim_Obj *objPtr = clientData;
         2137  +    Jim_Obj **objPtrPtr = clientData;
  2153   2138   
  2154         -    Jim_DecrRefCount(interp, objPtr);
         2139  +    Jim_DecrRefCount(interp, *objPtrPtr);
         2140  +    *objPtrPtr = NULL;
  2155   2141   }
  2156   2142   
  2157   2143   static int JimAioFileEventHandler(Jim_Interp *interp, void *clientData, int mask)
  2158   2144   {
  2159         -    Jim_Obj *objPtr = clientData;
         2145  +    Jim_Obj **objPtrPtr = clientData;
  2160   2146   
  2161         -    return Jim_EvalObjBackground(interp, objPtr);
         2147  +    return Jim_EvalObjBackground(interp, *objPtrPtr);
  2162   2148   }
  2163   2149   
  2164   2150   static int aio_eventinfo(Jim_Interp *interp, AioFile * af, unsigned mask, Jim_Obj **scriptHandlerObj,
  2165   2151       int argc, Jim_Obj * const *argv)
  2166   2152   {
  2167         -    int scriptlen = 0;
  2168         -
  2169   2153       if (argc == 0) {
  2170   2154           
  2171   2155           if (*scriptHandlerObj) {
  2172   2156               Jim_SetResult(interp, *scriptHandlerObj);
  2173   2157           }
  2174   2158           return JIM_OK;
  2175   2159       }
  2176   2160   
  2177   2161       if (*scriptHandlerObj) {
  2178   2162           
  2179         -        Jim_DeleteFileHandler(interp, af->fp);
  2180         -        *scriptHandlerObj = NULL;
         2163  +        Jim_DeleteFileHandler(interp, af->fp, mask);
  2181   2164       }
  2182   2165   
  2183   2166       
  2184         -    Jim_GetString(argv[0], &scriptlen);
  2185         -    if (scriptlen == 0) {
         2167  +    if (Jim_Length(argv[0]) == 0) {
  2186   2168           
  2187   2169           return JIM_OK;
  2188   2170       }
  2189   2171   
  2190   2172       
  2191   2173       Jim_IncrRefCount(argv[0]);
  2192   2174       *scriptHandlerObj = argv[0];
  2193   2175   
  2194   2176       Jim_CreateFileHandler(interp, af->fp, mask,
  2195         -        JimAioFileEventHandler, *scriptHandlerObj, JimAioFileEventFinalizer);
         2177  +        JimAioFileEventHandler, scriptHandlerObj, JimAioFileEventFinalizer);
  2196   2178   
  2197   2179       return JIM_OK;
  2198   2180   }
  2199   2181   
  2200   2182   static int aio_cmd_readable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
  2201   2183   {
  2202   2184       AioFile *af = Jim_CmdPrivData(interp);
................................................................................
  4003   3985   static const char *JimStrError(void);
  4004   3986   static char **JimSaveEnv(char **env);
  4005   3987   static void JimRestoreEnv(char **env);
  4006   3988   static int JimCreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv,
  4007   3989       pidtype **pidArrayPtr, fdtype *inPipePtr, fdtype *outPipePtr, fdtype *errFilePtr);
  4008   3990   static void JimDetachPids(Jim_Interp *interp, int numPids, const pidtype *pidPtr);
  4009   3991   static int JimCleanupChildren(Jim_Interp *interp, int numPids, pidtype *pidPtr, fdtype errorId);
  4010         -static fdtype JimCreateTemp(Jim_Interp *interp, const char *contents);
         3992  +static fdtype JimCreateTemp(Jim_Interp *interp, const char *contents, int len);
  4011   3993   static fdtype JimOpenForWrite(const char *filename, int append);
  4012   3994   static int JimRewindFd(fdtype fd);
  4013   3995   
  4014   3996   static void Jim_SetResultErrno(Jim_Interp *interp, const char *msg)
  4015   3997   {
  4016   3998       Jim_SetResultFormatted(interp, "%s: %s", msg, JimStrError());
  4017   3999   }
................................................................................
  4345   4327       int numPids = 0;            /* Actual number of processes that exist
  4346   4328                                    * at *pidPtr right now. */
  4347   4329       int cmdCount;               /* Count of number of distinct commands
  4348   4330                                    * found in argc/argv. */
  4349   4331       const char *input = NULL;   /* Describes input for pipeline, depending
  4350   4332                                    * on "inputFile".  NULL means take input
  4351   4333                                    * from stdin/pipe. */
         4334  +    int input_len = 0;          
  4352   4335   
  4353   4336   #define FILE_NAME   0           
  4354   4337   #define FILE_APPEND 1           
  4355   4338   #define FILE_HANDLE 2           
  4356   4339   #define FILE_TEXT   3           
  4357   4340   
  4358   4341       int inputFile = FILE_NAME;  /* 1 means input is name of input file.
................................................................................
  4410   4393           const char *arg = Jim_String(argv[i]);
  4411   4394   
  4412   4395           if (arg[0] == '<') {
  4413   4396               inputFile = FILE_NAME;
  4414   4397               input = arg + 1;
  4415   4398               if (*input == '<') {
  4416   4399                   inputFile = FILE_TEXT;
         4400  +                input_len = Jim_Length(argv[i]) - 2;
  4417   4401                   input++;
  4418   4402               }
  4419   4403               else if (*input == '@') {
  4420   4404                   inputFile = FILE_HANDLE;
  4421   4405                   input++;
  4422   4406               }
  4423   4407   
  4424   4408               if (!*input && ++i < argc) {
  4425         -                input = Jim_String(argv[i]);
         4409  +                input = Jim_GetString(argv[i], &input_len);
  4426   4410               }
  4427   4411           }
  4428   4412           else if (arg[0] == '>') {
  4429   4413               int dup_error = 0;
  4430   4414   
  4431   4415               outputFile = FILE_NAME;
  4432   4416   
................................................................................
  4496   4480       }
  4497   4481   
  4498   4482       
  4499   4483       save_environ = JimSaveEnv(JimBuildEnv(interp));
  4500   4484   
  4501   4485       if (input != NULL) {
  4502   4486           if (inputFile == FILE_TEXT) {
  4503         -            inputId = JimCreateTemp(interp, input);
         4487  +            inputId = JimCreateTemp(interp, input, input_len);
  4504   4488               if (inputId == JIM_BAD_FD) {
  4505   4489                   goto error;
  4506   4490               }
  4507   4491           }
  4508   4492           else if (inputFile == FILE_HANDLE) {
  4509   4493               
  4510   4494               FILE *fh = JimGetAioFilehandle(interp, input);
................................................................................
  4585   4569               if (errorId == JIM_BAD_FD) {
  4586   4570                   Jim_SetResultFormatted(interp, "couldn't write file \"%s\": %s", error, JimStrError());
  4587   4571                   goto error;
  4588   4572               }
  4589   4573           }
  4590   4574       }
  4591   4575       else if (errFilePtr != NULL) {
  4592         -        errorId = JimCreateTemp(interp, NULL);
         4576  +        errorId = JimCreateTemp(interp, NULL, 0);
  4593   4577           if (errorId == JIM_BAD_FD) {
  4594   4578               goto error;
  4595   4579           }
  4596   4580           *errFilePtr = JimDupFd(errorId);
  4597   4581       }
  4598   4582   
  4599   4583   
................................................................................
  4951   4935       }
  4952   4936       GetExitCodeProcess(pid, &ret);
  4953   4937       *status = ret;
  4954   4938       CloseHandle(pid);
  4955   4939       return pid;
  4956   4940   }
  4957   4941   
  4958         -static HANDLE JimCreateTemp(Jim_Interp *interp, const char *contents)
         4942  +static HANDLE JimCreateTemp(Jim_Interp *interp, const char *contents, int len)
  4959   4943   {
  4960   4944       char name[MAX_PATH];
  4961   4945       HANDLE handle;
  4962   4946   
  4963   4947       if (!GetTempPath(MAX_PATH, name) || !GetTempFileName(name, "JIM", 0, name)) {
  4964   4948           return JIM_BAD_FD;
  4965   4949       }
................................................................................
  4975   4959       if (contents != NULL) {
  4976   4960           
  4977   4961           FILE *fh = JimFdOpenForWrite(JimDupFd(handle));
  4978   4962           if (fh == NULL) {
  4979   4963               goto error;
  4980   4964           }
  4981   4965   
  4982         -        if (fwrite(contents, strlen(contents), 1, fh) != 1) {
         4966  +        if (fwrite(contents, len, 1, fh) != 1) {
  4983   4967               fclose(fh);
  4984   4968               goto error;
  4985   4969           }
  4986   4970           fseek(fh, 0, SEEK_SET);
  4987   4971           fclose(fh);
  4988   4972       }
  4989   4973       return handle;
................................................................................
  5194   5178   }
  5195   5179   
  5196   5180   static int JimRewindFd(int fd)
  5197   5181   {
  5198   5182       return lseek(fd, 0L, SEEK_SET);
  5199   5183   }
  5200   5184   
  5201         -static int JimCreateTemp(Jim_Interp *interp, const char *contents)
         5185  +static int JimCreateTemp(Jim_Interp *interp, const char *contents, int len)
  5202   5186   {
  5203   5187       char inName[] = "/tmp/tcl.tmp.XXXXXX";
  5204   5188   
  5205   5189       int fd = mkstemp(inName);
  5206   5190       if (fd == JIM_BAD_FD) {
  5207   5191           Jim_SetResultErrno(interp, "couldn't create temp file");
  5208   5192           return -1;
  5209   5193       }
  5210   5194       unlink(inName);
  5211   5195       if (contents) {
  5212         -        int length = strlen(contents);
  5213         -        if (write(fd, contents, length) != length) {
         5196  +        if (write(fd, contents, len) != len) {
  5214   5197               Jim_SetResultErrno(interp, "couldn't write temp file");
  5215   5198               close(fd);
  5216   5199               return -1;
  5217   5200           }
  5218   5201           lseek(fd, 0L, SEEK_SET);
  5219   5202       }
  5220   5203       return fd;
................................................................................
  5669   5652   
  5670   5653   
  5671   5654   #ifdef JIM_MAINTAINER
  5672   5655   #define JIM_DEBUG_COMMAND
  5673   5656   #define JIM_DEBUG_PANIC
  5674   5657   #endif
  5675   5658   
         5659  +
         5660  +
         5661  +#define JIM_INTEGER_SPACE 24
         5662  +
  5676   5663   const char *jim_tt_name(int type);
  5677   5664   
  5678   5665   #ifdef JIM_DEBUG_PANIC
  5679   5666   static void JimPanicDump(int panic_condition, const char *fmt, ...);
  5680   5667   #define JimPanic(X) JimPanicDump X
  5681   5668   #else
  5682   5669   #define JimPanic(X)
................................................................................
  5688   5675   static void JimChangeCallFrameId(Jim_Interp *interp, Jim_CallFrame *cf);
  5689   5676   static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int flags);
  5690   5677   static int ListSetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int listindex, Jim_Obj *newObjPtr,
  5691   5678       int flags);
  5692   5679   static int JimDeleteLocalProcs(Jim_Interp *interp, Jim_Stack *localCommands);
  5693   5680   static Jim_Obj *JimExpandDictSugar(Jim_Interp *interp, Jim_Obj *objPtr);
  5694   5681   static void SetDictSubstFromAny(Jim_Interp *interp, Jim_Obj *objPtr);
         5682  +static Jim_Obj **JimDictPairs(Jim_Obj *dictPtr, int *len);
  5695   5683   static void JimSetFailedEnumResult(Jim_Interp *interp, const char *arg, const char *badtype,
  5696   5684       const char *prefix, const char *const *tablePtr, const char *name);
  5697   5685   static int JimCallProcedure(Jim_Interp *interp, Jim_Cmd *cmd, int argc, Jim_Obj *const *argv);
  5698   5686   static int JimGetWideNoErr(Jim_Interp *interp, Jim_Obj *objPtr, jim_wide * widePtr);
  5699   5687   static int JimSign(jim_wide w);
  5700   5688   static int JimValidName(Jim_Interp *interp, const char *type, Jim_Obj *nameObjPtr);
  5701   5689   static void JimPrngSeed(Jim_Interp *interp, unsigned char *seed, int seedLen);
................................................................................
  5932   5920       if (n > 0) {
  5933   5921           n = utf8_strlen(s2, n);
  5934   5922       }
  5935   5923       return n;
  5936   5924   }
  5937   5925   #endif
  5938   5926   
  5939         -int Jim_WideToString(char *buf, jim_wide wideValue)
         5927  +static int JimWideToString(char *buf, jim_wide wideValue)
  5940   5928   {
  5941         -    const char *fmt = "%" JIM_WIDE_MODIFIER;
         5929  +    int pos = 0;
  5942   5930   
  5943         -    return sprintf(buf, fmt, wideValue);
         5931  +    if (wideValue == 0) {
         5932  +        buf[pos++] = '0';
         5933  +    }
         5934  +    else {
         5935  +        char tmp[JIM_INTEGER_SPACE];
         5936  +        int num = 0;
         5937  +        int i;
         5938  +
         5939  +        if (wideValue < 0) {
         5940  +            buf[pos++] = '-';
         5941  +            
         5942  +            i = wideValue % 10;
         5943  +            tmp[num++] = (i > 0) ? (10 - i) : -i;
         5944  +            wideValue /= -10;
         5945  +        }
         5946  +
         5947  +        while (wideValue) {
         5948  +            tmp[num++] = wideValue % 10;
         5949  +            wideValue /= 10;
         5950  +        }
         5951  +
         5952  +        for (i = 0; i < num; i++) {
         5953  +            buf[pos++] = '0' + tmp[num - i - 1];
         5954  +        }
         5955  +    }
         5956  +    buf[pos] = 0;
         5957  +
         5958  +    return pos;
  5944   5959   }
  5945   5960   
  5946   5961   static int JimCheckConversion(const char *str, const char *endptr)
  5947   5962   {
  5948   5963       if (str[0] == '\0' || str == endptr) {
  5949   5964           return JIM_ERR;
  5950   5965       }
................................................................................
  5996   6011       i += 2;
  5997   6012       
  5998   6013       if (str[i] != '-' && str[i] != '+' && !isspace(UCHAR(str[i]))) {
  5999   6014           
  6000   6015           return i;
  6001   6016       }
  6002   6017       
  6003         -    return 10;
         6018  +    *base = 10;
         6019  +    return 0;
  6004   6020   }
  6005   6021   
  6006   6022   static long jim_strtol(const char *str, char **endptr)
  6007   6023   {
  6008   6024       int sign;
  6009   6025       int base;
  6010   6026       int i = JimNumberBase(str, &base, &sign);
................................................................................
  6076   6092               }
  6077   6093   #endif
  6078   6094               return len;
  6079   6095           }
  6080   6096           
  6081   6097           if (buf[i] == 'i' || buf[i] == 'I' || buf[i] == 'n' || buf[i] == 'N') {
  6082   6098               buf[i] = toupper(UCHAR(buf[i]));
         6099  +            if (buf[i] == 'n' || buf[i] == 'N')
         6100  +                buf[i+2] = toupper(UCHAR(buf[i+2]));
  6083   6101               buf[i + 3] = 0;
  6084   6102               return i + 3;
  6085   6103           }
  6086   6104       }
  6087   6105   
  6088   6106       buf[i++] = '.';
  6089   6107       buf[i++] = '0';
................................................................................
  6226   6244   {
  6227   6245       ht->table = NULL;
  6228   6246       ht->size = 0;
  6229   6247       ht->sizemask = 0;
  6230   6248       ht->used = 0;
  6231   6249       ht->collisions = 0;
  6232   6250   }
         6251  +
         6252  +static void JimInitHashTableIterator(Jim_HashTable *ht, Jim_HashTableIterator *iter)
         6253  +{
         6254  +    iter->ht = ht;
         6255  +    iter->index = -1;
         6256  +    iter->entry = NULL;
         6257  +    iter->nextEntry = NULL;
         6258  +}
  6233   6259   
  6234   6260   
  6235   6261   int Jim_InitHashTable(Jim_HashTable *ht, const Jim_HashTableType *type, void *privDataPtr)
  6236   6262   {
  6237   6263       JimResetHashTable(ht);
  6238   6264       ht->type = type;
  6239   6265       ht->privdata = privDataPtr;
................................................................................
  6406   6432       }
  6407   6433       return NULL;
  6408   6434   }
  6409   6435   
  6410   6436   Jim_HashTableIterator *Jim_GetHashTableIterator(Jim_HashTable *ht)
  6411   6437   {
  6412   6438       Jim_HashTableIterator *iter = Jim_Alloc(sizeof(*iter));
  6413         -
  6414         -    iter->ht = ht;
  6415         -    iter->index = -1;
  6416         -    iter->entry = NULL;
  6417         -    iter->nextEntry = NULL;
         6439  +    JimInitHashTableIterator(ht, iter);
  6418   6440       return iter;
  6419   6441   }
  6420   6442   
  6421   6443   Jim_HashEntry *Jim_NextHashEntry(Jim_HashTableIterator *iter)
  6422   6444   {
  6423   6445       while (1) {
  6424   6446           if (iter->entry == NULL) {
................................................................................
  7544   7566       
  7545   7567       if (objPtr->prevObjPtr)
  7546   7568           objPtr->prevObjPtr->nextObjPtr = objPtr->nextObjPtr;
  7547   7569       if (objPtr->nextObjPtr)
  7548   7570           objPtr->nextObjPtr->prevObjPtr = objPtr->prevObjPtr;
  7549   7571       if (interp->liveList == objPtr)
  7550   7572           interp->liveList = objPtr->nextObjPtr;
         7573  +#ifdef JIM_DISABLE_OBJECT_POOL
         7574  +    Jim_Free(objPtr);
         7575  +#else
  7551   7576       
  7552   7577       objPtr->prevObjPtr = NULL;
  7553   7578       objPtr->nextObjPtr = interp->freeList;
  7554   7579       if (interp->freeList)
  7555   7580           interp->freeList->prevObjPtr = objPtr;
  7556   7581       interp->freeList = objPtr;
  7557   7582       objPtr->refCount = -1;
         7583  +#endif
  7558   7584   }
  7559   7585   
  7560   7586   
  7561   7587   void Jim_InvalidateStringRep(Jim_Obj *objPtr)
  7562   7588   {
  7563   7589       if (objPtr->bytes != NULL) {
  7564   7590           if (objPtr->bytes != JimEmptyStringRep)
................................................................................
  8207   8233           Jim_IncrRefCount(objPtr);
  8208   8234           Jim_DecrRefCount(interp, objPtr);
  8209   8235       }
  8210   8236   
  8211   8237       return strObjPtr;
  8212   8238   }
  8213   8239   
         8240  +
         8241  +#ifdef HAVE_ISASCII
         8242  +#define jim_isascii isascii
         8243  +#else
         8244  +static int jim_isascii(int c)
         8245  +{
         8246  +    return !(c & ~0x7f);
         8247  +}
         8248  +#endif
  8214   8249   
  8215   8250   static int JimStringIs(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *strClass, int strict)
  8216   8251   {
  8217   8252       static const char * const strclassnames[] = {
  8218   8253           "integer", "alpha", "alnum", "ascii", "digit",
  8219   8254           "double", "lower", "upper", "space", "xdigit",
  8220   8255           "control", "print", "graph", "punct",
................................................................................
  8254   8289                   double d;
  8255   8290                   Jim_SetResultInt(interp, Jim_GetDouble(interp, strObjPtr, &d) == JIM_OK && errno != ERANGE);
  8256   8291                   return JIM_OK;
  8257   8292               }
  8258   8293   
  8259   8294           case STR_IS_ALPHA: isclassfunc = isalpha; break;
  8260   8295           case STR_IS_ALNUM: isclassfunc = isalnum; break;
  8261         -        case STR_IS_ASCII: isclassfunc = isascii; break;
         8296  +        case STR_IS_ASCII: isclassfunc = jim_isascii; break;
  8262   8297           case STR_IS_DIGIT: isclassfunc = isdigit; break;
  8263   8298           case STR_IS_LOWER: isclassfunc = islower; break;
  8264   8299           case STR_IS_UPPER: isclassfunc = isupper; break;
  8265   8300           case STR_IS_SPACE: isclassfunc = isspace; break;
  8266   8301           case STR_IS_XDIGIT: isclassfunc = isxdigit; break;
  8267   8302           case STR_IS_CONTROL: isclassfunc = iscntrl; break;
  8268   8303           case STR_IS_PRINT: isclassfunc = isprint; break;
................................................................................
 10176  10211   
 10177  10212       if (elapsedId > JIM_COLLECT_ID_PERIOD || elapsedTime > JIM_COLLECT_TIME_PERIOD) {
 10178  10213           Jim_Collect(interp);
 10179  10214       }
 10180  10215   }
 10181  10216   #endif
 10182  10217   
 10183         -static int JimIsBigEndian(void)
        10218  +int Jim_IsBigEndian(void)
 10184  10219   {
 10185  10220       union {
 10186  10221           unsigned short s;
 10187  10222           unsigned char c[2];
 10188  10223       } uval = {0x0102};
 10189  10224   
 10190  10225       return uval.c[0] == 1;
................................................................................
 10232  10267       
 10233  10268       Jim_SetVariableStrWithStr(i, JIM_LIBPATH, TCL_LIBRARY);
 10234  10269       Jim_SetVariableStrWithStr(i, JIM_INTERACTIVE, "0");
 10235  10270   
 10236  10271       Jim_SetVariableStrWithStr(i, "tcl_platform(os)", TCL_PLATFORM_OS);
 10237  10272       Jim_SetVariableStrWithStr(i, "tcl_platform(platform)", TCL_PLATFORM_PLATFORM);
 10238  10273       Jim_SetVariableStrWithStr(i, "tcl_platform(pathSeparator)", TCL_PLATFORM_PATH_SEPARATOR);
 10239         -    Jim_SetVariableStrWithStr(i, "tcl_platform(byteOrder)", JimIsBigEndian() ? "bigEndian" : "littleEndian");
        10274  +    Jim_SetVariableStrWithStr(i, "tcl_platform(byteOrder)", Jim_IsBigEndian() ? "bigEndian" : "littleEndian");
 10240  10275       Jim_SetVariableStrWithStr(i, "tcl_platform(threaded)", "0");
 10241  10276       Jim_SetVariableStr(i, "tcl_platform(pointerSize)", Jim_NewIntObj(i, sizeof(void *)));
 10242  10277       Jim_SetVariableStr(i, "tcl_platform(wordSize)", Jim_NewIntObj(i, sizeof(jim_wide)));
 10243  10278   
 10244  10279       return i;
 10245  10280   }
 10246  10281   
................................................................................
 10412  10447       Jim_IncrRefCount(stackTraceObj);
 10413  10448       Jim_DecrRefCount(interp, interp->stackTrace);
 10414  10449       interp->stackTrace = stackTraceObj;
 10415  10450       interp->errorFlag = 1;
 10416  10451   
 10417  10452       len = Jim_ListLength(interp, interp->stackTrace);
 10418  10453       if (len >= 3) {
 10419         -        Jim_Obj *filenameObj;
 10420         -
 10421         -        Jim_ListIndex(interp, interp->stackTrace, len - 2, &filenameObj, JIM_NONE);
 10422         -
 10423         -        Jim_GetString(filenameObj, &len);
 10424         -
 10425         -        if (!Jim_Length(filenameObj)) {
        10454  +        if (Jim_Length(Jim_ListGetIndex(interp, interp->stackTrace, len - 2)) == 0) {
 10426  10455               interp->addStackTrace = 1;
 10427  10456           }
 10428  10457       }
 10429  10458   }
 10430  10459   
 10431  10460   
 10432  10461   static void JimAppendStackTrace(Jim_Interp *interp, const char *procname,
................................................................................
 10448  10477   
 10449  10478       
 10450  10479       if (!*procname && Jim_Length(fileNameObj)) {
 10451  10480           
 10452  10481           int len = Jim_ListLength(interp, interp->stackTrace);
 10453  10482   
 10454  10483           if (len >= 3) {
 10455         -            Jim_Obj *objPtr;
 10456         -            if (Jim_ListIndex(interp, interp->stackTrace, len - 3, &objPtr, JIM_NONE) == JIM_OK && Jim_Length(objPtr)) {
        10484  +            Jim_Obj *objPtr = Jim_ListGetIndex(interp, interp->stackTrace, len - 3);
        10485  +            if (Jim_Length(objPtr)) {
 10457  10486                   
 10458         -                if (Jim_ListIndex(interp, interp->stackTrace, len - 2, &objPtr, JIM_NONE) == JIM_OK && !Jim_Length(objPtr)) {
        10487  +                objPtr = Jim_ListGetIndex(interp, interp->stackTrace, len - 2);
        10488  +                if (Jim_Length(objPtr) == 0) {
 10459  10489                       
 10460  10490                       ListSetIndex(interp, interp->stackTrace, len - 2, fileNameObj, 0);
 10461  10491                       ListSetIndex(interp, interp->stackTrace, len - 1, Jim_NewIntObj(interp, linenr), 0);
 10462  10492                       return;
 10463  10493                   }
 10464  10494               }
 10465  10495           }
................................................................................
 10498  10528   }
 10499  10529   
 10500  10530   int Jim_GetExitCode(Jim_Interp *interp)
 10501  10531   {
 10502  10532       return interp->exitCode;
 10503  10533   }
 10504  10534   
 10505         -#define JIM_INTEGER_SPACE 24
 10506         -
 10507  10535   static void UpdateStringOfInt(struct Jim_Obj *objPtr);
 10508  10536   static int SetIntFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags);
 10509  10537   
 10510  10538   static const Jim_ObjType intObjType = {
 10511  10539       "int",
 10512  10540       NULL,
 10513  10541       NULL,
................................................................................
 10520  10548       NULL,
 10521  10549       NULL,
 10522  10550       UpdateStringOfInt,
 10523  10551       JIM_TYPE_NONE,
 10524  10552   };
 10525  10553   
 10526  10554   
 10527         -void UpdateStringOfInt(struct Jim_Obj *objPtr)
        10555  +static void UpdateStringOfInt(struct Jim_Obj *objPtr)
 10528  10556   {
 10529  10557       int len;
 10530  10558       char buf[JIM_INTEGER_SPACE + 1];
 10531  10559   
 10532         -    len = Jim_WideToString(buf, JimWideValue(objPtr));
        10560  +    len = JimWideToString(buf, JimWideValue(objPtr));
 10533  10561       objPtr->bytes = Jim_Alloc(len + 1);
 10534  10562       memcpy(objPtr->bytes, buf, len + 1);
 10535  10563       objPtr->length = len;
 10536  10564   }
 10537  10565   
 10538  10566   int SetIntFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags)
 10539  10567   {
................................................................................
 10753  10781       }
 10754  10782       dupPtr->typePtr = &listObjType;
 10755  10783   }
 10756  10784   
 10757  10785   #define JIM_ELESTR_SIMPLE 0
 10758  10786   #define JIM_ELESTR_BRACE 1
 10759  10787   #define JIM_ELESTR_QUOTE 2
 10760         -static int ListElementQuotingType(const char *s, int len)
        10788  +static unsigned char ListElementQuotingType(const char *s, int len)
 10761  10789   {
 10762  10790       int i, level, blevel, trySimple = 1;
 10763  10791   
 10764  10792       
 10765  10793       if (len == 0)
 10766  10794           return JIM_ELESTR_BRACE;
 10767  10795       if (s[0] == '"' || s[0] == '{') {
................................................................................
 10901  10929       *p = '\0';
 10902  10930   
 10903  10931       return p - q;
 10904  10932   }
 10905  10933   
 10906  10934   static void JimMakeListStringRep(Jim_Obj *objPtr, Jim_Obj **objv, int objc)
 10907  10935   {
        10936  +    #define STATIC_QUOTING_LEN 32
 10908  10937       int i, bufLen, realLength;
 10909  10938       const char *strRep;
 10910  10939       char *p;
 10911         -    int *quotingType;
        10940  +    unsigned char *quotingType, staticQuoting[STATIC_QUOTING_LEN];
 10912  10941   
 10913  10942       
 10914         -    quotingType = Jim_Alloc(sizeof(int) * objc + 1);
        10943  +    if (objc > STATIC_QUOTING_LEN) {
        10944  +        quotingType = Jim_Alloc(objc);
        10945  +    }
        10946  +    else {
        10947  +        quotingType = staticQuoting;
        10948  +    }
 10915  10949       bufLen = 0;
 10916  10950       for (i = 0; i < objc; i++) {
 10917  10951           int len;
 10918  10952   
 10919  10953           strRep = Jim_GetString(objv[i], &len);
 10920  10954           quotingType[i] = ListElementQuotingType(strRep, len);
 10921  10955           switch (quotingType[i]) {
................................................................................
 10973  11007           if (i + 1 != objc) {
 10974  11008               *p++ = ' ';
 10975  11009               realLength++;
 10976  11010           }
 10977  11011       }
 10978  11012       *p = '\0';                  
 10979  11013       objPtr->length = realLength;
        11014  +
        11015  +    if (quotingType != staticQuoting) {
 10980  11016       Jim_Free(quotingType);
 10981  11017   }
        11018  +}
 10982  11019   
 10983  11020   static void UpdateStringOfList(struct Jim_Obj *objPtr)
 10984  11021   {
 10985  11022       JimMakeListStringRep(objPtr, objPtr->internalRep.listValue.ele, objPtr->internalRep.listValue.len);
 10986  11023   }
 10987  11024   
 10988  11025   static int SetListFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr)
................................................................................
 10998  11035       }
 10999  11036   
 11000  11037       if (Jim_IsDict(objPtr) && !Jim_IsShared(objPtr)) {
 11001  11038           Jim_Obj **listObjPtrPtr;
 11002  11039           int len;
 11003  11040           int i;
 11004  11041   
 11005         -        Jim_DictPairs(interp, objPtr, &listObjPtrPtr, &len);
        11042  +        listObjPtrPtr = JimDictPairs(objPtr, &len);
 11006  11043           for (i = 0; i < len; i++) {
 11007  11044               Jim_IncrRefCount(listObjPtrPtr[i]);
 11008  11045           }
 11009  11046   
 11010  11047           
 11011  11048           Jim_FreeIntRep(interp, objPtr);
 11012  11049           objPtr->typePtr = &listObjType;
................................................................................
 11223  11260   {
 11224  11261       int currentLen = listPtr->internalRep.listValue.len;
 11225  11262       int requiredLen = currentLen + elemc;
 11226  11263       int i;
 11227  11264       Jim_Obj **point;
 11228  11265   
 11229  11266       if (requiredLen > listPtr->internalRep.listValue.maxLen) {
 11230         -        listPtr->internalRep.listValue.maxLen = requiredLen * 2;
        11267  +        if (requiredLen < 2) {
        11268  +            
        11269  +            requiredLen = 4;
        11270  +        }
        11271  +        else {
        11272  +            requiredLen *= 2;
        11273  +        }
 11231  11274   
 11232  11275           listPtr->internalRep.listValue.ele = Jim_Realloc(listPtr->internalRep.listValue.ele,
 11233         -            sizeof(Jim_Obj *) * listPtr->internalRep.listValue.maxLen);
        11276  +            sizeof(Jim_Obj *) * requiredLen);
        11277  +
        11278  +        listPtr->internalRep.listValue.maxLen = requiredLen;
 11234  11279       }
 11235  11280       if (idx < 0) {
 11236  11281           idx = currentLen;
 11237  11282       }
 11238  11283       point = listPtr->internalRep.listValue.ele + idx;
 11239  11284       memmove(point + elemc, point, (currentLen - idx) * sizeof(Jim_Obj *));
 11240  11285       for (i = 0; i < elemc; ++i) {
................................................................................
 11521  11566       Jim_FreeHashTable(objPtr->internalRep.ptr);
 11522  11567       Jim_Free(objPtr->internalRep.ptr);
 11523  11568   }
 11524  11569   
 11525  11570   void DupDictInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr)
 11526  11571   {
 11527  11572       Jim_HashTable *ht, *dupHt;
 11528         -    Jim_HashTableIterator *htiter;
        11573  +    Jim_HashTableIterator htiter;
 11529  11574       Jim_HashEntry *he;
 11530  11575   
 11531  11576       
 11532  11577       ht = srcPtr->internalRep.ptr;
 11533  11578       dupHt = Jim_Alloc(sizeof(*dupHt));
 11534  11579       Jim_InitHashTable(dupHt, &JimDictHashTableType, interp);
 11535  11580       if (ht->size != 0)
 11536  11581           Jim_ExpandHashTable(dupHt, ht->size);
 11537  11582       
 11538         -    htiter = Jim_GetHashTableIterator(ht);
 11539         -    while ((he = Jim_NextHashEntry(htiter)) != NULL) {
        11583  +    JimInitHashTableIterator(ht, &htiter);
        11584  +    while ((he = Jim_NextHashEntry(&htiter)) != NULL) {
 11540  11585           const Jim_Obj *keyObjPtr = he->key;
 11541  11586           Jim_Obj *valObjPtr = he->u.val;
 11542  11587   
 11543  11588           Jim_IncrRefCount((Jim_Obj *)keyObjPtr); 
 11544  11589           Jim_IncrRefCount(valObjPtr);
 11545  11590           Jim_AddHashEntry(dupHt, keyObjPtr, valObjPtr);
 11546  11591       }
 11547         -    Jim_FreeHashTableIterator(htiter);
 11548  11592   
 11549  11593       dupPtr->internalRep.ptr = dupHt;
 11550  11594       dupPtr->typePtr = &dictObjType;
 11551  11595   }
 11552  11596   
 11553  11597   static Jim_Obj **JimDictPairs(Jim_Obj *dictPtr, int *len)
 11554  11598   {
 11555  11599       Jim_HashTable *ht;
 11556         -    Jim_HashTableIterator *htiter;
        11600  +    Jim_HashTableIterator htiter;
 11557  11601       Jim_HashEntry *he;
 11558  11602       Jim_Obj **objv;
 11559  11603       int i;
 11560  11604   
 11561  11605       ht = dictPtr->internalRep.ptr;
 11562  11606   
 11563  11607       
 11564  11608       objv = Jim_Alloc((ht->used * 2) * sizeof(Jim_Obj *));
 11565         -    htiter = Jim_GetHashTableIterator(ht);
        11609  +    JimInitHashTableIterator(ht, &htiter);
 11566  11610       i = 0;
 11567         -    while ((he = Jim_NextHashEntry(htiter)) != NULL) {
        11611  +    while ((he = Jim_NextHashEntry(&htiter)) != NULL) {
 11568  11612           objv[i++] = (Jim_Obj *)he->key;
 11569  11613           objv[i++] = he->u.val;
 11570  11614       }
 11571  11615       *len = i;
 11572         -    Jim_FreeHashTableIterator(htiter);
 11573  11616       return objv;
 11574  11617   }
 11575  11618   
 11576  11619   static void UpdateStringOfDict(struct Jim_Obj *objPtr)
 11577  11620   {
 11578  11621       
 11579  11622       int len;
................................................................................
 12087  12130       int skip;
 12088  12131   };
 12089  12132   
 12090  12133   
 12091  12134   typedef struct Jim_ExprOperator
 12092  12135   {
 12093  12136       const char *name;
 12094         -    int precedence;
 12095         -    int arity;
 12096  12137       int (*funcop) (Jim_Interp *interp, struct JimExprState * e);
 12097         -    int lazy;
        12138  +    unsigned char precedence;
        12139  +    unsigned char arity;
        12140  +    unsigned char lazy;
        12141  +    unsigned char namelen;
 12098  12142   } Jim_ExprOperator;
 12099  12143   
 12100  12144   static void ExprPush(struct JimExprState *e, Jim_Obj *obj)
 12101  12145   {
 12102  12146       Jim_IncrRefCount(obj);
 12103  12147       e->stack[e->stacklen++] = obj;
 12104  12148   }
................................................................................
 12772  12816   {
 12773  12817       LAZY_NONE,
 12774  12818       LAZY_OP,
 12775  12819       LAZY_LEFT,
 12776  12820       LAZY_RIGHT
 12777  12821   };
 12778  12822   
        12823  +#define OPRINIT(N, P, A, F, L) {N, F, P, A, L, sizeof(N) - 1}
        12824  +
 12779  12825   static const struct Jim_ExprOperator Jim_ExprOperators[] = {
 12780         -    {"*", 200, 2, JimExprOpBin, LAZY_NONE},
 12781         -    {"/", 200, 2, JimExprOpBin, LAZY_NONE},
 12782         -    {"%", 200, 2, JimExprOpIntBin, LAZY_NONE},
 12783         -
 12784         -    {"-", 100, 2, JimExprOpBin, LAZY_NONE},
 12785         -    {"+", 100, 2, JimExprOpBin, LAZY_NONE},
 12786         -
 12787         -    {"<<", 90, 2, JimExprOpIntBin, LAZY_NONE},
 12788         -    {">>", 90, 2, JimExprOpIntBin, LAZY_NONE},
 12789         -
 12790         -    {"<<<", 90, 2, JimExprOpIntBin, LAZY_NONE},
 12791         -    {">>>", 90, 2, JimExprOpIntBin, LAZY_NONE},
 12792         -
 12793         -    {"<", 80, 2, JimExprOpBin, LAZY_NONE},
 12794         -    {">", 80, 2, JimExprOpBin, LAZY_NONE},
 12795         -    {"<=", 80, 2, JimExprOpBin, LAZY_NONE},
 12796         -    {">=", 80, 2, JimExprOpBin, LAZY_NONE},
 12797         -
 12798         -    {"==", 70, 2, JimExprOpBin, LAZY_NONE},
 12799         -    {"!=", 70, 2, JimExprOpBin, LAZY_NONE},
 12800         -
 12801         -    {"&", 50, 2, JimExprOpIntBin, LAZY_NONE},
 12802         -    {"^", 49, 2, JimExprOpIntBin, LAZY_NONE},
 12803         -    {"|", 48, 2, JimExprOpIntBin, LAZY_NONE},
 12804         -
 12805         -    {"&&", 10, 2, NULL, LAZY_OP},
 12806         -    {NULL, 10, 2, JimExprOpAndLeft, LAZY_LEFT},
 12807         -    {NULL, 10, 2, JimExprOpAndOrRight, LAZY_RIGHT},
 12808         -
 12809         -    {"||", 9, 2, NULL, LAZY_OP},
 12810         -    {NULL, 9, 2, JimExprOpOrLeft, LAZY_LEFT},
 12811         -    {NULL, 9, 2, JimExprOpAndOrRight, LAZY_RIGHT},
 12812         -
 12813         -    {"?", 5, 2, JimExprOpNull, LAZY_OP},
 12814         -    {NULL, 5, 2, JimExprOpTernaryLeft, LAZY_LEFT},
 12815         -    {NULL, 5, 2, JimExprOpNull, LAZY_RIGHT},
 12816         -
 12817         -    {":", 5, 2, JimExprOpNull, LAZY_OP},
 12818         -    {NULL, 5, 2, JimExprOpColonLeft, LAZY_LEFT},
 12819         -    {NULL, 5, 2, JimExprOpNull, LAZY_RIGHT},
 12820         -
 12821         -    {"**", 250, 2, JimExprOpBin, LAZY_NONE},
 12822         -
 12823         -    {"eq", 60, 2, JimExprOpStrBin, LAZY_NONE},
 12824         -    {"ne", 60, 2, JimExprOpStrBin, LAZY_NONE},
 12825         -
 12826         -    {"in", 55, 2, JimExprOpStrBin, LAZY_NONE},
 12827         -    {"ni", 55, 2, JimExprOpStrBin, LAZY_NONE},
 12828         -
 12829         -    {"!", 300, 1, JimExprOpNumUnary, LAZY_NONE},
 12830         -    {"~", 300, 1, JimExprOpIntUnary, LAZY_NONE},
 12831         -    {NULL, 300, 1, JimExprOpNumUnary, LAZY_NONE},
 12832         -    {NULL, 300, 1, JimExprOpNumUnary, LAZY_NONE},
 12833         -
 12834         -
 12835         -
 12836         -    {"int", 400, 1, JimExprOpNumUnary, LAZY_NONE},
 12837         -    {"abs", 400, 1, JimExprOpNumUnary, LAZY_NONE},
 12838         -    {"double", 400, 1, JimExprOpNumUnary, LAZY_NONE},
 12839         -    {"round", 400, 1, JimExprOpNumUnary, LAZY_NONE},
 12840         -    {"rand", 400, 0, JimExprOpNone, LAZY_NONE},
 12841         -    {"srand", 400, 1, JimExprOpIntUnary, LAZY_NONE},
        12826  +    OPRINIT("*", 110, 2, JimExprOpBin, LAZY_NONE),
        12827  +    OPRINIT("/", 110, 2, JimExprOpBin, LAZY_NONE),
        12828  +    OPRINIT("%", 110, 2, JimExprOpIntBin, LAZY_NONE),
        12829  +
        12830  +    OPRINIT("-", 100, 2, JimExprOpBin, LAZY_NONE),
        12831  +    OPRINIT("+", 100, 2, JimExprOpBin, LAZY_NONE),
        12832  +
        12833  +    OPRINIT("<<", 90, 2, JimExprOpIntBin, LAZY_NONE),
        12834  +    OPRINIT(">>", 90, 2, JimExprOpIntBin, LAZY_NONE),
        12835  +
        12836  +    OPRINIT("<<<", 90, 2, JimExprOpIntBin, LAZY_NONE),
        12837  +    OPRINIT(">>>", 90, 2, JimExprOpIntBin, LAZY_NONE),
        12838  +
        12839  +    OPRINIT("<", 80, 2, JimExprOpBin, LAZY_NONE),
        12840  +    OPRINIT(">", 80, 2, JimExprOpBin, LAZY_NONE),
        12841  +    OPRINIT("<=", 80, 2, JimExprOpBin, LAZY_NONE),
        12842  +    OPRINIT(">=", 80, 2, JimExprOpBin, LAZY_NONE),
        12843  +
        12844  +    OPRINIT("==", 70, 2, JimExprOpBin, LAZY_NONE),
        12845  +    OPRINIT("!=", 70, 2, JimExprOpBin, LAZY_NONE),
        12846  +
        12847  +    OPRINIT("&", 50, 2, JimExprOpIntBin, LAZY_NONE),
        12848  +    OPRINIT("^", 49, 2, JimExprOpIntBin, LAZY_NONE),
        12849  +    OPRINIT("|", 48, 2, JimExprOpIntBin, LAZY_NONE),
        12850  +
        12851  +    OPRINIT("&&", 10, 2, NULL, LAZY_OP),
        12852  +    OPRINIT(NULL, 10, 2, JimExprOpAndLeft, LAZY_LEFT),
        12853  +    OPRINIT(NULL, 10, 2, JimExprOpAndOrRight, LAZY_RIGHT),
        12854  +
        12855  +    OPRINIT("||", 9, 2, NULL, LAZY_OP),
        12856  +    OPRINIT(NULL, 9, 2, JimExprOpOrLeft, LAZY_LEFT),
        12857  +    OPRINIT(NULL, 9, 2, JimExprOpAndOrRight, LAZY_RIGHT),
        12858  +
        12859  +    OPRINIT("?", 5, 2, JimExprOpNull, LAZY_OP),
        12860  +    OPRINIT(NULL, 5, 2, JimExprOpTernaryLeft, LAZY_LEFT),
        12861  +    OPRINIT(NULL, 5, 2, JimExprOpNull, LAZY_RIGHT),
        12862  +
        12863  +    OPRINIT(":", 5, 2, JimExprOpNull, LAZY_OP),
        12864  +    OPRINIT(NULL, 5, 2, JimExprOpColonLeft, LAZY_LEFT),
        12865  +    OPRINIT(NULL, 5, 2, JimExprOpNull, LAZY_RIGHT),
        12866  +
        12867  +    OPRINIT("**", 250, 2, JimExprOpBin, LAZY_NONE),
        12868  +
        12869  +    OPRINIT("eq", 60, 2, JimExprOpStrBin, LAZY_NONE),
        12870  +    OPRINIT("ne", 60, 2, JimExprOpStrBin, LAZY_NONE),
        12871  +
        12872  +    OPRINIT("in", 55, 2, JimExprOpStrBin, LAZY_NONE),
        12873  +    OPRINIT("ni", 55, 2, JimExprOpStrBin, LAZY_NONE),
        12874  +
        12875  +    OPRINIT("!", 150, 1, JimExprOpNumUnary, LAZY_NONE),
        12876  +    OPRINIT("~", 150, 1, JimExprOpIntUnary, LAZY_NONE),
        12877  +    OPRINIT(NULL, 150, 1, JimExprOpNumUnary, LAZY_NONE),
        12878  +    OPRINIT(NULL, 150, 1, JimExprOpNumUnary, LAZY_NONE),
        12879  +
        12880  +
        12881  +
        12882  +    OPRINIT("int", 200, 1, JimExprOpNumUnary, LAZY_NONE),
        12883  +    OPRINIT("abs", 200, 1, JimExprOpNumUnary, LAZY_NONE),
        12884  +    OPRINIT("double", 200, 1, JimExprOpNumUnary, LAZY_NONE),
        12885  +    OPRINIT("round", 200, 1, JimExprOpNumUnary, LAZY_NONE),
        12886  +    OPRINIT("rand", 200, 0, JimExprOpNone, LAZY_NONE),
        12887  +    OPRINIT("srand", 200, 1, JimExprOpIntUnary, LAZY_NONE),
 12842  12888   
 12843  12889   #ifdef JIM_MATH_FUNCTIONS
 12844         -    {"sin", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12845         -    {"cos", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12846         -    {"tan", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12847         -    {"asin", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12848         -    {"acos", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12849         -    {"atan", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12850         -    {"sinh", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12851         -    {"cosh", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12852         -    {"tanh", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12853         -    {"ceil", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12854         -    {"floor", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12855         -    {"exp", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12856         -    {"log", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12857         -    {"log10", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12858         -    {"sqrt", 400, 1, JimExprOpDoubleUnary, LAZY_NONE},
 12859         -    {"pow", 400, 2, JimExprOpBin, LAZY_NONE},
        12890  +    OPRINIT("sin", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12891  +    OPRINIT("cos", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12892  +    OPRINIT("tan", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12893  +    OPRINIT("asin", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12894  +    OPRINIT("acos", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12895  +    OPRINIT("atan", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12896  +    OPRINIT("sinh", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12897  +    OPRINIT("cosh", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12898  +    OPRINIT("tanh", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12899  +    OPRINIT("ceil", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12900  +    OPRINIT("floor", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12901  +    OPRINIT("exp", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12902  +    OPRINIT("log", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12903  +    OPRINIT("log10", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12904  +    OPRINIT("sqrt", 200, 1, JimExprOpDoubleUnary, LAZY_NONE),
        12905  +    OPRINIT("pow", 200, 2, JimExprOpBin, LAZY_NONE),
 12860  12906   #endif
 12861  12907   };
        12908  +#undef OPRINIT
 12862  12909   
 12863  12910   #define JIM_EXPR_OPERATORS_NUM \
 12864  12911       (sizeof(Jim_ExprOperators)/sizeof(struct Jim_ExprOperator))
 12865  12912   
 12866  12913   static int JimParseExpression(struct JimParserCtx *pc)
 12867  12914   {
 12868  12915       
................................................................................
 13024  13071   static int JimParseExprOperator(struct JimParserCtx *pc)
 13025  13072   {
 13026  13073       int i;
 13027  13074       int bestIdx = -1, bestLen = 0;
 13028  13075   
 13029  13076       
 13030  13077       for (i = 0; i < (signed)JIM_EXPR_OPERATORS_NUM; i++) {
 13031         -        const char *opname;
 13032         -        int oplen;
        13078  +        const char * const opname = Jim_ExprOperators[i].name;
        13079  +        const int oplen = Jim_ExprOperators[i].namelen;
 13033  13080   
 13034         -        opname = Jim_ExprOperators[i].name;
 13035         -        if (opname == NULL) {
        13081  +        if (opname == NULL || opname[0] != pc->p[0]) {
 13036  13082               continue;
 13037  13083           }
 13038         -        oplen = strlen(opname);
 13039  13084   
 13040         -        if (strncmp(opname, pc->p, oplen) == 0 && oplen > bestLen) {
        13085  +        if (oplen > bestLen && strncmp(opname, pc->p, oplen) == 0) {
 13041  13086               bestIdx = i + JIM_TT_EXPR_OP;
 13042  13087               bestLen = oplen;
 13043  13088           }
 13044  13089       }
 13045  13090       if (bestIdx == -1) {
 13046  13091           return JIM_ERR;
 13047  13092       }
................................................................................
 13109  13154       NULL,
 13110  13155       JIM_TYPE_REFERENCES,
 13111  13156   };
 13112  13157   
 13113  13158   
 13114  13159   typedef struct ExprByteCode
 13115  13160   {
 13116         -    int len;                    
 13117  13161       ScriptToken *token;         
        13162  +    int len;                    
 13118  13163       int inUse;                  
 13119  13164   } ExprByteCode;
 13120  13165   
 13121  13166   static void ExprFreeByteCode(Jim_Interp *interp, ExprByteCode * expr)
 13122  13167   {
 13123  13168       int i;
 13124  13169   
................................................................................
 13853  13898   }
 13854  13899   
 13855  13900   
 13856  13901   
 13857  13902   
 13858  13903   typedef struct ScanFmtPartDescr
 13859  13904   {
 13860         -    char type;                  
 13861         -    char modifier;              
        13905  +    char *arg;                  
        13906  +    char *prefix;               
 13862  13907       size_t width;               
 13863  13908       int pos;                    
 13864         -    char *arg;                  
 13865         -    char *prefix;               
        13909  +    char type;                  
        13910  +    char modifier;              
 13866  13911   } ScanFmtPartDescr;
 13867  13912   
 13868  13913   
 13869  13914   typedef struct ScanFmtStringObj
 13870  13915   {
 13871  13916       jim_wide size;              
 13872  13917       char *stringRep;            
................................................................................
 14869  14914                   argc += len - 1;
 14870  14915               }
 14871  14916           }
 14872  14917   
 14873  14918           if (retcode == JIM_OK && argc) {
 14874  14919               
 14875  14920               retcode = JimInvokeCommand(interp, argc, argv);
 14876         -            if (interp->signal_level && interp->sigmask) {
 14877  14921                   
        14922  +            if (Jim_CheckSignal(interp)) {
 14878  14923                   retcode = JIM_SIGNAL;
 14879  14924               }
 14880  14925           }
 14881  14926   
 14882  14927           
 14883  14928           while (j-- > 0) {
 14884  14929               Jim_DecrRefCount(interp, argv[j]);
................................................................................
 15444  15489       if (patternObjPtr && JimTrivialMatch(Jim_String(patternObjPtr))) {
 15445  15490           he = Jim_FindHashEntry(ht, Jim_String(patternObjPtr));
 15446  15491           if (he) {
 15447  15492               callback(interp, listObjPtr, he, type);
 15448  15493           }
 15449  15494       }
 15450  15495       else {
 15451         -        Jim_HashTableIterator *htiter = Jim_GetHashTableIterator(ht);
 15452         -        while ((he = Jim_NextHashEntry(htiter)) != NULL) {
        15496  +        Jim_HashTableIterator htiter;
        15497  +        JimInitHashTableIterator(ht, &htiter);
        15498  +        while ((he = Jim_NextHashEntry(&htiter)) != NULL) {
 15453  15499               if (patternObjPtr == NULL || JimGlobMatch(Jim_String(patternObjPtr), he->key, 0)) {
 15454  15500                   callback(interp, listObjPtr, he, type);
 15455  15501               }
 15456  15502           }
 15457         -        Jim_FreeHashTableIterator(htiter);
 15458  15503       }
 15459  15504       return listObjPtr;
 15460  15505   }
 15461  15506   
 15462  15507   
 15463  15508   #define JIM_CMDLIST_COMMANDS 0
 15464  15509   #define JIM_CMDLIST_PROCS 1
................................................................................
 17107  17152   }
 17108  17153   
 17109  17154   
 17110  17155   static int Jim_LocalCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 17111  17156   {
 17112  17157       int retcode;
 17113  17158   
        17159  +    if (argc < 2) {
        17160  +        Jim_WrongNumArgs(interp, 1, argv, "cmd ?args ...?");
        17161  +        return JIM_ERR;
        17162  +    }
        17163  +
 17114  17164       
 17115  17165       interp->local++;
 17116  17166       retcode = Jim_EvalObjVector(interp, argc - 1, argv + 1);
 17117  17167       interp->local--;
 17118  17168   
 17119  17169   
 17120  17170       
................................................................................
 17793  17843       argv += i;
 17794  17844   
 17795  17845       if ((ignore_mask & (1 << JIM_SIGNAL)) == 0) {
 17796  17846           sig++;
 17797  17847       }
 17798  17848   
 17799  17849       interp->signal_level += sig;
 17800         -    if (interp->signal_level && interp->sigmask) {
        17850  +    if (Jim_CheckSignal(interp)) {
 17801  17851           
 17802  17852           exitCode = JIM_SIGNAL;
 17803  17853       }
 17804  17854       else {
 17805  17855           exitCode = Jim_EvalObj(interp, argv[0]);
 17806  17856       }
 17807  17857       interp->signal_level -= sig;
................................................................................
 17949  17999       return JIM_OK;
 17950  18000   }
 17951  18001   
 17952  18002   
 17953  18003   static int JimInfoReferences(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 17954  18004   {
 17955  18005       Jim_Obj *listObjPtr;
 17956         -    Jim_HashTableIterator *htiter;
        18006  +    Jim_HashTableIterator htiter;
 17957  18007       Jim_HashEntry *he;
 17958  18008   
 17959  18009       listObjPtr = Jim_NewListObj(interp, NULL, 0);
 17960  18010   
 17961         -    htiter = Jim_GetHashTableIterator(&interp->references);
 17962         -    while ((he = Jim_NextHashEntry(htiter)) != NULL) {
        18011  +    JimInitHashTableIterator(&interp->references, &htiter);
        18012  +    while ((he = Jim_NextHashEntry(&htiter)) != NULL) {
 17963  18013           char buf[JIM_REFERENCE_SPACE + 1];
 17964  18014           Jim_Reference *refPtr = he->u.val;
 17965  18015           const unsigned long *refId = he->key;
 17966  18016   
 17967  18017           JimFormatReference(buf, refPtr, *refId);
 17968  18018           Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, buf, -1));
 17969  18019       }
 17970         -    Jim_FreeHashTableIterator(htiter);
 17971  18020       Jim_SetResult(interp, listObjPtr);
 17972  18021       return JIM_OK;
 17973  18022   }
 17974  18023   #endif
 17975  18024   
 17976  18025   
 17977  18026   static int Jim_RenameCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
................................................................................
 18003  18052   static Jim_Obj *JimDictPatternMatch(Jim_Interp *interp, Jim_HashTable *ht, Jim_Obj *patternObjPtr,
 18004  18053       JimDictMatchCallbackType *callback, int type)
 18005  18054   {
 18006  18055       Jim_HashEntry *he;
 18007  18056       Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);
 18008  18057   
 18009  18058       
 18010         -    Jim_HashTableIterator *htiter = Jim_GetHashTableIterator(ht);
 18011         -    while ((he = Jim_NextHashEntry(htiter)) != NULL) {
        18059  +    Jim_HashTableIterator htiter;
        18060  +    JimInitHashTableIterator(ht, &htiter);
        18061  +    while ((he = Jim_NextHashEntry(&htiter)) != NULL) {
 18012  18062           if (patternObjPtr == NULL || JimGlobMatch(Jim_String(patternObjPtr), Jim_String((Jim_Obj *)he->key), 0)) {
 18013  18063               callback(interp, listObjPtr, he, type);
 18014  18064           }
 18015  18065       }
 18016         -    Jim_FreeHashTableIterator(htiter);
 18017  18066   
 18018  18067       return listObjPtr;
 18019  18068   }
 18020  18069   
 18021  18070   
 18022  18071   int Jim_DictKeys(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *patternObjPtr)
 18023  18072   {
................................................................................
 19501  19550       Jim_Obj *resultPtr;
 19502  19551   
 19503  19552       char *num_buffer = NULL;
 19504  19553       int num_buffer_size = 0;
 19505  19554   
 19506  19555       span = format = Jim_GetString(fmtObjPtr, &formatLen);
 19507  19556       formatEnd = format + formatLen;
 19508         -    resultPtr = Jim_NewStringObj(interp, "", 0);
        19557  +    resultPtr = Jim_NewEmptyStringObj(interp);
 19509  19558   
 19510  19559       while (format != formatEnd) {
 19511  19560   	char *end;
 19512  19561   	int gotMinus, sawFlag;
 19513  19562   	int gotPrecision, useShort;
 19514  19563   	long width, precision;
 19515  19564   	int newXpg;

Changes to autosetup/local.tcl.

    24     24   		if {[regexp {^(TCL_[^=]*)=(.*)$} $line -> name value]} {
    25     25   			set value [regsub -all {\$\{.*\}} $value ""]
    26     26   			set tclconfig($name) [string trim $value ']
    27     27   		}
    28     28   	}
    29     29   	return [array get tclconfig]
    30     30   }
           31  +
           32  +# The complex extension checking is done here.
           33  +
           34  +global withinfo
           35  +global extdb
           36  +
           37  +# Final determination of module status
           38  +dict set extdb status {}
           39  +
           40  +# Returns 1 if the extension has the attribute
           41  +proc ext-has {ext attr} {
           42  +    expr {$attr in [dict get $::extdb attrs $ext]}
           43  +}
           44  +
           45  +# Returns an entry from the extension 'info' table, or $default otherwise
           46  +proc ext-get {ext key {default {}}} {
           47  +    if {[dict exists $::extdb info $ext $key]} {
           48  +        return [dict get $::extdb info $ext $key]
           49  +    } else {
           50  +        return $default
           51  +    }
           52  +}
           53  +
           54  +# Set the status of the extension to the given value, and returns the value
           55  +proc ext-set-status {ext value} {
           56  +    dict set ::extdb status $ext $value
           57  +    return $value
           58  +}
           59  +
           60  +# Returns the status of the extension, or ? if unknown
           61  +proc ext-get-status {ext} {
           62  +    if {[dict exists $::extdb status $ext]} {
           63  +        return [dict get $::extdb status $ext]
           64  +    }
           65  +    return ?
           66  +}
           67  +
           68  +proc check-extension-status {ext required} {
           69  +    global withinfo
           70  +
           71  +    set status [ext-get-status $ext]
           72  +
           73  +    if {$ext in $withinfo(without)} {
           74  +        # Disabled without further ado
           75  +        msg-result "Extension $ext...disabled"
           76  +        return [ext-set-status $ext n]
           77  +    }
           78  +
           79  +    if {$status in {m y n}} {
           80  +        return $status
           81  +    }
           82  +
           83  +    # required is "required" if this extension *must* be enabled
           84  +    # required is "wanted" if it is not fatal for this extension
           85  +    # not to be enabled
           86  +
           87  +    array set depinfo {m 0 y 0 n 0}
           88  +
           89  +    # Check direct dependencies
           90  +    if [ext-get $ext check 1] {
           91  +        # "check" conditions are met
           92  +    } else {
           93  +        # not met
           94  +        incr depinfo(n)
           95  +    }
           96  +
           97  +    if {$depinfo(n) == 0} {
           98  +        # Now extension dependencies
           99  +        foreach i [ext-get $ext dep] {
          100  +            set status [check-extension-status $i $required]
          101  +            #puts "$ext: dep $i $required => $status"
          102  +            incr depinfo($status)
          103  +            if {$depinfo(n)} {
          104  +                break
          105  +            }
          106  +        }
          107  +    }
          108  +
          109  +    #parray depinfo
          110  +
          111  +    if {$depinfo(n)} {
          112  +        msg-checking "Extension $ext..."
          113  +        if {$required eq "required"} {
          114  +            user-error "dependencies not met"
          115  +        }
          116  +        msg-result "disabled (dependencies)"
          117  +        return [ext-set-status $ext n]
          118  +    }
          119  +
          120  +    # Selected as a module?
          121  +    if {$ext in $withinfo(mod)} {
          122  +        if {[ext-has $ext tcl]} {
          123  +            # Easy, a Tcl module
          124  +            msg-result "Extension $ext...tcl"
          125  +        } elseif {[ext-has $ext static]} {
          126  +            user-error "Extension $ext can't be a module"
          127  +        } else {
          128  +            msg-result "Extension $ext...module"
          129  +            foreach i [ext-get $ext libdep] {
          130  +                define-append LDLIBS_$ext [get-define $i ""]
          131  +            }
          132  +        }
          133  +        return [ext-set-status $ext m]
          134  +    }
          135  +
          136  +    # Selected as a static extension?
          137  +    if {[ext-has $ext shared]} {
          138  +        user-error "Extension $ext can only be selected as a module"
          139  +    } elseif {$ext in $withinfo(ext) || $required eq "$required"} {
          140  +        msg-result "Extension $ext...enabled"
          141  +    } elseif {$ext in $withinfo(maybe)} {
          142  +        msg-result "Extension $ext...enabled (default)"
          143  +    } else {
          144  +        # Could be selected, but isn't (yet)
          145  +        return [ext-set-status $ext x]
          146  +    }
          147  +    foreach i [ext-get $ext libdep] {
          148  +        define-append LDLIBS [get-define $i ""]
          149  +    }
          150  +    return [ext-set-status $ext y]
          151  +}
          152  +
          153  +# Examines the user options (the $withinfo array)
          154  +# and the extension database ($extdb) to determine
          155  +# what is selected, and in what way.
          156  +#
          157  +# The results are available via ext-get-status
          158  +# And a dictionary is returned containing four keys:
          159  +#   static-c     extensions which are static C
          160  +#   static-tcl   extensions which are static Tcl
          161  +#   module-c     extensions which are C modules
          162  +#   module-tcl   extensions which are Tcl modules
          163  +proc check-extensions {} {
          164  +    global extdb withinfo
          165  +
          166  +    # Check valid extension names
          167  +    foreach i [concat $withinfo(ext) $withinfo(mod)] {
          168  +        if {![dict exists $extdb attrs $i]} {
          169  +            user-error "Unknown extension: $i"
          170  +        }
          171  +    }
          172  +
          173  +    set extlist [lsort [dict keys [dict get $extdb attrs]]]
          174  +
          175  +    set withinfo(maybe) {}
          176  +
          177  +    # Now work out the default status. We have.
          178  +    # normal case, include !optional if possible
          179  +    # --without=default, don't include optional
          180  +    if {$withinfo(nodefault)} {
          181  +        lappend withinfo(maybe) stdlib
          182  +    } else {
          183  +        foreach i $extlist {
          184  +            if {![ext-has $i optional]} {
          185  +                lappend withinfo(maybe) $i
          186  +            }
          187  +        }
          188  +    }
          189  +
          190  +    foreach i $extlist {
          191  +        define LDLIBS_$i ""
          192  +    }
          193  +
          194  +    foreach i [concat $withinfo(ext) $withinfo(mod)] {
          195  +        check-extension-status $i required
          196  +    }
          197  +    foreach i $withinfo(maybe) {
          198  +        check-extension-status $i wanted
          199  +    }
          200  +
          201  +    array set extinfo {static-c {} static-tcl {} module-c {} module-tcl {}}
          202  +
          203  +    foreach i $extlist {
          204  +        set status [ext-get-status $i]
          205  +        set tcl [ext-has $i tcl]
          206  +        switch $status,$tcl {
          207  +            y,1 {
          208  +                define jim_ext_$i
          209  +                lappend extinfo(static-tcl) $i
          210  +            }
          211  +            y,0 {
          212  +                define jim_ext_$i
          213  +                lappend extinfo(static-c) $i
          214  +                # If there are any static C++ extensions, jimsh must be linked using
          215  +                # the C++ compiler
          216  +                if {[ext-has $i cpp]} {
          217  +                    define HAVE_CXX_EXTENSIONS
          218  +                }
          219  +            }
          220  +            m,1 { lappend extinfo(module-tcl) $i }
          221  +            m,0 { lappend extinfo(module-c) $i }
          222  +        }
          223  +    }
          224  +    return [array get extinfo]
          225  +}

Added compat/tcl-8.6/generic/tcl.h.

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

Added compat/tcl-8.6/generic/tclDecls.h.

            1  +/*
            2  + * tclDecls.h --
            3  + *
            4  + *	Declarations of functions in the platform independent public Tcl API.
            5  + *
            6  + * Copyright (c) 1998-1999 by Scriptics Corporation.
            7  + *
            8  + * See the file "license.terms" for information on usage and redistribution
            9  + * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
           10  + */
           11  +
           12  +#ifndef _TCLDECLS
           13  +#define _TCLDECLS
           14  +
           15  +#undef TCL_STORAGE_CLASS
           16  +#ifdef BUILD_tcl
           17  +#   define TCL_STORAGE_CLASS DLLEXPORT
           18  +#else
           19  +#   ifdef USE_TCL_STUBS
           20  +#      define TCL_STORAGE_CLASS
           21  +#   else
           22  +#      define TCL_STORAGE_CLASS DLLIMPORT
           23  +#   endif
           24  +#endif
           25  +
           26  +/*
           27  + * WARNING: This file is automatically generated by the tools/genStubs.tcl
           28  + * script.  Any modifications to the function declarations below should be made
           29  + * in the generic/tcl.decls script.
           30  + */
           31  +
           32  +/* !BEGIN!: Do not edit below this line. */
           33  +
           34  +/*
           35  + * Exported function declarations:
           36  + */
           37  +
           38  +/* 0 */
           39  +EXTERN int		Tcl_PkgProvideEx(Tcl_Interp *interp,
           40  +				const char *name, const char *version,
           41  +				const void *clientData);
           42  +/* 1 */
           43  +EXTERN CONST84_RETURN char * Tcl_PkgRequireEx(Tcl_Interp *interp,
           44  +				const char *name, const char *version,
           45  +				int exact, void *clientDataPtr);
           46  +/* 2 */
           47  +EXTERN void		Tcl_Panic(const char *format, ...) TCL_FORMAT_PRINTF(1, 2);
           48  +/* 3 */
           49  +EXTERN char *		Tcl_Alloc(unsigned int size);
           50  +/* 4 */
           51  +EXTERN void		Tcl_Free(char *ptr);
           52  +/* 5 */
           53  +EXTERN char *		Tcl_Realloc(char *ptr, unsigned int size);
           54  +/* 6 */
           55  +EXTERN char *		Tcl_DbCkalloc(unsigned int size, const char *file,
           56  +				int line);
           57  +/* 7 */
           58  +EXTERN void		Tcl_DbCkfree(char *ptr, const char *file, int line);
           59  +/* 8 */
           60  +EXTERN char *		Tcl_DbCkrealloc(char *ptr, unsigned int size,
           61  +				const char *file, int line);
           62  +#if !defined(__WIN32__) && !defined(MAC_OSX_TCL) /* UNIX */
           63  +/* 9 */
           64  +EXTERN void		Tcl_CreateFileHandler(int fd, int mask,
           65  +				Tcl_FileProc *proc, ClientData clientData);
           66  +#endif /* UNIX */
           67  +#ifdef MAC_OSX_TCL /* MACOSX */
           68  +/* 9 */
           69  +EXTERN void		Tcl_CreateFileHandler(int fd, int mask,
           70  +				Tcl_FileProc *proc, ClientData clientData);
           71  +#endif /* MACOSX */
           72  +#if !defined(__WIN32__) && !defined(MAC_OSX_TCL) /* UNIX */
           73  +/* 10 */
           74  +EXTERN void		Tcl_DeleteFileHandler(int fd);
           75  +#endif /* UNIX */
           76  +#ifdef MAC_OSX_TCL /* MACOSX */
           77  +/* 10 */
           78  +EXTERN void		Tcl_DeleteFileHandler(int fd);
           79  +#endif /* MACOSX */
           80  +/* 11 */
           81  +EXTERN void		Tcl_SetTimer(const Tcl_Time *timePtr);
           82  +/* 12 */
           83  +EXTERN void		Tcl_Sleep(int ms);
           84  +/* 13 */
           85  +EXTERN int		Tcl_WaitForEvent(const Tcl_Time *timePtr);
           86  +/* 14 */
           87  +EXTERN int		Tcl_AppendAllObjTypes(Tcl_Interp *interp,
           88  +				Tcl_Obj *objPtr);
           89  +/* 15 */
           90  +EXTERN void		Tcl_AppendStringsToObj(Tcl_Obj *objPtr, ...);
           91  +/* 16 */
           92  +EXTERN void		Tcl_AppendToObj(Tcl_Obj *objPtr, const char *bytes,
           93  +				int length);
           94  +/* 17 */
           95  +EXTERN Tcl_Obj *	Tcl_ConcatObj(int objc, Tcl_Obj *const objv[]);
           96  +/* 18 */
           97  +EXTERN int		Tcl_ConvertToType(Tcl_Interp *interp,
           98  +				Tcl_Obj *objPtr, const Tcl_ObjType *typePtr);
           99  +/* 19 */
          100  +EXTERN void		Tcl_DbDecrRefCount(Tcl_Obj *objPtr, const char *file,
          101  +				int line);
          102  +/* 20 */
          103  +EXTERN void		Tcl_DbIncrRefCount(Tcl_Obj *objPtr, const char *file,
          104  +				int line);
          105  +/* 21 */
          106  +EXTERN int		Tcl_DbIsShared(Tcl_Obj *objPtr, const char *file,
          107  +				int line);
          108  +/* 22 */
          109  +EXTERN Tcl_Obj *	Tcl_DbNewBooleanObj(int boolValue, const char *file,
          110  +				int line);
          111  +/* 23 */
          112  +EXTERN Tcl_Obj *	Tcl_DbNewByteArrayObj(const unsigned char *bytes,
          113  +				int length, const char *file, int line);
          114  +/* 24 */
          115  +EXTERN Tcl_Obj *	Tcl_DbNewDoubleObj(double doubleValue,
          116  +				const char *file, int line);
          117  +/* 25 */
          118  +EXTERN Tcl_Obj *	Tcl_DbNewListObj(int objc, Tcl_Obj *const *objv,
          119  +				const char *file, int line);
          120  +/* 26 */
          121  +EXTERN Tcl_Obj *	Tcl_DbNewLongObj(long longValue, const char *file,
          122  +				int line);
          123  +/* 27 */
          124  +EXTERN Tcl_Obj *	Tcl_DbNewObj(const char *file, int line);
          125  +/* 28 */
          126  +EXTERN Tcl_Obj *	Tcl_DbNewStringObj(const char *bytes, int length,
          127  +				const char *file, int line);
          128  +/* 29 */
          129  +EXTERN Tcl_Obj *	Tcl_DuplicateObj(Tcl_Obj *objPtr);
          130  +/* 30 */
          131  +EXTERN void		TclFreeObj(Tcl_Obj *objPtr);
          132  +/* 31 */
          133  +EXTERN int		Tcl_GetBoolean(Tcl_Interp *interp, const char *src,
          134  +				int *boolPtr);
          135  +/* 32 */
          136  +EXTERN int		Tcl_GetBooleanFromObj(Tcl_Interp *interp,
          137  +				Tcl_Obj *objPtr, int *boolPtr);
          138  +/* 33 */
          139  +EXTERN unsigned char *	Tcl_GetByteArrayFromObj(Tcl_Obj *objPtr,
          140  +				int *lengthPtr);
          141  +/* 34 */
          142  +EXTERN int		Tcl_GetDouble(Tcl_Interp *interp, const char *src,
          143  +				double *doublePtr);
          144  +/* 35 */
          145  +EXTERN int		Tcl_GetDoubleFromObj(Tcl_Interp *interp,
          146  +				Tcl_Obj *objPtr, double *doublePtr);
          147  +/* 36 */
          148  +EXTERN int		Tcl_GetIndexFromObj(Tcl_Interp *interp,
          149  +				Tcl_Obj *objPtr,
          150  +				CONST84 char *const *tablePtr,
          151  +				const char *msg, int flags, int *indexPtr);
          152  +/* 37 */
          153  +EXTERN int		Tcl_GetInt(Tcl_Interp *interp, const char *src,
          154  +				int *intPtr);
          155  +/* 38 */
          156  +EXTERN int		Tcl_GetIntFromObj(Tcl_Interp *interp,
          157  +				Tcl_Obj *objPtr, int *intPtr);
          158  +/* 39 */
          159  +EXTERN int		Tcl_GetLongFromObj(Tcl_Interp *interp,
          160  +				Tcl_Obj *objPtr, long *longPtr);
          161  +/* 40 */
          162  +EXTERN CONST86 Tcl_ObjType * Tcl_GetObjType(const char *typeName);
          163  +/* 41 */
          164  +EXTERN char *		Tcl_GetStringFromObj(Tcl_Obj *objPtr, int *lengthPtr);
          165  +/* 42 */
          166  +EXTERN void		Tcl_InvalidateStringRep(Tcl_Obj *objPtr);
          167  +/* 43 */
          168  +EXTERN int		Tcl_ListObjAppendList(Tcl_Interp *interp,
          169  +				Tcl_Obj *listPtr, Tcl_Obj *elemListPtr);
          170  +/* 44 */
          171  +EXTERN int		Tcl_ListObjAppendElement(Tcl_Interp *interp,
          172  +				Tcl_Obj *listPtr, Tcl_Obj *objPtr);
          173  +/* 45 */
          174  +EXTERN int		Tcl_ListObjGetElements(Tcl_Interp *interp,
          175  +				Tcl_Obj *listPtr, int *objcPtr,
          176  +				Tcl_Obj ***objvPtr);
          177  +/* 46 */
          178  +EXTERN int		Tcl_ListObjIndex(Tcl_Interp *interp,
          179  +				Tcl_Obj *listPtr, int index,
          180  +				Tcl_Obj **objPtrPtr);
          181  +/* 47 */
          182  +EXTERN int		Tcl_ListObjLength(Tcl_Interp *interp,
          183  +				Tcl_Obj *listPtr, int *lengthPtr);
          184  +/* 48 */
          185  +EXTERN int		Tcl_ListObjReplace(Tcl_Interp *interp,
          186  +				Tcl_Obj *listPtr, int first, int count,
          187  +				int objc, Tcl_Obj *const objv[]);
          188  +/* 49 */
          189  +EXTERN Tcl_Obj *	Tcl_NewBooleanObj(int boolValue);
          190  +/* 50 */
          191  +EXTERN Tcl_Obj *	Tcl_NewByteArrayObj(const unsigned char *bytes,
          192  +				int length);
          193  +/* 51 */
          194  +EXTERN Tcl_Obj *	Tcl_NewDoubleObj(double doubleValue);
          195  +/* 52 */
          196  +EXTERN Tcl_Obj *	Tcl_NewIntObj(int intValue);
          197  +/* 53 */
          198  +EXTERN Tcl_Obj *	Tcl_NewListObj(int objc, Tcl_Obj *const objv[]);
          199  +/* 54 */
          200  +EXTERN Tcl_Obj *	Tcl_NewLongObj(long longValue);
          201  +/* 55 */
          202  +EXTERN Tcl_Obj *	Tcl_NewObj(void);
          203  +/* 56 */
          204  +EXTERN Tcl_Obj *	Tcl_NewStringObj(const char *bytes, int length);
          205  +/* 57 */
          206  +EXTERN void		Tcl_SetBooleanObj(Tcl_Obj *objPtr, int boolValue);
          207  +/* 58 */
          208  +EXTERN unsigned char *	Tcl_SetByteArrayLength(Tcl_Obj *objPtr, int length);
          209  +/* 59 */
          210  +EXTERN void		Tcl_SetByteArrayObj(Tcl_Obj *objPtr,
          211  +				const unsigned char *bytes, int length);
          212  +/* 60 */
          213  +EXTERN void		Tcl_SetDoubleObj(Tcl_Obj *objPtr, double doubleValue);
          214  +/* 61 */
          215  +EXTERN void		Tcl_SetIntObj(Tcl_Obj *objPtr, int intValue);
          216  +/* 62 */
          217  +EXTERN void		Tcl_SetListObj(Tcl_Obj *objPtr, int objc,
          218  +				Tcl_Obj *const objv[]);
          219  +/* 63 */
          220  +EXTERN void		Tcl_SetLongObj(Tcl_Obj *objPtr, long longValue);
          221  +/* 64 */
          222  +EXTERN void		Tcl_SetObjLength(Tcl_Obj *objPtr, int length);
          223  +/* 65 */
          224  +EXTERN void		Tcl_SetStringObj(Tcl_Obj *objPtr, const char *bytes,
          225  +				int length);
          226  +/* 66 */
          227  +EXTERN void		Tcl_AddErrorInfo(Tcl_Interp *interp,
          228  +				const char *message);
          229  +/* 67 */
          230  +EXTERN void		Tcl_AddObjErrorInfo(Tcl_Interp *interp,
          231  +				const char *message, int length);
          232  +/* 68 */
          233  +EXTERN void		Tcl_AllowExceptions(Tcl_Interp *interp);
          234  +/* 69 */
          235  +EXTERN void		Tcl_AppendElement(Tcl_Interp *interp,
          236  +				const char *element);
          237  +/* 70 */
          238  +EXTERN void		Tcl_AppendResult(Tcl_Interp *interp, ...);
          239  +/* 71 */
          240  +EXTERN Tcl_AsyncHandler	 Tcl_AsyncCreate(Tcl_AsyncProc *proc,
          241  +				ClientData clientData);
          242  +/* 72 */
          243  +EXTERN void		Tcl_AsyncDelete(Tcl_AsyncHandler async);
          244  +/* 73 */
          245  +EXTERN int		Tcl_AsyncInvoke(Tcl_Interp *interp, int code);
          246  +/* 74 */
          247  +EXTERN void		Tcl_AsyncMark(Tcl_AsyncHandler async);
          248  +/* 75 */
          249  +EXTERN int		Tcl_AsyncReady(void);
          250  +/* 76 */
          251  +EXTERN void		Tcl_BackgroundError(Tcl_Interp *interp);
          252  +/* 77 */
          253  +EXTERN char		Tcl_Backslash(const char *src, int *readPtr);
          254  +/* 78 */
          255  +EXTERN int		Tcl_BadChannelOption(Tcl_Interp *interp,
          256  +				const char *optionName,
          257  +				const char *optionList);
          258  +/* 79 */
          259  +EXTERN void		Tcl_CallWhenDeleted(Tcl_Interp *interp,
          260  +				Tcl_InterpDeleteProc *proc,
          261  +				ClientData clientData);
          262  +/* 80 */
          263  +EXTERN void		Tcl_CancelIdleCall(Tcl_IdleProc *idleProc,
          264  +				ClientData clientData);
          265  +/* 81 */
          266  +EXTERN int		Tcl_Close(Tcl_Interp *interp, Tcl_Channel chan);
          267  +/* 82 */
          268  +EXTERN int		Tcl_CommandComplete(const char *cmd);
          269  +/* 83 */
          270  +EXTERN char *		Tcl_Concat(int argc, CONST84 char *const *argv);
          271  +/* 84 */
          272  +EXTERN int		Tcl_ConvertElement(const char *src, char *dst,
          273  +				int flags);
          274  +/* 85 */
          275  +EXTERN int		Tcl_ConvertCountedElement(const char *src,
          276  +				int length, char *dst, int flags);
          277  +/* 86 */
          278  +EXTERN int		Tcl_CreateAlias(Tcl_Interp *slave,
          279  +				const char *slaveCmd, Tcl_Interp *target,
          280  +				const char *targetCmd, int argc,
          281  +				CONST84 char *const *argv);
          282  +/* 87 */
          283  +EXTERN int		Tcl_CreateAliasObj(Tcl_Interp *slave,
          284  +				const char *slaveCmd, Tcl_Interp *target,
          285  +				const char *targetCmd, int objc,
          286  +				Tcl_Obj *const objv[]);
          287  +/* 88 */
          288  +EXTERN Tcl_Channel	Tcl_CreateChannel(const Tcl_ChannelType *typePtr,
          289  +				const char *chanName,
          290  +				ClientData instanceData, int mask);
          291  +/* 89 */
          292  +EXTERN void		Tcl_CreateChannelHandler(Tcl_Channel chan, int mask,
          293  +				Tcl_ChannelProc *proc, ClientData clientData);
          294  +/* 90 */
          295  +EXTERN void		Tcl_CreateCloseHandler(Tcl_Channel chan,
          296  +				Tcl_CloseProc *proc, ClientData clientData);
          297  +/* 91 */
          298  +EXTERN Tcl_Command	Tcl_CreateCommand(Tcl_Interp *interp,
          299  +				const char *cmdName, Tcl_CmdProc *proc,
          300  +				ClientData clientData,
          301  +				Tcl_CmdDeleteProc *deleteProc);
          302  +/* 92 */
          303  +EXTERN void		Tcl_CreateEventSource(Tcl_EventSetupProc *setupProc,
          304  +				Tcl_EventCheckProc *checkProc,
          305  +				ClientData clientData);
          306  +/* 93 */
          307  +EXTERN void		Tcl_CreateExitHandler(Tcl_ExitProc *proc,
          308  +				ClientData clientData);
          309  +/* 94 */
          310  +EXTERN Tcl_Interp *	Tcl_CreateInterp(void);
          311  +/* 95 */
          312  +EXTERN void		Tcl_CreateMathFunc(Tcl_Interp *interp,
          313  +				const char *name, int numArgs,
          314  +				Tcl_ValueType *argTypes, Tcl_MathProc *proc,
          315  +				ClientData clientData);
          316  +/* 96 */
          317  +EXTERN Tcl_Command	Tcl_CreateObjCommand(Tcl_Interp *interp,
          318  +				const char *cmdName, Tcl_ObjCmdProc *proc,
          319  +				ClientData clientData,
          320  +				Tcl_CmdDeleteProc *deleteProc);
          321  +/* 97 */
          322  +EXTERN Tcl_Interp *	Tcl_CreateSlave(Tcl_Interp *interp,
          323  +				const char *slaveName, int isSafe);
          324  +/* 98 */
          325  +EXTERN Tcl_TimerToken	Tcl_CreateTimerHandler(int milliseconds,
          326  +				Tcl_TimerProc *proc, ClientData clientData);
          327  +/* 99 */
          328  +EXTERN Tcl_Trace	Tcl_CreateTrace(Tcl_Interp *interp, int level,
          329  +				Tcl_CmdTraceProc *proc,
          330  +				ClientData clientData);
          331  +/* 100 */
          332  +EXTERN void		Tcl_DeleteAssocData(Tcl_Interp *interp,
          333  +				const char *name);
          334  +/* 101 */
          335  +EXTERN void		Tcl_DeleteChannelHandler(Tcl_Channel chan,
          336  +				Tcl_ChannelProc *proc, ClientData clientData);
          337  +/* 102 */
          338  +EXTERN void		Tcl_DeleteCloseHandler(Tcl_Channel chan,
          339  +				Tcl_CloseProc *proc, ClientData clientData);
          340  +/* 103 */
          341  +EXTERN int		Tcl_DeleteCommand(Tcl_Interp *interp,
          342  +				const char *cmdName);
          343  +/* 104 */
          344  +EXTERN int		Tcl_DeleteCommandFromToken(Tcl_Interp *interp,
          345  +				Tcl_Command command);
          346  +/* 105 */
          347  +EXTERN void		Tcl_DeleteEvents(Tcl_EventDeleteProc *proc,
          348  +				ClientData clientData);
          349  +/* 106 */
          350  +EXTERN void		Tcl_DeleteEventSource(Tcl_EventSetupProc *setupProc,
          351  +				Tcl_EventCheckProc *checkProc,
          352  +				ClientData clientData);
          353  +/* 107 */
          354  +EXTERN void		Tcl_DeleteExitHandler(Tcl_ExitProc *proc,
          355  +				ClientData clientData);
          356  +/* 108 */
          357  +EXTERN void		Tcl_DeleteHashEntry(Tcl_HashEntry *entryPtr);
          358  +/* 109 */
          359  +EXTERN void		Tcl_DeleteHashTable(Tcl_HashTable *tablePtr);
          360  +/* 110 */
          361  +EXTERN void		Tcl_DeleteInterp(Tcl_Interp *interp);
          362  +/* 111 */
          363  +EXTERN void		Tcl_DetachPids(int numPids, Tcl_Pid *pidPtr);
          364  +/* 112 */
          365  +EXTERN void		Tcl_DeleteTimerHandler(Tcl_TimerToken token);
          366  +/* 113 */
          367  +EXTERN void		Tcl_DeleteTrace(Tcl_Interp *interp, Tcl_Trace trace);
          368  +/* 114 */
          369  +EXTERN void		Tcl_DontCallWhenDeleted(Tcl_Interp *interp,
          370  +				Tcl_InterpDeleteProc *proc,
          371  +				ClientData clientData);
          372  +/* 115 */
          373  +EXTERN int		Tcl_DoOneEvent(int flags);
          374  +/* 116 */
          375  +EXTERN void		Tcl_DoWhenIdle(Tcl_IdleProc *proc,
          376  +				ClientData clientData);
          377  +/* 117 */
          378  +EXTERN char *		Tcl_DStringAppend(Tcl_DString *dsPtr,
          379  +				const char *bytes, int length);
          380  +/* 118 */
          381  +EXTERN char *		Tcl_DStringAppendElement(Tcl_DString *dsPtr,
          382  +				const char *element);
          383  +/* 119 */
          384  +EXTERN void		Tcl_DStringEndSublist(Tcl_DString *dsPtr);
          385  +/* 120 */
          386  +EXTERN void		Tcl_DStringFree(Tcl_DString *dsPtr);
          387  +/* 121 */
          388  +EXTERN void		Tcl_DStringGetResult(Tcl_Interp *interp,
          389  +				Tcl_DString *dsPtr);
          390  +/* 122 */
          391  +EXTERN void		Tcl_DStringInit(Tcl_DString *dsPtr);
          392  +/* 123 */
          393  +EXTERN void		Tcl_DStringResult(Tcl_Interp *interp,
          394  +				Tcl_DString *dsPtr);
          395  +/* 124 */
          396  +EXTERN void		Tcl_DStringSetLength(Tcl_DString *dsPtr, int length);
          397  +/* 125 */
          398  +EXTERN void		Tcl_DStringStartSublist(Tcl_DString *dsPtr);
          399  +/* 126 */
          400  +EXTERN int		Tcl_Eof(Tcl_Channel chan);
          401  +/* 127 */
          402  +EXTERN CONST84_RETURN char * Tcl_ErrnoId(void);
          403  +/* 128 */
          404  +EXTERN CONST84_RETURN char * Tcl_ErrnoMsg(int err);
          405  +/* 129 */
          406  +EXTERN int		Tcl_Eval(Tcl_Interp *interp, const char *script);
          407  +/* 130 */
          408  +EXTERN int		Tcl_EvalFile(Tcl_Interp *interp,
          409  +				const char *fileName);
          410  +/* 131 */
          411  +EXTERN int		Tcl_EvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr);
          412  +/* 132 */
          413  +EXTERN void		Tcl_EventuallyFree(ClientData clientData,
          414  +				Tcl_FreeProc *freeProc);
          415  +/* 133 */
          416  +EXTERN void		Tcl_Exit(int status);
          417  +/* 134 */
          418  +EXTERN int		Tcl_ExposeCommand(Tcl_Interp *interp,
          419  +				const char *hiddenCmdToken,
          420  +				const char *cmdName);
          421  +/* 135 */
          422  +EXTERN int		Tcl_ExprBoolean(Tcl_Interp *interp, const char *expr,
          423  +				int *ptr);
          424  +/* 136 */
          425  +EXTERN int		Tcl_ExprBooleanObj(Tcl_Interp *interp,
          426  +				Tcl_Obj *objPtr, int *ptr);
          427  +/* 137 */
          428  +EXTERN int		Tcl_ExprDouble(Tcl_Interp *interp, const char *expr,
          429  +				double *ptr);
          430  +/* 138 */
          431  +EXTERN int		Tcl_ExprDoubleObj(Tcl_Interp *interp,
          432  +				Tcl_Obj *objPtr, double *ptr);
          433  +/* 139 */
          434  +EXTERN int		Tcl_ExprLong(Tcl_Interp *interp, const char *expr,
          435  +				long *ptr);
          436  +/* 140 */
          437  +EXTERN int		Tcl_ExprLongObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
          438  +				long *ptr);
          439  +/* 141 */
          440  +EXTERN int		Tcl_ExprObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
          441  +				Tcl_Obj **resultPtrPtr);
          442  +/* 142 */
          443  +EXTERN int		Tcl_ExprString(Tcl_Interp *interp, const char *expr);
          444  +/* 143 */
          445  +EXTERN void		Tcl_Finalize(void);
          446  +/* 144 */
          447  +EXTERN void		Tcl_FindExecutable(const char *argv0);
          448  +/* 145 */
          449  +EXTERN Tcl_HashEntry *	Tcl_FirstHashEntry(Tcl_HashTable *tablePtr,
          450  +				Tcl_HashSearch *searchPtr);
          451  +/* 146 */
          452  +EXTERN int		Tcl_Flush(Tcl_Channel chan);
          453  +/* 147 */
          454  +EXTERN void		Tcl_FreeResult(Tcl_Interp *interp);
          455  +/* 148 */
          456  +EXTERN int		Tcl_GetAlias(Tcl_Interp *interp,
          457  +				const char *slaveCmd,
          458  +				Tcl_Interp **targetInterpPtr,
          459  +				CONST84 char **targetCmdPtr, int *argcPtr,
          460  +				CONST84 char ***argvPtr);
          461  +/* 149 */
          462  +EXTERN int		Tcl_GetAliasObj(Tcl_Interp *interp,
          463  +				const char *slaveCmd,
          464  +				Tcl_Interp **targetInterpPtr,
          465  +				CONST84 char **targetCmdPtr, int *objcPtr,
          466  +				Tcl_Obj ***objv);
          467  +/* 150 */
          468  +EXTERN ClientData	Tcl_GetAssocData(Tcl_Interp *interp,
          469  +				const char *name,
          470  +				Tcl_InterpDeleteProc **procPtr);
          471  +/* 151 */
          472  +EXTERN Tcl_Channel	Tcl_GetChannel(Tcl_Interp *interp,
          473  +				const char *chanName, int *modePtr);
          474  +/* 152 */
          475  +EXTERN int		Tcl_GetChannelBufferSize(Tcl_Channel chan);
          476  +/* 153 */
          477  +EXTERN int		Tcl_GetChannelHandle(Tcl_Channel chan, int direction,
          478  +				ClientData *handlePtr);
          479  +/* 154 */
          480  +EXTERN ClientData	Tcl_GetChannelInstanceData(Tcl_Channel chan);
          481  +/* 155 */
          482  +EXTERN int		Tcl_GetChannelMode(Tcl_Channel chan);
          483  +/* 156 */
          484  +EXTERN CONST84_RETURN char * Tcl_GetChannelName(Tcl_Channel chan);
          485  +/* 157 */
          486  +EXTERN int		Tcl_GetChannelOption(Tcl_Interp *interp,
          487  +				Tcl_Channel chan, const char *optionName,
          488  +				Tcl_DString *dsPtr);
          489  +/* 158 */
          490  +EXTERN CONST86 Tcl_ChannelType * Tcl_GetChannelType(Tcl_Channel chan);
          491  +/* 159 */
          492  +EXTERN int		Tcl_GetCommandInfo(Tcl_Interp *interp,
          493  +				const char *cmdName, Tcl_CmdInfo *infoPtr);
          494  +/* 160 */
          495  +EXTERN CONST84_RETURN char * Tcl_GetCommandName(Tcl_Interp *interp,
          496  +				Tcl_Command command);
          497  +/* 161 */
          498  +EXTERN int		Tcl_GetErrno(void);
          499  +/* 162 */
          500  +EXTERN CONST84_RETURN char * Tcl_GetHostName(void);
          501  +/* 163 */
          502  +EXTERN int		Tcl_GetInterpPath(Tcl_Interp *askInterp,
          503  +				Tcl_Interp *slaveInterp);
          504  +/* 164 */
          505  +EXTERN Tcl_Interp *	Tcl_GetMaster(Tcl_Interp *interp);
          506  +/* 165 */
          507  +EXTERN const char *	Tcl_GetNameOfExecutable(void);
          508  +/* 166 */
          509  +EXTERN Tcl_Obj *	Tcl_GetObjResult(Tcl_Interp *interp);
          510  +#if !defined(__WIN32__) && !defined(MAC_OSX_TCL) /* UNIX */
          511  +/* 167 */
          512  +EXTERN int		Tcl_GetOpenFile(Tcl_Interp *interp,
          513  +				const char *chanID, int forWriting,
          514  +				int checkUsage, ClientData *filePtr);
          515  +#endif /* UNIX */
          516  +#ifdef MAC_OSX_TCL /* MACOSX */
          517  +/* 167 */
          518  +EXTERN int		Tcl_GetOpenFile(Tcl_Interp *interp,
          519  +				const char *chanID, int forWriting,
          520  +				int checkUsage, ClientData *filePtr);
          521  +#endif /* MACOSX */
          522  +/* 168 */
          523  +EXTERN Tcl_PathType	Tcl_GetPathType(const char *path);
          524  +/* 169 */
          525  +EXTERN int		Tcl_Gets(Tcl_Channel chan, Tcl_DString *dsPtr);
          526  +/* 170 */
          527  +EXTERN int		Tcl_GetsObj(Tcl_Channel chan, Tcl_Obj *objPtr);
          528  +/* 171 */
          529  +EXTERN int		Tcl_GetServiceMode(void);
          530  +/* 172 */
          531  +EXTERN Tcl_Interp *	Tcl_GetSlave(Tcl_Interp *interp,
          532  +				const char *slaveName);
          533  +/* 173 */
          534  +EXTERN Tcl_Channel	Tcl_GetStdChannel(int type);
          535  +/* 174 */
          536  +EXTERN CONST84_RETURN char * Tcl_GetStringResult(Tcl_Interp *interp);
          537  +/* 175 */
          538  +EXTERN CONST84_RETURN char * Tcl_GetVar(Tcl_Interp *interp,
          539  +				const char *varName, int flags);
          540  +/* 176 */
          541  +EXTERN CONST84_RETURN char * Tcl_GetVar2(Tcl_Interp *interp,
          542  +				const char *part1, const char *part2,
          543  +				int flags);
          544  +/* 177 */
          545  +EXTERN int		Tcl_GlobalEval(Tcl_Interp *interp,
          546  +				const char *command);
          547  +/* 178 */
          548  +EXTERN int		Tcl_GlobalEvalObj(Tcl_Interp *interp,
          549  +				Tcl_Obj *objPtr);
          550  +/* 179 */
          551  +EXTERN int		Tcl_HideCommand(Tcl_Interp *interp,
          552  +				const char *cmdName,
          553  +				const char *hiddenCmdToken);
          554  +/* 180 */
          555  +EXTERN int		Tcl_Init(Tcl_Interp *interp);
          556  +/* 181 */
          557  +EXTERN void		Tcl_InitHashTable(Tcl_HashTable *tablePtr,
          558  +				int keyType);
          559  +/* 182 */
          560  +EXTERN int		Tcl_InputBlocked(Tcl_Channel chan);
          561  +/* 183 */
          562  +EXTERN int		Tcl_InputBuffered(Tcl_Channel chan);
          563  +/* 184 */
          564  +EXTERN int		Tcl_InterpDeleted(Tcl_Interp *interp);
          565  +/* 185 */
          566  +EXTERN int		Tcl_IsSafe(Tcl_Interp *interp);
          567  +/* 186 */
          568  +EXTERN char *		Tcl_JoinPath(int argc, CONST84 char *const *argv,
          569  +				Tcl_DString *resultPtr);
          570  +/* 187 */
          571  +EXTERN int		Tcl_LinkVar(Tcl_Interp *interp, const char *varName,
          572  +				char *addr, int type);
          573  +/* Slot 188 is reserved */
          574  +/* 189 */
          575  +EXTERN Tcl_Channel	Tcl_MakeFileChannel(ClientData handle, int mode);
          576  +/* 190 */
          577  +EXTERN int		Tcl_MakeSafe(Tcl_Interp *interp);
          578  +/* 191 */
          579  +EXTERN Tcl_Channel	Tcl_MakeTcpClientChannel(ClientData tcpSocket);
          580  +/* 192 */
          581  +EXTERN char *		Tcl_Merge(int argc, CONST84 char *const *argv);
          582  +/* 193 */
          583  +EXTERN Tcl_HashEntry *	Tcl_NextHashEntry(Tcl_HashSearch *searchPtr);
          584  +/* 194 */
          585  +EXTERN void		Tcl_NotifyChannel(Tcl_Channel channel, int mask);
          586  +/* 195 */
          587  +EXTERN Tcl_Obj *	Tcl_ObjGetVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
          588  +				Tcl_Obj *part2Ptr, int flags);
          589  +/* 196 */
          590  +EXTERN Tcl_Obj *	Tcl_ObjSetVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
          591  +				Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr,
          592  +				int flags);
          593  +/* 197 */
          594  +EXTERN Tcl_Channel	Tcl_OpenCommandChannel(Tcl_Interp *interp, int argc,
          595  +				CONST84 char **argv, int flags);
          596  +/* 198 */
          597  +EXTERN Tcl_Channel	Tcl_OpenFileChannel(Tcl_Interp *interp,
          598  +				const char *fileName, const char *modeString,
          599  +				int permissions);
          600  +/* 199 */
          601  +EXTERN Tcl_Channel	Tcl_OpenTcpClient(Tcl_Interp *interp, int port,
          602  +				const char *address, const char *myaddr,
          603  +				int myport, int async);
          604  +/* 200 */
          605  +EXTERN Tcl_Channel	Tcl_OpenTcpServer(Tcl_Interp *interp, int port,
          606  +				const char *host,
          607  +				Tcl_TcpAcceptProc *acceptProc,
          608  +				ClientData callbackData);
          609  +/* 201 */
          610  +EXTERN void		Tcl_Preserve(ClientData data);
          611  +/* 202 */
          612  +EXTERN void		Tcl_PrintDouble(Tcl_Interp *interp, double value,
          613  +				char *dst);
          614  +/* 203 */
          615  +EXTERN int		Tcl_PutEnv(const char *assignment);
          616  +/* 204 */
          617  +EXTERN CONST84_RETURN char * Tcl_PosixError(Tcl_Interp *interp);
          618  +/* 205 */
          619  +EXTERN void		Tcl_QueueEvent(Tcl_Event *evPtr,
          620  +				Tcl_QueuePosition position);
          621  +/* 206 */
          622  +EXTERN int		Tcl_Read(Tcl_Channel chan, char *bufPtr, int toRead);
          623  +/* 207 */
          624  +EXTERN void		Tcl_ReapDetachedProcs(void);
          625  +/* 208 */
          626  +EXTERN int		Tcl_RecordAndEval(Tcl_Interp *interp,
          627  +				const char *cmd, int flags);
          628  +/* 209 */
          629  +EXTERN int		Tcl_RecordAndEvalObj(Tcl_Interp *interp,
          630  +				Tcl_Obj *cmdPtr, int flags);
          631  +/* 210 */
          632  +EXTERN void		Tcl_RegisterChannel(Tcl_Interp *interp,
          633  +				Tcl_Channel chan);
          634  +/* 211 */
          635  +EXTERN void		Tcl_RegisterObjType(const Tcl_ObjType *typePtr);
          636  +/* 212 */
          637  +EXTERN Tcl_RegExp	Tcl_RegExpCompile(Tcl_Interp *interp,
          638  +				const char *pattern);
          639  +/* 213 */
          640  +EXTERN int		Tcl_RegExpExec(Tcl_Interp *interp, Tcl_RegExp regexp,
          641  +				const char *text, const char *start);
          642  +/* 214 */
          643  +EXTERN int		Tcl_RegExpMatch(Tcl_Interp *interp, const char *text,
          644  +				const char *pattern);
          645  +/* 215 */
          646  +EXTERN void		Tcl_RegExpRange(Tcl_RegExp regexp, int index,
          647  +				CONST84 char **startPtr,
          648  +				CONST84 char **endPtr);
          649  +/* 216 */
          650  +EXTERN void		Tcl_Release(ClientData clientData);
          651  +/* 217 */
          652  +EXTERN void		Tcl_ResetResult(Tcl_Interp *interp);
          653  +/* 218 */
          654  +EXTERN int		Tcl_ScanElement(const char *src, int *flagPtr);
          655  +/* 219 */
          656  +EXTERN int		Tcl_ScanCountedElement(const char *src, int length,
          657  +				int *flagPtr);
          658  +/* 220 */
          659  +EXTERN int		Tcl_SeekOld(Tcl_Channel chan, int offset, int mode);
          660  +/* 221 */
          661  +EXTERN int		Tcl_ServiceAll(void);
          662  +/* 222 */
          663  +EXTERN int		Tcl_ServiceEvent(int flags);
          664  +/* 223 */
          665  +EXTERN void		Tcl_SetAssocData(Tcl_Interp *interp,
          666  +				const char *name, Tcl_InterpDeleteProc *proc,
          667  +				ClientData clientData);
          668  +/* 224 */
          669  +EXTERN void		Tcl_SetChannelBufferSize(Tcl_Channel chan, int sz);
          670  +/* 225 */
          671  +EXTERN int		Tcl_SetChannelOption(Tcl_Interp *interp,
          672  +				Tcl_Channel chan, const char *optionName,
          673  +				const char *newValue);
          674  +/* 226 */
          675  +EXTERN int		Tcl_SetCommandInfo(Tcl_Interp *interp,
          676  +				const char *cmdName,
          677  +				const Tcl_CmdInfo *infoPtr);
          678  +/* 227 */
          679  +EXTERN void		Tcl_SetErrno(int err);
          680  +/* 228 */
          681  +EXTERN void		Tcl_SetErrorCode(Tcl_Interp *interp, ...);
          682  +/* 229 */
          683  +EXTERN void		Tcl_SetMaxBlockTime(const Tcl_Time *timePtr);
          684  +/* 230 */
          685  +EXTERN void		Tcl_SetPanicProc(Tcl_PanicProc *panicProc);
          686  +/* 231 */
          687  +EXTERN int		Tcl_SetRecursionLimit(Tcl_Interp *interp, int depth);
          688  +/* 232 */
          689  +EXTERN void		Tcl_SetResult(Tcl_Interp *interp, char *result,
          690  +				Tcl_FreeProc *freeProc);
          691  +/* 233 */
          692  +EXTERN int		Tcl_SetServiceMode(int mode);
          693  +/* 234 */
          694  +EXTERN void		Tcl_SetObjErrorCode(Tcl_Interp *interp,
          695  +				Tcl_Obj *errorObjPtr);
          696  +/* 235 */
          697  +EXTERN void		Tcl_SetObjResult(Tcl_Interp *interp,
          698  +				Tcl_Obj *resultObjPtr);
          699  +/* 236 */
          700  +EXTERN void		Tcl_SetStdChannel(Tcl_Channel channel, int type);
          701  +/* 237 */
          702  +EXTERN CONST84_RETURN char * Tcl_SetVar(Tcl_Interp *interp,
          703  +				const char *varName, const char *newValue,
          704  +				int flags);
          705  +/* 238 */
          706  +EXTERN CONST84_RETURN char * Tcl_SetVar2(Tcl_Interp *interp,
          707  +				const char *part1, const char *part2,
          708  +				const char *newValue, int flags);
          709  +/* 239 */
          710  +EXTERN CONST84_RETURN char * Tcl_SignalId(int sig);
          711  +/* 240 */
          712  +EXTERN CONST84_RETURN char * Tcl_SignalMsg(int sig);
          713  +/* 241 */
          714  +EXTERN void		Tcl_SourceRCFile(Tcl_Interp *interp);
          715  +/* 242 */
          716  +EXTERN int		Tcl_SplitList(Tcl_Interp *interp,
          717  +				const char *listStr, int *argcPtr,
          718  +				CONST84 char ***argvPtr);
          719  +/* 243 */
          720  +EXTERN void		Tcl_SplitPath(const char *path, int *argcPtr,
          721  +				CONST84 char ***argvPtr);
          722  +/* 244 */
          723  +EXTERN void		Tcl_StaticPackage(Tcl_Interp *interp,
          724  +				const char *pkgName,
          725  +				Tcl_PackageInitProc *initProc,
          726  +				Tcl_PackageInitProc *safeInitProc);
          727  +/* 245 */
          728  +EXTERN int		Tcl_StringMatch(const char *str, const char *pattern);
          729  +/* 246 */
          730  +EXTERN int		Tcl_TellOld(Tcl_Channel chan);
          731  +/* 247 */
          732  +EXTERN int		Tcl_TraceVar(Tcl_Interp *interp, const char *varName,
          733  +				int flags, Tcl_VarTraceProc *proc,
          734  +				ClientData clientData);
          735  +/* 248 */
          736  +EXTERN int		Tcl_TraceVar2(Tcl_Interp *interp, const char *part1,
          737  +				const char *part2, int flags,
          738  +				Tcl_VarTraceProc *proc,
          739  +				ClientData clientData);
          740  +/* 249 */
          741  +EXTERN char *		Tcl_TranslateFileName(Tcl_Interp *interp,
          742  +				const char *name, Tcl_DString *bufferPtr);
          743  +/* 250 */
          744  +EXTERN int		Tcl_Ungets(Tcl_Channel chan, const char *str,
          745  +				int len, int atHead);
          746  +/* 251 */
          747  +EXTERN void		Tcl_UnlinkVar(Tcl_Interp *interp,
          748  +				const char *varName);
          749  +/* 252 */
          750  +EXTERN int		Tcl_UnregisterChannel(Tcl_Interp *interp,
          751  +				Tcl_Channel chan);
          752  +/* 253 */
          753  +EXTERN int		Tcl_UnsetVar(Tcl_Interp *interp, const char *varName,
          754  +				int flags);
          755  +/* 254 */
          756  +EXTERN int		Tcl_UnsetVar2(Tcl_Interp *interp, const char *part1,
          757  +				const char *part2, int flags);
          758  +/* 255 */
          759  +EXTERN void		Tcl_UntraceVar(Tcl_Interp *interp,
          760  +				const char *varName, int flags,
          761  +				Tcl_VarTraceProc *proc,
          762  +				ClientData clientData);
          763  +/* 256 */
          764  +EXTERN void		Tcl_UntraceVar2(Tcl_Interp *interp,
          765  +				const char *part1, const char *part2,
          766  +				int flags, Tcl_VarTraceProc *proc,
          767  +				ClientData clientData);
          768  +/* 257 */
          769  +EXTERN void		Tcl_UpdateLinkedVar(Tcl_Interp *interp,
          770  +				const char *varName);
          771  +/* 258 */
          772  +EXTERN int		Tcl_UpVar(Tcl_Interp *interp, const char *frameName,
          773  +				const char *varName, const char *localName,
          774  +				int flags);
          775  +/* 259 */
          776  +EXTERN int		Tcl_UpVar2(Tcl_Interp *interp, const char *frameName,
          777  +				const char *part1, const char *part2,
          778  +				const char *localName, int flags);
          779  +/* 260 */
          780  +EXTERN int		Tcl_VarEval(Tcl_Interp *interp, ...);
          781  +/* 261 */
          782  +EXTERN ClientData	Tcl_VarTraceInfo(Tcl_Interp *interp,
          783  +				const char *varName, int flags,
          784  +				Tcl_VarTraceProc *procPtr,
          785  +				ClientData prevClientData);
          786  +/* 262 */
          787  +EXTERN ClientData	Tcl_VarTraceInfo2(Tcl_Interp *interp,
          788  +				const char *part1, const char *part2,
          789  +				int flags, Tcl_VarTraceProc *procPtr,
          790  +				ClientData prevClientData);
          791  +/* 263 */
          792  +EXTERN int		Tcl_Write(Tcl_Channel chan, const char *s, int slen);
          793  +/* 264 */
          794  +EXTERN void		Tcl_WrongNumArgs(Tcl_Interp *interp, int objc,
          795  +				Tcl_Obj *const objv[], const char *message);
          796  +/* 265 */
          797  +EXTERN int		Tcl_DumpActiveMemory(const char *fileName);
          798  +/* 266 */
          799  +EXTERN void		Tcl_ValidateAllMemory(const char *file, int line);
          800  +/* 267 */
          801  +EXTERN void		Tcl_AppendResultVA(Tcl_Interp *interp,
          802  +				va_list argList);
          803  +/* 268 */
          804  +EXTERN void		Tcl_AppendStringsToObjVA(Tcl_Obj *objPtr,
          805  +				va_list argList);
          806  +/* 269 */
          807  +EXTERN char *		Tcl_HashStats(Tcl_HashTable *tablePtr);
          808  +/* 270 */
          809  +EXTERN CONST84_RETURN char * Tcl_ParseVar(Tcl_Interp *interp,
          810  +				const char *start, CONST84 char **termPtr);
          811  +/* 271 */
          812  +EXTERN CONST84_RETURN char * Tcl_PkgPresent(Tcl_Interp *interp,
          813  +				const char *name, const char *version,
          814  +				int exact);
          815  +/* 272 */
          816  +EXTERN CONST84_RETURN char * Tcl_PkgPresentEx(Tcl_Interp *interp,
          817  +				const char *name, const char *version,
          818  +				int exact, void *clientDataPtr);
          819  +/* 273 */
          820  +EXTERN int		Tcl_PkgProvide(Tcl_Interp *interp, const char *name,
          821  +				const char *version);
          822  +/* 274 */
          823  +EXTERN CONST84_RETURN char * Tcl_PkgRequire(Tcl_Interp *interp,
          824  +				const char *name, const char *version,
          825  +				int exact);
          826  +/* 275 */
          827  +EXTERN void		Tcl_SetErrorCodeVA(Tcl_Interp *interp,
          828  +				va_list argList);
          829  +/* 276 */
          830  +EXTERN int		Tcl_VarEvalVA(Tcl_Interp *interp, va_list argList);
          831  +/* 277 */
          832  +EXTERN Tcl_Pid		Tcl_WaitPid(Tcl_Pid pid, int *statPtr, int options);
          833  +/* 278 */
          834  +EXTERN void		Tcl_PanicVA(const char *format, va_list argList);
          835  +/* 279 */
          836  +EXTERN void		Tcl_GetVersion(int *major, int *minor,
          837  +				int *patchLevel, int *type);
          838  +/* 280 */
          839  +EXTERN void		Tcl_InitMemory(Tcl_Interp *interp);
          840  +/* 281 */
          841  +EXTERN Tcl_Channel	Tcl_StackChannel(Tcl_Interp *interp,
          842  +				const Tcl_ChannelType *typePtr,
          843  +				ClientData instanceData, int mask,
          844  +				Tcl_Channel prevChan);
          845  +/* 282 */
          846  +EXTERN int		Tcl_UnstackChannel(Tcl_Interp *interp,
          847  +				Tcl_Channel chan);
          848  +/* 283 */
          849  +EXTERN Tcl_Channel	Tcl_GetStackedChannel(Tcl_Channel chan);
          850  +/* 284 */
          851  +EXTERN void		Tcl_SetMainLoop(Tcl_MainLoopProc *proc);
          852  +/* Slot 285 is reserved */
          853  +/* 286 */
          854  +EXTERN void		Tcl_AppendObjToObj(Tcl_Obj *objPtr,
          855  +				Tcl_Obj *appendObjPtr);
          856  +/* 287 */
          857  +EXTERN Tcl_Encoding	Tcl_CreateEncoding(const Tcl_EncodingType *typePtr);
          858  +/* 288 */
          859  +EXTERN void		Tcl_CreateThreadExitHandler(Tcl_ExitProc *proc,
          860  +				ClientData clientData);
          861  +/* 289 */
          862  +EXTERN void		Tcl_DeleteThreadExitHandler(Tcl_ExitProc *proc,
          863  +				ClientData clientData);
          864  +/* 290 */
          865  +EXTERN void		Tcl_DiscardResult(Tcl_SavedResult *statePtr);
          866  +/* 291 */
          867  +EXTERN int		Tcl_EvalEx(Tcl_Interp *interp, const char *script,
          868  +				int numBytes, int flags);
          869  +/* 292 */
          870  +EXTERN int		Tcl_EvalObjv(Tcl_Interp *interp, int objc,
          871  +				Tcl_Obj *const objv[], int flags);
          872  +/* 293 */
          873  +EXTERN int		Tcl_EvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr,
          874  +				int flags);
          875  +/* 294 */
          876  +EXTERN void		Tcl_ExitThread(int status);
          877  +/* 295 */
          878  +EXTERN int		Tcl_ExternalToUtf(Tcl_Interp *interp,
          879  +				Tcl_Encoding encoding, const char *src,
          880  +				int srcLen, int flags,
          881  +				Tcl_EncodingState *statePtr, char *dst,
          882  +				int dstLen, int *srcReadPtr,
          883  +				int *dstWrotePtr, int *dstCharsPtr);
          884  +/* 296 */
          885  +EXTERN char *		Tcl_ExternalToUtfDString(Tcl_Encoding encoding,
          886  +				const char *src, int srcLen,
          887  +				Tcl_DString *dsPtr);
          888  +/* 297 */
          889  +EXTERN void		Tcl_FinalizeThread(void);
          890  +/* 298 */
          891  +EXTERN void		Tcl_FinalizeNotifier(ClientData clientData);
          892  +/* 299 */
          893  +EXTERN void		Tcl_FreeEncoding(Tcl_Encoding encoding);
          894  +/* 300 */
          895  +EXTERN Tcl_ThreadId	Tcl_GetCurrentThread(void);
          896  +/* 301 */
          897  +EXTERN Tcl_Encoding	Tcl_GetEncoding(Tcl_Interp *interp, const char *name);
          898  +/* 302 */
          899  +EXTERN CONST84_RETURN char * Tcl_GetEncodingName(Tcl_Encoding encoding);
          900  +/* 303 */
          901  +EXTERN void		Tcl_GetEncodingNames(Tcl_Interp *interp);
          902  +/* 304 */
          903  +EXTERN int		Tcl_GetIndexFromObjStruct(Tcl_Interp *interp,
          904  +				Tcl_Obj *objPtr, const void *tablePtr,
          905  +				int offset, const char *msg, int flags,
          906  +				int *indexPtr);
          907  +/* 305 */
          908  +EXTERN void *		Tcl_GetThreadData(Tcl_ThreadDataKey *keyPtr,
          909  +				int size);
          910  +/* 306 */
          911  +EXTERN Tcl_Obj *	Tcl_GetVar2Ex(Tcl_Interp *interp, const char *part1,
          912  +				const char *part2, int flags);
          913  +/* 307 */
          914  +EXTERN ClientData	Tcl_InitNotifier(void);
          915  +/* 308 */
          916  +EXTERN void		Tcl_MutexLock(Tcl_Mutex *mutexPtr);
          917  +/* 309 */
          918  +EXTERN void		Tcl_MutexUnlock(Tcl_Mutex *mutexPtr);
          919  +/* 310 */
          920  +EXTERN void		Tcl_ConditionNotify(Tcl_Condition *condPtr);
          921  +/* 311 */
          922  +EXTERN void		Tcl_ConditionWait(Tcl_Condition *condPtr,
          923  +				Tcl_Mutex *mutexPtr, const Tcl_Time *timePtr);
          924  +/* 312 */
          925  +EXTERN int		Tcl_NumUtfChars(const char *src, int length);
          926  +/* 313 */
          927  +EXTERN int		Tcl_ReadChars(Tcl_Channel channel, Tcl_Obj *objPtr,
          928  +				int charsToRead, int appendFlag);
          929  +/* 314 */
          930  +EXTERN void		Tcl_RestoreResult(Tcl_Interp *interp,
          931  +				Tcl_SavedResult *statePtr);
          932  +/* 315 */
          933  +EXTERN void		Tcl_SaveResult(Tcl_Interp *interp,
          934  +				Tcl_SavedResult *statePtr);
          935  +/* 316 */
          936  +EXTERN int		Tcl_SetSystemEncoding(Tcl_Interp *interp,
          937  +				const char *name);
          938  +/* 317 */
          939  +EXTERN Tcl_Obj *	Tcl_SetVar2Ex(Tcl_Interp *interp, const char *part1,
          940  +				const char *part2, Tcl_Obj *newValuePtr,
          941  +				int flags);
          942  +/* 318 */
          943  +EXTERN void		Tcl_ThreadAlert(Tcl_ThreadId threadId);
          944  +/* 319 */
          945  +EXTERN void		Tcl_ThreadQueueEvent(Tcl_ThreadId threadId,
          946  +				Tcl_Event *evPtr, Tcl_QueuePosition position);
          947  +/* 320 */
          948  +EXTERN Tcl_UniChar	Tcl_UniCharAtIndex(const char *src, int index);
          949  +/* 321 */
          950  +EXTERN Tcl_UniChar	Tcl_UniCharToLower(int ch);
          951  +/* 322 */
          952  +EXTERN Tcl_UniChar	Tcl_UniCharToTitle(int ch);
          953  +/* 323 */
          954  +EXTERN Tcl_UniChar	Tcl_UniCharToUpper(int ch);
          955  +/* 324 */
          956  +EXTERN int		Tcl_UniCharToUtf(int ch, char *buf);
          957  +/* 325 */
          958  +EXTERN CONST84_RETURN char * Tcl_UtfAtIndex(const char *src, int index);
          959  +/* 326 */
          960  +EXTERN int		Tcl_UtfCharComplete(const char *src, int length);
          961  +/* 327 */
          962  +EXTERN int		Tcl_UtfBackslash(const char *src, int *readPtr,
          963  +				char *dst);
          964  +/* 328 */
          965  +EXTERN CONST84_RETURN char * Tcl_UtfFindFirst(const char *src, int ch);
          966  +/* 329 */
          967  +EXTERN CONST84_RETURN char * Tcl_UtfFindLast(const char *src, int ch);
          968  +/* 330 */
          969  +EXTERN CONST84_RETURN char * Tcl_UtfNext(const char *src);
          970  +/* 331 */
          971  +EXTERN CONST84_RETURN char * Tcl_UtfPrev(const char *src, const char *start);
          972  +/* 332 */
          973  +EXTERN int		Tcl_UtfToExternal(Tcl_Interp *interp,
          974  +				Tcl_Encoding encoding, const char *src,
          975  +				int srcLen, int flags,
          976  +				Tcl_EncodingState *statePtr, char *dst,
          977  +				int dstLen, int *srcReadPtr,
          978  +				int *dstWrotePtr, int *dstCharsPtr);
          979  +/* 333 */
          980  +EXTERN char *		Tcl_UtfToExternalDString(Tcl_Encoding encoding,
          981  +				const char *src, int srcLen,
          982  +				Tcl_DString *dsPtr);
          983  +/* 334 */
          984  +EXTERN int		Tcl_UtfToLower(char *src);
          985  +/* 335 */
          986  +EXTERN int		Tcl_UtfToTitle(char *src);
          987  +/* 336 */
          988  +EXTERN int		Tcl_UtfToUniChar(const char *src, Tcl_UniChar *chPtr);
          989  +/* 337 */
          990  +EXTERN int		Tcl_UtfToUpper(char *src);
          991  +/* 338 */
          992  +EXTERN int		Tcl_WriteChars(Tcl_Channel chan, const char *src,
          993  +				int srcLen);
          994  +/* 339 */
          995  +EXTERN int		Tcl_WriteObj(Tcl_Channel chan, Tcl_Obj *objPtr);
          996  +/* 340 */
          997  +EXTERN char *		Tcl_GetString(Tcl_Obj *objPtr);
          998  +/* 341 */
          999  +EXTERN CONST84_RETURN char * Tcl_GetDefaultEncodingDir(void);
         1000  +/* 342 */
         1001  +EXTERN void		Tcl_SetDefaultEncodingDir(const char *path);
         1002  +/* 343 */
         1003  +EXTERN void		Tcl_AlertNotifier(ClientData clientData);
         1004  +/* 344 */
         1005  +EXTERN void		Tcl_ServiceModeHook(int mode);
         1006  +/* 345 */
         1007  +EXTERN int		Tcl_UniCharIsAlnum(int ch);
         1008  +/* 346 */
         1009  +EXTERN int		Tcl_UniCharIsAlpha(int ch);
         1010  +/* 347 */
         1011  +EXTERN int		Tcl_UniCharIsDigit(int ch);
         1012  +/* 348 */
         1013  +EXTERN int		Tcl_UniCharIsLower(int ch);
         1014  +/* 349 */
         1015  +EXTERN int		Tcl_UniCharIsSpace(int ch);
         1016  +/* 350 */
         1017  +EXTERN int		Tcl_UniCharIsUpper(int ch);
         1018  +/* 351 */
         1019  +EXTERN int		Tcl_UniCharIsWordChar(int ch);
         1020  +/* 352 */
         1021  +EXTERN int		Tcl_UniCharLen(const Tcl_UniChar *uniStr);
         1022  +/* 353 */
         1023  +EXTERN int		Tcl_UniCharNcmp(const Tcl_UniChar *ucs,
         1024  +				const Tcl_UniChar *uct,
         1025  +				unsigned long numChars);
         1026  +/* 354 */
         1027  +EXTERN char *		Tcl_UniCharToUtfDString(const Tcl_UniChar *uniStr,
         1028  +				int uniLength, Tcl_DString *dsPtr);
         1029  +/* 355 */
         1030  +EXTERN Tcl_UniChar *	Tcl_UtfToUniCharDString(const char *src, int length,
         1031  +				Tcl_DString *dsPtr);
         1032  +/* 356 */
         1033  +EXTERN Tcl_RegExp	Tcl_GetRegExpFromObj(Tcl_Interp *interp,
         1034  +				Tcl_Obj *patObj, int flags);
         1035  +/* 357 */
         1036  +EXTERN Tcl_Obj *	Tcl_EvalTokens(Tcl_Interp *interp,
         1037  +				Tcl_Token *tokenPtr, int count);
         1038  +/* 358 */
         1039  +EXTERN void		Tcl_FreeParse(Tcl_Parse *parsePtr);
         1040  +/* 359 */
         1041  +EXTERN void		Tcl_LogCommandInfo(Tcl_Interp *interp,
         1042  +				const char *script, const char *command,
         1043  +				int length);
         1044  +/* 360 */
         1045  +EXTERN int		Tcl_ParseBraces(Tcl_Interp *interp,
         1046  +				const char *start, int numBytes,
         1047  +				Tcl_Parse *parsePtr, int append,
         1048  +				CONST84 char **termPtr);
         1049  +/* 361 */
         1050  +EXTERN int		Tcl_ParseCommand(Tcl_Interp *interp,
         1051  +				const char *start, int numBytes, int nested,
         1052  +				Tcl_Parse *parsePtr);
         1053  +/* 362 */
         1054  +EXTERN int		Tcl_ParseExpr(Tcl_Interp *interp, const char *start,
         1055  +				int numBytes, Tcl_Parse *parsePtr);
         1056  +/* 363 */
         1057  +EXTERN int		Tcl_ParseQuotedString(Tcl_Interp *interp,
         1058  +				const char *start, int numBytes,
         1059  +				Tcl_Parse *parsePtr, int append,
         1060  +				CONST84 char **termPtr);
         1061  +/* 364 */
         1062  +EXTERN int		Tcl_ParseVarName(Tcl_Interp *interp,
         1063  +				const char *start, int numBytes,
         1064  +				Tcl_Parse *parsePtr, int append);
         1065  +/* 365 */
         1066  +EXTERN char *		Tcl_GetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr);
         1067  +/* 366 */
         1068  +EXTERN int		Tcl_Chdir(const char *dirName);
         1069  +/* 367 */
         1070  +EXTERN int		Tcl_Access(const char *path, int mode);
         1071  +/* 368 */
         1072  +EXTERN int		Tcl_Stat(const char *path, struct stat *bufPtr);
         1073  +/* 369 */
         1074  +EXTERN int		Tcl_UtfNcmp(const char *s1, const char *s2,
         1075  +				unsigned long n);
         1076  +/* 370 */
         1077  +EXTERN int		Tcl_UtfNcasecmp(const char *s1, const char *s2,
         1078  +				unsigned long n);
         1079  +/* 371 */
         1080  +EXTERN int		Tcl_StringCaseMatch(const char *str,
         1081  +				const char *pattern, int nocase);
         1082  +/* 372 */
         1083  +EXTERN int		Tcl_UniCharIsControl(int ch);
         1084  +/* 373 */
         1085  +EXTERN int		Tcl_UniCharIsGraph(int ch);
         1086  +/* 374 */
         1087  +EXTERN int		Tcl_UniCharIsPrint(int ch);
         1088  +/* 375 */
         1089  +EXTERN int		Tcl_UniCharIsPunct(int ch);
         1090  +/* 376 */
         1091  +EXTERN int		Tcl_RegExpExecObj(Tcl_Interp *interp,
         1092  +				Tcl_RegExp regexp, Tcl_Obj *textObj,
         1093  +				int offset, int nmatches, int flags);
         1094  +/* 377 */
         1095  +EXTERN void		Tcl_RegExpGetInfo(Tcl_RegExp regexp,
         1096  +				Tcl_RegExpInfo *infoPtr);
         1097  +/* 378 */
         1098  +EXTERN Tcl_Obj *	Tcl_NewUnicodeObj(const Tcl_UniChar *unicode,
         1099  +				int numChars);
         1100  +/* 379 */
         1101  +EXTERN void		Tcl_SetUnicodeObj(Tcl_Obj *objPtr,
         1102  +				const Tcl_UniChar *unicode, int numChars);
         1103  +/* 380 */
         1104  +EXTERN int		Tcl_GetCharLength(Tcl_Obj *objPtr);
         1105  +/* 381 */
         1106  +EXTERN Tcl_UniChar	Tcl_GetUniChar(Tcl_Obj *objPtr, int index);
         1107  +/* 382 */
         1108  +EXTERN Tcl_UniChar *	Tcl_GetUnicode(Tcl_Obj *objPtr);
         1109  +/* 383 */
         1110  +EXTERN Tcl_Obj *	Tcl_GetRange(Tcl_Obj *objPtr, int first, int last);
         1111  +/* 384 */
         1112  +EXTERN void		Tcl_AppendUnicodeToObj(Tcl_Obj *objPtr,
         1113  +				const Tcl_UniChar *unicode, int length);
         1114  +/* 385 */
         1115  +EXTERN int		Tcl_RegExpMatchObj(Tcl_Interp *interp,
         1116  +				Tcl_Obj *textObj, Tcl_Obj *patternObj);
         1117  +/* 386 */
         1118  +EXTERN void		Tcl_SetNotifier(Tcl_NotifierProcs *notifierProcPtr);
         1119  +/* 387 */
         1120  +EXTERN Tcl_Mutex *	Tcl_GetAllocMutex(void);
         1121  +/* 388 */
         1122  +EXTERN int		Tcl_GetChannelNames(Tcl_Interp *interp);
         1123  +/* 389 */
         1124  +EXTERN int		Tcl_GetChannelNamesEx(Tcl_Interp *interp,
         1125  +				const char *pattern);
         1126  +/* 390 */
         1127  +EXTERN int		Tcl_ProcObjCmd(ClientData clientData,
         1128  +				Tcl_Interp *interp, int objc,
         1129  +				Tcl_Obj *const objv[]);
         1130  +/* 391 */
         1131  +EXTERN void		Tcl_ConditionFinalize(Tcl_Condition *condPtr);
         1132  +/* 392 */
         1133  +EXTERN void		Tcl_MutexFinalize(Tcl_Mutex *mutex);
         1134  +/* 393 */
         1135  +EXTERN int		Tcl_CreateThread(Tcl_ThreadId *idPtr,
         1136  +				Tcl_ThreadCreateProc *proc,
         1137  +				ClientData clientData, int stackSize,
         1138  +				int flags);
         1139  +/* 394 */
         1140  +EXTERN int		Tcl_ReadRaw(Tcl_Channel chan, char *dst,
         1141  +				int bytesToRead);
         1142  +/* 395 */
         1143  +EXTERN int		Tcl_WriteRaw(Tcl_Channel chan, const char *src,
         1144  +				int srcLen);
         1145  +/* 396 */
         1146  +EXTERN Tcl_Channel	Tcl_GetTopChannel(Tcl_Channel chan);
         1147  +/* 397 */
         1148  +EXTERN int		Tcl_ChannelBuffered(Tcl_Channel chan);
         1149  +/* 398 */
         1150  +EXTERN CONST84_RETURN char * Tcl_ChannelName(
         1151  +				const Tcl_ChannelType *chanTypePtr);
         1152  +/* 399 */
         1153  +EXTERN Tcl_ChannelTypeVersion Tcl_ChannelVersion(
         1154  +				const Tcl_ChannelType *chanTypePtr);
         1155  +/* 400 */
         1156  +EXTERN Tcl_DriverBlockModeProc * Tcl_ChannelBlockModeProc(
         1157  +				const Tcl_ChannelType *chanTypePtr);
         1158  +/* 401 */
         1159  +EXTERN Tcl_DriverCloseProc * Tcl_ChannelCloseProc(
         1160  +				const Tcl_ChannelType *chanTypePtr);
         1161  +/* 402 */
         1162  +EXTERN Tcl_DriverClose2Proc * Tcl_ChannelClose2Proc(
         1163  +				const Tcl_ChannelType *chanTypePtr);
         1164  +/* 403 */
         1165  +EXTERN Tcl_DriverInputProc * Tcl_ChannelInputProc(
         1166  +				const Tcl_ChannelType *chanTypePtr);
         1167  +/* 404 */
         1168  +EXTERN Tcl_DriverOutputProc * Tcl_ChannelOutputProc(
         1169  +				const Tcl_ChannelType *chanTypePtr);
         1170  +/* 405 */
         1171  +EXTERN Tcl_DriverSeekProc * Tcl_ChannelSeekProc(
         1172  +				const Tcl_ChannelType *chanTypePtr);
         1173  +/* 406 */
         1174  +EXTERN Tcl_DriverSetOptionProc * Tcl_ChannelSetOptionProc(
         1175  +				const Tcl_ChannelType *chanTypePtr);
         1176  +/* 407 */
         1177  +EXTERN Tcl_DriverGetOptionProc * Tcl_ChannelGetOptionProc(
         1178  +				const Tcl_ChannelType *chanTypePtr);
         1179  +/* 408 */
         1180  +EXTERN Tcl_DriverWatchProc * Tcl_ChannelWatchProc(
         1181  +				const Tcl_ChannelType *chanTypePtr);
         1182  +/* 409 */
         1183  +EXTERN Tcl_DriverGetHandleProc * Tcl_ChannelGetHandleProc(
         1184  +				const Tcl_ChannelType *chanTypePtr);
         1185  +/* 410 */
         1186  +EXTERN Tcl_DriverFlushProc * Tcl_ChannelFlushProc(
         1187  +				const Tcl_ChannelType *chanTypePtr);
         1188  +/* 411 */
         1189  +EXTERN Tcl_DriverHandlerProc * Tcl_ChannelHandlerProc(
         1190  +				const Tcl_ChannelType *chanTypePtr);
         1191  +/* 412 */
         1192  +EXTERN int		Tcl_JoinThread(Tcl_ThreadId threadId, int *result);
         1193  +/* 413 */
         1194  +EXTERN int		Tcl_IsChannelShared(Tcl_Channel channel);
         1195  +/* 414 */
         1196  +EXTERN int		Tcl_IsChannelRegistered(Tcl_Interp *interp,
         1197  +				Tcl_Channel channel);
         1198  +/* 415 */
         1199  +EXTERN void		Tcl_CutChannel(Tcl_Channel channel);
         1200  +/* 416 */
         1201  +EXTERN void		Tcl_SpliceChannel(Tcl_Channel channel);
         1202  +/* 417 */
         1203  +EXTERN void		Tcl_ClearChannelHandlers(Tcl_Channel channel);
         1204  +/* 418 */
         1205  +EXTERN int		Tcl_IsChannelExisting(const char *channelName);
         1206  +/* 419 */
         1207  +EXTERN int		Tcl_UniCharNcasecmp(const Tcl_UniChar *ucs,
         1208  +				const Tcl_UniChar *uct,
         1209  +				unsigned long numChars);
         1210  +/* 420 */
         1211  +EXTERN int		Tcl_UniCharCaseMatch(const Tcl_UniChar *uniStr,
         1212  +				const Tcl_UniChar *uniPattern, int nocase);
         1213  +/* 421 */
         1214  +EXTERN Tcl_HashEntry *	Tcl_FindHashEntry(Tcl_HashTable *tablePtr,
         1215  +				const void *key);
         1216  +/* 422 */
         1217  +EXTERN Tcl_HashEntry *	Tcl_CreateHashEntry(Tcl_HashTable *tablePtr,
         1218  +				const void *key, int *newPtr);
         1219  +/* 423 */
         1220  +EXTERN void		Tcl_InitCustomHashTable(Tcl_HashTable *tablePtr,
         1221  +				int keyType, const Tcl_HashKeyType *typePtr);
         1222  +/* 424 */
         1223  +EXTERN void		Tcl_InitObjHashTable(Tcl_HashTable *tablePtr);
         1224  +/* 425 */
         1225  +EXTERN ClientData	Tcl_CommandTraceInfo(Tcl_Interp *interp,
         1226  +				const char *varName, int flags,
         1227  +				Tcl_CommandTraceProc *procPtr,
         1228  +				ClientData prevClientData);
         1229  +/* 426 */
         1230  +EXTERN int		Tcl_TraceCommand(Tcl_Interp *interp,
         1231  +				const char *varName, int flags,
         1232  +				Tcl_CommandTraceProc *proc,
         1233  +				ClientData clientData);
         1234  +/* 427 */
         1235  +EXTERN void		Tcl_UntraceCommand(Tcl_Interp *interp,
         1236  +				const char *varName, int flags,
         1237  +				Tcl_CommandTraceProc *proc,
         1238  +				ClientData clientData);
         1239  +/* 428 */
         1240  +EXTERN char *		Tcl_AttemptAlloc(unsigned int size);
         1241  +/* 429 */
         1242  +EXTERN char *		Tcl_AttemptDbCkalloc(unsigned int size,
         1243  +				const char *file, int line);
         1244  +/* 430 */
         1245  +EXTERN char *		Tcl_AttemptRealloc(char *ptr, unsigned int size);
         1246  +/* 431 */
         1247  +EXTERN char *		Tcl_AttemptDbCkrealloc(char *ptr, unsigned int size,
         1248  +				const char *file, int line);
         1249  +/* 432 */
         1250  +EXTERN int		Tcl_AttemptSetObjLength(Tcl_Obj *objPtr, int length);
         1251  +/* 433 */
         1252  +EXTERN Tcl_ThreadId	Tcl_GetChannelThread(Tcl_Channel channel);
         1253  +/* 434 */
         1254  +EXTERN Tcl_UniChar *	Tcl_GetUnicodeFromObj(Tcl_Obj *objPtr,
         1255  +				int *lengthPtr);
         1256  +/* 435 */
         1257  +EXTERN int		Tcl_GetMathFuncInfo(Tcl_Interp *interp,
         1258  +				const char *name, int *numArgsPtr,
         1259  +				Tcl_ValueType **argTypesPtr,
         1260  +				Tcl_MathProc **procPtr,
         1261  +				ClientData *clientDataPtr);
         1262  +/* 436 */
         1263  +EXTERN Tcl_Obj *	Tcl_ListMathFuncs(Tcl_Interp *interp,
         1264  +				const char *pattern);
         1265  +/* 437 */
         1266  +EXTERN Tcl_Obj *	Tcl_SubstObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
         1267  +				int flags);
         1268  +/* 438 */
         1269  +EXTERN int		Tcl_DetachChannel(Tcl_Interp *interp,
         1270  +				Tcl_Channel channel);
         1271  +/* 439 */
         1272  +EXTERN int		Tcl_IsStandardChannel(Tcl_Channel channel);
         1273  +/* 440 */
         1274  +EXTERN int		Tcl_FSCopyFile(Tcl_Obj *srcPathPtr,
         1275  +				Tcl_Obj *destPathPtr);
         1276  +/* 441 */
         1277  +EXTERN int		Tcl_FSCopyDirectory(Tcl_Obj *srcPathPtr,
         1278  +				Tcl_Obj *destPathPtr, Tcl_Obj **errorPtr);
         1279  +/* 442 */
         1280  +EXTERN int		Tcl_FSCreateDirectory(Tcl_Obj *pathPtr);
         1281  +/* 443 */
         1282  +EXTERN int		Tcl_FSDeleteFile(Tcl_Obj *pathPtr);
         1283  +/* 444 */
         1284  +EXTERN int		Tcl_FSLoadFile(Tcl_Interp *interp, Tcl_Obj *pathPtr,
         1285  +				const char *sym1, const char *sym2,
         1286  +				Tcl_PackageInitProc **proc1Ptr,
         1287  +				Tcl_PackageInitProc **proc2Ptr,
         1288  +				Tcl_LoadHandle *handlePtr,
         1289  +				Tcl_FSUnloadFileProc **unloadProcPtr);
         1290  +/* 445 */
         1291  +EXTERN int		Tcl_FSMatchInDirectory(Tcl_Interp *interp,
         1292  +				Tcl_Obj *result, Tcl_Obj *pathPtr,
         1293  +				const char *pattern, Tcl_GlobTypeData *types);
         1294  +/* 446 */
         1295  +EXTERN Tcl_Obj *	Tcl_FSLink(Tcl_Obj *pathPtr, Tcl_Obj *toPtr,
         1296  +				int linkAction);
         1297  +/* 447 */
         1298  +EXTERN int		Tcl_FSRemoveDirectory(Tcl_Obj *pathPtr,
         1299  +				int recursive, Tcl_Obj **errorPtr);
         1300  +/* 448 */
         1301  +EXTERN int		Tcl_FSRenameFile(Tcl_Obj *srcPathPtr,
         1302  +				Tcl_Obj *destPathPtr);
         1303  +/* 449 */
         1304  +EXTERN int		Tcl_FSLstat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf);
         1305  +/* 450 */
         1306  +EXTERN int		Tcl_FSUtime(Tcl_Obj *pathPtr, struct utimbuf *tval);
         1307  +/* 451 */
         1308  +EXTERN int		Tcl_FSFileAttrsGet(Tcl_Interp *interp, int index,
         1309  +				Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef);
         1310  +/* 452 */
         1311  +EXTERN int		Tcl_FSFileAttrsSet(Tcl_Interp *interp, int index,
         1312  +				Tcl_Obj *pathPtr, Tcl_Obj *objPtr);
         1313  +/* 453 */
         1314  +EXTERN const char *CONST86 * Tcl_FSFileAttrStrings(Tcl_Obj *pathPtr,
         1315  +				Tcl_Obj **objPtrRef);
         1316  +/* 454 */
         1317  +EXTERN int		Tcl_FSStat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf);
         1318  +/* 455 */
         1319  +EXTERN int		Tcl_FSAccess(Tcl_Obj *pathPtr, int mode);
         1320  +/* 456 */
         1321  +EXTERN Tcl_Channel	Tcl_FSOpenFileChannel(Tcl_Interp *interp,
         1322  +				Tcl_Obj *pathPtr, const char *modeString,
         1323  +				int permissions);
         1324  +/* 457 */
         1325  +EXTERN Tcl_Obj *	Tcl_FSGetCwd(Tcl_Interp *interp);
         1326  +/* 458 */
         1327  +EXTERN int		Tcl_FSChdir(Tcl_Obj *pathPtr);
         1328  +/* 459 */
         1329  +EXTERN int		Tcl_FSConvertToPathType(Tcl_Interp *interp,
         1330  +				Tcl_Obj *pathPtr);
         1331  +/* 460 */
         1332  +EXTERN Tcl_Obj *	Tcl_FSJoinPath(Tcl_Obj *listObj, int elements);
         1333  +/* 461 */
         1334  +EXTERN Tcl_Obj *	Tcl_FSSplitPath(Tcl_Obj *pathPtr, int *lenPtr);
         1335  +/* 462 */
         1336  +EXTERN int		Tcl_FSEqualPaths(Tcl_Obj *firstPtr,
         1337  +				Tcl_Obj *secondPtr);
         1338  +/* 463 */
         1339  +EXTERN Tcl_Obj *	Tcl_FSGetNormalizedPath(Tcl_Interp *interp,
         1340  +				Tcl_Obj *pathPtr);
         1341  +/* 464 */
         1342  +EXTERN Tcl_Obj *	Tcl_FSJoinToPath(Tcl_Obj *pathPtr, int objc,
         1343  +				Tcl_Obj *const objv[]);
         1344  +/* 465 */
         1345  +EXTERN ClientData	Tcl_FSGetInternalRep(Tcl_Obj *pathPtr,
         1346  +				const Tcl_Filesystem *fsPtr);
         1347  +/* 466 */
         1348  +EXTERN Tcl_Obj *	Tcl_FSGetTranslatedPath(Tcl_Interp *interp,
         1349  +				Tcl_Obj *pathPtr);
         1350  +/* 467 */
         1351  +EXTERN int		Tcl_FSEvalFile(Tcl_Interp *interp, Tcl_Obj *fileName);
         1352  +/* 468 */
         1353  +EXTERN Tcl_Obj *	Tcl_FSNewNativePath(
         1354  +				const Tcl_Filesystem *fromFilesystem,
         1355  +				ClientData clientData);
         1356  +/* 469 */
         1357  +EXTERN const void *	Tcl_FSGetNativePath(Tcl_Obj *pathPtr);
         1358  +/* 470 */
         1359  +EXTERN Tcl_Obj *	Tcl_FSFileSystemInfo(Tcl_Obj *pathPtr);
         1360  +/* 471 */
         1361  +EXTERN Tcl_Obj *	Tcl_FSPathSeparator(Tcl_Obj *pathPtr);
         1362  +/* 472 */
         1363  +EXTERN Tcl_Obj *	Tcl_FSListVolumes(void);
         1364  +/* 473 */
         1365  +EXTERN int		Tcl_FSRegister(ClientData clientData,
         1366  +				const Tcl_Filesystem *fsPtr);
         1367  +/* 474 */
         1368  +EXTERN int		Tcl_FSUnregister(const Tcl_Filesystem *fsPtr);
         1369  +/* 475 */
         1370  +EXTERN ClientData	Tcl_FSData(const Tcl_Filesystem *fsPtr);
         1371  +/* 476 */
         1372  +EXTERN const char *	Tcl_FSGetTranslatedStringPath(Tcl_Interp *interp,
         1373  +				Tcl_Obj *pathPtr);
         1374  +/* 477 */
         1375  +EXTERN CONST86 Tcl_Filesystem * Tcl_FSGetFileSystemForPath(Tcl_Obj *pathPtr);
         1376  +/* 478 */
         1377  +EXTERN Tcl_PathType	Tcl_FSGetPathType(Tcl_Obj *pathPtr);
         1378  +/* 479 */
         1379  +EXTERN int		Tcl_OutputBuffered(Tcl_Channel chan);
         1380  +/* 480 */
         1381  +EXTERN void		Tcl_FSMountsChanged(const Tcl_Filesystem *fsPtr);
         1382  +/* 481 */
         1383  +EXTERN int		Tcl_EvalTokensStandard(Tcl_Interp *interp,
         1384  +				Tcl_Token *tokenPtr, int count);
         1385  +/* 482 */
         1386  +EXTERN void		Tcl_GetTime(Tcl_Time *timeBuf);
         1387  +/* 483 */
         1388  +EXTERN Tcl_Trace	Tcl_CreateObjTrace(Tcl_Interp *interp, int level,
         1389  +				int flags, Tcl_CmdObjTraceProc *objProc,
         1390  +				ClientData clientData,
         1391  +				Tcl_CmdObjTraceDeleteProc *delProc);
         1392  +/* 484 */
         1393  +EXTERN int		Tcl_GetCommandInfoFromToken(Tcl_Command token,
         1394  +				Tcl_CmdInfo *infoPtr);
         1395  +/* 485 */
         1396  +EXTERN int		Tcl_SetCommandInfoFromToken(Tcl_Command token,
         1397  +				const Tcl_CmdInfo *infoPtr);
         1398  +/* 486 */
         1399  +EXTERN Tcl_Obj *	Tcl_DbNewWideIntObj(Tcl_WideInt wideValue,
         1400  +				const char *file, int line);
         1401  +/* 487 */
         1402  +EXTERN int		Tcl_GetWideIntFromObj(Tcl_Interp *interp,
         1403  +				Tcl_Obj *objPtr, Tcl_WideInt *widePtr);
         1404  +/* 488 */
         1405  +EXTERN Tcl_Obj *	Tcl_NewWideIntObj(Tcl_WideInt wideValue);
         1406  +/* 489 */
         1407  +EXTERN void		Tcl_SetWideIntObj(Tcl_Obj *objPtr,
         1408  +				Tcl_WideInt wideValue);
         1409  +/* 490 */
         1410  +EXTERN Tcl_StatBuf *	Tcl_AllocStatBuf(void);
         1411  +/* 491 */
         1412  +EXTERN Tcl_WideInt	Tcl_Seek(Tcl_Channel chan, Tcl_WideInt offset,
         1413  +				int mode);
         1414  +/* 492 */
         1415  +EXTERN Tcl_WideInt	Tcl_Tell(Tcl_Channel chan);
         1416  +/* 493 */
         1417  +EXTERN Tcl_DriverWideSeekProc * Tcl_ChannelWideSeekProc(
         1418  +				const Tcl_ChannelType *chanTypePtr);
         1419  +/* 494 */
         1420  +EXTERN int		Tcl_DictObjPut(Tcl_Interp *interp, Tcl_Obj *dictPtr,
         1421  +				Tcl_Obj *keyPtr, Tcl_Obj *valuePtr);
         1422  +/* 495 */
         1423  +EXTERN int		Tcl_DictObjGet(Tcl_Interp *interp, Tcl_Obj *dictPtr,
         1424  +				Tcl_Obj *keyPtr, Tcl_Obj **valuePtrPtr);
         1425  +/* 496 */
         1426  +EXTERN int		Tcl_DictObjRemove(Tcl_Interp *interp,
         1427  +				Tcl_Obj *dictPtr, Tcl_Obj *keyPtr);
         1428  +/* 497 */
         1429  +EXTERN int		Tcl_DictObjSize(Tcl_Interp *interp, Tcl_Obj *dictPtr,
         1430  +				int *sizePtr);
         1431  +/* 498 */
         1432  +EXTERN int		Tcl_DictObjFirst(Tcl_Interp *interp,
         1433  +				Tcl_Obj *dictPtr, Tcl_DictSearch *searchPtr,
         1434  +				Tcl_Obj **keyPtrPtr, Tcl_Obj **valuePtrPtr,
         1435  +				int *donePtr);
         1436  +/* 499 */
         1437  +EXTERN void		Tcl_DictObjNext(Tcl_DictSearch *searchPtr,
         1438  +				Tcl_Obj **keyPtrPtr, Tcl_Obj **valuePtrPtr,
         1439  +				int *donePtr);
         1440  +/* 500 */
         1441  +EXTERN void		Tcl_DictObjDone(Tcl_DictSearch *searchPtr);
         1442  +/* 501 */
         1443  +EXTERN int		Tcl_DictObjPutKeyList(Tcl_Interp *interp,
         1444  +				Tcl_Obj *dictPtr, int keyc,
         1445  +				Tcl_Obj *const *keyv, Tcl_Obj *valuePtr);
         1446  +/* 502 */
         1447  +EXTERN int		Tcl_DictObjRemoveKeyList(Tcl_Interp *interp,
         1448  +				Tcl_Obj *dictPtr, int keyc,
         1449  +				Tcl_Obj *const *keyv);
         1450  +/* 503 */
         1451  +EXTERN Tcl_Obj *	Tcl_NewDictObj(void);
         1452  +/* 504 */
         1453  +EXTERN Tcl_Obj *	Tcl_DbNewDictObj(const char *file, int line);
         1454  +/* 505 */
         1455  +EXTERN void		Tcl_RegisterConfig(Tcl_Interp *interp,
         1456  +				const char *pkgName,
         1457  +				const Tcl_Config *configuration,
         1458  +				const char *valEncoding);
         1459  +/* 506 */
         1460  +EXTERN Tcl_Namespace *	Tcl_CreateNamespace(Tcl_Interp *interp,
         1461  +				const char *name, ClientData clientData,
         1462  +				Tcl_NamespaceDeleteProc *deleteProc);
         1463  +/* 507 */
         1464  +EXTERN void		Tcl_DeleteNamespace(Tcl_Namespace *nsPtr);
         1465  +/* 508 */
         1466  +EXTERN int		Tcl_AppendExportList(Tcl_Interp *interp,
         1467  +				Tcl_Namespace *nsPtr, Tcl_Obj *objPtr);
         1468  +/* 509 */
         1469  +EXTERN int		Tcl_Export(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
         1470  +				const char *pattern, int resetListFirst);
         1471  +/* 510 */
         1472  +EXTERN int		Tcl_Import(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
         1473  +				const char *pattern, int allowOverwrite);
         1474  +/* 511 */
         1475  +EXTERN int		Tcl_ForgetImport(Tcl_Interp *interp,
         1476  +				Tcl_Namespace *nsPtr, const char *pattern);
         1477  +/* 512 */
         1478  +EXTERN Tcl_Namespace *	Tcl_GetCurrentNamespace(Tcl_Interp *interp);
         1479  +/* 513 */
         1480  +EXTERN Tcl_Namespace *	Tcl_GetGlobalNamespace(Tcl_Interp *interp);
         1481  +/* 514 */
         1482  +EXTERN Tcl_Namespace *	Tcl_FindNamespace(Tcl_Interp *interp,
         1483  +				const char *name,
         1484  +				Tcl_Namespace *contextNsPtr, int flags);
         1485  +/* 515 */
         1486  +EXTERN Tcl_Command	Tcl_FindCommand(Tcl_Interp *interp, const char *name,
         1487  +				Tcl_Namespace *contextNsPtr, int flags);
         1488  +/* 516 */
         1489  +EXTERN Tcl_Command	Tcl_GetCommandFromObj(Tcl_Interp *interp,
         1490  +				Tcl_Obj *objPtr);
         1491  +/* 517 */
         1492  +EXTERN void		Tcl_GetCommandFullName(Tcl_Interp *interp,
         1493  +				Tcl_Command command, Tcl_Obj *objPtr);
         1494  +/* 518 */
         1495  +EXTERN int		Tcl_FSEvalFileEx(Tcl_Interp *interp,
         1496  +				Tcl_Obj *fileName, const char *encodingName);
         1497  +/* 519 */
         1498  +EXTERN Tcl_ExitProc *	Tcl_SetExitProc(Tcl_ExitProc *proc);
         1499  +/* 520 */
         1500  +EXTERN void		Tcl_LimitAddHandler(Tcl_Interp *interp, int type,
         1501  +				Tcl_LimitHandlerProc *handlerProc,
         1502  +				ClientData clientData,
         1503  +				Tcl_LimitHandlerDeleteProc *deleteProc);
         1504  +/* 521 */
         1505  +EXTERN void		Tcl_LimitRemoveHandler(Tcl_Interp *interp, int type,
         1506  +				Tcl_LimitHandlerProc *handlerProc,
         1507  +				ClientData clientData);
         1508  +/* 522 */
         1509  +EXTERN int		Tcl_LimitReady(Tcl_Interp *interp);
         1510  +/* 523 */
         1511  +EXTERN int		Tcl_LimitCheck(Tcl_Interp *interp);
         1512  +/* 524 */
         1513  +EXTERN int		Tcl_LimitExceeded(Tcl_Interp *interp);
         1514  +/* 525 */
         1515  +EXTERN void		Tcl_LimitSetCommands(Tcl_Interp *interp,
         1516  +				int commandLimit);
         1517  +/* 526 */
         1518  +EXTERN void		Tcl_LimitSetTime(Tcl_Interp *interp,
         1519  +				Tcl_Time *timeLimitPtr);
         1520  +/* 527 */
         1521  +EXTERN void		Tcl_LimitSetGranularity(Tcl_Interp *interp, int type,
         1522  +				int granularity);
         1523  +/* 528 */
         1524  +EXTERN int		Tcl_LimitTypeEnabled(Tcl_Interp *interp, int type);
         1525  +/* 529 */
         1526  +EXTERN int		Tcl_LimitTypeExceeded(Tcl_Interp *interp, int type);
         1527  +/* 530 */
         1528  +EXTERN void		Tcl_LimitTypeSet(Tcl_Interp *interp, int type);
         1529  +/* 531 */
         1530  +EXTERN void		Tcl_LimitTypeReset(Tcl_Interp *interp, int type);
         1531  +/* 532 */
         1532  +EXTERN int		Tcl_LimitGetCommands(Tcl_Interp *interp);
         1533  +/* 533 */
         1534  +EXTERN void		Tcl_LimitGetTime(Tcl_Interp *interp,
         1535  +				Tcl_Time *timeLimitPtr);
         1536  +/* 534 */
         1537  +EXTERN int		Tcl_LimitGetGranularity(Tcl_Interp *interp, int type);
         1538  +/* 535 */
         1539  +EXTERN Tcl_InterpState	Tcl_SaveInterpState(Tcl_Interp *interp, int status);
         1540  +/* 536 */
         1541  +EXTERN int		Tcl_RestoreInterpState(Tcl_Interp *interp,
         1542  +				Tcl_InterpState state);
         1543  +/* 537 */
         1544  +EXTERN void		Tcl_DiscardInterpState(Tcl_InterpState state);
         1545  +/* 538 */
         1546  +EXTERN int		Tcl_SetReturnOptions(Tcl_Interp *interp,
         1547  +				Tcl_Obj *options);
         1548  +/* 539 */
         1549  +EXTERN Tcl_Obj *	Tcl_GetReturnOptions(Tcl_Interp *interp, int result);
         1550  +/* 540 */
         1551  +EXTERN int		Tcl_IsEnsemble(Tcl_Command token);
         1552  +/* 541 */
         1553  +EXTERN Tcl_Command	Tcl_CreateEnsemble(Tcl_Interp *interp,
         1554  +				const char *name,
         1555  +				Tcl_Namespace *namespacePtr, int flags);
         1556  +/* 542 */
         1557  +EXTERN Tcl_Command	Tcl_FindEnsemble(Tcl_Interp *interp,
         1558  +				Tcl_Obj *cmdNameObj, int flags);
         1559  +/* 543 */
         1560  +EXTERN int		Tcl_SetEnsembleSubcommandList(Tcl_Interp *interp,
         1561  +				Tcl_Command token, Tcl_Obj *subcmdList);
         1562  +/* 544 */
         1563  +EXTERN int		Tcl_SetEnsembleMappingDict(Tcl_Interp *interp,
         1564  +				Tcl_Command token, Tcl_Obj *mapDict);
         1565  +/* 545 */
         1566  +EXTERN int		Tcl_SetEnsembleUnknownHandler(Tcl_Interp *interp,
         1567  +				Tcl_Command token, Tcl_Obj *unknownList);
         1568  +/* 546 */
         1569  +EXTERN int		Tcl_SetEnsembleFlags(Tcl_Interp *interp,
         1570  +				Tcl_Command token, int flags);
         1571  +/* 547 */
         1572  +EXTERN int		Tcl_GetEnsembleSubcommandList(Tcl_Interp *interp,
         1573  +				Tcl_Command token, Tcl_Obj **subcmdListPtr);
         1574  +/* 548 */
         1575  +EXTERN int		Tcl_GetEnsembleMappingDict(Tcl_Interp *interp,
         1576  +				Tcl_Command token, Tcl_Obj **mapDictPtr);
         1577  +/* 549 */
         1578  +EXTERN int		Tcl_GetEnsembleUnknownHandler(Tcl_Interp *interp,
         1579  +				Tcl_Command token, Tcl_Obj **unknownListPtr);
         1580  +/* 550 */
         1581  +EXTERN int		Tcl_GetEnsembleFlags(Tcl_Interp *interp,
         1582  +				Tcl_Command token, int *flagsPtr);
         1583  +/* 551 */
         1584  +EXTERN int		Tcl_GetEnsembleNamespace(Tcl_Interp *interp,
         1585  +				Tcl_Command token,
         1586  +				Tcl_Namespace **namespacePtrPtr);
         1587  +/* 552 */
         1588  +EXTERN void		Tcl_SetTimeProc(Tcl_GetTimeProc *getProc,
         1589  +				Tcl_ScaleTimeProc *scaleProc,
         1590  +				ClientData clientData);
         1591  +/* 553 */
         1592  +EXTERN void		Tcl_QueryTimeProc(Tcl_GetTimeProc **getProc,
         1593  +				Tcl_ScaleTimeProc **scaleProc,
         1594  +				ClientData *clientData);
         1595  +/* 554 */
         1596  +EXTERN Tcl_DriverThreadActionProc * Tcl_ChannelThreadActionProc(
         1597  +				const Tcl_ChannelType *chanTypePtr);
         1598  +/* 555 */
         1599  +EXTERN Tcl_Obj *	Tcl_NewBignumObj(mp_int *value);
         1600  +/* 556 */
         1601  +EXTERN Tcl_Obj *	Tcl_DbNewBignumObj(mp_int *value, const char *file,
         1602  +				int line);
         1603  +/* 557 */
         1604  +EXTERN void		Tcl_SetBignumObj(Tcl_Obj *obj, mp_int *value);
         1605  +/* 558 */
         1606  +EXTERN int		Tcl_GetBignumFromObj(Tcl_Interp *interp,
         1607  +				Tcl_Obj *obj, mp_int *value);
         1608  +/* 559 */
         1609  +EXTERN int		Tcl_TakeBignumFromObj(Tcl_Interp *interp,
         1610  +				Tcl_Obj *obj, mp_int *value);
         1611  +/* 560 */
         1612  +EXTERN int		Tcl_TruncateChannel(Tcl_Channel chan,
         1613  +				Tcl_WideInt length);
         1614  +/* 561 */
         1615  +EXTERN Tcl_DriverTruncateProc * Tcl_ChannelTruncateProc(
         1616  +				const Tcl_ChannelType *chanTypePtr);
         1617  +/* 562 */
         1618  +EXTERN void		Tcl_SetChannelErrorInterp(Tcl_Interp *interp,
         1619  +				Tcl_Obj *msg);
         1620  +/* 563 */
         1621  +EXTERN void		Tcl_GetChannelErrorInterp(Tcl_Interp *interp,
         1622  +				Tcl_Obj **msg);
         1623  +/* 564 */
         1624  +EXTERN void		Tcl_SetChannelError(Tcl_Channel chan, Tcl_Obj *msg);
         1625  +/* 565 */
         1626  +EXTERN void		Tcl_GetChannelError(Tcl_Channel chan, Tcl_Obj **msg);
         1627  +/* 566 */
         1628  +EXTERN int		Tcl_InitBignumFromDouble(Tcl_Interp *interp,
         1629  +				double initval, mp_int *toInit);
         1630  +/* 567 */
         1631  +EXTERN Tcl_Obj *	Tcl_GetNamespaceUnknownHandler(Tcl_Interp *interp,
         1632  +				Tcl_Namespace *nsPtr);
         1633  +/* 568 */
         1634  +EXTERN int		Tcl_SetNamespaceUnknownHandler(Tcl_Interp *interp,
         1635  +				Tcl_Namespace *nsPtr, Tcl_Obj *handlerPtr);
         1636  +/* 569 */
         1637  +EXTERN int		Tcl_GetEncodingFromObj(Tcl_Interp *interp,
         1638  +				Tcl_Obj *objPtr, Tcl_Encoding *encodingPtr);
         1639  +/* 570 */
         1640  +EXTERN Tcl_Obj *	Tcl_GetEncodingSearchPath(void);
         1641  +/* 571 */
         1642  +EXTERN int		Tcl_SetEncodingSearchPath(Tcl_Obj *searchPath);
         1643  +/* 572 */
         1644  +EXTERN const char *	Tcl_GetEncodingNameFromEnvironment(
         1645  +				Tcl_DString *bufPtr);
         1646  +/* 573 */
         1647  +EXTERN int		Tcl_PkgRequireProc(Tcl_Interp *interp,
         1648  +				const char *name, int objc,
         1649  +				Tcl_Obj *const objv[], void *clientDataPtr);
         1650  +/* 574 */
         1651  +EXTERN void		Tcl_AppendObjToErrorInfo(Tcl_Interp *interp,
         1652  +				Tcl_Obj *objPtr);
         1653  +/* 575 */
         1654  +EXTERN void		Tcl_AppendLimitedToObj(Tcl_Obj *objPtr,
         1655  +				const char *bytes, int length, int limit,
         1656  +				const char *ellipsis);
         1657  +/* 576 */
         1658  +EXTERN Tcl_Obj *	Tcl_Format(Tcl_Interp *interp, const char *format,
         1659  +				int objc, Tcl_Obj *const objv[]);
         1660  +/* 577 */
         1661  +EXTERN int		Tcl_AppendFormatToObj(Tcl_Interp *interp,
         1662  +				Tcl_Obj *objPtr, const char *format,
         1663  +				int objc, Tcl_Obj *const objv[]);
         1664  +/* 578 */
         1665  +EXTERN Tcl_Obj *	Tcl_ObjPrintf(const char *format, ...) TCL_FORMAT_PRINTF(1, 2);
         1666  +/* 579 */
         1667  +EXTERN void		Tcl_AppendPrintfToObj(Tcl_Obj *objPtr,
         1668  +				const char *format, ...) TCL_FORMAT_PRINTF(2, 3);
         1669  +/* 580 */
         1670  +EXTERN int		Tcl_CancelEval(Tcl_Interp *interp,
         1671  +				Tcl_Obj *resultObjPtr, ClientData clientData,
         1672  +				int flags);
         1673  +/* 581 */
         1674  +EXTERN int		Tcl_Canceled(Tcl_Interp *interp, int flags);
         1675  +/* 582 */
         1676  +EXTERN int		Tcl_CreatePipe(Tcl_Interp *interp,
         1677  +				Tcl_Channel *rchan, Tcl_Channel *wchan,
         1678  +				int flags);
         1679  +/* 583 */
         1680  +EXTERN Tcl_Command	Tcl_NRCreateCommand(Tcl_Interp *interp,
         1681  +				const char *cmdName, Tcl_ObjCmdProc *proc,
         1682  +				Tcl_ObjCmdProc *nreProc,
         1683  +				ClientData clientData,
         1684  +				Tcl_CmdDeleteProc *deleteProc);
         1685  +/* 584 */
         1686  +EXTERN int		Tcl_NREvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
         1687  +				int flags);
         1688  +/* 585 */
         1689  +EXTERN int		Tcl_NREvalObjv(Tcl_Interp *interp, int objc,
         1690  +				Tcl_Obj *const objv[], int flags);
         1691  +/* 586 */
         1692  +EXTERN int		Tcl_NRCmdSwap(Tcl_Interp *interp, Tcl_Command cmd,
         1693  +				int objc, Tcl_Obj *const objv[], int flags);
         1694  +/* 587 */
         1695  +EXTERN void		Tcl_NRAddCallback(Tcl_Interp *interp,
         1696  +				Tcl_NRPostProc *postProcPtr,
         1697  +				ClientData data0, ClientData data1,
         1698  +				ClientData data2, ClientData data3);
         1699  +/* 588 */
         1700  +EXTERN int		Tcl_NRCallObjProc(Tcl_Interp *interp,
         1701  +				Tcl_ObjCmdProc *objProc,
         1702  +				ClientData clientData, int objc,
         1703  +				Tcl_Obj *const objv[]);
         1704  +/* 589 */
         1705  +EXTERN unsigned		Tcl_GetFSDeviceFromStat(const Tcl_StatBuf *statPtr);
         1706  +/* 590 */
         1707  +EXTERN unsigned		Tcl_GetFSInodeFromStat(const Tcl_StatBuf *statPtr);
         1708  +/* 591 */
         1709  +EXTERN unsigned		Tcl_GetModeFromStat(const Tcl_StatBuf *statPtr);
         1710  +/* 592 */
         1711  +EXTERN int		Tcl_GetLinkCountFromStat(const Tcl_StatBuf *statPtr);
         1712  +/* 593 */
         1713  +EXTERN int		Tcl_GetUserIdFromStat(const Tcl_StatBuf *statPtr);
         1714  +/* 594 */
         1715  +EXTERN int		Tcl_GetGroupIdFromStat(const Tcl_StatBuf *statPtr);
         1716  +/* 595 */
         1717  +EXTERN int		Tcl_GetDeviceTypeFromStat(const Tcl_StatBuf *statPtr);
         1718  +/* 596 */
         1719  +EXTERN Tcl_WideInt	Tcl_GetAccessTimeFromStat(const Tcl_StatBuf *statPtr);
         1720  +/* 597 */
         1721  +EXTERN Tcl_WideInt	Tcl_GetModificationTimeFromStat(
         1722  +				const Tcl_StatBuf *statPtr);
         1723  +/* 598 */
         1724  +EXTERN Tcl_WideInt	Tcl_GetChangeTimeFromStat(const Tcl_StatBuf *statPtr);
         1725  +/* 599 */
         1726  +EXTERN Tcl_WideUInt	Tcl_GetSizeFromStat(const Tcl_StatBuf *statPtr);
         1727  +/* 600 */
         1728  +EXTERN Tcl_WideUInt	Tcl_GetBlocksFromStat(const Tcl_StatBuf *statPtr);
         1729  +/* 601 */
         1730  +EXTERN unsigned		Tcl_GetBlockSizeFromStat(const Tcl_StatBuf *statPtr);
         1731  +/* 602 */
         1732  +EXTERN int		Tcl_SetEnsembleParameterList(Tcl_Interp *interp,
         1733  +				Tcl_Command token, Tcl_Obj *paramList);
         1734  +/* 603 */
         1735  +EXTERN int		Tcl_GetEnsembleParameterList(Tcl_Interp *interp,
         1736  +				Tcl_Command token, Tcl_Obj **paramListPtr);
         1737  +/* 604 */
         1738  +EXTERN int		Tcl_ParseArgsObjv(Tcl_Interp *interp,
         1739  +				const Tcl_ArgvInfo *argTable, int *objcPtr,
         1740  +				Tcl_Obj *const *objv, Tcl_Obj ***remObjv);
         1741  +/* 605 */
         1742  +EXTERN int		Tcl_GetErrorLine(Tcl_Interp *interp);
         1743  +/* 606 */
         1744  +EXTERN void		Tcl_SetErrorLine(Tcl_Interp *interp, int lineNum);
         1745  +/* 607 */
         1746  +EXTERN void		Tcl_TransferResult(Tcl_Interp *sourceInterp,
         1747  +				int result, Tcl_Interp *targetInterp);
         1748  +/* 608 */
         1749  +EXTERN int		Tcl_InterpActive(Tcl_Interp *interp);
         1750  +/* 609 */
         1751  +EXTERN void		Tcl_BackgroundException(Tcl_Interp *interp, int code);
         1752  +/* 610 */
         1753  +EXTERN int		Tcl_ZlibDeflate(Tcl_Interp *interp, int format,
         1754  +				Tcl_Obj *data, int level,
         1755  +				Tcl_Obj *gzipHeaderDictObj);
         1756  +/* 611 */
         1757  +EXTERN int		Tcl_ZlibInflate(Tcl_Interp *interp, int format,
         1758  +				Tcl_Obj *data, int buffersize,
         1759  +				Tcl_Obj *gzipHeaderDictObj);
         1760  +/* 612 */
         1761  +EXTERN unsigned int	Tcl_ZlibCRC32(unsigned int crc,
         1762  +				const unsigned char *buf, int len);
         1763  +/* 613 */
         1764  +EXTERN unsigned int	Tcl_ZlibAdler32(unsigned int adler,
         1765  +				const unsigned char *buf, int len);
         1766  +/* 614 */
         1767  +EXTERN int		Tcl_ZlibStreamInit(Tcl_Interp *interp, int mode,
         1768  +				int format, int level, Tcl_Obj *dictObj,
         1769  +				Tcl_ZlibStream *zshandle);
         1770  +/* 615 */
         1771  +EXTERN Tcl_Obj *	Tcl_ZlibStreamGetCommandName(Tcl_ZlibStream zshandle);
         1772  +/* 616 */
         1773  +EXTERN int		Tcl_ZlibStreamEof(Tcl_ZlibStream zshandle);
         1774  +/* 617 */
         1775  +EXTERN int		Tcl_ZlibStreamChecksum(Tcl_ZlibStream zshandle);
         1776  +/* 618 */
         1777  +EXTERN int		Tcl_ZlibStreamPut(Tcl_ZlibStream zshandle,
         1778  +				Tcl_Obj *data, int flush);
         1779  +/* 619 */
         1780  +EXTERN int		Tcl_ZlibStreamGet(Tcl_ZlibStream zshandle,
         1781  +				Tcl_Obj *data, int count);
         1782  +/* 620 */
         1783  +EXTERN int		Tcl_ZlibStreamClose(Tcl_ZlibStream zshandle);
         1784  +/* 621 */
         1785  +EXTERN int		Tcl_ZlibStreamReset(Tcl_ZlibStream zshandle);
         1786  +/* 622 */
         1787  +EXTERN void		Tcl_SetStartupScript(Tcl_Obj *path,
         1788  +				const char *encoding);
         1789  +/* 623 */
         1790  +EXTERN Tcl_Obj *	Tcl_GetStartupScript(const char **encodingPtr);
         1791  +/* 624 */
         1792  +EXTERN int		Tcl_CloseEx(Tcl_Interp *interp, Tcl_Channel chan,
         1793  +				int flags);
         1794  +/* 625 */
         1795  +EXTERN int		Tcl_NRExprObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
         1796  +				Tcl_Obj *resultPtr);
         1797  +/* 626 */
         1798  +EXTERN int		Tcl_NRSubstObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
         1799  +				int flags);
         1800  +/* 627 */
         1801  +EXTERN int		Tcl_LoadFile(Tcl_Interp *interp, Tcl_Obj *pathPtr,
         1802  +				const char *const symv[], int flags,
         1803  +				void *procPtrs, Tcl_LoadHandle *handlePtr);
         1804  +/* 628 */
         1805  +EXTERN void *		Tcl_FindSymbol(Tcl_Interp *interp,
         1806  +				Tcl_LoadHandle handle, const char *symbol);
         1807  +/* 629 */
         1808  +EXTERN int		Tcl_FSUnloadFile(Tcl_Interp *interp,
         1809  +				Tcl_LoadHandle handlePtr);
         1810  +/* 630 */
         1811  +EXTERN void		Tcl_ZlibStreamSetCompressionDictionary(
         1812  +				Tcl_ZlibStream zhandle,
         1813  +				Tcl_Obj *compressionDictionaryObj);
         1814  +
         1815  +typedef struct {
         1816  +    const struct TclPlatStubs *tclPlatStubs;
         1817  +    const struct TclIntStubs *tclIntStubs;
         1818  +    const struct TclIntPlatStubs *tclIntPlatStubs;
         1819  +} TclStubHooks;
         1820  +
         1821  +typedef struct TclStubs {
         1822  +    int magic;
         1823  +    const TclStubHooks *hooks;
         1824  +
         1825  +    int (*tcl_PkgProvideEx) (Tcl_Interp *interp, const char *name, const char *version, const void *clientData); /* 0 */
         1826  +    CONST84_RETURN char * (*tcl_PkgRequireEx) (Tcl_Interp *interp, const char *name, const char *version, int exact, void *clientDataPtr); /* 1 */
         1827  +    void (*tcl_Panic) (const char *format, ...) TCL_FORMAT_PRINTF(1, 2); /* 2 */
         1828  +    char * (*tcl_Alloc) (unsigned int size); /* 3 */
         1829  +    void (*tcl_Free) (char *ptr); /* 4 */
         1830  +    char * (*tcl_Realloc) (char *ptr, unsigned int size); /* 5 */
         1831  +    char * (*tcl_DbCkalloc) (unsigned int size, const char *file, int line); /* 6 */
         1832  +    void (*tcl_DbCkfree) (char *ptr, const char *file, int line); /* 7 */
         1833  +    char * (*tcl_DbCkrealloc) (char *ptr, unsigned int size, const char *file, int line); /* 8 */
         1834  +#if !defined(__WIN32__) && !defined(MAC_OSX_TCL) /* UNIX */
         1835  +    void (*tcl_CreateFileHandler) (int fd, int mask, Tcl_FileProc *proc, ClientData clientData); /* 9 */
         1836  +#endif /* UNIX */
         1837  +#if defined(__WIN32__) /* WIN */
         1838  +    void (*reserved9)(void);
         1839  +#endif /* WIN */
         1840  +#ifdef MAC_OSX_TCL /* MACOSX */
         1841  +    void (*tcl_CreateFileHandler) (int fd, int mask, Tcl_FileProc *proc, ClientData clientData); /* 9 */
         1842  +#endif /* MACOSX */
         1843  +#if !defined(__WIN32__) && !defined(MAC_OSX_TCL) /* UNIX */
         1844  +    void (*tcl_DeleteFileHandler) (int fd); /* 10 */
         1845  +#endif /* UNIX */
         1846  +#if defined(__WIN32__) /* WIN */
         1847  +    void (*reserved10)(void);
         1848  +#endif /* WIN */
         1849  +#ifdef MAC_OSX_TCL /* MACOSX */
         1850  +    void (*tcl_DeleteFileHandler) (int fd); /* 10 */
         1851  +#endif /* MACOSX */
         1852  +    void (*tcl_SetTimer) (const Tcl_Time *timePtr); /* 11 */
         1853  +    void (*tcl_Sleep) (int ms); /* 12 */
         1854  +    int (*tcl_WaitForEvent) (const Tcl_Time *timePtr); /* 13 */
         1855  +    int (*tcl_AppendAllObjTypes) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 14 */
         1856  +    void (*tcl_AppendStringsToObj) (Tcl_Obj *objPtr, ...); /* 15 */
         1857  +    void (*tcl_AppendToObj) (Tcl_Obj *objPtr, const char *bytes, int length); /* 16 */
         1858  +    Tcl_Obj * (*tcl_ConcatObj) (int objc, Tcl_Obj *const objv[]); /* 17 */
         1859  +    int (*tcl_ConvertToType) (Tcl_Interp *interp, Tcl_Obj *objPtr, const Tcl_ObjType *typePtr); /* 18 */
         1860  +    void (*tcl_DbDecrRefCount) (Tcl_Obj *objPtr, const char *file, int line); /* 19 */
         1861  +    void (*tcl_DbIncrRefCount) (Tcl_Obj *objPtr, const char *file, int line); /* 20 */
         1862  +    int (*tcl_DbIsShared) (Tcl_Obj *objPtr, const char *file, int line); /* 21 */
         1863  +    Tcl_Obj * (*tcl_DbNewBooleanObj) (int boolValue, const char *file, int line); /* 22 */
         1864  +    Tcl_Obj * (*tcl_DbNewByteArrayObj) (const unsigned char *bytes, int length, const char *file, int line); /* 23 */
         1865  +    Tcl_Obj * (*tcl_DbNewDoubleObj) (double doubleValue, const char *file, int line); /* 24 */
         1866  +    Tcl_Obj * (*tcl_DbNewListObj) (int objc, Tcl_Obj *const *objv, const char *file, int line); /* 25 */
         1867  +    Tcl_Obj * (*tcl_DbNewLongObj) (long longValue, const char *file, int line); /* 26 */
         1868  +    Tcl_Obj * (*tcl_DbNewObj) (const char *file, int line); /* 27 */
         1869  +    Tcl_Obj * (*tcl_DbNewStringObj) (const char *bytes, int length, const char *file, int line); /* 28 */
         1870  +    Tcl_Obj * (*tcl_DuplicateObj) (Tcl_Obj *objPtr); /* 29 */
         1871  +    void (*tclFreeObj) (Tcl_Obj *objPtr); /* 30 */
         1872  +    int (*tcl_GetBoolean) (Tcl_Interp *interp, const char *src, int *boolPtr); /* 31 */
         1873  +    int (*tcl_GetBooleanFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int *boolPtr); /* 32 */
         1874  +    unsigned char * (*tcl_GetByteArrayFromObj) (Tcl_Obj *objPtr, int *lengthPtr); /* 33 */
         1875  +    int (*tcl_GetDouble) (Tcl_Interp *interp, const char *src, double *doublePtr); /* 34 */
         1876  +    int (*tcl_GetDoubleFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, double *doublePtr); /* 35 */
         1877  +    int (*tcl_GetIndexFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, CONST84 char *const *tablePtr, const char *msg, int flags, int *indexPtr); /* 36 */
         1878  +    int (*tcl_GetInt) (Tcl_Interp *interp, const char *src, int *intPtr); /* 37 */
         1879  +    int (*tcl_GetIntFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int *intPtr); /* 38 */
         1880  +    int (*tcl_GetLongFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, long *longPtr); /* 39 */
         1881  +    CONST86 Tcl_ObjType * (*tcl_GetObjType) (const char *typeName); /* 40 */
         1882  +    char * (*tcl_GetStringFromObj) (Tcl_Obj *objPtr, int *lengthPtr); /* 41 */
         1883  +    void (*tcl_InvalidateStringRep) (Tcl_Obj *objPtr); /* 42 */
         1884  +    int (*tcl_ListObjAppendList) (Tcl_Interp *interp, Tcl_Obj *listPtr, Tcl_Obj *elemListPtr); /* 43 */
         1885  +    int (*tcl_ListObjAppendElement) (Tcl_Interp *interp, Tcl_Obj *listPtr, Tcl_Obj *objPtr); /* 44 */
         1886  +    int (*tcl_ListObjGetElements) (Tcl_Interp *interp, Tcl_Obj *listPtr, int *objcPtr, Tcl_Obj ***objvPtr); /* 45 */
         1887  +    int (*tcl_ListObjIndex) (Tcl_Interp *interp, Tcl_Obj *listPtr, int index, Tcl_Obj **objPtrPtr); /* 46 */
         1888  +    int (*tcl_ListObjLength) (Tcl_Interp *interp, Tcl_Obj *listPtr, int *lengthPtr); /* 47 */
         1889  +    int (*tcl_ListObjReplace) (Tcl_Interp *interp, Tcl_Obj *listPtr, int first, int count, int objc, Tcl_Obj *const objv[]); /* 48 */
         1890  +    Tcl_Obj * (*tcl_NewBooleanObj) (int boolValue); /* 49 */
         1891  +    Tcl_Obj * (*tcl_NewByteArrayObj) (const unsigned char *bytes, int length); /* 50 */
         1892  +    Tcl_Obj * (*tcl_NewDoubleObj) (double doubleValue); /* 51 */
         1893  +    Tcl_Obj * (*tcl_NewIntObj) (int intValue); /* 52 */
         1894  +    Tcl_Obj * (*tcl_NewListObj) (int objc, Tcl_Obj *const objv[]); /* 53 */
         1895  +    Tcl_Obj * (*tcl_NewLongObj) (long longValue); /* 54 */
         1896  +    Tcl_Obj * (*tcl_NewObj) (void); /* 55 */
         1897  +    Tcl_Obj * (*tcl_NewStringObj) (const char *bytes, int length); /* 56 */
         1898  +    void (*tcl_SetBooleanObj) (Tcl_Obj *objPtr, int boolValue); /* 57 */
         1899  +    unsigned char * (*tcl_SetByteArrayLength) (Tcl_Obj *objPtr, int length); /* 58 */
         1900  +    void (*tcl_SetByteArrayObj) (Tcl_Obj *objPtr, const unsigned char *bytes, int length); /* 59 */
         1901  +    void (*tcl_SetDoubleObj) (Tcl_Obj *objPtr, double doubleValue); /* 60 */
         1902  +    void (*tcl_SetIntObj) (Tcl_Obj *objPtr, int intValue); /* 61 */
         1903  +    void (*tcl_SetListObj) (Tcl_Obj *objPtr, int objc, Tcl_Obj *const objv[]); /* 62 */
         1904  +    void (*tcl_SetLongObj) (Tcl_Obj *objPtr, long longValue); /* 63 */
         1905  +    void (*tcl_SetObjLength) (Tcl_Obj *objPtr, int length); /* 64 */
         1906  +    void (*tcl_SetStringObj) (Tcl_Obj *objPtr, const char *bytes, int length); /* 65 */
         1907  +    void (*tcl_AddErrorInfo) (Tcl_Interp *interp, const char *message); /* 66 */
         1908  +    void (*tcl_AddObjErrorInfo) (Tcl_Interp *interp, const char *message, int length); /* 67 */
         1909  +    void (*tcl_AllowExceptions) (Tcl_Interp *interp); /* 68 */
         1910  +    void (*tcl_AppendElement) (Tcl_Interp *interp, const char *element); /* 69 */
         1911  +    void (*tcl_AppendResult) (Tcl_Interp *interp, ...); /* 70 */
         1912  +    Tcl_AsyncHandler (*tcl_AsyncCreate) (Tcl_AsyncProc *proc, ClientData clientData); /* 71 */
         1913  +    void (*tcl_AsyncDelete) (Tcl_AsyncHandler async); /* 72 */
         1914  +    int (*tcl_AsyncInvoke) (Tcl_Interp *interp, int code); /* 73 */
         1915  +    void (*tcl_AsyncMark) (Tcl_AsyncHandler async); /* 74 */
         1916  +    int (*tcl_AsyncReady) (void); /* 75 */
         1917  +    void (*tcl_BackgroundError) (Tcl_Interp *interp); /* 76 */
         1918  +    char (*tcl_Backslash) (const char *src, int *readPtr); /* 77 */
         1919  +    int (*tcl_BadChannelOption) (Tcl_Interp *interp, const char *optionName, const char *optionList); /* 78 */
         1920  +    void (*tcl_CallWhenDeleted) (Tcl_Interp *interp, Tcl_InterpDeleteProc *proc, ClientData clientData); /* 79 */
         1921  +    void (*tcl_CancelIdleCall) (Tcl_IdleProc *idleProc, ClientData clientData); /* 80 */
         1922  +    int (*tcl_Close) (Tcl_Interp *interp, Tcl_Channel chan); /* 81 */
         1923  +    int (*tcl_CommandComplete) (const char *cmd); /* 82 */
         1924  +    char * (*tcl_Concat) (int argc, CONST84 char *const *argv); /* 83 */
         1925  +    int (*tcl_ConvertElement) (const char *src, char *dst, int flags); /* 84 */
         1926  +    int (*tcl_ConvertCountedElement) (const char *src, int length, char *dst, int flags); /* 85 */
         1927  +    int (*tcl_CreateAlias) (Tcl_Interp *slave, const char *slaveCmd, Tcl_Interp *target, const char *targetCmd, int argc, CONST84 char *const *argv); /* 86 */
         1928  +    int (*tcl_CreateAliasObj) (Tcl_Interp *slave, const char *slaveCmd, Tcl_Interp *target, const char *targetCmd, int objc, Tcl_Obj *const objv[]); /* 87 */
         1929  +    Tcl_Channel (*tcl_CreateChannel) (const Tcl_ChannelType *typePtr, const char *chanName, ClientData instanceData, int mask); /* 88 */
         1930  +    void (*tcl_CreateChannelHandler) (Tcl_Channel chan, int mask, Tcl_ChannelProc *proc, ClientData clientData); /* 89 */
         1931  +    void (*tcl_CreateCloseHandler) (Tcl_Channel chan, Tcl_CloseProc *proc, ClientData clientData); /* 90 */
         1932  +    Tcl_Command (*tcl_CreateCommand) (Tcl_Interp *interp, const char *cmdName, Tcl_CmdProc *proc, ClientData clientData, Tcl_CmdDeleteProc *deleteProc); /* 91 */
         1933  +    void (*tcl_CreateEventSource) (Tcl_EventSetupProc *setupProc, Tcl_EventCheckProc *checkProc, ClientData clientData); /* 92 */
         1934  +    void (*tcl_CreateExitHandler) (Tcl_ExitProc *proc, ClientData clientData); /* 93 */
         1935  +    Tcl_Interp * (*tcl_CreateInterp) (void); /* 94 */
         1936  +    void (*tcl_CreateMathFunc) (Tcl_Interp *interp, const char *name, int numArgs, Tcl_ValueType *argTypes, Tcl_MathProc *proc, ClientData clientData); /* 95 */
         1937  +    Tcl_Command (*tcl_CreateObjCommand) (Tcl_Interp *interp, const char *cmdName, Tcl_ObjCmdProc *proc, ClientData clientData, Tcl_CmdDeleteProc *deleteProc); /* 96 */
         1938  +    Tcl_Interp * (*tcl_CreateSlave) (Tcl_Interp *interp, const char *slaveName, int isSafe); /* 97 */
         1939  +    Tcl_TimerToken (*tcl_CreateTimerHandler) (int milliseconds, Tcl_TimerProc *proc, ClientData clientData); /* 98 */
         1940  +    Tcl_Trace (*tcl_CreateTrace) (Tcl_Interp *interp, int level, Tcl_CmdTraceProc *proc, ClientData clientData); /* 99 */
         1941  +    void (*tcl_DeleteAssocData) (Tcl_Interp *interp, const char *name); /* 100 */
         1942  +    void (*tcl_DeleteChannelHandler) (Tcl_Channel chan, Tcl_ChannelProc *proc, ClientData clientData); /* 101 */
         1943  +    void (*tcl_DeleteCloseHandler) (Tcl_Channel chan, Tcl_CloseProc *proc, ClientData clientData); /* 102 */
         1944  +    int (*tcl_DeleteCommand) (Tcl_Interp *interp, const char *cmdName); /* 103 */
         1945  +    int (*tcl_DeleteCommandFromToken) (Tcl_Interp *interp, Tcl_Command command); /* 104 */
         1946  +    void (*tcl_DeleteEvents) (Tcl_EventDeleteProc *proc, ClientData clientData); /* 105 */
         1947  +    void (*tcl_DeleteEventSource) (Tcl_EventSetupProc *setupProc, Tcl_EventCheckProc *checkProc, ClientData clientData); /* 106 */
         1948  +    void (*tcl_DeleteExitHandler) (Tcl_ExitProc *proc, ClientData clientData); /* 107 */
         1949  +    void (*tcl_DeleteHashEntry) (Tcl_HashEntry *entryPtr); /* 108 */
         1950  +    void (*tcl_DeleteHashTable) (Tcl_HashTable *tablePtr); /* 109 */
         1951  +    void (*tcl_DeleteInterp) (Tcl_Interp *interp); /* 110 */
         1952  +    void (*tcl_DetachPids) (int numPids, Tcl_Pid *pidPtr); /* 111 */
         1953  +    void (*tcl_DeleteTimerHandler) (Tcl_TimerToken token); /* 112 */
         1954  +    void (*tcl_DeleteTrace) (Tcl_Interp *interp, Tcl_Trace trace); /* 113 */
         1955  +    void (*tcl_DontCallWhenDeleted) (Tcl_Interp *interp, Tcl_InterpDeleteProc *proc, ClientData clientData); /* 114 */
         1956  +    int (*tcl_DoOneEvent) (int flags); /* 115 */
         1957  +    void (*tcl_DoWhenIdle) (Tcl_IdleProc *proc, ClientData clientData); /* 116 */
         1958  +    char * (*tcl_DStringAppend) (Tcl_DString *dsPtr, const char *bytes, int length); /* 117 */
         1959  +    char * (*tcl_DStringAppendElement) (Tcl_DString *dsPtr, const char *element); /* 118 */
         1960  +    void (*tcl_DStringEndSublist) (Tcl_DString *dsPtr); /* 119 */
         1961  +    void (*tcl_DStringFree) (Tcl_DString *dsPtr); /* 120 */
         1962  +    void (*tcl_DStringGetResult) (Tcl_Interp *interp, Tcl_DString *dsPtr); /* 121 */
         1963  +    void (*tcl_DStringInit) (Tcl_DString *dsPtr); /* 122 */
         1964  +    void (*tcl_DStringResult) (Tcl_Interp *interp, Tcl_DString *dsPtr); /* 123 */
         1965  +    void (*tcl_DStringSetLength) (Tcl_DString *dsPtr, int length); /* 124 */
         1966  +    void (*tcl_DStringStartSublist) (Tcl_DString *dsPtr); /* 125 */
         1967  +    int (*tcl_Eof) (Tcl_Channel chan); /* 126 */
         1968  +    CONST84_RETURN char * (*tcl_ErrnoId) (void); /* 127 */
         1969  +    CONST84_RETURN char * (*tcl_ErrnoMsg) (int err); /* 128 */
         1970  +    int (*tcl_Eval) (Tcl_Interp *interp, const char *script); /* 129 */
         1971  +    int (*tcl_EvalFile) (Tcl_Interp *interp, const char *fileName); /* 130 */
         1972  +    int (*tcl_EvalObj) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 131 */
         1973  +    void (*tcl_EventuallyFree) (ClientData clientData, Tcl_FreeProc *freeProc); /* 132 */
         1974  +    void (*tcl_Exit) (int status); /* 133 */
         1975  +    int (*tcl_ExposeCommand) (Tcl_Interp *interp, const char *hiddenCmdToken, const char *cmdName); /* 134 */
         1976  +    int (*tcl_ExprBoolean) (Tcl_Interp *interp, const char *expr, int *ptr); /* 135 */
         1977  +    int (*tcl_ExprBooleanObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int *ptr); /* 136 */
         1978  +    int (*tcl_ExprDouble) (Tcl_Interp *interp, const char *expr, double *ptr); /* 137 */
         1979  +    int (*tcl_ExprDoubleObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, double *ptr); /* 138 */
         1980  +    int (*tcl_ExprLong) (Tcl_Interp *interp, const char *expr, long *ptr); /* 139 */
         1981  +    int (*tcl_ExprLongObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, long *ptr); /* 140 */
         1982  +    int (*tcl_ExprObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_Obj **resultPtrPtr); /* 141 */
         1983  +    int (*tcl_ExprString) (Tcl_Interp *interp, const char *expr); /* 142 */
         1984  +    void (*tcl_Finalize) (void); /* 143 */
         1985  +    void (*tcl_FindExecutable) (const char *argv0); /* 144 */
         1986  +    Tcl_HashEntry * (*tcl_FirstHashEntry) (Tcl_HashTable *tablePtr, Tcl_HashSearch *searchPtr); /* 145 */
         1987  +    int (*tcl_Flush) (Tcl_Channel chan); /* 146 */
         1988  +    void (*tcl_FreeResult) (Tcl_Interp *interp); /* 147 */
         1989  +    int (*tcl_GetAlias) (Tcl_Interp *interp, const char *slaveCmd, Tcl_Interp **targetInterpPtr, CONST84 char **targetCmdPtr, int *argcPtr, CONST84 char ***argvPtr); /* 148 */
         1990  +    int (*tcl_GetAliasObj) (Tcl_Interp *interp, const char *slaveCmd, Tcl_Interp **targetInterpPtr, CONST84 char **targetCmdPtr, int *objcPtr, Tcl_Obj ***objv); /* 149 */
         1991  +    ClientData (*tcl_GetAssocData) (Tcl_Interp *interp, const char *name, Tcl_InterpDeleteProc **procPtr); /* 150 */
         1992  +    Tcl_Channel (*tcl_GetChannel) (Tcl_Interp *interp, const char *chanName, int *modePtr); /* 151 */
         1993  +    int (*tcl_GetChannelBufferSize) (Tcl_Channel chan); /* 152 */
         1994  +    int (*tcl_GetChannelHandle) (Tcl_Channel chan, int direction, ClientData *handlePtr); /* 153 */
         1995  +    ClientData (*tcl_GetChannelInstanceData) (Tcl_Channel chan); /* 154 */
         1996  +    int (*tcl_GetChannelMode) (Tcl_Channel chan); /* 155 */
         1997  +    CONST84_RETURN char * (*tcl_GetChannelName) (Tcl_Channel chan); /* 156 */
         1998  +    int (*tcl_GetChannelOption) (Tcl_Interp *interp, Tcl_Channel chan, const char *optionName, Tcl_DString *dsPtr); /* 157 */
         1999  +    CONST86 Tcl_ChannelType * (*tcl_GetChannelType) (Tcl_Channel chan); /* 158 */
         2000  +    int (*tcl_GetCommandInfo) (Tcl_Interp *interp, const char *cmdName, Tcl_CmdInfo *infoPtr); /* 159 */
         2001  +    CONST84_RETURN char * (*tcl_GetCommandName) (Tcl_Interp *interp, Tcl_Command command); /* 160 */
         2002  +    int (*tcl_GetErrno) (void); /* 161 */
         2003  +    CONST84_RETURN char * (*tcl_GetHostName) (void); /* 162 */
         2004  +    int (*tcl_GetInterpPath) (Tcl_Interp *askInterp, Tcl_Interp *slaveInterp); /* 163 */
         2005  +    Tcl_Interp * (*tcl_GetMaster) (Tcl_Interp *interp); /* 164 */
         2006  +    const char * (*tcl_GetNameOfExecutable) (void); /* 165 */
         2007  +    Tcl_Obj * (*tcl_GetObjResult) (Tcl_Interp *interp); /* 166 */
         2008  +#if !defined(__WIN32__) && !defined(MAC_OSX_TCL) /* UNIX */
         2009  +    int (*tcl_GetOpenFile) (Tcl_Interp *interp, const char *chanID, int forWriting, int checkUsage, ClientData *filePtr); /* 167 */
         2010  +#endif /* UNIX */
         2011  +#if defined(__WIN32__) /* WIN */
         2012  +    void (*reserved167)(void);
         2013  +#endif /* WIN */
         2014  +#ifdef MAC_OSX_TCL /* MACOSX */
         2015  +    int (*tcl_GetOpenFile) (Tcl_Interp *interp, const char *chanID, int forWriting, int checkUsage, ClientData *filePtr); /* 167 */
         2016  +#endif /* MACOSX */
         2017  +    Tcl_PathType (*tcl_GetPathType) (const char *path); /* 168 */
         2018  +    int (*tcl_Gets) (Tcl_Channel chan, Tcl_DString *dsPtr); /* 169 */
         2019  +    int (*tcl_GetsObj) (Tcl_Channel chan, Tcl_Obj *objPtr); /* 170 */
         2020  +    int (*tcl_GetServiceMode) (void); /* 171 */
         2021  +    Tcl_Interp * (*tcl_GetSlave) (Tcl_Interp *interp, const char *slaveName); /* 172 */
         2022  +    Tcl_Channel (*tcl_GetStdChannel) (int type); /* 173 */
         2023  +    CONST84_RETURN char * (*tcl_GetStringResult) (Tcl_Interp *interp); /* 174 */
         2024  +    CONST84_RETURN char * (*tcl_GetVar) (Tcl_Interp *interp, const char *varName, int flags); /* 175 */
         2025  +    CONST84_RETURN char * (*tcl_GetVar2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags); /* 176 */
         2026  +    int (*tcl_GlobalEval) (Tcl_Interp *interp, const char *command); /* 177 */
         2027  +    int (*tcl_GlobalEvalObj) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 178 */
         2028  +    int (*tcl_HideCommand) (Tcl_Interp *interp, const char *cmdName, const char *hiddenCmdToken); /* 179 */
         2029  +    int (*tcl_Init) (Tcl_Interp *interp); /* 180 */
         2030  +    void (*tcl_InitHashTable) (Tcl_HashTable *tablePtr, int keyType); /* 181 */
         2031  +    int (*tcl_InputBlocked) (Tcl_Channel chan); /* 182 */
         2032  +    int (*tcl_InputBuffered) (Tcl_Channel chan); /* 183 */
         2033  +    int (*tcl_InterpDeleted) (Tcl_Interp *interp); /* 184 */
         2034  +    int (*tcl_IsSafe) (Tcl_Interp *interp); /* 185 */
         2035  +    char * (*tcl_JoinPath) (int argc, CONST84 char *const *argv, Tcl_DString *resultPtr); /* 186 */
         2036  +    int (*tcl_LinkVar) (Tcl_Interp *interp, const char *varName, char *addr, int type); /* 187 */
         2037  +    void (*reserved188)(void);
         2038  +    Tcl_Channel (*tcl_MakeFileChannel) (ClientData handle, int mode); /* 189 */
         2039  +    int (*tcl_MakeSafe) (Tcl_Interp *interp); /* 190 */
         2040  +    Tcl_Channel (*tcl_MakeTcpClientChannel) (ClientData tcpSocket); /* 191 */
         2041  +    char * (*tcl_Merge) (int argc, CONST84 char *const *argv); /* 192 */
         2042  +    Tcl_HashEntry * (*tcl_NextHashEntry) (Tcl_HashSearch *searchPtr); /* 193 */
         2043  +    void (*tcl_NotifyChannel) (Tcl_Channel channel, int mask); /* 194 */
         2044  +    Tcl_Obj * (*tcl_ObjGetVar2) (Tcl_Interp *interp, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, int flags); /* 195 */
         2045  +    Tcl_Obj * (*tcl_ObjSetVar2) (Tcl_Interp *interp, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr, int flags); /* 196 */
         2046  +    Tcl_Channel (*tcl_OpenCommandChannel) (Tcl_Interp *interp, int argc, CONST84 char **argv, int flags); /* 197 */
         2047  +    Tcl_Channel (*tcl_OpenFileChannel) (Tcl_Interp *interp, const char *fileName, const char *modeString, int permissions); /* 198 */
         2048  +    Tcl_Channel (*tcl_OpenTcpClient) (Tcl_Interp *interp, int port, const char *address, const char *myaddr, int myport, int async); /* 199 */
         2049  +    Tcl_Channel (*tcl_OpenTcpServer) (Tcl_Interp *interp, int port, const char *host, Tcl_TcpAcceptProc *acceptProc, ClientData callbackData); /* 200 */
         2050  +    void (*tcl_Preserve) (ClientData data); /* 201 */
         2051  +    void (*tcl_PrintDouble) (Tcl_Interp *interp, double value, char *dst); /* 202 */
         2052  +    int (*tcl_PutEnv) (const char *assignment); /* 203 */
         2053  +    CONST84_RETURN char * (*tcl_PosixError) (Tcl_Interp *interp); /* 204 */
         2054  +    void (*tcl_QueueEvent) (Tcl_Event *evPtr, Tcl_QueuePosition position); /* 205 */
         2055  +    int (*tcl_Read) (Tcl_Channel chan, char *bufPtr, int toRead); /* 206 */
         2056  +    void (*tcl_ReapDetachedProcs) (void); /* 207 */
         2057  +    int (*tcl_RecordAndEval) (Tcl_Interp *interp, const char *cmd, int flags); /* 208 */
         2058  +    int (*tcl_RecordAndEvalObj) (Tcl_Interp *interp, Tcl_Obj *cmdPtr, int flags); /* 209 */
         2059  +    void (*tcl_RegisterChannel) (Tcl_Interp *interp, Tcl_Channel chan); /* 210 */
         2060  +    void (*tcl_RegisterObjType) (const Tcl_ObjType *typePtr); /* 211 */
         2061  +    Tcl_RegExp (*tcl_RegExpCompile) (Tcl_Interp *interp, const char *pattern); /* 212 */
         2062  +    int (*tcl_RegExpExec) (Tcl_Interp *interp, Tcl_RegExp regexp, const char *text, const char *start); /* 213 */
         2063  +    int (*tcl_RegExpMatch) (Tcl_Interp *interp, const char *text, const char *pattern); /* 214 */
         2064  +    void (*tcl_RegExpRange) (Tcl_RegExp regexp, int index, CONST84 char **startPtr, CONST84 char **endPtr); /* 215 */
         2065  +    void (*tcl_Release) (ClientData clientData); /* 216 */
         2066  +    void (*tcl_ResetResult) (Tcl_Interp *interp); /* 217 */
         2067  +    int (*tcl_ScanElement) (const char *src, int *flagPtr); /* 218 */
         2068  +    int (*tcl_ScanCountedElement) (const char *src, int length, int *flagPtr); /* 219 */
         2069  +    int (*tcl_SeekOld) (Tcl_Channel chan, int offset, int mode); /* 220 */
         2070  +    int (*tcl_ServiceAll) (void); /* 221 */
         2071  +    int (*tcl_ServiceEvent) (int flags); /* 222 */
         2072  +    void (*tcl_SetAssocData) (Tcl_Interp *interp, const char *name, Tcl_InterpDeleteProc *proc, ClientData clientData); /* 223 */
         2073  +    void (*tcl_SetChannelBufferSize) (Tcl_Channel chan, int sz); /* 224 */
         2074  +    int (*tcl_SetChannelOption) (Tcl_Interp *interp, Tcl_Channel chan, const char *optionName, const char *newValue); /* 225 */
         2075  +    int (*tcl_SetCommandInfo) (Tcl_Interp *interp, const char *cmdName, const Tcl_CmdInfo *infoPtr); /* 226 */
         2076  +    void (*tcl_SetErrno) (int err); /* 227 */
         2077  +    void (*tcl_SetErrorCode) (Tcl_Interp *interp, ...); /* 228 */
         2078  +    void (*tcl_SetMaxBlockTime) (const Tcl_Time *timePtr); /* 229 */
         2079  +    void (*tcl_SetPanicProc) (Tcl_PanicProc *panicProc); /* 230 */
         2080  +    int (*tcl_SetRecursionLimit) (Tcl_Interp *interp, int depth); /* 231 */
         2081  +    void (*tcl_SetResult) (Tcl_Interp *interp, char *result, Tcl_FreeProc *freeProc); /* 232 */
         2082  +    int (*tcl_SetServiceMode) (int mode); /* 233 */
         2083  +    void (*tcl_SetObjErrorCode) (Tcl_Interp *interp, Tcl_Obj *errorObjPtr); /* 234 */
         2084  +    void (*tcl_SetObjResult) (Tcl_Interp *interp, Tcl_Obj *resultObjPtr); /* 235 */
         2085  +    void (*tcl_SetStdChannel) (Tcl_Channel channel, int type); /* 236 */
         2086  +    CONST84_RETURN char * (*tcl_SetVar) (Tcl_Interp *interp, const char *varName, const char *newValue, int flags); /* 237 */
         2087  +    CONST84_RETURN char * (*tcl_SetVar2) (Tcl_Interp *interp, const char *part1, const char *part2, const char *newValue, int flags); /* 238 */
         2088  +    CONST84_RETURN char * (*tcl_SignalId) (int sig); /* 239 */
         2089  +    CONST84_RETURN char * (*tcl_SignalMsg) (int sig); /* 240 */
         2090  +    void (*tcl_SourceRCFile) (Tcl_Interp *interp); /* 241 */
         2091  +    int (*tcl_SplitList) (Tcl_Interp *interp, const char *listStr, int *argcPtr, CONST84 char ***argvPtr); /* 242 */
         2092  +    void (*tcl_SplitPath) (const char *path, int *argcPtr, CONST84 char ***argvPtr); /* 243 */
         2093  +    void (*tcl_StaticPackage) (Tcl_Interp *interp, const char *pkgName, Tcl_PackageInitProc *initProc, Tcl_PackageInitProc *safeInitProc); /* 244 */
         2094  +    int (*tcl_StringMatch) (const char *str, const char *pattern); /* 245 */
         2095  +    int (*tcl_TellOld) (Tcl_Channel chan); /* 246 */
         2096  +    int (*tcl_TraceVar) (Tcl_Interp *interp, const char *varName, int flags, Tcl_VarTraceProc *proc, ClientData clientData); /* 247 */
         2097  +    int (*tcl_TraceVar2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, Tcl_VarTraceProc *proc, ClientData clientData); /* 248 */
         2098  +    char * (*tcl_TranslateFileName) (Tcl_Interp *interp, const char *name, Tcl_DString *bufferPtr); /* 249 */
         2099  +    int (*tcl_Ungets) (Tcl_Channel chan, const char *str, int len, int atHead); /* 250 */
         2100  +    void (*tcl_UnlinkVar) (Tcl_Interp *interp, const char *varName); /* 251 */
         2101  +    int (*tcl_UnregisterChannel) (Tcl_Interp *interp, Tcl_Channel chan); /* 252 */
         2102  +    int (*tcl_UnsetVar) (Tcl_Interp *interp, const char *varName, int flags); /* 253 */
         2103  +    int (*tcl_UnsetVar2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags); /* 254 */
         2104  +    void (*tcl_UntraceVar) (Tcl_Interp *interp, const char *varName, int flags, Tcl_VarTraceProc *proc, ClientData clientData); /* 255 */
         2105  +    void (*tcl_UntraceVar2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, Tcl_VarTraceProc *proc, ClientData clientData); /* 256 */
         2106  +    void (*tcl_UpdateLinkedVar) (Tcl_Interp *interp, const char *varName); /* 257 */
         2107  +    int (*tcl_UpVar) (Tcl_Interp *interp, const char *frameName, const char *varName, const char *localName, int flags); /* 258 */
         2108  +    int (*tcl_UpVar2) (Tcl_Interp *interp, const char *frameName, const char *part1, const char *part2, const char *localName, int flags); /* 259 */
         2109  +    int (*tcl_VarEval) (Tcl_Interp *interp, ...); /* 260 */
         2110  +    ClientData (*tcl_VarTraceInfo) (Tcl_Interp *interp, const char *varName, int flags, Tcl_VarTraceProc *procPtr, ClientData prevClientData); /* 261 */
         2111  +    ClientData (*tcl_VarTraceInfo2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, Tcl_VarTraceProc *procPtr, ClientData prevClientData); /* 262 */
         2112  +    int (*tcl_Write) (Tcl_Channel chan, const char *s, int slen); /* 263 */
         2113  +    void (*tcl_WrongNumArgs) (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], const char *message); /* 264 */
         2114  +    int (*tcl_DumpActiveMemory) (const char *fileName); /* 265 */
         2115  +    void (*tcl_ValidateAllMemory) (const char *file, int line); /* 266 */
         2116  +    void (*tcl_AppendResultVA) (Tcl_Interp *interp, va_list argList); /* 267 */
         2117  +    void (*tcl_AppendStringsToObjVA) (Tcl_Obj *objPtr, va_list argList); /* 268 */
         2118  +    char * (*tcl_HashStats) (Tcl_HashTable *tablePtr); /* 269 */
         2119  +    CONST84_RETURN char * (*tcl_ParseVar) (Tcl_Interp *interp, const char *start, CONST84 char **termPtr); /* 270 */
         2120  +    CONST84_RETURN char * (*tcl_PkgPresent) (Tcl_Interp *interp, const char *name, const char *version, int exact); /* 271 */
         2121  +    CONST84_RETURN char * (*tcl_PkgPresentEx) (Tcl_Interp *interp, const char *name, const char *version, int exact, void *clientDataPtr); /* 272 */
         2122  +    int (*tcl_PkgProvide) (Tcl_Interp *interp, const char *name, const char *version); /* 273 */
         2123  +    CONST84_RETURN char * (*tcl_PkgRequire) (Tcl_Interp *interp, const char *name, const char *version, int exact); /* 274 */
         2124  +    void (*tcl_SetErrorCodeVA) (Tcl_Interp *interp, va_list argList); /* 275 */
         2125  +    int (*tcl_VarEvalVA) (Tcl_Interp *interp, va_list argList); /* 276 */
         2126  +    Tcl_Pid (*tcl_WaitPid) (Tcl_Pid pid, int *statPtr, int options); /* 277 */
         2127  +    void (*tcl_PanicVA) (const char *format, va_list argList); /* 278 */
         2128  +    void (*tcl_GetVersion) (int *major, int *minor, int *patchLevel, int *type); /* 279 */
         2129  +    void (*tcl_InitMemory) (Tcl_Interp *interp); /* 280 */
         2130  +    Tcl_Channel (*tcl_StackChannel) (Tcl_Interp *interp, const Tcl_ChannelType *typePtr, ClientData instanceData, int mask, Tcl_Channel prevChan); /* 281 */
         2131  +    int (*tcl_UnstackChannel) (Tcl_Interp *interp, Tcl_Channel chan); /* 282 */
         2132  +    Tcl_Channel (*tcl_GetStackedChannel) (Tcl_Channel chan); /* 283 */
         2133  +    void (*tcl_SetMainLoop) (Tcl_MainLoopProc *proc); /* 284 */
         2134  +    void (*reserved285)(void);
         2135  +    void (*tcl_AppendObjToObj) (Tcl_Obj *objPtr, Tcl_Obj *appendObjPtr); /* 286 */
         2136  +    Tcl_Encoding (*tcl_CreateEncoding) (const Tcl_EncodingType *typePtr); /* 287 */
         2137  +    void (*tcl_CreateThreadExitHandler) (Tcl_ExitProc *proc, ClientData clientData); /* 288 */
         2138  +    void (*tcl_DeleteThreadExitHandler) (Tcl_ExitProc *proc, ClientData clientData); /* 289 */
         2139  +    void (*tcl_DiscardResult) (Tcl_SavedResult *statePtr); /* 290 */
         2140  +    int (*tcl_EvalEx) (Tcl_Interp *interp, const char *script, int numBytes, int flags); /* 291 */
         2141  +    int (*tcl_EvalObjv) (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], int flags); /* 292 */
         2142  +    int (*tcl_EvalObjEx) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags); /* 293 */
         2143  +    void (*tcl_ExitThread) (int status); /* 294 */
         2144  +    int (*tcl_ExternalToUtf) (Tcl_Interp *interp, Tcl_Encoding encoding, const char *src, int srcLen, int flags, Tcl_EncodingState *statePtr, char *dst, int dstLen, int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr); /* 295 */
         2145  +    char * (*tcl_ExternalToUtfDString) (Tcl_Encoding encoding, const char *src, int srcLen, Tcl_DString *dsPtr); /* 296 */
         2146  +    void (*tcl_FinalizeThread) (void); /* 297 */
         2147  +    void (*tcl_FinalizeNotifier) (ClientData clientData); /* 298 */
         2148  +    void (*tcl_FreeEncoding) (Tcl_Encoding encoding); /* 299 */
         2149  +    Tcl_ThreadId (*tcl_GetCurrentThread) (void); /* 300 */
         2150  +    Tcl_Encoding (*tcl_GetEncoding) (Tcl_Interp *interp, const char *name); /* 301 */
         2151  +    CONST84_RETURN char * (*tcl_GetEncodingName) (Tcl_Encoding encoding); /* 302 */
         2152  +    void (*tcl_GetEncodingNames) (Tcl_Interp *interp); /* 303 */
         2153  +    int (*tcl_GetIndexFromObjStruct) (Tcl_Interp *interp, Tcl_Obj *objPtr, const void *tablePtr, int offset, const char *msg, int flags, int *indexPtr); /* 304 */
         2154  +    void * (*tcl_GetThreadData) (Tcl_ThreadDataKey *keyPtr, int size); /* 305 */
         2155  +    Tcl_Obj * (*tcl_GetVar2Ex) (Tcl_Interp *interp, const char *part1, const char *part2, int flags); /* 306 */
         2156  +    ClientData (*tcl_InitNotifier) (void); /* 307 */
         2157  +    void (*tcl_MutexLock) (Tcl_Mutex *mutexPtr); /* 308 */
         2158  +    void (*tcl_MutexUnlock) (Tcl_Mutex *mutexPtr); /* 309 */
         2159  +    void (*tcl_ConditionNotify) (Tcl_Condition *condPtr); /* 310 */
         2160  +    void (*tcl_ConditionWait) (Tcl_Condition *condPtr, Tcl_Mutex *mutexPtr, const Tcl_Time *timePtr); /* 311 */
         2161  +    int (*tcl_NumUtfChars) (const char *src, int length); /* 312 */
         2162  +    int (*tcl_ReadChars) (Tcl_Channel channel, Tcl_Obj *objPtr, int charsToRead, int appendFlag); /* 313 */
         2163  +    void (*tcl_RestoreResult) (Tcl_Interp *interp, Tcl_SavedResult *statePtr); /* 314 */
         2164  +    void (*tcl_SaveResult) (Tcl_Interp *interp, Tcl_SavedResult *statePtr); /* 315 */
         2165  +    int (*tcl_SetSystemEncoding) (Tcl_Interp *interp, const char *name); /* 316 */
         2166  +    Tcl_Obj * (*tcl_SetVar2Ex) (Tcl_Interp *interp, const char *part1, const char *part2, Tcl_Obj *newValuePtr, int flags); /* 317 */
         2167  +    void (*tcl_ThreadAlert) (Tcl_ThreadId threadId); /* 318 */
         2168  +    void (*tcl_ThreadQueueEvent) (Tcl_ThreadId threadId, Tcl_Event *evPtr, Tcl_QueuePosition position); /* 319 */
         2169  +    Tcl_UniChar (*tcl_UniCharAtIndex) (const char *src, int index); /* 320 */
         2170  +    Tcl_UniChar (*tcl_UniCharToLower) (int ch); /* 321 */
         2171  +    Tcl_UniChar (*tcl_UniCharToTitle) (int ch); /* 322 */
         2172  +    Tcl_UniChar (*tcl_UniCharToUpper) (int ch); /* 323 */
         2173  +    int (*tcl_UniCharToUtf) (int ch, char *buf); /* 324 */
         2174  +    CONST84_RETURN char * (*tcl_UtfAtIndex) (const char *src, int index); /* 325 */
         2175  +    int (*tcl_UtfCharComplete) (const char *src, int length); /* 326 */
         2176  +    int (*tcl_UtfBackslash) (const char *src, int *readPtr, char *dst); /* 327 */
         2177  +    CONST84_RETURN char * (*tcl_UtfFindFirst) (const char *src, int ch); /* 328 */
         2178  +    CONST84_RETURN char * (*tcl_UtfFindLast) (const char *src, int ch); /* 329 */
         2179  +    CONST84_RETURN char * (*tcl_UtfNext) (const char *src); /* 330 */
         2180  +    CONST84_RETURN char * (*tcl_UtfPrev) (const char *src, const char *start); /* 331 */
         2181  +    int (*tcl_UtfToExternal) (Tcl_Interp *interp, Tcl_Encoding encoding, const char *src, int srcLen, int flags, Tcl_EncodingState *statePtr, char *dst, int dstLen, int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr); /* 332 */
         2182  +    char * (*tcl_UtfToExternalDString) (Tcl_Encoding encoding, const char *src, int srcLen, Tcl_DString *dsPtr); /* 333 */
         2183  +    int (*tcl_UtfToLower) (char *src); /* 334 */
         2184  +    int (*tcl_UtfToTitle) (char *src); /* 335 */
         2185  +    int (*tcl_UtfToUniChar) (const char *src, Tcl_UniChar *chPtr); /* 336 */
         2186  +    int (*tcl_UtfToUpper) (char *src); /* 337 */
         2187  +    int (*tcl_WriteChars) (Tcl_Channel chan, const char *src, int srcLen); /* 338 */
         2188  +    int (*tcl_WriteObj) (Tcl_Channel chan, Tcl_Obj *objPtr); /* 339 */
         2189  +    char * (*tcl_GetString) (Tcl_Obj *objPtr); /* 340 */
         2190  +    CONST84_RETURN char * (*tcl_GetDefaultEncodingDir) (void); /* 341 */
         2191  +    void (*tcl_SetDefaultEncodingDir) (const char *path); /* 342 */
         2192  +    void (*tcl_AlertNotifier) (ClientData clientData); /* 343 */
         2193  +    void (*tcl_ServiceModeHook) (int mode); /* 344 */
         2194  +    int (*tcl_UniCharIsAlnum) (int ch); /* 345 */
         2195  +    int (*tcl_UniCharIsAlpha) (int ch); /* 346 */
         2196  +    int (*tcl_UniCharIsDigit) (int ch); /* 347 */
         2197  +    int (*tcl_UniCharIsLower) (int ch); /* 348 */
         2198  +    int (*tcl_UniCharIsSpace) (int ch); /* 349 */
         2199  +    int (*tcl_UniCharIsUpper) (int ch); /* 350 */
         2200  +    int (*tcl_UniCharIsWordChar) (int ch); /* 351 */
         2201  +    int (*tcl_UniCharLen) (const Tcl_UniChar *uniStr); /* 352 */
         2202  +    int (*tcl_UniCharNcmp) (const Tcl_UniChar *ucs, const Tcl_UniChar *uct, unsigned long numChars); /* 353 */
         2203  +    char * (*tcl_UniCharToUtfDString) (const Tcl_UniChar *uniStr, int uniLength, Tcl_DString *dsPtr); /* 354 */
         2204  +    Tcl_UniChar * (*tcl_UtfToUniCharDString) (const char *src, int length, Tcl_DString *dsPtr); /* 355 */
         2205  +    Tcl_RegExp (*tcl_GetRegExpFromObj) (Tcl_Interp *interp, Tcl_Obj *patObj, int flags); /* 356 */
         2206  +    Tcl_Obj * (*tcl_EvalTokens) (Tcl_Interp *interp, Tcl_Token *tokenPtr, int count); /* 357 */
         2207  +    void (*tcl_FreeParse) (Tcl_Parse *parsePtr); /* 358 */
         2208  +    void (*tcl_LogCommandInfo) (Tcl_Interp *interp, const char *script, const char *command, int length); /* 359 */
         2209  +    int (*tcl_ParseBraces) (Tcl_Interp *interp, const char *start, int numBytes, Tcl_Parse *parsePtr, int append, CONST84 char **termPtr); /* 360 */
         2210  +    int (*tcl_ParseCommand) (Tcl_Interp *interp, const char *start, int numBytes, int nested, Tcl_Parse *parsePtr); /* 361 */
         2211  +    int (*tcl_ParseExpr) (Tcl_Interp *interp, const char *start, int numBytes, Tcl_Parse *parsePtr); /* 362 */
         2212  +    int (*tcl_ParseQuotedString) (Tcl_Interp *interp, const char *start, int numBytes, Tcl_Parse *parsePtr, int append, CONST84 char **termPtr); /* 363 */
         2213  +    int (*tcl_ParseVarName) (Tcl_Interp *interp, const char *start, int numBytes, Tcl_Parse *parsePtr, int append); /* 364 */
         2214  +    char * (*tcl_GetCwd) (Tcl_Interp *interp, Tcl_DString *cwdPtr); /* 365 */
         2215  +    int (*tcl_Chdir) (const char *dirName); /* 366 */
         2216  +    int (*tcl_Access) (const char *path, int mode); /* 367 */
         2217  +    int (*tcl_Stat) (const char *path, struct stat *bufPtr); /* 368 */
         2218  +    int (*tcl_UtfNcmp) (const char *s1, const char *s2, unsigned long n); /* 369 */
         2219  +    int (*tcl_UtfNcasecmp) (const char *s1, const char *s2, unsigned long n); /* 370 */
         2220  +    int (*tcl_StringCaseMatch) (const char *str, const char *pattern, int nocase); /* 371 */
         2221  +    int (*tcl_UniCharIsControl) (int ch); /* 372 */
         2222  +    int (*tcl_UniCharIsGraph) (int ch); /* 373 */
         2223  +    int (*tcl_UniCharIsPrint) (int ch); /* 374 */
         2224  +    int (*tcl_UniCharIsPunct) (int ch); /* 375 */
         2225  +    int (*tcl_RegExpExecObj) (Tcl_Interp *interp, Tcl_RegExp regexp, Tcl_Obj *textObj, int offset, int nmatches, int flags); /* 376 */
         2226  +    void (*tcl_RegExpGetInfo) (Tcl_RegExp regexp, Tcl_RegExpInfo *infoPtr); /* 377 */
         2227  +    Tcl_Obj * (*tcl_NewUnicodeObj) (const Tcl_UniChar *unicode, int numChars); /* 378 */
         2228  +    void (*tcl_SetUnicodeObj) (Tcl_Obj *objPtr, const Tcl_UniChar *unicode, int numChars); /* 379 */
         2229  +    int (*tcl_GetCharLength) (Tcl_Obj *objPtr); /* 380 */
         2230  +    Tcl_UniChar (*tcl_GetUniChar) (Tcl_Obj *objPtr, int index); /* 381 */
         2231  +    Tcl_UniChar * (*tcl_GetUnicode) (Tcl_Obj *objPtr); /* 382 */
         2232  +    Tcl_Obj * (*tcl_GetRange) (Tcl_Obj *objPtr, int first, int last); /* 383 */
         2233  +    void (*tcl_AppendUnicodeToObj) (Tcl_Obj *objPtr, const Tcl_UniChar *unicode, int length); /* 384 */
         2234  +    int (*tcl_RegExpMatchObj) (Tcl_Interp *interp, Tcl_Obj *textObj, Tcl_Obj *patternObj); /* 385 */
         2235  +    void (*tcl_SetNotifier) (Tcl_NotifierProcs *notifierProcPtr); /* 386 */
         2236  +    Tcl_Mutex * (*tcl_GetAllocMutex) (void); /* 387 */
         2237  +    int (*tcl_GetChannelNames) (Tcl_Interp *interp); /* 388 */
         2238  +    int (*tcl_GetChannelNamesEx) (Tcl_Interp *interp, const char *pattern); /* 389 */
         2239  +    int (*tcl_ProcObjCmd) (ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 390 */
         2240  +    void (*tcl_ConditionFinalize) (Tcl_Condition *condPtr); /* 391 */
         2241  +    void (*tcl_MutexFinalize) (Tcl_Mutex *mutex); /* 392 */
         2242  +    int (*tcl_CreateThread) (Tcl_ThreadId *idPtr, Tcl_ThreadCreateProc *proc, ClientData clientData, int stackSize, int flags); /* 393 */
         2243  +    int (*tcl_ReadRaw) (Tcl_Channel chan, char *dst, int bytesToRead); /* 394 */
         2244  +    int (*tcl_WriteRaw) (Tcl_Channel chan, const char *src, int srcLen); /* 395 */
         2245  +    Tcl_Channel (*tcl_GetTopChannel) (Tcl_Channel chan); /* 396 */
         2246  +    int (*tcl_ChannelBuffered) (Tcl_Channel chan); /* 397 */
         2247  +    CONST84_RETURN char * (*tcl_ChannelName) (const Tcl_ChannelType *chanTypePtr); /* 398 */
         2248  +    Tcl_ChannelTypeVersion (*tcl_ChannelVersion) (const Tcl_ChannelType *chanTypePtr); /* 399 */
         2249  +    Tcl_DriverBlockModeProc * (*tcl_ChannelBlockModeProc) (const Tcl_ChannelType *chanTypePtr); /* 400 */
         2250  +    Tcl_DriverCloseProc * (*tcl_ChannelCloseProc) (const Tcl_ChannelType *chanTypePtr); /* 401 */
         2251  +    Tcl_DriverClose2Proc * (*tcl_ChannelClose2Proc) (const Tcl_ChannelType *chanTypePtr); /* 402 */
         2252  +    Tcl_DriverInputProc * (*tcl_ChannelInputProc) (const Tcl_ChannelType *chanTypePtr); /* 403 */
         2253  +    Tcl_DriverOutputProc * (*tcl_ChannelOutputProc) (const Tcl_ChannelType *chanTypePtr); /* 404 */
         2254  +    Tcl_DriverSeekProc * (*tcl_ChannelSeekProc) (const Tcl_ChannelType *chanTypePtr); /* 405 */
         2255  +    Tcl_DriverSetOptionProc * (*tcl_ChannelSetOptionProc) (const Tcl_ChannelType *chanTypePtr); /* 406 */
         2256  +    Tcl_DriverGetOptionProc * (*tcl_ChannelGetOptionProc) (const Tcl_ChannelType *chanTypePtr); /* 407 */
         2257  +    Tcl_DriverWatchProc * (*tcl_ChannelWatchProc) (const Tcl_ChannelType *chanTypePtr); /* 408 */
         2258  +    Tcl_DriverGetHandleProc * (*tcl_ChannelGetHandleProc) (const Tcl_ChannelType *chanTypePtr); /* 409 */
         2259  +    Tcl_DriverFlushProc * (*tcl_ChannelFlushProc) (const Tcl_ChannelType *chanTypePtr); /* 410 */
         2260  +    Tcl_DriverHandlerProc * (*tcl_ChannelHandlerProc) (const Tcl_ChannelType *chanTypePtr); /* 411 */
         2261  +    int (*tcl_JoinThread) (Tcl_ThreadId threadId, int *result); /* 412 */
         2262  +    int (*tcl_IsChannelShared) (Tcl_Channel channel); /* 413 */
         2263  +    int (*tcl_IsChannelRegistered) (Tcl_Interp *interp, Tcl_Channel channel); /* 414 */
         2264  +    void (*tcl_CutChannel) (Tcl_Channel channel); /* 415 */
         2265  +    void (*tcl_SpliceChannel) (Tcl_Channel channel); /* 416 */
         2266  +    void (*tcl_ClearChannelHandlers) (Tcl_Channel channel); /* 417 */
         2267  +    int (*tcl_IsChannelExisting) (const char *channelName); /* 418 */
         2268  +    int (*tcl_UniCharNcasecmp) (const Tcl_UniChar *ucs, const Tcl_UniChar *uct, unsigned long numChars); /* 419 */
         2269  +    int (*tcl_UniCharCaseMatch) (const Tcl_UniChar *uniStr, const Tcl_UniChar *uniPattern, int nocase); /* 420 */
         2270  +    Tcl_HashEntry * (*tcl_FindHashEntry) (Tcl_HashTable *tablePtr, const void *key); /* 421 */
         2271  +    Tcl_HashEntry * (*tcl_CreateHashEntry) (Tcl_HashTable *tablePtr, const void *key, int *newPtr); /* 422 */
         2272  +    void (*tcl_InitCustomHashTable) (Tcl_HashTable *tablePtr, int keyType, const Tcl_HashKeyType *typePtr); /* 423 */
         2273  +    void (*tcl_InitObjHashTable) (Tcl_HashTable *tablePtr); /* 424 */
         2274  +    ClientData (*tcl_CommandTraceInfo) (Tcl_Interp *interp, const char *varName, int flags, Tcl_CommandTraceProc *procPtr, ClientData prevClientData); /* 425 */
         2275  +    int (*tcl_TraceCommand) (Tcl_Interp *interp, const char *varName, int flags, Tcl_CommandTraceProc *proc, ClientData clientData); /* 426 */
         2276  +    void (*tcl_UntraceCommand) (Tcl_Interp *interp, const char *varName, int flags, Tcl_CommandTraceProc *proc, ClientData clientData); /* 427 */
         2277  +    char * (*tcl_AttemptAlloc) (unsigned int size); /* 428 */
         2278  +    char * (*tcl_AttemptDbCkalloc) (unsigned int size, const char *file, int line); /* 429 */
         2279  +    char * (*tcl_AttemptRealloc) (char *ptr, unsigned int size); /* 430 */
         2280  +    char * (*tcl_AttemptDbCkrealloc) (char *ptr, unsigned int size, const char *file, int line); /* 431 */
         2281  +    int (*tcl_AttemptSetObjLength) (Tcl_Obj *objPtr, int length); /* 432 */
         2282  +    Tcl_ThreadId (*tcl_GetChannelThread) (Tcl_Channel channel); /* 433 */
         2283  +    Tcl_UniChar * (*tcl_GetUnicodeFromObj) (Tcl_Obj *objPtr, int *lengthPtr); /* 434 */
         2284  +    int (*tcl_GetMathFuncInfo) (Tcl_Interp *interp, const char *name, int *numArgsPtr, Tcl_ValueType **argTypesPtr, Tcl_MathProc **procPtr, ClientData *clientDataPtr); /* 435 */
         2285  +    Tcl_Obj * (*tcl_ListMathFuncs) (Tcl_Interp *interp, const char *pattern); /* 436 */
         2286  +    Tcl_Obj * (*tcl_SubstObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags); /* 437 */
         2287  +    int (*tcl_DetachChannel) (Tcl_Interp *interp, Tcl_Channel channel); /* 438 */
         2288  +    int (*tcl_IsStandardChannel) (Tcl_Channel channel); /* 439 */
         2289  +    int (*tcl_FSCopyFile) (Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr); /* 440 */
         2290  +    int (*tcl_FSCopyDirectory) (Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr, Tcl_Obj **errorPtr); /* 441 */
         2291  +    int (*tcl_FSCreateDirectory) (Tcl_Obj *pathPtr); /* 442 */
         2292  +    int (*tcl_FSDeleteFile) (Tcl_Obj *pathPtr); /* 443 */
         2293  +    int (*tcl_FSLoadFile) (Tcl_Interp *interp, Tcl_Obj *pathPtr, const char *sym1, const char *sym2, Tcl_PackageInitProc **proc1Ptr, Tcl_PackageInitProc **proc2Ptr, Tcl_LoadHandle *handlePtr, Tcl_FSUnloadFileProc **unloadProcPtr); /* 444 */
         2294  +    int (*tcl_FSMatchInDirectory) (Tcl_Interp *interp, Tcl_Obj *result, Tcl_Obj *pathPtr, const char *pattern, Tcl_GlobTypeData *types); /* 445 */
         2295  +    Tcl_Obj * (*tcl_FSLink) (Tcl_Obj *pathPtr, Tcl_Obj *toPtr, int linkAction); /* 446 */
         2296  +    int (*tcl_FSRemoveDirectory) (Tcl_Obj *pathPtr, int recursive, Tcl_Obj **errorPtr); /* 447 */
         2297  +    int (*tcl_FSRenameFile) (Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr); /* 448 */
         2298  +    int (*tcl_FSLstat) (Tcl_Obj *pathPtr, Tcl_StatBuf *buf); /* 449 */
         2299  +    int (*tcl_FSUtime) (Tcl_Obj *pathPtr, struct utimbuf *tval); /* 450 */
         2300  +    int (*tcl_FSFileAttrsGet) (Tcl_Interp *interp, int index, Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef); /* 451 */
         2301  +    int (*tcl_FSFileAttrsSet) (Tcl_Interp *interp, int index, Tcl_Obj *pathPtr, Tcl_Obj *objPtr); /* 452 */
         2302  +    const char *CONST86 * (*tcl_FSFileAttrStrings) (Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef); /* 453 */
         2303  +    int (*tcl_FSStat) (Tcl_Obj *pathPtr, Tcl_StatBuf *buf); /* 454 */
         2304  +    int (*tcl_FSAccess) (Tcl_Obj *pathPtr, int mode); /* 455 */
         2305  +    Tcl_Channel (*tcl_FSOpenFileChannel) (Tcl_Interp *interp, Tcl_Obj *pathPtr, const char *modeString, int permissions); /* 456 */
         2306  +    Tcl_Obj * (*tcl_FSGetCwd) (Tcl_Interp *interp); /* 457 */
         2307  +    int (*tcl_FSChdir) (Tcl_Obj *pathPtr); /* 458 */
         2308  +    int (*tcl_FSConvertToPathType) (Tcl_Interp *interp, Tcl_Obj *pathPtr); /* 459 */
         2309  +    Tcl_Obj * (*tcl_FSJoinPath) (Tcl_Obj *listObj, int elements); /* 460 */
         2310  +    Tcl_Obj * (*tcl_FSSplitPath) (Tcl_Obj *pathPtr, int *lenPtr); /* 461 */
         2311  +    int (*tcl_FSEqualPaths) (Tcl_Obj *firstPtr, Tcl_Obj *secondPtr); /* 462 */
         2312  +    Tcl_Obj * (*tcl_FSGetNormalizedPath) (Tcl_Interp *interp, Tcl_Obj *pathPtr); /* 463 */
         2313  +    Tcl_Obj * (*tcl_FSJoinToPath) (Tcl_Obj *pathPtr, int objc, Tcl_Obj *const objv[]); /* 464 */
         2314  +    ClientData (*tcl_FSGetInternalRep) (Tcl_Obj *pathPtr, const Tcl_Filesystem *fsPtr); /* 465 */
         2315  +    Tcl_Obj * (*tcl_FSGetTranslatedPath) (Tcl_Interp *interp, Tcl_Obj *pathPtr); /* 466 */
         2316  +    int (*tcl_FSEvalFile) (Tcl_Interp *interp, Tcl_Obj *fileName); /* 467 */
         2317  +    Tcl_Obj * (*tcl_FSNewNativePath) (const Tcl_Filesystem *fromFilesystem, ClientData clientData); /* 468 */
         2318  +    const void * (*tcl_FSGetNativePath) (Tcl_Obj *pathPtr); /* 469 */
         2319  +    Tcl_Obj * (*tcl_FSFileSystemInfo) (Tcl_Obj *pathPtr); /* 470 */
         2320  +    Tcl_Obj * (*tcl_FSPathSeparator) (Tcl_Obj *pathPtr); /* 471 */
         2321  +    Tcl_Obj * (*tcl_FSListVolumes) (void); /* 472 */
         2322  +    int (*tcl_FSRegister) (ClientData clientData, const Tcl_Filesystem *fsPtr); /* 473 */
         2323  +    int (*tcl_FSUnregister) (const Tcl_Filesystem *fsPtr); /* 474 */
         2324  +    ClientData (*tcl_FSData) (const Tcl_Filesystem *fsPtr); /* 475 */
         2325  +    const char * (*tcl_FSGetTranslatedStringPath) (Tcl_Interp *interp, Tcl_Obj *pathPtr); /* 476 */
         2326  +    CONST86 Tcl_Filesystem * (*tcl_FSGetFileSystemForPath) (Tcl_Obj *pathPtr); /* 477 */
         2327  +    Tcl_PathType (*tcl_FSGetPathType) (Tcl_Obj *pathPtr); /* 478 */
         2328  +    int (*tcl_OutputBuffered) (Tcl_Channel chan); /* 479 */
         2329  +    void (*tcl_FSMountsChanged) (const Tcl_Filesystem *fsPtr); /* 480 */
         2330  +    int (*tcl_EvalTokensStandard) (Tcl_Interp *interp, Tcl_Token *tokenPtr, int count); /* 481 */
         2331  +    void (*tcl_GetTime) (Tcl_Time *timeBuf); /* 482 */
         2332  +    Tcl_Trace (*tcl_CreateObjTrace) (Tcl_Interp *interp, int level, int flags, Tcl_CmdObjTraceProc *objProc, ClientData clientData, Tcl_CmdObjTraceDeleteProc *delProc); /* 483 */
         2333  +    int (*tcl_GetCommandInfoFromToken) (Tcl_Command token, Tcl_CmdInfo *infoPtr); /* 484 */
         2334  +    int (*tcl_SetCommandInfoFromToken) (Tcl_Command token, const Tcl_CmdInfo *infoPtr); /* 485 */
         2335  +    Tcl_Obj * (*tcl_DbNewWideIntObj) (Tcl_WideInt wideValue, const char *file, int line); /* 486 */
         2336  +    int (*tcl_GetWideIntFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_WideInt *widePtr); /* 487 */
         2337  +    Tcl_Obj * (*tcl_NewWideIntObj) (Tcl_WideInt wideValue); /* 488 */
         2338  +    void (*tcl_SetWideIntObj) (Tcl_Obj *objPtr, Tcl_WideInt wideValue); /* 489 */
         2339  +    Tcl_StatBuf * (*tcl_AllocStatBuf) (void); /* 490 */
         2340  +    Tcl_WideInt (*tcl_Seek) (Tcl_Channel chan, Tcl_WideInt offset, int mode); /* 491 */
         2341  +    Tcl_WideInt (*tcl_Tell) (Tcl_Channel chan); /* 492 */
         2342  +    Tcl_DriverWideSeekProc * (*tcl_ChannelWideSeekProc) (const Tcl_ChannelType *chanTypePtr); /* 493 */
         2343  +    int (*tcl_DictObjPut) (Tcl_Interp *interp, Tcl_Obj *dictPtr, Tcl_Obj *keyPtr, Tcl_Obj *valuePtr); /* 494 */
         2344  +    int (*tcl_DictObjGet) (Tcl_Interp *interp, Tcl_Obj *dictPtr, Tcl_Obj *keyPtr, Tcl_Obj **valuePtrPtr); /* 495 */
         2345  +    int (*tcl_DictObjRemove) (Tcl_Interp *interp, Tcl_Obj *dictPtr, Tcl_Obj *keyPtr); /* 496 */
         2346  +    int (*tcl_DictObjSize) (Tcl_Interp *interp, Tcl_Obj *dictPtr, int *sizePtr); /* 497 */
         2347  +    int (*tcl_DictObjFirst) (Tcl_Interp *interp, Tcl_Obj *dictPtr, Tcl_DictSearch *searchPtr, Tcl_Obj **keyPtrPtr, Tcl_Obj **valuePtrPtr, int *donePtr); /* 498 */
         2348  +    void (*tcl_DictObjNext) (Tcl_DictSearch *searchPtr, Tcl_Obj **keyPtrPtr, Tcl_Obj **valuePtrPtr, int *donePtr); /* 499 */
         2349  +    void (*tcl_DictObjDone) (Tcl_DictSearch *searchPtr); /* 500 */
         2350  +    int (*tcl_DictObjPutKeyList) (Tcl_Interp *interp, Tcl_Obj *dictPtr, int keyc, Tcl_Obj *const *keyv, Tcl_Obj *valuePtr); /* 501 */
         2351  +    int (*tcl_DictObjRemoveKeyList) (Tcl_Interp *interp, Tcl_Obj *dictPtr, int keyc, Tcl_Obj *const *keyv); /* 502 */
         2352  +    Tcl_Obj * (*tcl_NewDictObj) (void); /* 503 */
         2353  +    Tcl_Obj * (*tcl_DbNewDictObj) (const char *file, int line); /* 504 */
         2354  +    void (*tcl_RegisterConfig) (Tcl_Interp *interp, const char *pkgName, const Tcl_Config *configuration, const char *valEncoding); /* 505 */
         2355  +    Tcl_Namespace * (*tcl_CreateNamespace) (Tcl_Interp *interp, const char *name, ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc); /* 506 */
         2356  +    void (*tcl_DeleteNamespace) (Tcl_Namespace *nsPtr); /* 507 */
         2357  +    int (*tcl_AppendExportList) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, Tcl_Obj *objPtr); /* 508 */
         2358  +    int (*tcl_Export) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern, int resetListFirst); /* 509 */
         2359  +    int (*tcl_Import) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern, int allowOverwrite); /* 510 */
         2360  +    int (*tcl_ForgetImport) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern); /* 511 */
         2361  +    Tcl_Namespace * (*tcl_GetCurrentNamespace) (Tcl_Interp *interp); /* 512 */
         2362  +    Tcl_Namespace * (*tcl_GetGlobalNamespace) (Tcl_Interp *interp); /* 513 */
         2363  +    Tcl_Namespace * (*tcl_FindNamespace) (Tcl_Interp *interp, const char *name, Tcl_Namespace *contextNsPtr, int flags); /* 514 */
         2364  +    Tcl_Command (*tcl_FindCommand) (Tcl_Interp *interp, const char *name, Tcl_Namespace *contextNsPtr, int flags); /* 515 */
         2365  +    Tcl_Command (*tcl_GetCommandFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 516 */
         2366  +    void (*tcl_GetCommandFullName) (Tcl_Interp *interp, Tcl_Command command, Tcl_Obj *objPtr); /* 517 */
         2367  +    int (*tcl_FSEvalFileEx) (Tcl_Interp *interp, Tcl_Obj *fileName, const char *encodingName); /* 518 */
         2368  +    Tcl_ExitProc * (*tcl_SetExitProc) (Tcl_ExitProc *proc); /* 519 */
         2369  +    void (*tcl_LimitAddHandler) (Tcl_Interp *interp, int type, Tcl_LimitHandlerProc *handlerProc, ClientData clientData, Tcl_LimitHandlerDeleteProc *deleteProc); /* 520 */
         2370  +    void (*tcl_LimitRemoveHandler) (Tcl_Interp *interp, int type, Tcl_LimitHandlerProc *handlerProc, ClientData clientData); /* 521 */
         2371  +    int (*tcl_LimitReady) (Tcl_Interp *interp); /* 522 */
         2372  +    int (*tcl_LimitCheck) (Tcl_Interp *interp); /* 523 */
         2373  +    int (*tcl_LimitExceeded) (Tcl_Interp *interp); /* 524 */
         2374  +    void (*tcl_LimitSetCommands) (Tcl_Interp *interp, int commandLimit); /* 525 */
         2375  +    void (*tcl_LimitSetTime) (Tcl_Interp *interp, Tcl_Time *timeLimitPtr); /* 526 */
         2376  +    void (*tcl_LimitSetGranularity) (Tcl_Interp *interp, int type, int granularity); /* 527 */
         2377  +    int (*tcl_LimitTypeEnabled) (Tcl_Interp *interp, int type); /* 528 */
         2378  +    int (*tcl_LimitTypeExceeded) (Tcl_Interp *interp, int type); /* 529 */
         2379  +    void (*tcl_LimitTypeSet) (Tcl_Interp *interp, int type); /* 530 */
         2380  +    void (*tcl_LimitTypeReset) (Tcl_Interp *interp, int type); /* 531 */
         2381  +    int (*tcl_LimitGetCommands) (Tcl_Interp *interp); /* 532 */
         2382  +    void (*tcl_LimitGetTime) (Tcl_Interp *interp, Tcl_Time *timeLimitPtr); /* 533 */
         2383  +    int (*tcl_LimitGetGranularity) (Tcl_Interp *interp, int type); /* 534 */
         2384  +    Tcl_InterpState (*tcl_SaveInterpState) (Tcl_Interp *interp, int status); /* 535 */
         2385  +    int (*tcl_RestoreInterpState) (Tcl_Interp *interp, Tcl_InterpState state); /* 536 */
         2386  +    void (*tcl_DiscardInterpState) (Tcl_InterpState state); /* 537 */
         2387  +    int (*tcl_SetReturnOptions) (Tcl_Interp *interp, Tcl_Obj *options); /* 538 */
         2388  +    Tcl_Obj * (*tcl_GetReturnOptions) (Tcl_Interp *interp, int result); /* 539 */
         2389  +    int (*tcl_IsEnsemble) (Tcl_Command token); /* 540 */
         2390  +    Tcl_Command (*tcl_CreateEnsemble) (Tcl_Interp *interp, const char *name, Tcl_Namespace *namespacePtr, int flags); /* 541 */
         2391  +    Tcl_Command (*tcl_FindEnsemble) (Tcl_Interp *interp, Tcl_Obj *cmdNameObj, int flags); /* 542 */
         2392  +    int (*tcl_SetEnsembleSubcommandList) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj *subcmdList); /* 543 */
         2393  +    int (*tcl_SetEnsembleMappingDict) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj *mapDict); /* 544 */
         2394  +    int (*tcl_SetEnsembleUnknownHandler) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj *unknownList); /* 545 */
         2395  +    int (*tcl_SetEnsembleFlags) (Tcl_Interp *interp, Tcl_Command token, int flags); /* 546 */
         2396  +    int (*tcl_GetEnsembleSubcommandList) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj **subcmdListPtr); /* 547 */
         2397  +    int (*tcl_GetEnsembleMappingDict) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj **mapDictPtr); /* 548 */
         2398  +    int (*tcl_GetEnsembleUnknownHandler) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj **unknownListPtr); /* 549 */
         2399  +    int (*tcl_GetEnsembleFlags) (Tcl_Interp *interp, Tcl_Command token, int *flagsPtr); /* 550 */
         2400  +    int (*tcl_GetEnsembleNamespace) (Tcl_Interp *interp, Tcl_Command token, Tcl_Namespace **namespacePtrPtr); /* 551 */
         2401  +    void (*tcl_SetTimeProc) (Tcl_GetTimeProc *getProc, Tcl_ScaleTimeProc *scaleProc, ClientData clientData); /* 552 */
         2402  +    void (*tcl_QueryTimeProc) (Tcl_GetTimeProc **getProc, Tcl_ScaleTimeProc **scaleProc, ClientData *clientData); /* 553 */
         2403  +    Tcl_DriverThreadActionProc * (*tcl_ChannelThreadActionProc) (const Tcl_ChannelType *chanTypePtr); /* 554 */
         2404  +    Tcl_Obj * (*tcl_NewBignumObj) (mp_int *value); /* 555 */
         2405  +    Tcl_Obj * (*tcl_DbNewBignumObj) (mp_int *value, const char *file, int line); /* 556 */
         2406  +    void (*tcl_SetBignumObj) (Tcl_Obj *obj, mp_int *value); /* 557 */
         2407  +    int (*tcl_GetBignumFromObj) (Tcl_Interp *interp, Tcl_Obj *obj, mp_int *value); /* 558 */
         2408  +    int (*tcl_TakeBignumFromObj) (Tcl_Interp *interp, Tcl_Obj *obj, mp_int *value); /* 559 */
         2409  +    int (*tcl_TruncateChannel) (Tcl_Channel chan, Tcl_WideInt length); /* 560 */
         2410  +    Tcl_DriverTruncateProc * (*tcl_ChannelTruncateProc) (const Tcl_ChannelType *chanTypePtr); /* 561 */
         2411  +    void (*tcl_SetChannelErrorInterp) (Tcl_Interp *interp, Tcl_Obj *msg); /* 562 */
         2412  +    void (*tcl_GetChannelErrorInterp) (Tcl_Interp *interp, Tcl_Obj **msg); /* 563 */
         2413  +    void (*tcl_SetChannelError) (Tcl_Channel chan, Tcl_Obj *msg); /* 564 */
         2414  +    void (*tcl_GetChannelError) (Tcl_Channel chan, Tcl_Obj **msg); /* 565 */
         2415  +    int (*tcl_InitBignumFromDouble) (Tcl_Interp *interp, double initval, mp_int *toInit); /* 566 */
         2416  +    Tcl_Obj * (*tcl_GetNamespaceUnknownHandler) (Tcl_Interp *interp, Tcl_Namespace *nsPtr); /* 567 */
         2417  +    int (*tcl_SetNamespaceUnknownHandler) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, Tcl_Obj *handlerPtr); /* 568 */
         2418  +    int (*tcl_GetEncodingFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_Encoding *encodingPtr); /* 569 */
         2419  +    Tcl_Obj * (*tcl_GetEncodingSearchPath) (void); /* 570 */
         2420  +    int (*tcl_SetEncodingSearchPath) (Tcl_Obj *searchPath); /* 571 */
         2421  +    const char * (*tcl_GetEncodingNameFromEnvironment) (Tcl_DString *bufPtr); /* 572 */
         2422  +    int (*tcl_PkgRequireProc) (Tcl_Interp *interp, const char *name, int objc, Tcl_Obj *const objv[], void *clientDataPtr); /* 573 */
         2423  +    void (*tcl_AppendObjToErrorInfo) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 574 */
         2424  +    void (*tcl_AppendLimitedToObj) (Tcl_Obj *objPtr, const char *bytes, int length, int limit, const char *ellipsis); /* 575 */
         2425  +    Tcl_Obj * (*tcl_Format) (Tcl_Interp *interp, const char *format, int objc, Tcl_Obj *const objv[]); /* 576 */
         2426  +    int (*tcl_AppendFormatToObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, const char *format, int objc, Tcl_Obj *const objv[]); /* 577 */
         2427  +    Tcl_Obj * (*tcl_ObjPrintf) (const char *format, ...) TCL_FORMAT_PRINTF(1, 2); /* 578 */
         2428  +    void (*tcl_AppendPrintfToObj) (Tcl_Obj *objPtr, const char *format, ...) TCL_FORMAT_PRINTF(2, 3); /* 579 */
         2429  +    int (*tcl_CancelEval) (Tcl_Interp *interp, Tcl_Obj *resultObjPtr, ClientData clientData, int flags); /* 580 */
         2430  +    int (*tcl_Canceled) (Tcl_Interp *interp, int flags); /* 581 */
         2431  +    int (*tcl_CreatePipe) (Tcl_Interp *interp, Tcl_Channel *rchan, Tcl_Channel *wchan, int flags); /* 582 */
         2432  +    Tcl_Command (*tcl_NRCreateCommand) (Tcl_Interp *interp, const char *cmdName, Tcl_ObjCmdProc *proc, Tcl_ObjCmdProc *nreProc, ClientData clientData, Tcl_CmdDeleteProc *deleteProc); /* 583 */
         2433  +    int (*tcl_NREvalObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags); /* 584 */
         2434  +    int (*tcl_NREvalObjv) (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], int flags); /* 585 */
         2435  +    int (*tcl_NRCmdSwap) (Tcl_Interp *interp, Tcl_Command cmd, int objc, Tcl_Obj *const objv[], int flags); /* 586 */
         2436  +    void (*tcl_NRAddCallback) (Tcl_Interp *interp, Tcl_NRPostProc *postProcPtr, ClientData data0, ClientData data1, ClientData data2, ClientData data3); /* 587 */
         2437  +    int (*tcl_NRCallObjProc) (Tcl_Interp *interp, Tcl_ObjCmdProc *objProc, ClientData clientData, int objc, Tcl_Obj *const objv[]); /* 588 */
         2438  +    unsigned (*tcl_GetFSDeviceFromStat) (const Tcl_StatBuf *statPtr); /* 589 */
         2439  +    unsigned (*tcl_GetFSInodeFromStat) (const Tcl_StatBuf *statPtr); /* 590 */
         2440  +    unsigned (*tcl_GetModeFromStat) (const Tcl_StatBuf *statPtr); /* 591 */
         2441  +    int (*tcl_GetLinkCountFromStat) (const Tcl_StatBuf *statPtr); /* 592 */
         2442  +    int (*tcl_GetUserIdFromStat) (const Tcl_StatBuf *statPtr); /* 593 */
         2443  +    int (*tcl_GetGroupIdFromStat) (const Tcl_StatBuf *statPtr); /* 594 */
         2444  +    int (*tcl_GetDeviceTypeFromStat) (const Tcl_StatBuf *statPtr); /* 595 */
         2445  +    Tcl_WideInt (*tcl_GetAccessTimeFromStat) (const Tcl_StatBuf *statPtr); /* 596 */
         2446  +    Tcl_WideInt (*tcl_GetModificationTimeFromStat) (const Tcl_StatBuf *statPtr); /* 597 */
         2447  +    Tcl_WideInt (*tcl_GetChangeTimeFromStat) (const Tcl_StatBuf *statPtr); /* 598 */
         2448  +    Tcl_WideUInt (*tcl_GetSizeFromStat) (const Tcl_StatBuf *statPtr); /* 599 */
         2449  +    Tcl_WideUInt (*tcl_GetBlocksFromStat) (const Tcl_StatBuf *statPtr); /* 600 */
         2450  +    unsigned (*tcl_GetBlockSizeFromStat) (const Tcl_StatBuf *statPtr); /* 601 */
         2451  +    int (*tcl_SetEnsembleParameterList) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj *paramList); /* 602 */
         2452  +    int (*tcl_GetEnsembleParameterList) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj **paramListPtr); /* 603 */
         2453  +    int (*tcl_ParseArgsObjv) (Tcl_Interp *interp, const Tcl_ArgvInfo *argTable, int *objcPtr, Tcl_Obj *const *objv, Tcl_Obj ***remObjv); /* 604 */
         2454  +    int (*tcl_GetErrorLine) (Tcl_Interp *interp); /* 605 */
         2455  +    void (*tcl_SetErrorLine) (Tcl_Interp *interp, int lineNum); /* 606 */
         2456  +    void (*tcl_TransferResult) (Tcl_Interp *sourceInterp, int result, Tcl_Interp *targetInterp); /* 607 */
         2457  +    int (*tcl_InterpActive) (Tcl_Interp *interp); /* 608 */
         2458  +    void (*tcl_BackgroundException) (Tcl_Interp *interp, int code); /* 609 */
         2459  +    int (*tcl_ZlibDeflate) (Tcl_Interp *interp, int format, Tcl_Obj *data, int level, Tcl_Obj *gzipHeaderDictObj); /* 610 */
         2460  +    int (*tcl_ZlibInflate) (Tcl_Interp *interp, int format, Tcl_Obj *data, int buffersize, Tcl_Obj *gzipHeaderDictObj); /* 611 */
         2461  +    unsigned int (*tcl_ZlibCRC32) (unsigned int crc, const unsigned char *buf, int len); /* 612 */
         2462  +    unsigned int (*tcl_ZlibAdler32) (unsigned int adler, const unsigned char *buf, int len); /* 613 */
         2463  +    int (*tcl_ZlibStreamInit) (Tcl_Interp *interp, int mode, int format, int level, Tcl_Obj *dictObj, Tcl_ZlibStream *zshandle); /* 614 */
         2464  +    Tcl_Obj * (*tcl_ZlibStreamGetCommandName) (Tcl_ZlibStream zshandle); /* 615 */
         2465  +    int (*tcl_ZlibStreamEof) (Tcl_ZlibStream zshandle); /* 616 */
         2466  +    int (*tcl_ZlibStreamChecksum) (Tcl_ZlibStream zshandle); /* 617 */
         2467  +    int (*tcl_ZlibStreamPut) (Tcl_ZlibStream zshandle, Tcl_Obj *data, int flush); /* 618 */
         2468  +    int (*tcl_ZlibStreamGet) (Tcl_ZlibStream zshandle, Tcl_Obj *data, int count); /* 619 */
         2469  +    int (*tcl_ZlibStreamClose) (Tcl_ZlibStream zshandle); /* 620 */
         2470  +    int (*tcl_ZlibStreamReset) (Tcl_ZlibStream zshandle); /* 621 */
         2471  +    void (*tcl_SetStartupScript) (Tcl_Obj *path, const char *encoding); /* 622 */
         2472  +    Tcl_Obj * (*tcl_GetStartupScript) (const char **encodingPtr); /* 623 */
         2473  +    int (*tcl_CloseEx) (Tcl_Interp *interp, Tcl_Channel chan, int flags); /* 624 */
         2474  +    int (*tcl_NRExprObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_Obj *resultPtr); /* 625 */
         2475  +    int (*tcl_NRSubstObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags); /* 626 */
         2476  +    int (*tcl_LoadFile) (Tcl_Interp *interp, Tcl_Obj *pathPtr, const char *const symv[], int flags, void *procPtrs, Tcl_LoadHandle *handlePtr); /* 627 */
         2477  +    void * (*tcl_FindSymbol) (Tcl_Interp *interp, Tcl_LoadHandle handle, const char *symbol); /* 628 */
         2478  +    int (*tcl_FSUnloadFile) (Tcl_Interp *interp, Tcl_LoadHandle handlePtr); /* 629 */
         2479  +    void (*tcl_ZlibStreamSetCompressionDictionary) (Tcl_ZlibStream zhandle, Tcl_Obj *compressionDictionaryObj); /* 630 */
         2480  +} TclStubs;
         2481  +
         2482  +#ifdef __cplusplus
         2483  +extern "C" {
         2484  +#endif
         2485  +extern const TclStubs *tclStubsPtr;
         2486  +#ifdef __cplusplus
         2487  +}
         2488  +#endif
         2489  +
         2490  +#if defined(USE_TCL_STUBS)
         2491  +
         2492  +/*
         2493  + * Inline function declarations:
         2494  + */
         2495  +
         2496  +#define Tcl_PkgProvideEx \
         2497  +	(tclStubsPtr->tcl_PkgProvideEx) /* 0 */
         2498  +#define Tcl_PkgRequireEx \
         2499  +	(tclStubsPtr->tcl_PkgRequireEx) /* 1 */
         2500  +#define Tcl_Panic \
         2501  +	(tclStubsPtr->tcl_Panic) /* 2 */
         2502  +#define Tcl_Alloc \
         2503  +	(tclStubsPtr->tcl_Alloc) /* 3 */
         2504  +#define Tcl_Free \
         2505  +	(tclStubsPtr->tcl_Free) /* 4 */
         2506  +#define Tcl_Realloc \
         2507  +	(tclStubsPtr->tcl_Realloc) /* 5 */
         2508  +#define Tcl_DbCkalloc \
         2509  +	(tclStubsPtr->tcl_DbCkalloc) /* 6 */
         2510  +#define Tcl_DbCkfree \
         2511  +	(tclStubsPtr->tcl_DbCkfree) /* 7 */
         2512  +#define Tcl_DbCkrealloc \
         2513  +	(tclStubsPtr->tcl_DbCkrealloc) /* 8 */
         2514  +#if !defined(__WIN32__) && !defined(MAC_OSX_TCL) /* UNIX */
         2515  +#define Tcl_CreateFileHandler \
         2516  +	(tclStubsPtr->tcl_CreateFileHandler) /* 9 */
         2517  +#endif /* UNIX */
         2518  +#ifdef MAC_OSX_TCL /* MACOSX */
         2519  +#define Tcl_CreateFileHandler \
         2520  +	(tclStubsPtr->tcl_CreateFileHandler) /* 9 */
         2521  +#endif /* MACOSX */
         2522  +#if !defined(__WIN32__) && !defined(MAC_OSX_TCL) /* UNIX */
         2523  +#define Tcl_DeleteFileHandler \
         2524  +	(tclStubsPtr->tcl_DeleteFileHandler) /* 10 */
         2525  +#endif /* UNIX */
         2526  +#ifdef MAC_OSX_TCL /* MACOSX */
         2527  +#define Tcl_DeleteFileHandler \
         2528  +	(tclStubsPtr->tcl_DeleteFileHandler) /* 10 */
         2529  +#endif /* MACOSX */
         2530  +#define Tcl_SetTimer \
         2531  +	(tclStubsPtr->tcl_SetTimer) /* 11 */
         2532  +#define Tcl_Sleep \
         2533  +	(tclStubsPtr->tcl_Sleep) /* 12 */
         2534  +#define Tcl_WaitForEvent \
         2535  +	(tclStubsPtr->tcl_WaitForEvent) /* 13 */
         2536  +#define Tcl_AppendAllObjTypes \
         2537  +	(tclStubsPtr->tcl_AppendAllObjTypes) /* 14 */
         2538  +#define Tcl_AppendStringsToObj \
         2539  +	(tclStubsPtr->tcl_AppendStringsToObj) /* 15 */
         2540  +#define Tcl_AppendToObj \
         2541  +	(tclStubsPtr->tcl_AppendToObj) /* 16 */
         2542  +#define Tcl_ConcatObj \
         2543  +	(tclStubsPtr->tcl_ConcatObj) /* 17 */
         2544  +#define Tcl_ConvertToType \
         2545  +	(tclStubsPtr->tcl_ConvertToType) /* 18 */
         2546  +#define Tcl_DbDecrRefCount \
         2547  +	(tclStubsPtr->tcl_DbDecrRefCount) /* 19 */
         2548  +#define Tcl_DbIncrRefCount \
         2549  +	(tclStubsPtr->tcl_DbIncrRefCount) /* 20 */
         2550  +#define Tcl_DbIsShared \
         2551  +	(tclStubsPtr->tcl_DbIsShared) /* 21 */
         2552  +#define Tcl_DbNewBooleanObj \
         2553  +	(tclStubsPtr->tcl_DbNewBooleanObj) /* 22 */
         2554  +#define Tcl_DbNewByteArrayObj \
         2555  +	(tclStubsPtr->tcl_DbNewByteArrayObj) /* 23 */
         2556  +#define Tcl_DbNewDoubleObj \
         2557  +	(tclStubsPtr->tcl_DbNewDoubleObj) /* 24 */
         2558  +#define Tcl_DbNewListObj \
         2559  +	(tclStubsPtr->tcl_DbNewListObj) /* 25 */
         2560  +#define Tcl_DbNewLongObj \
         2561  +	(tclStubsPtr->tcl_DbNewLongObj) /* 26 */
         2562  +#define Tcl_DbNewObj \
         2563  +	(tclStubsPtr->tcl_DbNewObj) /* 27 */
         2564  +#define Tcl_DbNewStringObj \
         2565  +	(tclStubsPtr->tcl_DbNewStringObj) /* 28 */
         2566  +#define Tcl_DuplicateObj \
         2567  +	(tclStubsPtr->tcl_DuplicateObj) /* 29 */
         2568  +#define TclFreeObj \
         2569  +	(tclStubsPtr->tclFreeObj) /* 30 */
         2570  +#define Tcl_GetBoolean \
         2571  +	(tclStubsPtr->tcl_GetBoolean) /* 31 */
         2572  +#define Tcl_GetBooleanFromObj \
         2573  +	(tclStubsPtr->tcl_GetBooleanFromObj) /* 32 */
         2574  +#define Tcl_GetByteArrayFromObj \
         2575  +	(tclStubsPtr->tcl_GetByteArrayFromObj) /* 33 */
         2576  +#define Tcl_GetDouble \
         2577  +	(tclStubsPtr->tcl_GetDouble) /* 34 */
         2578  +#define Tcl_GetDoubleFromObj \
         2579  +	(tclStubsPtr->tcl_GetDoubleFromObj) /* 35 */
         2580  +#define Tcl_GetIndexFromObj \
         2581  +	(tclStubsPtr->tcl_GetIndexFromObj) /* 36 */
         2582  +#define Tcl_GetInt \
         2583  +	(tclStubsPtr->tcl_GetInt) /* 37 */
         2584  +#define Tcl_GetIntFromObj \
         2585  +	(tclStubsPtr->tcl_GetIntFromObj) /* 38 */
         2586  +#define Tcl_GetLongFromObj \
         2587  +	(tclStubsPtr->tcl_GetLongFromObj) /* 39 */
         2588  +#define Tcl_GetObjType \
         2589  +	(tclStubsPtr->tcl_GetObjType) /* 40 */
         2590  +#define Tcl_GetStringFromObj \
         2591  +	(tclStubsPtr->tcl_GetStringFromObj) /* 41 */
         2592  +#define Tcl_InvalidateStringRep \
         2593  +	(tclStubsPtr->tcl_InvalidateStringRep) /* 42 */
         2594  +#define Tcl_ListObjAppendList \
         2595  +	(tclStubsPtr->tcl_ListObjAppendList) /* 43 */
         2596  +#define Tcl_ListObjAppendElement \
         2597  +	(tclStubsPtr->tcl_ListObjAppendElement) /* 44 */
         2598  +#define Tcl_ListObjGetElements \
         2599  +	(tclStubsPtr->tcl_ListObjGetElements) /* 45 */
         2600  +#define Tcl_ListObjIndex \
         2601  +	(tclStubsPtr->tcl_ListObjIndex) /* 46 */
         2602  +#define Tcl_ListObjLength \
         2603  +	(tclStubsPtr->tcl_ListObjLength) /* 47 */
         2604  +#define Tcl_ListObjReplace \
         2605  +	(tclStubsPtr->tcl_ListObjReplace) /* 48 */
         2606  +#define Tcl_NewBooleanObj \
         2607  +	(tclStubsPtr->tcl_NewBooleanObj) /* 49 */
         2608  +#define Tcl_NewByteArrayObj \
         2609  +	(tclStubsPtr->tcl_NewByteArrayObj) /* 50 */
         2610  +#define Tcl_NewDoubleObj \
         2611  +	(tclStubsPtr->tcl_NewDoubleObj) /* 51 */
         2612  +#define Tcl_NewIntObj \
         2613  +	(tclStubsPtr->tcl_NewIntObj) /* 52 */
         2614  +#define Tcl_NewListObj \
         2615  +	(tclStubsPtr->tcl_NewListObj) /* 53 */
         2616  +#define Tcl_NewLongObj \
         2617  +	(tclStubsPtr->tcl_NewLongObj) /* 54 */
         2618  +#define Tcl_NewObj \
         2619  +	(tclStubsPtr->tcl_NewObj) /* 55 */
         2620  +#define Tcl_NewStringObj \
         2621  +	(tclStubsPtr->tcl_NewStringObj) /* 56 */
         2622  +#define Tcl_SetBooleanObj \
         2623  +	(tclStubsPtr->tcl_SetBooleanObj) /* 57 */
         2624  +#define Tcl_SetByteArrayLength \
         2625  +	(tclStubsPtr->tcl_SetByteArrayLength) /* 58 */
         2626  +#define Tcl_SetByteArrayObj \
         2627  +	(tclStubsPtr->tcl_SetByteArrayObj) /* 59 */
         2628  +#define Tcl_SetDoubleObj \
         2629  +	(tclStubsPtr->tcl_SetDoubleObj) /* 60 */
         2630  +#define Tcl_SetIntObj \
         2631  +	(tclStubsPtr->tcl_SetIntObj) /* 61 */
         2632  +#define Tcl_SetListObj \
         2633  +	(tclStubsPtr->tcl_SetListObj) /* 62 */
         2634  +#define Tcl_SetLongObj \
         2635  +	(tclStubsPtr->tcl_SetLongObj) /* 63 */
         2636  +#define Tcl_SetObjLength \
         2637  +	(tclStubsPtr->tcl_SetObjLength) /* 64 */
         2638  +#define Tcl_SetStringObj \
         2639  +	(tclStubsPtr->tcl_SetStringObj) /* 65 */
         2640  +#define Tcl_AddErrorInfo \
         2641  +	(tclStubsPtr->tcl_AddErrorInfo) /* 66 */
         2642  +#define Tcl_AddObjErrorInfo \
         2643  +	(tclStubsPtr->tcl_AddObjErrorInfo) /* 67 */
         2644  +#define Tcl_AllowExceptions \
         2645  +	(tclStubsPtr->tcl_AllowExceptions) /* 68 */
         2646  +#define Tcl_AppendElement \
         2647  +	(tclStubsPtr->tcl_AppendElement) /* 69 */
         2648  +#define Tcl_AppendResult \
         2649  +	(tclStubsPtr->tcl_AppendResult) /* 70 */
         2650  +#define Tcl_AsyncCreate \
         2651  +	(tclStubsPtr->tcl_AsyncCreate) /* 71 */
         2652  +#define Tcl_AsyncDelete \
         2653  +	(tclStubsPtr->tcl_AsyncDelete) /* 72 */
         2654  +#define Tcl_AsyncInvoke \
         2655  +	(tclStubsPtr->tcl_AsyncInvoke) /* 73 */
         2656  +#define Tcl_AsyncMark \
         2657  +	(tclStubsPtr->tcl_AsyncMark) /* 74 */
         2658  +#define Tcl_AsyncReady \
         2659  +	(tclStubsPtr->tcl_AsyncReady) /* 75 */
         2660  +#define Tcl_BackgroundError \
         2661  +	(tclStubsPtr->tcl_BackgroundError) /* 76 */
         2662  +#define Tcl_Backslash \
         2663  +	(tclStubsPtr->tcl_Backslash) /* 77 */
         2664  +#define Tcl_BadChannelOption \
         2665  +	(tclStubsPtr->tcl_BadChannelOption) /* 78 */
         2666  +#define Tcl_CallWhenDeleted \
         2667  +	(tclStubsPtr->tcl_CallWhenDeleted) /* 79 */
         2668  +#define Tcl_CancelIdleCall \
         2669  +	(tclStubsPtr->tcl_CancelIdleCall) /* 80 */
         2670  +#define Tcl_Close \
         2671  +	(tclStubsPtr->tcl_Close) /* 81 */
         2672  +#define Tcl_CommandComplete \
         2673  +	(tclStubsPtr->tcl_CommandComplete) /* 82 */
         2674  +#define Tcl_Concat \
         2675  +	(tclStubsPtr->tcl_Concat) /* 83 */
         2676  +#define Tcl_ConvertElement \
         2677  +	(tclStubsPtr->tcl_ConvertElement) /* 84 */
         2678  +#define Tcl_ConvertCountedElement \
         2679  +	(tclStubsPtr->tcl_ConvertCountedElement) /* 85 */
         2680  +#define Tcl_CreateAlias \
         2681  +	(tclStubsPtr->tcl_CreateAlias) /* 86 */
         2682  +#define Tcl_CreateAliasObj \
         2683  +	(tclStubsPtr->tcl_CreateAliasObj) /* 87 */
         2684  +#define Tcl_CreateChannel \
         2685  +	(tclStubsPtr->tcl_CreateChannel) /* 88 */
         2686  +#define Tcl_CreateChannelHandler \
         2687  +	(tclStubsPtr->tcl_CreateChannelHandler) /* 89 */
         2688  +#define Tcl_CreateCloseHandler \
         2689  +	(tclStubsPtr->tcl_CreateCloseHandler) /* 90 */
         2690  +#define Tcl_CreateCommand \
         2691  +	(tclStubsPtr->tcl_CreateCommand) /* 91 */
         2692  +#define Tcl_CreateEventSource \
         2693  +	(tclStubsPtr->tcl_CreateEventSource) /* 92 */
         2694  +#define Tcl_CreateExitHandler \
         2695  +	(tclStubsPtr->tcl_CreateExitHandler) /* 93 */
         2696  +#define Tcl_CreateInterp \
         2697  +	(tclStubsPtr->tcl_CreateInterp) /* 94 */
         2698  +#define Tcl_CreateMathFunc \
         2699  +	(tclStubsPtr->tcl_CreateMathFunc) /* 95 */
         2700  +#define Tcl_CreateObjCommand \
         2701  +	(tclStubsPtr->tcl_CreateObjCommand) /* 96 */
         2702  +#define Tcl_CreateSlave \
         2703  +	(tclStubsPtr->tcl_CreateSlave) /* 97 */
         2704  +#define Tcl_CreateTimerHandler \
         2705  +	(tclStubsPtr->tcl_CreateTimerHandler) /* 98 */
         2706  +#define Tcl_CreateTrace \
         2707  +	(tclStubsPtr->tcl_CreateTrace) /* 99 */
         2708  +#define Tcl_DeleteAssocData \
         2709  +	(tclStubsPtr->tcl_DeleteAssocData) /* 100 */
         2710  +#define Tcl_DeleteChannelHandler \
         2711  +	(tclStubsPtr->tcl_DeleteChannelHandler) /* 101 */
         2712  +#define Tcl_DeleteCloseHandler \
         2713  +	(tclStubsPtr->tcl_DeleteCloseHandler) /* 102 */
         2714  +#define Tcl_DeleteCommand \
         2715  +	(tclStubsPtr->tcl_DeleteCommand) /* 103 */
         2716  +#define Tcl_DeleteCommandFromToken \
         2717  +	(tclStubsPtr->tcl_DeleteCommandFromToken) /* 104 */
         2718  +#define Tcl_DeleteEvents \
         2719  +	(tclStubsPtr->tcl_DeleteEvents) /* 105 */
         2720  +#define Tcl_DeleteEventSource \
         2721  +	(tclStubsPtr->tcl_DeleteEventSource) /* 106 */
         2722  +#define Tcl_DeleteExitHandler \
         2723  +	(tclStubsPtr->tcl_DeleteExitHandler) /* 107 */
         2724  +#define Tcl_DeleteHashEntry \
         2725  +	(tclStubsPtr->tcl_DeleteHashEntry) /* 108 */
         2726  +#define Tcl_DeleteHashTable \
         2727  +	(tclStubsPtr->tcl_DeleteHashTable) /* 109 */
         2728  +#define Tcl_DeleteInterp \
         2729  +	(tclStubsPtr->tcl_DeleteInterp) /* 110 */
         2730  +#define Tcl_DetachPids \
         2731  +	(tclStubsPtr->tcl_DetachPids) /* 111 */
         2732  +#define Tcl_DeleteTimerHandler \
         2733  +	(tclStubsPtr->tcl_DeleteTimerHandler) /* 112 */
         2734  +#define Tcl_DeleteTrace \
         2735  +	(tclStubsPtr->tcl_DeleteTrace) /* 113 */
         2736  +#define Tcl_DontCallWhenDeleted \
         2737  +	(tclStubsPtr->tcl_DontCallWhenDeleted) /* 114 */
         2738  +#define Tcl_DoOneEvent \
         2739  +	(tclStubsPtr->tcl_DoOneEvent) /* 115 */
         2740  +#define Tcl_DoWhenIdle \
         2741  +	(tclStubsPtr->tcl_DoWhenIdle) /* 116 */
         2742  +#define Tcl_DStringAppend \
         2743  +	(tclStubsPtr->tcl_DStringAppend) /* 117 */
         2744  +#define Tcl_DStringAppendElement \
         2745  +	(tclStubsPtr->tcl_DStringAppendElement) /* 118 */
         2746  +#define Tcl_DStringEndSublist \
         2747  +	(tclStubsPtr->tcl_DStringEndSublist) /* 119 */
         2748  +#define Tcl_DStringFree \
         2749  +	(tclStubsPtr->tcl_DStringFree) /* 120 */
         2750  +#define Tcl_DStringGetResult \
         2751  +	(tclStubsPtr->tcl_DStringGetResult) /* 121 */
         2752  +#define Tcl_DStringInit \
         2753  +	(tclStubsPtr->tcl_DStringInit) /* 122 */
         2754  +#define Tcl_DStringResult \
         2755  +	(tclStubsPtr->tcl_DStringResult) /* 123 */
         2756  +#define Tcl_DStringSetLength \
         2757  +	(tclStubsPtr->tcl_DStringSetLength) /* 124 */
         2758  +#define Tcl_DStringStartSublist \
         2759  +	(tclStubsPtr->tcl_DStringStartSublist) /* 125 */
         2760  +#define Tcl_Eof \
         2761  +	(tclStubsPtr->tcl_Eof) /* 126 */
         2762  +#define Tcl_ErrnoId \
         2763  +	(tclStubsPtr->tcl_ErrnoId) /* 127 */
         2764  +#define Tcl_ErrnoMsg \
         2765  +	(tclStubsPtr->tcl_ErrnoMsg) /* 128 */
         2766  +#define Tcl_Eval \
         2767  +	(tclStubsPtr->tcl_Eval) /* 129 */
         2768  +#define Tcl_EvalFile \
         2769  +	(tclStubsPtr->tcl_EvalFile) /* 130 */
         2770  +#define Tcl_EvalObj \
         2771  +	(tclStubsPtr->tcl_EvalObj) /* 131 */
         2772  +#define Tcl_EventuallyFree \
         2773  +	(tclStubsPtr->tcl_EventuallyFree) /* 132 */
         2774  +#define Tcl_Exit \
         2775  +	(tclStubsPtr->tcl_Exit) /* 133 */
         2776  +#define Tcl_ExposeCommand \
         2777  +	(tclStubsPtr->tcl_ExposeCommand) /* 134 */
         2778  +#define Tcl_ExprBoolean \
         2779  +	(tclStubsPtr->tcl_ExprBoolean) /* 135 */
         2780  +#define Tcl_ExprBooleanObj \
         2781  +	(tclStubsPtr->tcl_ExprBooleanObj) /* 136 */
         2782  +#define Tcl_ExprDouble \
         2783  +	(tclStubsPtr->tcl_ExprDouble) /* 137 */
         2784  +#define Tcl_ExprDoubleObj \
         2785  +	(tclStubsPtr->tcl_ExprDoubleObj) /* 138 */
         2786  +#define Tcl_ExprLong \
         2787  +	(tclStubsPtr->tcl_ExprLong) /* 139 */
         2788  +#define Tcl_ExprLongObj \
         2789  +	(tclStubsPtr->tcl_ExprLongObj) /* 140 */
         2790  +#define Tcl_ExprObj \
         2791  +	(tclStubsPtr->tcl_ExprObj) /* 141 */
         2792  +#define Tcl_ExprString \
         2793  +	(tclStubsPtr->tcl_ExprString) /* 142 */
         2794  +#define Tcl_Finalize \
         2795  +	(tclStubsPtr->tcl_Finalize) /* 143 */
         2796  +#define Tcl_FindExecutable \
         2797  +	(tclStubsPtr->tcl_FindExecutable) /* 144 */
         2798  +#define Tcl_FirstHashEntry \
         2799  +	(tclStubsPtr->tcl_FirstHashEntry) /* 145 */
         2800  +#define Tcl_Flush \
         2801  +	(tclStubsPtr->tcl_Flush) /* 146 */
         2802  +#define Tcl_FreeResult \
         2803  +	(tclStubsPtr->tcl_FreeResult) /* 147 */
         2804  +#define Tcl_GetAlias \
         2805  +	(tclStubsPtr->tcl_GetAlias) /* 148 */
         2806  +#define Tcl_GetAliasObj \
         2807  +	(tclStubsPtr->tcl_GetAliasObj) /* 149 */
         2808  +#define Tcl_GetAssocData \
         2809  +	(tclStubsPtr->tcl_GetAssocData) /* 150 */
         2810  +#define Tcl_GetChannel \
         2811  +	(tclStubsPtr->tcl_GetChannel) /* 151 */
         2812  +#define Tcl_GetChannelBufferSize \
         2813  +	(tclStubsPtr->tcl_GetChannelBufferSize) /* 152 */
         2814  +#define Tcl_GetChannelHandle \
         2815  +	(tclStubsPtr->tcl_GetChannelHandle) /* 153 */
         2816  +#define Tcl_GetChannelInstanceData \
         2817  +	(tclStubsPtr->tcl_GetChannelInstanceData) /* 154 */
         2818  +#define Tcl_GetChannelMode \
         2819  +	(tclStubsPtr->tcl_GetChannelMode) /* 155 */
         2820  +#define Tcl_GetChannelName \
         2821  +	(tclStubsPtr->tcl_GetChannelName) /* 156 */
         2822  +#define Tcl_GetChannelOption \
         2823  +	(tclStubsPtr->tcl_GetChannelOption) /* 157 */
         2824  +#define Tcl_GetChannelType \
         2825  +	(tclStubsPtr->tcl_GetChannelType) /* 158 */
         2826  +#define Tcl_GetCommandInfo \
         2827  +	(tclStubsPtr->tcl_GetCommandInfo) /* 159 */
         2828  +#define Tcl_GetCommandName \
         2829  +	(tclStubsPtr->tcl_GetCommandName) /* 160 */
         2830  +#define Tcl_GetErrno \
         2831  +	(tclStubsPtr->tcl_GetErrno) /* 161 */
         2832  +#define Tcl_GetHostName \
         2833  +	(tclStubsPtr->tcl_GetHostName) /* 162 */
         2834  +#define Tcl_GetInterpPath \
         2835  +	(tclStubsPtr->tcl_GetInterpPath) /* 163 */
         2836  +#define Tcl_GetMaster \
         2837  +	(tclStubsPtr->tcl_GetMaster) /* 164 */
         2838  +#define Tcl_GetNameOfExecutable \
         2839  +	(tclStubsPtr->tcl_GetNameOfExecutable) /* 165 */
         2840  +#define Tcl_GetObjResult \
         2841  +	(tclStubsPtr->tcl_GetObjResult) /* 166 */
         2842  +#if !defined(__WIN32__) && !defined(MAC_OSX_TCL) /* UNIX */
         2843  +#define Tcl_GetOpenFile \
         2844  +	(tclStubsPtr->tcl_GetOpenFile) /* 167 */
         2845  +#endif /* UNIX */
         2846  +#ifdef MAC_OSX_TCL /* MACOSX */
         2847  +#define Tcl_GetOpenFile \
         2848  +	(tclStubsPtr->tcl_GetOpenFile) /* 167 */
         2849  +#endif /* MACOSX */
         2850  +#define Tcl_GetPathType \
         2851  +	(tclStubsPtr->tcl_GetPathType) /* 168 */
         2852  +#define Tcl_Gets \
         2853  +	(tclStubsPtr->tcl_Gets) /* 169 */
         2854  +#define Tcl_GetsObj \
         2855  +	(tclStubsPtr->tcl_GetsObj) /* 170 */
         2856  +#define Tcl_GetServiceMode \
         2857  +	(tclStubsPtr->tcl_GetServiceMode) /* 171 */
         2858  +#define Tcl_GetSlave \
         2859  +	(tclStubsPtr->tcl_GetSlave) /* 172 */
         2860  +#define Tcl_GetStdChannel \
         2861  +	(tclStubsPtr->tcl_GetStdChannel) /* 173 */
         2862  +#define Tcl_GetStringResult \
         2863  +	(tclStubsPtr->tcl_GetStringResult) /* 174 */
         2864  +#define Tcl_GetVar \
         2865  +	(tclStubsPtr->tcl_GetVar) /* 175 */
         2866  +#define Tcl_GetVar2 \
         2867  +	(tclStubsPtr->tcl_GetVar2) /* 176 */
         2868  +#define Tcl_GlobalEval \
         2869  +	(tclStubsPtr->tcl_GlobalEval) /* 177 */
         2870  +#define Tcl_GlobalEvalObj \
         2871  +	(tclStubsPtr->tcl_GlobalEvalObj) /* 178 */
         2872  +#define Tcl_HideCommand \
         2873  +	(tclStubsPtr->tcl_HideCommand) /* 179 */
         2874  +#define Tcl_Init \
         2875  +	(tclStubsPtr->tcl_Init) /* 180 */
         2876  +#define Tcl_InitHashTable \
         2877  +	(tclStubsPtr->tcl_InitHashTable) /* 181 */
         2878  +#define Tcl_InputBlocked \
         2879  +	(tclStubsPtr->tcl_InputBlocked) /* 182 */
         2880  +#define Tcl_InputBuffered \
         2881  +	(tclStubsPtr->tcl_InputBuffered) /* 183 */
         2882  +#define Tcl_InterpDeleted \
         2883  +	(tclStubsPtr->tcl_InterpDeleted) /* 184 */
         2884  +#define Tcl_IsSafe \
         2885  +	(tclStubsPtr->tcl_IsSafe) /* 185 */
         2886  +#define Tcl_JoinPath \
         2887  +	(tclStubsPtr->tcl_JoinPath) /* 186 */
         2888  +#define Tcl_LinkVar \
         2889  +	(tclStubsPtr->tcl_LinkVar) /* 187 */
         2890  +/* Slot 188 is reserved */
         2891  +#define Tcl_MakeFileChannel \
         2892  +	(tclStubsPtr->tcl_MakeFileChannel) /* 189 */
         2893  +#define Tcl_MakeSafe \
         2894  +	(tclStubsPtr->tcl_MakeSafe) /* 190 */
         2895  +#define Tcl_MakeTcpClientChannel \
         2896  +	(tclStubsPtr->tcl_MakeTcpClientChannel) /* 191 */
         2897  +#define Tcl_Merge \
         2898  +	(tclStubsPtr->tcl_Merge) /* 192 */
         2899  +#define Tcl_NextHashEntry \
         2900  +	(tclStubsPtr->tcl_NextHashEntry) /* 193 */
         2901  +#define Tcl_NotifyChannel \
         2902  +	(tclStubsPtr->tcl_NotifyChannel) /* 194 */
         2903  +#define Tcl_ObjGetVar2 \
         2904  +	(tclStubsPtr->tcl_ObjGetVar2) /* 195 */
         2905  +#define Tcl_ObjSetVar2 \
         2906  +	(tclStubsPtr->tcl_ObjSetVar2) /* 196 */
         2907  +#define Tcl_OpenCommandChannel \
         2908  +	(tclStubsPtr->tcl_OpenCommandChannel) /* 197 */
         2909  +#define Tcl_OpenFileChannel \
         2910  +	(tclStubsPtr->tcl_OpenFileChannel) /* 198 */
         2911  +#define Tcl_OpenTcpClient \
         2912  +	(tclStubsPtr->tcl_OpenTcpClient) /* 199 */
         2913  +#define Tcl_OpenTcpServer \
         2914  +	(tclStubsPtr->tcl_OpenTcpServer) /* 200 */
         2915  +#define Tcl_Preserve \
         2916  +	(tclStubsPtr->tcl_Preserve) /* 201 */
         2917  +#define Tcl_PrintDouble \
         2918  +	(tclStubsPtr->tcl_PrintDouble) /* 202 */
         2919  +#define Tcl_PutEnv \
         2920  +	(tclStubsPtr->tcl_PutEnv) /* 203 */
         2921  +#define Tcl_PosixError \
         2922  +	(tclStubsPtr->tcl_PosixError) /* 204 */
         2923  +#define Tcl_QueueEvent \
         2924  +	(tclStubsPtr->tcl_QueueEvent) /* 205 */
         2925  +#define Tcl_Read \
         2926  +	(tclStubsPtr->tcl_Read) /* 206 */
         2927  +#define Tcl_ReapDetachedProcs \
         2928  +	(tclStubsPtr->tcl_ReapDetachedProcs) /* 207 */
         2929  +#define Tcl_RecordAndEval \
         2930  +	(tclStubsPtr->tcl_RecordAndEval) /* 208 */
         2931  +#define Tcl_RecordAndEvalObj \
         2932  +	(tclStubsPtr->tcl_RecordAndEvalObj) /* 209 */
         2933  +#define Tcl_RegisterChannel \
         2934  +	(tclStubsPtr->tcl_RegisterChannel) /* 210 */
         2935  +#define Tcl_RegisterObjType \
         2936  +	(tclStubsPtr->tcl_RegisterObjType) /* 211 */
         2937  +#define Tcl_RegExpCompile \
         2938  +	(tclStubsPtr->tcl_RegExpCompile) /* 212 */
         2939  +#define Tcl_RegExpExec \
         2940  +	(tclStubsPtr->tcl_RegExpExec) /* 213 */
         2941  +#define Tcl_RegExpMatch \
         2942  +	(tclStubsPtr->tcl_RegExpMatch) /* 214 */
         2943  +#define Tcl_RegExpRange \
         2944  +	(tclStubsPtr->tcl_RegExpRange) /* 215 */
         2945  +#define Tcl_Release \
         2946  +	(tclStubsPtr->tcl_Release) /* 216 */
         2947  +#define Tcl_ResetResult \
         2948  +	(tclStubsPtr->tcl_ResetResult) /* 217 */
         2949  +#define Tcl_ScanElement \
         2950  +	(tclStubsPtr->tcl_ScanElement) /* 218 */
         2951  +#define Tcl_ScanCountedElement \
         2952  +	(tclStubsPtr->tcl_ScanCountedElement) /* 219 */
         2953  +#define Tcl_SeekOld \
         2954  +	(tclStubsPtr->tcl_SeekOld) /* 220 */
         2955  +#define Tcl_ServiceAll \
         2956  +	(tclStubsPtr->tcl_ServiceAll) /* 221 */
         2957  +#define Tcl_ServiceEvent \
         2958  +	(tclStubsPtr->tcl_ServiceEvent) /* 222 */
         2959  +#define Tcl_SetAssocData \
         2960  +	(tclStubsPtr->tcl_SetAssocData) /* 223 */
         2961  +#define Tcl_SetChannelBufferSize \
         2962  +	(tclStubsPtr->tcl_SetChannelBufferSize) /* 224 */
         2963  +#define Tcl_SetChannelOption \
         2964  +	(tclStubsPtr->tcl_SetChannelOption) /* 225 */
         2965  +#define Tcl_SetCommandInfo \
         2966  +	(tclStubsPtr->tcl_SetCommandInfo) /* 226 */
         2967  +#define Tcl_SetErrno \
         2968  +	(tclStubsPtr->tcl_SetErrno) /* 227 */
         2969  +#define Tcl_SetErrorCode \
         2970  +	(tclStubsPtr->tcl_SetErrorCode) /* 228 */
         2971  +#define Tcl_SetMaxBlockTime \
         2972  +	(tclStubsPtr->tcl_SetMaxBlockTime) /* 229 */
         2973  +#define Tcl_SetPanicProc \
         2974  +	(tclStubsPtr->tcl_SetPanicProc) /* 230 */
         2975  +#define Tcl_SetRecursionLimit \
         2976  +	(tclStubsPtr->tcl_SetRecursionLimit) /* 231 */
         2977  +#define Tcl_SetResult \
         2978  +	(tclStubsPtr->tcl_SetResult) /* 232 */
         2979  +#define Tcl_SetServiceMode \
         2980  +	(tclStubsPtr->tcl_SetServiceMode) /* 233 */
         2981  +#define Tcl_SetObjErrorCode \
         2982  +	(tclStubsPtr->tcl_SetObjErrorCode) /* 234 */
         2983  +#define Tcl_SetObjResult \
         2984  +	(tclStubsPtr->tcl_SetObjResult) /* 235 */
         2985  +#define Tcl_SetStdChannel \
         2986  +	(tclStubsPtr->tcl_SetStdChannel) /* 236 */
         2987  +#define Tcl_SetVar \
         2988  +	(tclStubsPtr->tcl_SetVar) /* 237 */
         2989  +#define Tcl_SetVar2 \
         2990  +	(tclStubsPtr->tcl_SetVar2) /* 238 */
         2991  +#define Tcl_SignalId \
         2992  +	(tclStubsPtr->tcl_SignalId) /* 239 */
         2993  +#define Tcl_SignalMsg \
         2994  +	(tclStubsPtr->tcl_SignalMsg) /* 240 */
         2995  +#define Tcl_SourceRCFile \
         2996  +	(tclStubsPtr->tcl_SourceRCFile) /* 241 */
         2997  +#define Tcl_SplitList \
         2998  +	(tclStubsPtr->tcl_SplitList) /* 242 */
         2999  +#define Tcl_SplitPath \
         3000  +	(tclStubsPtr->tcl_SplitPath) /* 243 */
         3001  +#define Tcl_StaticPackage \
         3002  +	(tclStubsPtr->tcl_StaticPackage) /* 244 */
         3003  +#define Tcl_StringMatch \
         3004  +	(tclStubsPtr->tcl_StringMatch) /* 245 */
         3005  +#define Tcl_TellOld \
         3006  +	(tclStubsPtr->tcl_TellOld) /* 246 */
         3007  +#define Tcl_TraceVar \
         3008  +	(tclStubsPtr->tcl_TraceVar) /* 247 */
         3009  +#define Tcl_TraceVar2 \
         3010  +	(tclStubsPtr->tcl_TraceVar2) /* 248 */
         3011  +#define Tcl_TranslateFileName \
         3012  +	(tclStubsPtr->tcl_TranslateFileName) /* 249 */
         3013  +#define Tcl_Ungets \
         3014  +	(tclStubsPtr->tcl_Ungets) /* 250 */
         3015  +#define Tcl_UnlinkVar \
         3016  +	(tclStubsPtr->tcl_UnlinkVar) /* 251 */
         3017  +#define Tcl_UnregisterChannel \
         3018  +	(tclStubsPtr->tcl_UnregisterChannel) /* 252 */
         3019  +#define Tcl_UnsetVar \
         3020  +	(tclStubsPtr->tcl_UnsetVar) /* 253 */
         3021  +#define Tcl_UnsetVar2 \
         3022  +	(tclStubsPtr->tcl_UnsetVar2) /* 254 */
         3023  +#define Tcl_UntraceVar \
         3024  +	(tclStubsPtr->tcl_UntraceVar) /* 255 */
         3025  +#define Tcl_UntraceVar2 \
         3026  +	(tclStubsPtr->tcl_UntraceVar2) /* 256 */
         3027  +#define Tcl_UpdateLinkedVar \
         3028  +	(tclStubsPtr->tcl_UpdateLinkedVar) /* 257 */
         3029  +#define Tcl_UpVar \
         3030  +	(tclStubsPtr->tcl_UpVar) /* 258 */
         3031  +#define Tcl_UpVar2 \
         3032  +	(tclStubsPtr->tcl_UpVar2) /* 259 */
         3033  +#define Tcl_VarEval \
         3034  +	(tclStubsPtr->tcl_VarEval) /* 260 */
         3035  +#define Tcl_VarTraceInfo \
         3036  +	(tclStubsPtr->tcl_VarTraceInfo) /* 261 */
         3037  +#define Tcl_VarTraceInfo2 \
         3038  +	(tclStubsPtr->tcl_VarTraceInfo2) /* 262 */
         3039  +#define Tcl_Write \
         3040  +	(tclStubsPtr->tcl_Write) /* 263 */
         3041  +#define Tcl_WrongNumArgs \
         3042  +	(tclStubsPtr->tcl_WrongNumArgs) /* 264 */
         3043  +#define Tcl_DumpActiveMemory \
         3044  +	(tclStubsPtr->tcl_DumpActiveMemory) /* 265 */
         3045  +#define Tcl_ValidateAllMemory \
         3046  +	(tclStubsPtr->tcl_ValidateAllMemory) /* 266 */
         3047  +#define Tcl_AppendResultVA \
         3048  +	(tclStubsPtr->tcl_AppendResultVA) /* 267 */
         3049  +#define Tcl_AppendStringsToObjVA \
         3050  +	(tclStubsPtr->tcl_AppendStringsToObjVA) /* 268 */
         3051  +#define Tcl_HashStats \
         3052  +	(tclStubsPtr->tcl_HashStats) /* 269 */
         3053  +#define Tcl_ParseVar \
         3054  +	(tclStubsPtr->tcl_ParseVar) /* 270 */
         3055  +#define Tcl_PkgPresent \
         3056  +	(tclStubsPtr->tcl_PkgPresent) /* 271 */
         3057  +#define Tcl_PkgPresentEx \
         3058  +	(tclStubsPtr->tcl_PkgPresentEx) /* 272 */
         3059  +#define Tcl_PkgProvide \
         3060  +	(tclStubsPtr->tcl_PkgProvide) /* 273 */
         3061  +#define Tcl_PkgRequire \
         3062  +	(tclStubsPtr->tcl_PkgRequire) /* 274 */
         3063  +#define Tcl_SetErrorCodeVA \
         3064  +	(tclStubsPtr->tcl_SetErrorCodeVA) /* 275 */
         3065  +#define Tcl_VarEvalVA \
         3066  +	(tclStubsPtr->tcl_VarEvalVA) /* 276 */
         3067  +#define Tcl_WaitPid \
         3068  +	(tclStubsPtr->tcl_WaitPid) /* 277 */
         3069  +#define Tcl_PanicVA \
         3070  +	(tclStubsPtr->tcl_PanicVA) /* 278 */
         3071  +#define Tcl_GetVersion \
         3072  +	(tclStubsPtr->tcl_GetVersion) /* 279 */
         3073  +#define Tcl_InitMemory \
         3074  +	(tclStubsPtr->tcl_InitMemory) /* 280 */
         3075  +#define Tcl_StackChannel \
         3076  +	(tclStubsPtr->tcl_StackChannel) /* 281 */
         3077  +#define Tcl_UnstackChannel \
         3078  +	(tclStubsPtr->tcl_UnstackChannel) /* 282 */
         3079  +#define Tcl_GetStackedChannel \
         3080  +	(tclStubsPtr->tcl_GetStackedChannel) /* 283 */
         3081  +#define Tcl_SetMainLoop \
         3082  +	(tclStubsPtr->tcl_SetMainLoop) /* 284 */
         3083  +/* Slot 285 is reserved */
         3084  +#define Tcl_AppendObjToObj \
         3085  +	(tclStubsPtr->tcl_AppendObjToObj) /* 286 */
         3086  +#define Tcl_CreateEncoding \
         3087  +	(tclStubsPtr->tcl_CreateEncoding) /* 287 */
         3088  +#define Tcl_CreateThreadExitHandler \
         3089  +	(tclStubsPtr->tcl_CreateThreadExitHandler) /* 288 */
         3090  +#define Tcl_DeleteThreadExitHandler \
         3091  +	(tclStubsPtr->tcl_DeleteThreadExitHandler) /* 289 */
         3092  +#define Tcl_DiscardResult \
         3093  +	(tclStubsPtr->tcl_DiscardResult) /* 290 */
         3094  +#define Tcl_EvalEx \
         3095  +	(tclStubsPtr->tcl_EvalEx) /* 291 */
         3096  +#define Tcl_EvalObjv \
         3097  +	(tclStubsPtr->tcl_EvalObjv) /* 292 */
         3098  +#define Tcl_EvalObjEx \
         3099  +	(tclStubsPtr->tcl_EvalObjEx) /* 293 */
         3100  +#define Tcl_ExitThread \
         3101  +	(tclStubsPtr->tcl_ExitThread) /* 294 */
         3102  +#define Tcl_ExternalToUtf \
         3103  +	(tclStubsPtr->tcl_ExternalToUtf) /* 295 */
         3104  +#define Tcl_ExternalToUtfDString \
         3105  +	(tclStubsPtr->tcl_ExternalToUtfDString) /* 296 */
         3106  +#define Tcl_FinalizeThread \
         3107  +	(tclStubsPtr->tcl_FinalizeThread) /* 297 */
         3108  +#define Tcl_FinalizeNotifier \
         3109  +	(tclStubsPtr->tcl_FinalizeNotifier) /* 298 */
         3110  +#define Tcl_FreeEncoding \
         3111  +	(tclStubsPtr->tcl_FreeEncoding) /* 299 */
         3112  +#define Tcl_GetCurrentThread \
         3113  +	(tclStubsPtr->tcl_GetCurrentThread) /* 300 */
         3114  +#define Tcl_GetEncoding \
         3115  +	(tclStubsPtr->tcl_GetEncoding) /* 301 */
         3116  +#define Tcl_GetEncodingName \
         3117  +	(tclStubsPtr->tcl_GetEncodingName) /* 302 */
         3118  +#define Tcl_GetEncodingNames \
         3119  +	(tclStubsPtr->tcl_GetEncodingNames) /* 303 */
         3120  +#define Tcl_GetIndexFromObjStruct \
         3121  +	(tclStubsPtr->tcl_GetIndexFromObjStruct) /* 304 */
         3122  +#define Tcl_GetThreadData \
         3123  +	(tclStubsPtr->tcl_GetThreadData) /* 305 */
         3124  +#define Tcl_GetVar2Ex \
         3125  +	(tclStubsPtr->tcl_GetVar2Ex) /* 306 */
         3126  +#define Tcl_InitNotifier \
         3127  +	(tclStubsPtr->tcl_InitNotifier) /* 307 */
         3128  +#define Tcl_MutexLock \
         3129  +	(tclStubsPtr->tcl_MutexLock) /* 308 */
         3130  +#define Tcl_MutexUnlock \
         3131  +	(tclStubsPtr->tcl_MutexUnlock) /* 309 */
         3132  +#define Tcl_ConditionNotify \
         3133  +	(tclStubsPtr->tcl_ConditionNotify) /* 310 */
         3134  +#define Tcl_ConditionWait \
         3135  +	(tclStubsPtr->tcl_ConditionWait) /* 311 */
         3136  +#define Tcl_NumUtfChars \
         3137  +	(tclStubsPtr->tcl_NumUtfChars) /* 312 */
         3138  +#define Tcl_ReadChars \
         3139  +	(tclStubsPtr->tcl_ReadChars) /* 313 */
         3140  +#define Tcl_RestoreResult \
         3141  +	(tclStubsPtr->tcl_RestoreResult) /* 314 */
         3142  +#define Tcl_SaveResult \
         3143  +	(tclStubsPtr->tcl_SaveResult) /* 315 */
         3144  +#define Tcl_SetSystemEncoding \
         3145  +	(tclStubsPtr->tcl_SetSystemEncoding) /* 316 */
         3146  +#define Tcl_SetVar2Ex \
         3147  +	(tclStubsPtr->tcl_SetVar2Ex) /* 317 */
         3148  +#define Tcl_ThreadAlert \
         3149  +	(tclStubsPtr->tcl_ThreadAlert) /* 318 */
         3150  +#define Tcl_ThreadQueueEvent \
         3151  +	(tclStubsPtr->tcl_ThreadQueueEvent) /* 319 */
         3152  +#define Tcl_UniCharAtIndex \
         3153  +	(tclStubsPtr->tcl_UniCharAtIndex) /* 320 */
         3154  +#define Tcl_UniCharToLower \
         3155  +	(tclStubsPtr->tcl_UniCharToLower) /* 321 */
         3156  +#define Tcl_UniCharToTitle \
         3157  +	(tclStubsPtr->tcl_UniCharToTitle) /* 322 */
         3158  +#define Tcl_UniCharToUpper \
         3159  +	(tclStubsPtr->tcl_UniCharToUpper) /* 323 */
         3160  +#define Tcl_UniCharToUtf \
         3161  +	(tclStubsPtr->tcl_UniCharToUtf) /* 324 */
         3162  +#define Tcl_UtfAtIndex \
         3163  +	(tclStubsPtr->tcl_UtfAtIndex) /* 325 */
         3164  +#define Tcl_UtfCharComplete \
         3165  +	(tclStubsPtr->tcl_UtfCharComplete) /* 326 */
         3166  +#define Tcl_UtfBackslash \
         3167  +	(tclStubsPtr->tcl_UtfBackslash) /* 327 */
         3168  +#define Tcl_UtfFindFirst \
         3169  +	(tclStubsPtr->tcl_UtfFindFirst) /* 328 */
         3170  +#define Tcl_UtfFindLast \
         3171  +	(tclStubsPtr->tcl_UtfFindLast) /* 329 */
         3172  +#define Tcl_UtfNext \
         3173  +	(tclStubsPtr->tcl_UtfNext) /* 330 */
         3174  +#define Tcl_UtfPrev \
         3175  +	(tclStubsPtr->tcl_UtfPrev) /* 331 */
         3176  +#define Tcl_UtfToExternal \
         3177  +	(tclStubsPtr->tcl_UtfToExternal) /* 332 */
         3178  +#define Tcl_UtfToExternalDString \
         3179  +	(tclStubsPtr->tcl_UtfToExternalDString) /* 333 */
         3180  +#define Tcl_UtfToLower \
         3181  +	(tclStubsPtr->tcl_UtfToLower) /* 334 */
         3182  +#define Tcl_UtfToTitle \
         3183  +	(tclStubsPtr->tcl_UtfToTitle) /* 335 */
         3184  +#define Tcl_UtfToUniChar \
         3185  +	(tclStubsPtr->tcl_UtfToUniChar) /* 336 */
         3186  +#define Tcl_UtfToUpper \
         3187  +	(tclStubsPtr->tcl_UtfToUpper) /* 337 */
         3188  +#define Tcl_WriteChars \
         3189  +	(tclStubsPtr->tcl_WriteChars) /* 338 */
         3190  +#define Tcl_WriteObj \
         3191  +	(tclStubsPtr->tcl_WriteObj) /* 339 */
         3192  +#define Tcl_GetString \
         3193  +	(tclStubsPtr->tcl_GetString) /* 340 */
         3194  +#define Tcl_GetDefaultEncodingDir \
         3195  +	(tclStubsPtr->tcl_GetDefaultEncodingDir) /* 341 */
         3196  +#define Tcl_SetDefaultEncodingDir \
         3197  +	(tclStubsPtr->tcl_SetDefaultEncodingDir) /* 342 */
         3198  +#define Tcl_AlertNotifier \
         3199  +	(tclStubsPtr->tcl_AlertNotifier) /* 343 */
         3200  +#define Tcl_ServiceModeHook \
         3201  +	(tclStubsPtr->tcl_ServiceModeHook) /* 344 */
         3202  +#define Tcl_UniCharIsAlnum \
         3203  +	(tclStubsPtr->tcl_UniCharIsAlnum) /* 345 */
         3204  +#define Tcl_UniCharIsAlpha \
         3205  +	(tclStubsPtr->tcl_UniCharIsAlpha) /* 346 */
         3206  +#define Tcl_UniCharIsDigit \
         3207  +	(tclStubsPtr->tcl_UniCharIsDigit) /* 347 */
         3208  +#define Tcl_UniCharIsLower \
         3209  +	(tclStubsPtr->tcl_UniCharIsLower) /* 348 */
         3210  +#define Tcl_UniCharIsSpace \
         3211  +	(tclStubsPtr->tcl_UniCharIsSpace) /* 349 */
         3212  +#define Tcl_UniCharIsUpper \
         3213  +	(tclStubsPtr->tcl_UniCharIsUpper) /* 350 */
         3214  +#define Tcl_UniCharIsWordChar \
         3215  +	(tclStubsPtr->tcl_UniCharIsWordChar) /* 351 */
         3216  +#define Tcl_UniCharLen \
         3217  +	(tclStubsPtr->tcl_UniCharLen) /* 352 */
         3218  +#define Tcl_UniCharNcmp \
         3219  +	(tclStubsPtr->tcl_UniCharNcmp) /* 353 */
         3220  +#define Tcl_UniCharToUtfDString \
         3221  +	(tclStubsPtr->tcl_UniCharToUtfDString) /* 354 */
         3222  +#define Tcl_UtfToUniCharDString \
         3223  +	(tclStubsPtr->tcl_UtfToUniCharDString) /* 355 */
         3224  +#define Tcl_GetRegExpFromObj \
         3225  +	(tclStubsPtr->tcl_GetRegExpFromObj) /* 356 */
         3226  +#define Tcl_EvalTokens \
         3227  +	(tclStubsPtr->tcl_EvalTokens) /* 357 */
         3228  +#define Tcl_FreeParse \
         3229  +	(tclStubsPtr->tcl_FreeParse) /* 358 */
         3230  +#define Tcl_LogCommandInfo \
         3231  +	(tclStubsPtr->tcl_LogCommandInfo) /* 359 */
         3232  +#define Tcl_ParseBraces \
         3233  +	(tclStubsPtr->tcl_ParseBraces) /* 360 */
         3234  +#define Tcl_ParseCommand \
         3235  +	(tclStubsPtr->tcl_ParseCommand) /* 361 */
         3236  +#define Tcl_ParseExpr \
         3237  +	(tclStubsPtr->tcl_ParseExpr) /* 362 */
         3238  +#define Tcl_ParseQuotedString \
         3239  +	(tclStubsPtr->tcl_ParseQuotedString) /* 363 */
         3240  +#define Tcl_ParseVarName \
         3241  +	(tclStubsPtr->tcl_ParseVarName) /* 364 */
         3242  +#define Tcl_GetCwd \
         3243  +	(tclStubsPtr->tcl_GetCwd) /* 365 */
         3244  +#define Tcl_Chdir \
         3245  +	(tclStubsPtr->tcl_Chdir) /* 366 */
         3246  +#define Tcl_Access \
         3247  +	(tclStubsPtr->tcl_Access) /* 367 */
         3248  +#define Tcl_Stat \
         3249  +	(tclStubsPtr->tcl_Stat) /* 368 */
         3250  +#define Tcl_UtfNcmp \
         3251  +	(tclStubsPtr->tcl_UtfNcmp) /* 369 */
         3252  +#define Tcl_UtfNcasecmp \
         3253  +	(tclStubsPtr->tcl_UtfNcasecmp) /* 370 */
         3254  +#define Tcl_StringCaseMatch \
         3255  +	(tclStubsPtr->tcl_StringCaseMatch) /* 371 */
         3256  +#define Tcl_UniCharIsControl \
         3257  +	(tclStubsPtr->tcl_UniCharIsControl) /* 372 */
         3258  +#define Tcl_UniCharIsGraph \
         3259  +	(tclStubsPtr->tcl_UniCharIsGraph) /* 373 */
         3260  +#define Tcl_UniCharIsPrint \
         3261  +	(tclStubsPtr->tcl_UniCharIsPrint) /* 374 */
         3262  +#define Tcl_UniCharIsPunct \
         3263  +	(tclStubsPtr->tcl_UniCharIsPunct) /* 375 */
         3264  +#define Tcl_RegExpExecObj \
         3265  +	(tclStubsPtr->tcl_RegExpExecObj) /* 376 */
         3266  +#define Tcl_RegExpGetInfo \
         3267  +	(tclStubsPtr->tcl_RegExpGetInfo) /* 377 */
         3268  +#define Tcl_NewUnicodeObj \
         3269  +	(tclStubsPtr->tcl_NewUnicodeObj) /* 378 */
         3270  +#define Tcl_SetUnicodeObj \
         3271  +	(tclStubsPtr->tcl_SetUnicodeObj) /* 379 */
         3272  +#define Tcl_GetCharLength \
         3273  +	(tclStubsPtr->tcl_GetCharLength) /* 380 */
         3274  +#define Tcl_GetUniChar \
         3275  +	(tclStubsPtr->tcl_GetUniChar) /* 381 */
         3276  +#define Tcl_GetUnicode \
         3277  +	(tclStubsPtr->tcl_GetUnicode) /* 382 */
         3278  +#define Tcl_GetRange \
         3279  +	(tclStubsPtr->tcl_GetRange) /* 383 */
         3280  +#define Tcl_AppendUnicodeToObj \
         3281  +	(tclStubsPtr->tcl_AppendUnicodeToObj) /* 384 */
         3282  +#define Tcl_RegExpMatchObj \
         3283  +	(tclStubsPtr->tcl_RegExpMatchObj) /* 385 */
         3284  +#define Tcl_SetNotifier \
         3285  +	(tclStubsPtr->tcl_SetNotifier) /* 386 */
         3286  +#define Tcl_GetAllocMutex \
         3287  +	(tclStubsPtr->tcl_GetAllocMutex) /* 387 */
         3288  +#define Tcl_GetChannelNames \
         3289  +	(tclStubsPtr->tcl_GetChannelNames) /* 388 */
         3290  +#define Tcl_GetChannelNamesEx \
         3291  +	(tclStubsPtr->tcl_GetChannelNamesEx) /* 389 */
         3292  +#define Tcl_ProcObjCmd \
         3293  +	(tclStubsPtr->tcl_ProcObjCmd) /* 390 */
         3294  +#define Tcl_ConditionFinalize \
         3295  +	(tclStubsPtr->tcl_ConditionFinalize) /* 391 */
         3296  +#define Tcl_MutexFinalize \
         3297  +	(tclStubsPtr->tcl_MutexFinalize) /* 392 */
         3298  +#define Tcl_CreateThread \
         3299  +	(tclStubsPtr->tcl_CreateThread) /* 393 */
         3300  +#define Tcl_ReadRaw \
         3301  +	(tclStubsPtr->tcl_ReadRaw) /* 394 */
         3302  +#define Tcl_WriteRaw \
         3303  +	(tclStubsPtr->tcl_WriteRaw) /* 395 */
         3304  +#define Tcl_GetTopChannel \
         3305  +	(tclStubsPtr->tcl_GetTopChannel) /* 396 */
         3306  +#define Tcl_ChannelBuffered \
         3307  +	(tclStubsPtr->tcl_ChannelBuffered) /* 397 */
         3308  +#define Tcl_ChannelName \
         3309  +	(tclStubsPtr->tcl_ChannelName) /* 398 */
         3310  +#define Tcl_ChannelVersion \
         3311  +	(tclStubsPtr->tcl_ChannelVersion) /* 399 */
         3312  +#define Tcl_ChannelBlockModeProc \
         3313  +	(tclStubsPtr->tcl_ChannelBlockModeProc) /* 400 */
         3314  +#define Tcl_ChannelCloseProc \
         3315  +	(tclStubsPtr->tcl_ChannelCloseProc) /* 401 */
         3316  +#define Tcl_ChannelClose2Proc \
         3317  +	(tclStubsPtr->tcl_ChannelClose2Proc) /* 402 */
         3318  +#define Tcl_ChannelInputProc \
         3319  +	(tclStubsPtr->tcl_ChannelInputProc) /* 403 */
         3320  +#define Tcl_ChannelOutputProc \
         3321  +	(tclStubsPtr->tcl_ChannelOutputProc) /* 404 */
         3322  +#define Tcl_ChannelSeekProc \
         3323  +	(tclStubsPtr->tcl_ChannelSeekProc) /* 405 */
         3324  +#define Tcl_ChannelSetOptionProc \
         3325  +	(tclStubsPtr->tcl_ChannelSetOptionProc) /* 406 */
         3326  +#define Tcl_ChannelGetOptionProc \
         3327  +	(tclStubsPtr->tcl_ChannelGetOptionProc) /* 407 */
         3328  +#define Tcl_ChannelWatchProc \
         3329  +	(tclStubsPtr->tcl_ChannelWatchProc) /* 408 */
         3330  +#define Tcl_ChannelGetHandleProc \
         3331  +	(tclStubsPtr->tcl_ChannelGetHandleProc) /* 409 */
         3332  +#define Tcl_ChannelFlushProc \
         3333  +	(tclStubsPtr->tcl_ChannelFlushProc) /* 410 */
         3334  +#define Tcl_ChannelHandlerProc \
         3335  +	(tclStubsPtr->tcl_ChannelHandlerProc) /* 411 */
         3336  +#define Tcl_JoinThread \
         3337  +	(tclStubsPtr->tcl_JoinThread) /* 412 */
         3338  +#define Tcl_IsChannelShared \
         3339  +	(tclStubsPtr->tcl_IsChannelShared) /* 413 */
         3340  +#define Tcl_IsChannelRegistered \
         3341  +	(tclStubsPtr->tcl_IsChannelRegistered) /* 414 */
         3342  +#define Tcl_CutChannel \
         3343  +	(tclStubsPtr->tcl_CutChannel) /* 415 */
         3344  +#define Tcl_SpliceChannel \
         3345  +	(tclStubsPtr->tcl_SpliceChannel) /* 416 */
         3346  +#define Tcl_ClearChannelHandlers \
         3347  +	(tclStubsPtr->tcl_ClearChannelHandlers) /* 417 */
         3348  +#define Tcl_IsChannelExisting \
         3349  +	(tclStubsPtr->tcl_IsChannelExisting) /* 418 */
         3350  +#define Tcl_UniCharNcasecmp \
         3351  +	(tclStubsPtr->tcl_UniCharNcasecmp) /* 419 */
         3352  +#define Tcl_UniCharCaseMatch \
         3353  +	(tclStubsPtr->tcl_UniCharCaseMatch) /* 420 */
         3354  +#define Tcl_FindHashEntry \
         3355  +	(tclStubsPtr->tcl_FindHashEntry) /* 421 */
         3356  +#define Tcl_CreateHashEntry \
         3357  +	(tclStubsPtr->tcl_CreateHashEntry) /* 422 */
         3358  +#define Tcl_InitCustomHashTable \
         3359  +	(tclStubsPtr->tcl_InitCustomHashTable) /* 423 */
         3360  +#define Tcl_InitObjHashTable \
         3361  +	(tclStubsPtr->tcl_InitObjHashTable) /* 424 */
         3362  +#define Tcl_CommandTraceInfo \
         3363  +	(tclStubsPtr->tcl_CommandTraceInfo) /* 425 */
         3364  +#define Tcl_TraceCommand \
         3365  +	(tclStubsPtr->tcl_TraceCommand) /* 426 */
         3366  +#define Tcl_UntraceCommand \
         3367  +	(tclStubsPtr->tcl_UntraceCommand) /* 427 */
         3368  +#define Tcl_AttemptAlloc \
         3369  +	(tclStubsPtr->tcl_AttemptAlloc) /* 428 */
         3370  +#define Tcl_AttemptDbCkalloc \
         3371  +	(tclStubsPtr->tcl_AttemptDbCkalloc) /* 429 */
         3372  +#define Tcl_AttemptRealloc \
         3373  +	(tclStubsPtr->tcl_AttemptRealloc) /* 430 */
         3374  +#define Tcl_AttemptDbCkrealloc \
         3375  +	(tclStubsPtr->tcl_AttemptDbCkrealloc) /* 431 */
         3376  +#define Tcl_AttemptSetObjLength \
         3377  +	(tclStubsPtr->tcl_AttemptSetObjLength) /* 432 */
         3378  +#define Tcl_GetChannelThread \
         3379  +	(tclStubsPtr->tcl_GetChannelThread) /* 433 */
         3380  +#define Tcl_GetUnicodeFromObj \
         3381  +	(tclStubsPtr->tcl_GetUnicodeFromObj) /* 434 */
         3382  +#define Tcl_GetMathFuncInfo \
         3383  +	(tclStubsPtr->tcl_GetMathFuncInfo) /* 435 */
         3384  +#define Tcl_ListMathFuncs \
         3385  +	(tclStubsPtr->tcl_ListMathFuncs) /* 436 */
         3386  +#define Tcl_SubstObj \
         3387  +	(tclStubsPtr->tcl_SubstObj) /* 437 */
         3388  +#define Tcl_DetachChannel \
         3389  +	(tclStubsPtr->tcl_DetachChannel) /* 438 */
         3390  +#define Tcl_IsStandardChannel \
         3391  +	(tclStubsPtr->tcl_IsStandardChannel) /* 439 */
         3392  +#define Tcl_FSCopyFile \
         3393  +	(tclStubsPtr->tcl_FSCopyFile) /* 440 */
         3394  +#define Tcl_FSCopyDirectory \
         3395  +	(tclStubsPtr->tcl_FSCopyDirectory) /* 441 */
         3396  +#define Tcl_FSCreateDirectory \
         3397  +	(tclStubsPtr->tcl_FSCreateDirectory) /* 442 */
         3398  +#define Tcl_FSDeleteFile \
         3399  +	(tclStubsPtr->tcl_FSDeleteFile) /* 443 */
         3400  +#define Tcl_FSLoadFile \
         3401  +	(tclStubsPtr->tcl_FSLoadFile) /* 444 */
         3402  +#define Tcl_FSMatchInDirectory \
         3403  +	(tclStubsPtr->tcl_FSMatchInDirectory) /* 445 */
         3404  +#define Tcl_FSLink \
         3405  +	(tclStubsPtr->tcl_FSLink) /* 446 */
         3406  +#define Tcl_FSRemoveDirectory \
         3407  +	(tclStubsPtr->tcl_FSRemoveDirectory) /* 447 */
         3408  +#define Tcl_FSRenameFile \
         3409  +	(tclStubsPtr->tcl_FSRenameFile) /* 448 */
         3410  +#define Tcl_FSLstat \
         3411  +	(tclStubsPtr->tcl_FSLstat) /* 449 */
         3412  +#define Tcl_FSUtime \
         3413  +	(tclStubsPtr->tcl_FSUtime) /* 450 */
         3414  +#define Tcl_FSFileAttrsGet \
         3415  +	(tclStubsPtr->tcl_FSFileAttrsGet) /* 451 */
         3416  +#define Tcl_FSFileAttrsSet \
         3417  +	(tclStubsPtr->tcl_FSFileAttrsSet) /* 452 */
         3418  +#define Tcl_FSFileAttrStrings \
         3419  +	(tclStubsPtr->tcl_FSFileAttrStrings) /* 453 */
         3420  +#define Tcl_FSStat \
         3421  +	(tclStubsPtr->tcl_FSStat) /* 454 */
         3422  +#define Tcl_FSAccess \
         3423  +	(tclStubsPtr->tcl_FSAccess) /* 455 */
         3424  +#define Tcl_FSOpenFileChannel \
         3425  +	(tclStubsPtr->tcl_FSOpenFileChannel) /* 456 */
         3426  +#define Tcl_FSGetCwd \
         3427  +	(tclStubsPtr->tcl_FSGetCwd) /* 457 */
         3428  +#define Tcl_FSChdir \
         3429  +	(tclStubsPtr->tcl_FSChdir) /* 458 */
         3430  +#define Tcl_FSConvertToPathType \
         3431  +	(tclStubsPtr->tcl_FSConvertToPathType) /* 459 */
         3432  +#define Tcl_FSJoinPath \
         3433  +	(tclStubsPtr->tcl_FSJoinPath) /* 460 */
         3434  +#define Tcl_FSSplitPath \
         3435  +	(tclStubsPtr->tcl_FSSplitPath) /* 461 */
         3436  +#define Tcl_FSEqualPaths \
         3437  +	(tclStubsPtr->tcl_FSEqualPaths) /* 462 */
         3438  +#define Tcl_FSGetNormalizedPath \
         3439  +	(tclStubsPtr->tcl_FSGetNormalizedPath) /* 463 */
         3440  +#define Tcl_FSJoinToPath \
         3441  +	(tclStubsPtr->tcl_FSJoinToPath) /* 464 */
         3442  +#define Tcl_FSGetInternalRep \
         3443  +	(tclStubsPtr->tcl_FSGetInternalRep) /* 465 */
         3444  +#define Tcl_FSGetTranslatedPath \
         3445  +	(tclStubsPtr->tcl_FSGetTranslatedPath) /* 466 */
         3446  +#define Tcl_FSEvalFile \
         3447  +	(tclStubsPtr->tcl_FSEvalFile) /* 467 */
         3448  +#define Tcl_FSNewNativePath \
         3449  +	(tclStubsPtr->tcl_FSNewNativePath) /* 468 */
         3450  +#define Tcl_FSGetNativePath \
         3451  +	(tclStubsPtr->tcl_FSGetNativePath) /* 469 */
         3452  +#define Tcl_FSFileSystemInfo \
         3453  +	(tclStubsPtr->tcl_FSFileSystemInfo) /* 470 */
         3454  +#define Tcl_FSPathSeparator \
         3455  +	(tclStubsPtr->tcl_FSPathSeparator) /* 471 */
         3456  +#define Tcl_FSListVolumes \
         3457  +	(tclStubsPtr->tcl_FSListVolumes) /* 472 */
         3458  +#define Tcl_FSRegister \
         3459  +	(tclStubsPtr->tcl_FSRegister) /* 473 */
         3460  +#define Tcl_FSUnregister \
         3461  +	(tclStubsPtr->tcl_FSUnregister) /* 474 */
         3462  +#define Tcl_FSData \
         3463  +	(tclStubsPtr->tcl_FSData) /* 475 */
         3464  +#define Tcl_FSGetTranslatedStringPath \
         3465  +	(tclStubsPtr->tcl_FSGetTranslatedStringPath) /* 476 */
         3466  +#define Tcl_FSGetFileSystemForPath \
         3467  +	(tclStubsPtr->tcl_FSGetFileSystemForPath) /* 477 */
         3468  +#define Tcl_FSGetPathType \
         3469  +	(tclStubsPtr->tcl_FSGetPathType) /* 478 */
         3470  +#define Tcl_OutputBuffered \
         3471  +	(tclStubsPtr->tcl_OutputBuffered) /* 479 */
         3472  +#define Tcl_FSMountsChanged \
         3473  +	(tclStubsPtr->tcl_FSMountsChanged) /* 480 */
         3474  +#define Tcl_EvalTokensStandard \
         3475  +	(tclStubsPtr->tcl_EvalTokensStandard) /* 481 */
         3476  +#define Tcl_GetTime \
         3477  +	(tclStubsPtr->tcl_GetTime) /* 482 */
         3478  +#define Tcl_CreateObjTrace \
         3479  +	(tclStubsPtr->tcl_CreateObjTrace) /* 483 */
         3480  +#define Tcl_GetCommandInfoFromToken \
         3481  +	(tclStubsPtr->tcl_GetCommandInfoFromToken) /* 484 */
         3482  +#define Tcl_SetCommandInfoFromToken \
         3483  +	(tclStubsPtr->tcl_SetCommandInfoFromToken) /* 485 */
         3484  +#define Tcl_DbNewWideIntObj \
         3485  +	(tclStubsPtr->tcl_DbNewWideIntObj) /* 486 */
         3486  +#define Tcl_GetWideIntFromObj \
         3487  +	(tclStubsPtr->tcl_GetWideIntFromObj) /* 487 */
         3488  +#define Tcl_NewWideIntObj \
         3489  +	(tclStubsPtr->tcl_NewWideIntObj) /* 488 */
         3490  +#define Tcl_SetWideIntObj \
         3491  +	(tclStubsPtr->tcl_SetWideIntObj) /* 489 */
         3492  +#define Tcl_AllocStatBuf \
         3493  +	(tclStubsPtr->tcl_AllocStatBuf) /* 490 */
         3494  +#define Tcl_Seek \
         3495  +	(tclStubsPtr->tcl_Seek) /* 491 */
         3496  +#define Tcl_Tell \
         3497  +	(tclStubsPtr->tcl_Tell) /* 492 */
         3498  +#define Tcl_ChannelWideSeekProc \
         3499  +	(tclStubsPtr->tcl_ChannelWideSeekProc) /* 493 */
         3500  +#define Tcl_DictObjPut \
         3501  +	(tclStubsPtr->tcl_DictObjPut) /* 494 */
         3502  +#define Tcl_DictObjGet \
         3503  +	(tclStubsPtr->tcl_DictObjGet) /* 495 */
         3504  +#define Tcl_DictObjRemove \
         3505  +	(tclStubsPtr->tcl_DictObjRemove) /* 496 */
         3506  +#define Tcl_DictObjSize \
         3507  +	(tclStubsPtr->tcl_DictObjSize) /* 497 */
         3508  +#define Tcl_DictObjFirst \
         3509  +	(tclStubsPtr->tcl_DictObjFirst) /* 498 */
         3510  +#define Tcl_DictObjNext \
         3511  +	(tclStubsPtr->tcl_DictObjNext) /* 499 */
         3512  +#define Tcl_DictObjDone \
         3513  +	(tclStubsPtr->tcl_DictObjDone) /* 500 */
         3514  +#define Tcl_DictObjPutKeyList \
         3515  +	(tclStubsPtr->tcl_DictObjPutKeyList) /* 501 */
         3516  +#define Tcl_DictObjRemoveKeyList \
         3517  +	(tclStubsPtr->tcl_DictObjRemoveKeyList) /* 502 */
         3518  +#define Tcl_NewDictObj \
         3519  +	(tclStubsPtr->tcl_NewDictObj) /* 503 */
         3520  +#define Tcl_DbNewDictObj \
         3521  +	(tclStubsPtr->tcl_DbNewDictObj) /* 504 */
         3522  +#define Tcl_RegisterConfig \
         3523  +	(tclStubsPtr->tcl_RegisterConfig) /* 505 */
         3524  +#define Tcl_CreateNamespace \
         3525  +	(tclStubsPtr->tcl_CreateNamespace) /* 506 */
         3526  +#define Tcl_DeleteNamespace \
         3527  +	(tclStubsPtr->tcl_DeleteNamespace) /* 507 */
         3528  +#define Tcl_AppendExportList \
         3529  +	(tclStubsPtr->tcl_AppendExportList) /* 508 */
         3530  +#define Tcl_Export \
         3531  +	(tclStubsPtr->tcl_Export) /* 509 */
         3532  +#define Tcl_Import \
         3533  +	(tclStubsPtr->tcl_Import) /* 510 */
         3534  +#define Tcl_ForgetImport \
         3535  +	(tclStubsPtr->tcl_ForgetImport) /* 511 */
         3536  +#define Tcl_GetCurrentNamespace \
         3537  +	(tclStubsPtr->tcl_GetCurrentNamespace) /* 512 */
         3538  +#define Tcl_GetGlobalNamespace \
         3539  +	(tclStubsPtr->tcl_GetGlobalNamespace) /* 513 */
         3540  +#define Tcl_FindNamespace \
         3541  +	(tclStubsPtr->tcl_FindNamespace) /* 514 */
         3542  +#define Tcl_FindCommand \
         3543  +	(tclStubsPtr->tcl_FindCommand) /* 515 */
         3544  +#define Tcl_GetCommandFromObj \
         3545  +	(tclStubsPtr->tcl_GetCommandFromObj) /* 516 */
         3546  +#define Tcl_GetCommandFullName \
         3547  +	(tclStubsPtr->tcl_GetCommandFullName) /* 517 */
         3548  +#define Tcl_FSEvalFileEx \
         3549  +	(tclStubsPtr->tcl_FSEvalFileEx) /* 518 */
         3550  +#define Tcl_SetExitProc \
         3551  +	(tclStubsPtr->tcl_SetExitProc) /* 519 */
         3552  +#define Tcl_LimitAddHandler \
         3553  +	(tclStubsPtr->tcl_LimitAddHandler) /* 520 */
         3554  +#define Tcl_LimitRemoveHandler \
         3555  +	(tclStubsPtr->tcl_LimitRemoveHandler) /* 521 */
         3556  +#define Tcl_LimitReady \
         3557  +	(tclStubsPtr->tcl_LimitReady) /* 522 */
         3558  +#define Tcl_LimitCheck \
         3559  +	(tclStubsPtr->tcl_LimitCheck) /* 523 */
         3560  +#define Tcl_LimitExceeded \
         3561  +	(tclStubsPtr->tcl_LimitExceeded) /* 524 */
         3562  +#define Tcl_LimitSetCommands \
         3563  +	(tclStubsPtr->tcl_LimitSetCommands) /* 525 */
         3564  +#define Tcl_LimitSetTime \
         3565  +	(tclStubsPtr->tcl_LimitSetTime) /* 526 */
         3566  +#define Tcl_LimitSetGranularity \
         3567  +	(tclStubsPtr->tcl_LimitSetGranularity) /* 527 */
         3568  +#define Tcl_LimitTypeEnabled \
         3569  +	(tclStubsPtr->tcl_LimitTypeEnabled) /* 528 */
         3570  +#define Tcl_LimitTypeExceeded \
         3571  +	(tclStubsPtr->tcl_LimitTypeExceeded) /* 529 */
         3572  +#define Tcl_LimitTypeSet \
         3573  +	(tclStubsPtr->tcl_LimitTypeSet) /* 530 */
         3574  +#define Tcl_LimitTypeReset \
         3575  +	(tclStubsPtr->tcl_LimitTypeReset) /* 531 */
         3576  +#define Tcl_LimitGetCommands \
         3577  +	(tclStubsPtr->tcl_LimitGetCommands) /* 532 */
         3578  +#define Tcl_LimitGetTime \
         3579  +	(tclStubsPtr->tcl_LimitGetTime) /* 533 */
         3580  +#define Tcl_LimitGetGranularity \
         3581  +	(tclStubsPtr->tcl_LimitGetGranularity) /* 534 */
         3582  +#define Tcl_SaveInterpState \
         3583  +	(tclStubsPtr->tcl_SaveInterpState) /* 535 */
         3584  +#define Tcl_RestoreInterpState \
         3585  +	(tclStubsPtr->tcl_RestoreInterpState) /* 536 */
         3586  +#define Tcl_DiscardInterpState \
         3587  +	(tclStubsPtr->tcl_DiscardInterpState) /* 537 */
         3588  +#define Tcl_SetReturnOptions \
         3589  +	(tclStubsPtr->tcl_SetReturnOptions) /* 538 */
         3590  +#define Tcl_GetReturnOptions \
         3591  +	(tclStubsPtr->tcl_GetReturnOptions) /* 539 */
         3592  +#define Tcl_IsEnsemble \
         3593  +	(tclStubsPtr->tcl_IsEnsemble) /* 540 */
         3594  +#define Tcl_CreateEnsemble \
         3595  +	(tclStubsPtr->tcl_CreateEnsemble) /* 541 */
         3596  +#define Tcl_FindEnsemble \
         3597  +	(tclStubsPtr->tcl_FindEnsemble) /* 542 */
         3598  +#define Tcl_SetEnsembleSubcommandList \
         3599  +	(tclStubsPtr->tcl_SetEnsembleSubcommandList) /* 543 */
         3600  +#define Tcl_SetEnsembleMappingDict \
         3601  +	(tclStubsPtr->tcl_SetEnsembleMappingDict) /* 544 */
         3602  +#define Tcl_SetEnsembleUnknownHandler \
         3603  +	(tclStubsPtr->tcl_SetEnsembleUnknownHandler) /* 545 */
         3604  +#define Tcl_SetEnsembleFlags \
         3605  +	(tclStubsPtr->tcl_SetEnsembleFlags) /* 546 */
         3606  +#define Tcl_GetEnsembleSubcommandList \
         3607  +	(tclStubsPtr->tcl_GetEnsembleSubcommandList) /* 547 */
         3608  +#define Tcl_GetEnsembleMappingDict \
         3609  +	(tclStubsPtr->tcl_GetEnsembleMappingDict) /* 548 */
         3610  +#define Tcl_GetEnsembleUnknownHandler \
         3611  +	(tclStubsPtr->tcl_GetEnsembleUnknownHandler) /* 549 */
         3612  +#define Tcl_GetEnsembleFlags \
         3613  +	(tclStubsPtr->tcl_GetEnsembleFlags) /* 550 */
         3614  +#define Tcl_GetEnsembleNamespace \
         3615  +	(tclStubsPtr->tcl_GetEnsembleNamespace) /* 551 */
         3616  +#define Tcl_SetTimeProc \
         3617  +	(tclStubsPtr->tcl_SetTimeProc) /* 552 */
         3618  +#define Tcl_QueryTimeProc \
         3619  +	(tclStubsPtr->tcl_QueryTimeProc) /* 553 */
         3620  +#define Tcl_ChannelThreadActionProc \
         3621  +	(tclStubsPtr->tcl_ChannelThreadActionProc) /* 554 */
         3622  +#define Tcl_NewBignumObj \
         3623  +	(tclStubsPtr->tcl_NewBignumObj) /* 555 */
         3624  +#define Tcl_DbNewBignumObj \
         3625  +	(tclStubsPtr->tcl_DbNewBignumObj) /* 556 */
         3626  +#define Tcl_SetBignumObj \
         3627  +	(tclStubsPtr->tcl_SetBignumObj) /* 557 */
         3628  +#define Tcl_GetBignumFromObj \
         3629  +	(tclStubsPtr->tcl_GetBignumFromObj) /* 558 */
         3630  +#define Tcl_TakeBignumFromObj \
         3631  +	(tclStubsPtr->tcl_TakeBignumFromObj) /* 559 */
         3632  +#define Tcl_TruncateChannel \
         3633  +	(tclStubsPtr->tcl_TruncateChannel) /* 560 */
         3634  +#define Tcl_ChannelTruncateProc \
         3635  +	(tclStubsPtr->tcl_ChannelTruncateProc) /* 561 */
         3636  +#define Tcl_SetChannelErrorInterp \
         3637  +	(tclStubsPtr->tcl_SetChannelErrorInterp) /* 562 */
         3638  +#define Tcl_GetChannelErrorInterp \
         3639  +	(tclStubsPtr->tcl_GetChannelErrorInterp) /* 563 */
         3640  +#define Tcl_SetChannelError \
         3641  +	(tclStubsPtr->tcl_SetChannelError) /* 564 */
         3642  +#define Tcl_GetChannelError \
         3643  +	(tclStubsPtr->tcl_GetChannelError) /* 565 */
         3644  +#define Tcl_InitBignumFromDouble \
         3645  +	(tclStubsPtr->tcl_InitBignumFromDouble) /* 566 */
         3646  +#define Tcl_GetNamespaceUnknownHandler \
         3647  +	(tclStubsPtr->tcl_GetNamespaceUnknownHandler) /* 567 */
         3648  +#define Tcl_SetNamespaceUnknownHandler \
         3649  +	(tclStubsPtr->tcl_SetNamespaceUnknownHandler) /* 568 */
         3650  +#define Tcl_GetEncodingFromObj \
         3651  +	(tclStubsPtr->tcl_GetEncodingFromObj) /* 569 */
         3652  +#define Tcl_GetEncodingSearchPath \
         3653  +	(tclStubsPtr->tcl_GetEncodingSearchPath) /* 570 */
         3654  +#define Tcl_SetEncodingSearchPath \
         3655  +	(tclStubsPtr->tcl_SetEncodingSearchPath) /* 571 */
         3656  +#define Tcl_GetEncodingNameFromEnvironment \
         3657  +	(tclStubsPtr->tcl_GetEncodingNameFromEnvironment) /* 572 */
         3658  +#define Tcl_PkgRequireProc \
         3659  +	(tclStubsPtr->tcl_PkgRequireProc) /* 573 */
         3660  +#define Tcl_AppendObjToErrorInfo \
         3661  +	(tclStubsPtr->tcl_AppendObjToErrorInfo) /* 574 */
         3662  +#define Tcl_AppendLimitedToObj \
         3663  +	(tclStubsPtr->tcl_AppendLimitedToObj) /* 575 */
         3664  +#define Tcl_Format \
         3665  +	(tclStubsPtr->tcl_Format) /* 576 */
         3666  +#define Tcl_AppendFormatToObj \
         3667  +	(tclStubsPtr->tcl_AppendFormatToObj) /* 577 */
         3668  +#define Tcl_ObjPrintf \
         3669  +	(tclStubsPtr->tcl_ObjPrintf) /* 578 */
         3670  +#define Tcl_AppendPrintfToObj \
         3671  +	(tclStubsPtr->tcl_AppendPrintfToObj) /* 579 */
         3672  +#define Tcl_CancelEval \
         3673  +	(tclStubsPtr->tcl_CancelEval) /* 580 */
         3674  +#define Tcl_Canceled \
         3675  +	(tclStubsPtr->tcl_Canceled) /* 581 */
         3676  +#define Tcl_CreatePipe \
         3677  +	(tclStubsPtr->tcl_CreatePipe) /* 582 */
         3678  +#define Tcl_NRCreateCommand \
         3679  +	(tclStubsPtr->tcl_NRCreateCommand) /* 583 */
         3680  +#define Tcl_NREvalObj \
         3681  +	(tclStubsPtr->tcl_NREvalObj) /* 584 */
         3682  +#define Tcl_NREvalObjv \
         3683  +	(tclStubsPtr->tcl_NREvalObjv) /* 585 */
         3684  +#define Tcl_NRCmdSwap \
         3685  +	(tclStubsPtr->tcl_NRCmdSwap) /* 586 */
         3686  +#define Tcl_NRAddCallback \
         3687  +	(tclStubsPtr->tcl_NRAddCallback) /* 587 */
         3688  +#define Tcl_NRCallObjProc \
         3689  +	(tclStubsPtr->tcl_NRCallObjProc) /* 588 */
         3690  +#define Tcl_GetFSDeviceFromStat \
         3691  +	(tclStubsPtr->tcl_GetFSDeviceFromStat) /* 589 */
         3692  +#define Tcl_GetFSInodeFromStat \
         3693  +	(tclStubsPtr->tcl_GetFSInodeFromStat) /* 590 */
         3694  +#define Tcl_GetModeFromStat \
         3695  +	(tclStubsPtr->tcl_GetModeFromStat) /* 591 */
         3696  +#define Tcl_GetLinkCountFromStat \
         3697  +	(tclStubsPtr->tcl_GetLinkCountFromStat) /* 592 */
         3698  +#define Tcl_GetUserIdFromStat \
         3699  +	(tclStubsPtr->tcl_GetUserIdFromStat) /* 593 */
         3700  +#define Tcl_GetGroupIdFromStat \
         3701  +	(tclStubsPtr->tcl_GetGroupIdFromStat) /* 594 */
         3702  +#define Tcl_GetDeviceTypeFromStat \
         3703  +	(tclStubsPtr->tcl_GetDeviceTypeFromStat) /* 595 */
         3704  +#define Tcl_GetAccessTimeFromStat \
         3705  +	(tclStubsPtr->tcl_GetAccessTimeFromStat) /* 596 */
         3706  +#define Tcl_GetModificationTimeFromStat \
         3707  +	(tclStubsPtr->tcl_GetModificationTimeFromStat) /* 597 */
         3708  +#define Tcl_GetChangeTimeFromStat \
         3709  +	(tclStubsPtr->tcl_GetChangeTimeFromStat) /* 598 */
         3710  +#define Tcl_GetSizeFromStat \
         3711  +	(tclStubsPtr->tcl_GetSizeFromStat) /* 599 */
         3712  +#define Tcl_GetBlocksFromStat \
         3713  +	(tclStubsPtr->tcl_GetBlocksFromStat) /* 600 */
         3714  +#define Tcl_GetBlockSizeFromStat \
         3715  +	(tclStubsPtr->tcl_GetBlockSizeFromStat) /* 601 */
         3716  +#define Tcl_SetEnsembleParameterList \
         3717  +	(tclStubsPtr->tcl_SetEnsembleParameterList) /* 602 */
         3718  +#define Tcl_GetEnsembleParameterList \
         3719  +	(tclStubsPtr->tcl_GetEnsembleParameterList) /* 603 */
         3720  +#define Tcl_ParseArgsObjv \
         3721  +	(tclStubsPtr->tcl_ParseArgsObjv) /* 604 */
         3722  +#define Tcl_GetErrorLine \
         3723  +	(tclStubsPtr->tcl_GetErrorLine) /* 605 */
         3724  +#define Tcl_SetErrorLine \
         3725  +	(tclStubsPtr->tcl_SetErrorLine) /* 606 */
         3726  +#define Tcl_TransferResult \
         3727  +	(tclStubsPtr->tcl_TransferResult) /* 607 */
         3728  +#define Tcl_InterpActive \
         3729  +	(tclStubsPtr->tcl_InterpActive) /* 608 */
         3730  +#define Tcl_BackgroundException \
         3731  +	(tclStubsPtr->tcl_BackgroundException) /* 609 */
         3732  +#define Tcl_ZlibDeflate \
         3733  +	(tclStubsPtr->tcl_ZlibDeflate) /* 610 */
         3734  +#define Tcl_ZlibInflate \
         3735  +	(tclStubsPtr->tcl_ZlibInflate) /* 611 */
         3736  +#define Tcl_ZlibCRC32 \
         3737  +	(tclStubsPtr->tcl_ZlibCRC32) /* 612 */
         3738  +#define Tcl_ZlibAdler32 \
         3739  +	(tclStubsPtr->tcl_ZlibAdler32) /* 613 */
         3740  +#define Tcl_ZlibStreamInit \
         3741  +	(tclStubsPtr->tcl_ZlibStreamInit) /* 614 */
         3742  +#define Tcl_ZlibStreamGetCommandName \
         3743  +	(tclStubsPtr->tcl_ZlibStreamGetCommandName) /* 615 */
         3744  +#define Tcl_ZlibStreamEof \
         3745  +	(tclStubsPtr->tcl_ZlibStreamEof) /* 616 */
         3746  +#define Tcl_ZlibStreamChecksum \
         3747  +	(tclStubsPtr->tcl_ZlibStreamChecksum) /* 617 */
         3748  +#define Tcl_ZlibStreamPut \
         3749  +	(tclStubsPtr->tcl_ZlibStreamPut) /* 618 */
         3750  +#define Tcl_ZlibStreamGet \
         3751  +	(tclStubsPtr->tcl_ZlibStreamGet) /* 619 */
         3752  +#define Tcl_ZlibStreamClose \
         3753  +	(tclStubsPtr->tcl_ZlibStreamClose) /* 620 */
         3754  +#define Tcl_ZlibStreamReset \
         3755  +	(tclStubsPtr->tcl_ZlibStreamReset) /* 621 */
         3756  +#define Tcl_SetStartupScript \
         3757  +	(tclStubsPtr->tcl_SetStartupScript) /* 622 */
         3758  +#define Tcl_GetStartupScript \
         3759  +	(tclStubsPtr->tcl_GetStartupScript) /* 623 */
         3760  +#define Tcl_CloseEx \
         3761  +	(tclStubsPtr->tcl_CloseEx) /* 624 */
         3762  +#define Tcl_NRExprObj \
         3763  +	(tclStubsPtr->tcl_NRExprObj) /* 625 */
         3764  +#define Tcl_NRSubstObj \
         3765  +	(tclStubsPtr->tcl_NRSubstObj) /* 626 */
         3766  +#define Tcl_LoadFile \
         3767  +	(tclStubsPtr->tcl_LoadFile) /* 627 */
         3768  +#define Tcl_FindSymbol \
         3769  +	(tclStubsPtr->tcl_FindSymbol) /* 628 */
         3770  +#define Tcl_FSUnloadFile \
         3771  +	(tclStubsPtr->tcl_FSUnloadFile) /* 629 */
         3772  +#define Tcl_ZlibStreamSetCompressionDictionary \
         3773  +	(tclStubsPtr->tcl_ZlibStreamSetCompressionDictionary) /* 630 */
         3774  +
         3775  +#endif /* defined(USE_TCL_STUBS) */
         3776  +
         3777  +/* !END!: Do not edit above this line. */
         3778  +
         3779  +#if defined(USE_TCL_STUBS)
         3780  +#   undef Tcl_CreateInterp
         3781  +#   undef Tcl_FindExecutable
         3782  +#   undef Tcl_GetStringResult
         3783  +#   undef Tcl_Init
         3784  +#   undef Tcl_SetPanicProc
         3785  +#   undef Tcl_SetVar
         3786  +#   undef Tcl_StaticPackage
         3787  +#   undef TclFSGetNativePath
         3788  +#   define Tcl_CreateInterp() (tclStubsPtr->tcl_CreateInterp())
         3789  +#   define Tcl_GetStringResult(interp) (tclStubsPtr->tcl_GetStringResult(interp))
         3790  +#   define Tcl_Init(interp) (tclStubsPtr->tcl_Init(interp))
         3791  +#   define Tcl_SetPanicProc(proc) (tclStubsPtr->tcl_SetPanicProc(proc))
         3792  +#   define Tcl_SetVar(interp, varName, newValue, flags) \
         3793  +	    (tclStubsPtr->tcl_SetVar(interp, varName, newValue, flags))
         3794  +#endif
         3795  +
         3796  +#if defined(_WIN32) && defined(UNICODE)
         3797  +#   define Tcl_FindExecutable(arg) ((Tcl_FindExecutable)((const char *)(arg)))
         3798  +#   define Tcl_MainEx Tcl_MainExW
         3799  +    EXTERN void Tcl_MainExW(int argc, wchar_t **argv,
         3800  +	    Tcl_AppInitProc *appInitProc, Tcl_Interp *interp);
         3801  +#endif
         3802  +
         3803  +#undef TCL_STORAGE_CLASS
         3804  +#define TCL_STORAGE_CLASS DLLIMPORT
         3805  +
         3806  +#endif /* _TCLDECLS */

Added compat/tcl-8.6/generic/tclPlatDecls.h.

            1  +/*
            2  + * tclPlatDecls.h --
            3  + *
            4  + *	Declarations of platform specific Tcl APIs.
            5  + *
            6  + * Copyright (c) 1998-1999 by Scriptics Corporation.
            7  + * All rights reserved.
            8  + */
            9  +
           10  +#ifndef _TCLPLATDECLS
           11  +#define _TCLPLATDECLS
           12  +
           13  +#undef TCL_STORAGE_CLASS
           14  +#ifdef BUILD_tcl
           15  +#   define TCL_STORAGE_CLASS DLLEXPORT
           16  +#else
           17  +#   ifdef USE_TCL_STUBS
           18  +#      define TCL_STORAGE_CLASS
           19  +#   else
           20  +#      define TCL_STORAGE_CLASS DLLIMPORT
           21  +#   endif
           22  +#endif
           23  +
           24  +/*
           25  + * WARNING: This file is automatically generated by the tools/genStubs.tcl
           26  + * script.  Any modifications to the function declarations below should be made
           27  + * in the generic/tcl.decls script.
           28  + */
           29  +
           30  +/*
           31  + * TCHAR is needed here for win32, so if it is not defined yet do it here.
           32  + * This way, we don't need to include <tchar.h> just for one define.
           33  + */
           34  +#if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(_TCHAR_DEFINED)
           35  +#   if defined(_UNICODE)
           36  +	typedef wchar_t TCHAR;
           37  +#   else
           38  +	typedef char TCHAR;
           39  +#   endif
           40  +#   define _TCHAR_DEFINED
           41  +#endif
           42  +
           43  +/* !BEGIN!: Do not edit below this line. */
           44  +
           45  +/*
           46  + * Exported function declarations:
           47  + */
           48  +
           49  +#if defined(__WIN32__) || defined(__CYGWIN__) /* WIN */
           50  +/* 0 */
           51  +EXTERN TCHAR *		Tcl_WinUtfToTChar(const char *str, int len,
           52  +				Tcl_DString *dsPtr);
           53  +/* 1 */
           54  +EXTERN char *		Tcl_WinTCharToUtf(const TCHAR *str, int len,
           55  +				Tcl_DString *dsPtr);
           56  +#endif /* WIN */
           57  +#ifdef MAC_OSX_TCL /* MACOSX */
           58  +/* 0 */
           59  +EXTERN int		Tcl_MacOSXOpenBundleResources(Tcl_Interp *interp,
           60  +				const char *bundleName, int hasResourceFile,
           61  +				int maxPathLen, char *libraryPath);
           62  +/* 1 */
           63  +EXTERN int		Tcl_MacOSXOpenVersionedBundleResources(
           64  +				Tcl_Interp *interp, const char *bundleName,
           65  +				const char *bundleVersion,
           66  +				int hasResourceFile, int maxPathLen,
           67  +				char *libraryPath);
           68  +#endif /* MACOSX */
           69  +
           70  +typedef struct TclPlatStubs {
           71  +    int magic;
           72  +    void *hooks;
           73  +
           74  +#if defined(__WIN32__) || defined(__CYGWIN__) /* WIN */
           75  +    TCHAR * (*tcl_WinUtfToTChar) (const char *str, int len, Tcl_DString *dsPtr); /* 0 */
           76  +    char * (*tcl_WinTCharToUtf) (const TCHAR *str, int len, Tcl_DString *dsPtr); /* 1 */
           77  +#endif /* WIN */
           78  +#ifdef MAC_OSX_TCL /* MACOSX */
           79  +    int (*tcl_MacOSXOpenBundleResources) (Tcl_Interp *interp, const char *bundleName, int hasResourceFile, int maxPathLen, char *libraryPath); /* 0 */
           80  +    int (*tcl_MacOSXOpenVersionedBundleResources) (Tcl_Interp *interp, const char *bundleName, const char *bundleVersion, int hasResourceFile, int maxPathLen, char *libraryPath); /* 1 */
           81  +#endif /* MACOSX */
           82  +} TclPlatStubs;
           83  +
           84  +#ifdef __cplusplus
           85  +extern "C" {
           86  +#endif
           87  +extern const TclPlatStubs *tclPlatStubsPtr;
           88  +#ifdef __cplusplus
           89  +}
           90  +#endif
           91  +
           92  +#if defined(USE_TCL_STUBS)
           93  +
           94  +/*
           95  + * Inline function declarations:
           96  + */
           97  +
           98  +#if defined(__WIN32__) || defined(__CYGWIN__) /* WIN */
           99  +#define Tcl_WinUtfToTChar \
          100  +	(tclPlatStubsPtr->tcl_WinUtfToTChar) /* 0 */
          101  +#define Tcl_WinTCharToUtf \
          102  +	(tclPlatStubsPtr->tcl_WinTCharToUtf) /* 1 */
          103  +#endif /* WIN */
          104  +#ifdef MAC_OSX_TCL /* MACOSX */
          105  +#define Tcl_MacOSXOpenBundleResources \
          106  +	(tclPlatStubsPtr->tcl_MacOSXOpenBundleResources) /* 0 */
          107  +#define Tcl_MacOSXOpenVersionedBundleResources \
          108  +	(tclPlatStubsPtr->tcl_MacOSXOpenVersionedBundleResources) /* 1 */
          109  +#endif /* MACOSX */
          110  +
          111  +#endif /* defined(USE_TCL_STUBS) */
          112  +
          113  +/* !END!: Do not edit above this line. */
          114  +
          115  +#undef TCL_STORAGE_CLASS
          116  +#define TCL_STORAGE_CLASS DLLIMPORT
          117  +
          118  +#endif /* _TCLPLATDECLS */
          119  +
          120  +

Changes to compat/zlib/CMakeLists.txt.

     1      1   cmake_minimum_required(VERSION 2.4.4)
     2      2   set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)
     3      3   
     4      4   project(zlib C)
     5      5   
     6         -set(VERSION "1.2.7")
            6  +set(VERSION "1.2.8")
            7  +
            8  +option(ASM686 "Enable building i686 assembly implementation")
            9  +option(AMD64 "Enable building amd64 assembly implementation")
     7     10   
     8     11   set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables")
     9     12   set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries")
    10     13   set(INSTALL_INC_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "Installation directory for headers")
    11     14   set(INSTALL_MAN_DIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Installation directory for manual pages")
    12     15   set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/share/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
    13     16   
................................................................................
   117    120       inffast.c
   118    121       trees.c
   119    122       uncompr.c
   120    123       zutil.c
   121    124   )
   122    125   
   123    126   if(NOT MINGW)
   124         -    set(ZLIB_SRCS ${ZLIB_SRCS}
          127  +    set(ZLIB_DLL_SRCS
   125    128           win32/zlib1.rc # If present will override custom build rule below.
   126    129       )
   127    130   endif()
          131  +
          132  +if(CMAKE_COMPILER_IS_GNUCC)
          133  +    if(ASM686)
          134  +        set(ZLIB_ASMS contrib/asm686/match.S)
          135  +    elseif (AMD64)
          136  +        set(ZLIB_ASMS contrib/amd64/amd64-match.S)
          137  +    endif ()
          138  +
          139  +	if(ZLIB_ASMS)
          140  +		add_definitions(-DASMV)
          141  +		set_source_files_properties(${ZLIB_ASMS} PROPERTIES LANGUAGE C COMPILE_FLAGS -DNO_UNDERLINE)
          142  +	endif()
          143  +endif()
          144  +
          145  +if(MSVC)
          146  +    if(ASM686)
          147  +		ENABLE_LANGUAGE(ASM_MASM)
          148  +        set(ZLIB_ASMS
          149  +			contrib/masmx86/inffas32.asm
          150  +			contrib/masmx86/match686.asm
          151  +		)
          152  +    elseif (AMD64)
          153  +		ENABLE_LANGUAGE(ASM_MASM)
          154  +        set(ZLIB_ASMS
          155  +			contrib/masmx64/gvmat64.asm
          156  +			contrib/masmx64/inffasx64.asm
          157  +		)
          158  +    endif()
          159  +
          160  +	if(ZLIB_ASMS)
          161  +		add_definitions(-DASMV -DASMINF)
          162  +	endif()
          163  +endif()
   128    164   
   129    165   # parse the full version number from zlib.h and include in ZLIB_FULL_VERSION
   130    166   file(READ ${CMAKE_CURRENT_SOURCE_DIR}/zlib.h _zlib_h_contents)
   131    167   string(REGEX REPLACE ".*#define[ \t]+ZLIB_VERSION[ \t]+\"([-0-9A-Za-z.]+)\".*"
   132    168       "\\1" ZLIB_FULL_VERSION ${_zlib_h_contents})
   133    169   
   134    170   if(MINGW)
   135    171       # This gets us DLL resource information when compiling on MinGW.
   136    172       if(NOT CMAKE_RC_COMPILER)
   137         -        SET(CMAKE_RC_COMPILER windres.exe)
          173  +        set(CMAKE_RC_COMPILER windres.exe)
   138    174       endif()
   139    175   
   140    176       add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj
   141    177                          COMMAND ${CMAKE_RC_COMPILER}
   142    178                               -D GCC_WINDRES
   143    179                               -I ${CMAKE_CURRENT_SOURCE_DIR}
   144    180                               -I ${CMAKE_CURRENT_BINARY_DIR}
   145    181                               -o ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj
   146    182                               -i ${CMAKE_CURRENT_SOURCE_DIR}/win32/zlib1.rc)
   147         -    set(ZLIB_SRCS ${ZLIB_SRCS} ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj)
          183  +    set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj)
   148    184   endif(MINGW)
   149    185   
   150         -add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
   151         -add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
          186  +add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
          187  +add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
   152    188   set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)
   153    189   set_target_properties(zlib PROPERTIES SOVERSION 1)
   154    190   
   155    191   if(NOT CYGWIN)
   156    192       # This property causes shared libraries on Linux to have the full version
   157    193       # encoded into their final filename.  We disable this on Cygwin because
   158    194       # it causes cygz-${ZLIB_FULL_VERSION}.dll to be created when cygz.dll
................................................................................
   162    198       # the DLL comes from the resource file win32/zlib1.rc
   163    199       set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION})
   164    200   endif()
   165    201   
   166    202   if(UNIX)
   167    203       # On unix-like platforms the library is almost always called libz
   168    204      set_target_properties(zlib zlibstatic PROPERTIES OUTPUT_NAME z)
   169         -   set_target_properties(zlib PROPERTIES LINK_FLAGS "-Wl,--version-script,${CMAKE_CURRENT_SOURCE_DIR}/zlib.map")
          205  +   if(NOT APPLE)
          206  +     set_target_properties(zlib PROPERTIES LINK_FLAGS "-Wl,--version-script,\"${CMAKE_CURRENT_SOURCE_DIR}/zlib.map\"")
          207  +   endif()
   170    208   elseif(BUILD_SHARED_LIBS AND WIN32)
   171    209       # Creates zlib1.dll when building shared library version
   172    210       set_target_properties(zlib PROPERTIES SUFFIX "1.dll")
   173    211   endif()
   174    212   
   175    213   if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
   176    214       install(TARGETS zlib zlibstatic

Changes to compat/zlib/ChangeLog.

     1      1   
     2      2                   ChangeLog file for zlib
     3      3   
            4  +Changes in 1.2.8 (28 Apr 2013)
            5  +- Update contrib/minizip/iowin32.c for Windows RT [Vollant]
            6  +- Do not force Z_CONST for C++
            7  +- Clean up contrib/vstudio [Ro]
            8  +- Correct spelling error in zlib.h
            9  +- Fix mixed line endings in contrib/vstudio
           10  +
           11  +Changes in 1.2.7.3 (13 Apr 2013)
           12  +- Fix version numbers and DLL names in contrib/vstudio/*/zlib.rc
           13  +
           14  +Changes in 1.2.7.2 (13 Apr 2013)
           15  +- Change check for a four-byte type back to hexadecimal
           16  +- Fix typo in win32/Makefile.msc
           17  +- Add casts in gzwrite.c for pointer differences
           18  +
           19  +Changes in 1.2.7.1 (24 Mar 2013)
           20  +- Replace use of unsafe string functions with snprintf if available
           21  +- Avoid including stddef.h on Windows for Z_SOLO compile [Niessink]
           22  +- Fix gzgetc undefine when Z_PREFIX set [Turk]
           23  +- Eliminate use of mktemp in Makefile (not always available)
           24  +- Fix bug in 'F' mode for gzopen()
           25  +- Add inflateGetDictionary() function
           26  +- Correct comment in deflate.h
           27  +- Use _snprintf for snprintf in Microsoft C
           28  +- On Darwin, only use /usr/bin/libtool if libtool is not Apple
           29  +- Delete "--version" file if created by "ar --version" [Richard G.]
           30  +- Fix configure check for veracity of compiler error return codes
           31  +- Fix CMake compilation of static lib for MSVC2010 x64
           32  +- Remove unused variable in infback9.c
           33  +- Fix argument checks in gzlog_compress() and gzlog_write()
           34  +- Clean up the usage of z_const and respect const usage within zlib
           35  +- Clean up examples/gzlog.[ch] comparisons of different types
           36  +- Avoid shift equal to bits in type (caused endless loop)
           37  +- Fix unintialized value bug in gzputc() introduced by const patches
           38  +- Fix memory allocation error in examples/zran.c [Nor]
           39  +- Fix bug where gzopen(), gzclose() would write an empty file
           40  +- Fix bug in gzclose() when gzwrite() runs out of memory
           41  +- Check for input buffer malloc failure in examples/gzappend.c
           42  +- Add note to contrib/blast to use binary mode in stdio
           43  +- Fix comparisons of differently signed integers in contrib/blast
           44  +- Check for invalid code length codes in contrib/puff
           45  +- Fix serious but very rare decompression bug in inftrees.c
           46  +- Update inflateBack() comments, since inflate() can be faster
           47  +- Use underscored I/O function names for WINAPI_FAMILY
           48  +- Add _tr_flush_bits to the external symbols prefixed by --zprefix
           49  +- Add contrib/vstudio/vc10 pre-build step for static only
           50  +- Quote --version-script argument in CMakeLists.txt
           51  +- Don't specify --version-script on Apple platforms in CMakeLists.txt
           52  +- Fix casting error in contrib/testzlib/testzlib.c
           53  +- Fix types in contrib/minizip to match result of get_crc_table()
           54  +- Simplify contrib/vstudio/vc10 with 'd' suffix
           55  +- Add TOP support to win32/Makefile.msc
           56  +- Suport i686 and amd64 assembler builds in CMakeLists.txt
           57  +- Fix typos in the use of _LARGEFILE64_SOURCE in zconf.h
           58  +- Add vc11 and vc12 build files to contrib/vstudio
           59  +- Add gzvprintf() as an undocumented function in zlib
           60  +- Fix configure for Sun shell
           61  +- Remove runtime check in configure for four-byte integer type
           62  +- Add casts and consts to ease user conversion to C++
           63  +- Add man pages for minizip and miniunzip
           64  +- In Makefile uninstall, don't rm if preceding cd fails
           65  +- Do not return Z_BUF_ERROR if deflateParam() has nothing to write
           66  +
     4     67   Changes in 1.2.7 (2 May 2012)
     5     68   - Replace use of memmove() with a simple copy for portability
     6     69   - Test for existence of strerror
     7     70   - Restore gzgetc_ for backward compatibility with 1.2.6
     8     71   - Fix build with non-GNU make on Solaris
     9     72   - Require gcc 4.0 or later on Mac OS X to use the hidden attribute
    10     73   - Include unistd.h for Watcom C

Changes to compat/zlib/Makefile.in.

     1      1   # Makefile for zlib
     2         -# Copyright (C) 1995-2011 Jean-loup Gailly.
            2  +# Copyright (C) 1995-2013 Jean-loup Gailly, Mark Adler
     3      3   # For conditions of distribution and use, see copyright notice in zlib.h
     4      4   
     5      5   # To compile and test, type:
     6      6   #    ./configure; make test
     7      7   # Normally configure builds both a static and a shared library.
     8      8   # If you want to build just a static library, use: ./configure --static
     9      9   
................................................................................
    28     28   LDFLAGS=
    29     29   TEST_LDFLAGS=-L. libz.a
    30     30   LDSHARED=$(CC)
    31     31   CPP=$(CC) -E
    32     32   
    33     33   STATICLIB=libz.a
    34     34   SHAREDLIB=libz.so
    35         -SHAREDLIBV=libz.so.1.2.7
           35  +SHAREDLIBV=libz.so.1.2.8
    36     36   SHAREDLIBM=libz.so.1
    37     37   LIBS=$(STATICLIB) $(SHAREDLIBV)
    38     38   
    39     39   AR=ar
    40     40   ARFLAGS=rc
    41     41   RANLIB=ranlib
    42     42   LDCONFIG=ldconfig
................................................................................
    79     79   all64: example64$(EXE) minigzip64$(EXE)
    80     80   
    81     81   check: test
    82     82   
    83     83   test: all teststatic testshared
    84     84   
    85     85   teststatic: static
    86         -	@TMPST=`mktemp fooXXXXXX`; \
           86  +	@TMPST=tmpst_$$; \
    87     87   	if echo hello world | ./minigzip | ./minigzip -d && ./example $$TMPST ; then \
    88     88   	  echo '		*** zlib test OK ***'; \
    89     89   	else \
    90     90   	  echo '		*** zlib test FAILED ***'; false; \
    91     91   	fi; \
    92     92   	rm -f $$TMPST
    93     93   
    94     94   testshared: shared
    95     95   	@LD_LIBRARY_PATH=`pwd`:$(LD_LIBRARY_PATH) ; export LD_LIBRARY_PATH; \
    96     96   	LD_LIBRARYN32_PATH=`pwd`:$(LD_LIBRARYN32_PATH) ; export LD_LIBRARYN32_PATH; \
    97     97   	DYLD_LIBRARY_PATH=`pwd`:$(DYLD_LIBRARY_PATH) ; export DYLD_LIBRARY_PATH; \
    98     98   	SHLIB_PATH=`pwd`:$(SHLIB_PATH) ; export SHLIB_PATH; \
    99         -	TMPSH=`mktemp fooXXXXXX`; \
           99  +	TMPSH=tmpsh_$$; \
   100    100   	if echo hello world | ./minigzipsh | ./minigzipsh -d && ./examplesh $$TMPSH; then \
   101    101   	  echo '		*** zlib shared test OK ***'; \
   102    102   	else \
   103    103   	  echo '		*** zlib shared test FAILED ***'; false; \
   104    104   	fi; \
   105    105   	rm -f $$TMPSH
   106    106   
   107    107   test64: all64
   108         -	@TMP64=`mktemp fooXXXXXX`; \
          108  +	@TMP64=tmp64_$$; \
   109    109   	if echo hello world | ./minigzip64 | ./minigzip64 -d && ./example64 $$TMP64; then \
   110    110   	  echo '		*** zlib 64-bit test OK ***'; \
   111    111   	else \
   112    112   	  echo '		*** zlib 64-bit test FAILED ***'; false; \
   113    113   	fi; \
   114    114   	rm -f $$TMP64
   115    115   
................................................................................
   212    212   
   213    213   install: install-libs
   214    214   	-@if [ ! -d $(DESTDIR)$(includedir)   ]; then mkdir -p $(DESTDIR)$(includedir); fi
   215    215   	cp zlib.h zconf.h $(DESTDIR)$(includedir)
   216    216   	chmod 644 $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
   217    217   
   218    218   uninstall:
   219         -	cd $(DESTDIR)$(includedir); rm -f zlib.h zconf.h
   220         -	cd $(DESTDIR)$(libdir); rm -f libz.a; \
          219  +	cd $(DESTDIR)$(includedir) && rm -f zlib.h zconf.h
          220  +	cd $(DESTDIR)$(libdir) && rm -f libz.a; \
   221    221   	if test -n "$(SHAREDLIBV)" -a -f $(SHAREDLIBV); then \
   222    222   	  rm -f $(SHAREDLIBV) $(SHAREDLIB) $(SHAREDLIBM); \
   223    223   	fi
   224         -	cd $(DESTDIR)$(man3dir); rm -f zlib.3
   225         -	cd $(DESTDIR)$(pkgconfigdir); rm -f zlib.pc
          224  +	cd $(DESTDIR)$(man3dir) && rm -f zlib.3
          225  +	cd $(DESTDIR)$(pkgconfigdir) && rm -f zlib.pc
   226    226   
   227    227   docs: zlib.3.pdf
   228    228   
   229    229   zlib.3.pdf: zlib.3
   230    230   	groff -mandoc -f H -T ps zlib.3 | ps2pdf - zlib.3.pdf
   231    231   
   232    232   zconf.h.cmakein: zconf.h.in
   233         -	-@ TEMPFILE=`mktemp __XXXXXX`; \
          233  +	-@ TEMPFILE=zconfh_$$; \
   234    234   	echo "/#define ZCONF_H/ a\\\\\n#cmakedefine Z_PREFIX\\\\\n#cmakedefine Z_HAVE_UNISTD_H\n" >> $$TEMPFILE &&\
   235    235   	sed -f $$TEMPFILE zconf.h.in > zconf.h.cmakein &&\
   236    236   	touch -r zconf.h.in zconf.h.cmakein &&\
   237    237   	rm $$TEMPFILE
   238    238   
   239    239   zconf: zconf.h.in
   240    240   	cp -p zconf.h.in zconf.h

Changes to compat/zlib/README.

     1      1   ZLIB DATA COMPRESSION LIBRARY
     2      2   
     3         -zlib 1.2.7 is a general purpose data compression library.  All the code is
            3  +zlib 1.2.8 is a general purpose data compression library.  All the code is
     4      4   thread safe.  The data format used by the zlib library is described by RFCs
     5      5   (Request for Comments) 1950 to 1952 in the files
     6      6   http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and
     7      7   rfc1952 (gzip format).
     8      8   
     9      9   All functions of the compression library are documented in the file zlib.h
    10     10   (volunteer to write man pages welcome, contact zlib@gzip.org).  A usage example
................................................................................
    27     27   
    28     28   PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help.
    29     29   
    30     30   Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan.  1997
    31     31   issue of Dr.  Dobb's Journal; a copy of the article is available at
    32     32   http://marknelson.us/1997/01/01/zlib-engine/ .
    33     33   
    34         -The changes made in version 1.2.7 are documented in the file ChangeLog.
           34  +The changes made in version 1.2.8 are documented in the file ChangeLog.
    35     35   
    36     36   Unsupported third party contributions are provided in directory contrib/ .
    37     37   
    38     38   zlib is available in Java using the java.util.zip package, documented at
    39     39   http://java.sun.com/developer/technicalArticles/Programming/compression/ .
    40     40   
    41     41   A Perl interface to zlib written by Paul Marquess <pmqs@cpan.org> is available
................................................................................
    80     80     The deflate format used by zlib was defined by Phil Katz.  The deflate and
    81     81     zlib specifications were written by L.  Peter Deutsch.  Thanks to all the
    82     82     people who reported problems and suggested various improvements in zlib; they
    83     83     are too numerous to cite here.
    84     84   
    85     85   Copyright notice:
    86     86   
    87         - (C) 1995-2012 Jean-loup Gailly and Mark Adler
           87  + (C) 1995-2013 Jean-loup Gailly and Mark Adler
    88     88   
    89     89     This software is provided 'as-is', without any express or implied
    90     90     warranty.  In no event will the authors be held liable for any damages
    91     91     arising from the use of this software.
    92     92   
    93     93     Permission is granted to anyone to use this software for any purpose,
    94     94     including commercial applications, and to alter it and redistribute it

Changes to compat/zlib/as400/bndsrc.

   197    197     EXPORT SYMBOL("gzgetc_")
   198    198   
   199    199   /********************************************************************/
   200    200   /*   *MODULE      INFLATE      ZLIB         01/02/01  00:15:09      */
   201    201   /********************************************************************/
   202    202   
   203    203     EXPORT SYMBOL("inflateResetKeep")
          204  +
          205  +/*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
          206  +/*   Version 1.2.8 additional entry points.                         */
          207  +/*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
          208  +
          209  +/********************************************************************/
          210  +/*   *MODULE      INFLATE      ZLIB         01/02/01  00:15:09      */
          211  +/********************************************************************/
          212  +
          213  +  EXPORT SYMBOL("inflateGetDictionary")
   204    214   
   205    215   ENDPGMEXP

Changes to compat/zlib/as400/compile.clp.

   101    101                                    &MODLIB/GZCLOSE     &MODLIB/GZLIB       +
   102    102                                    &MODLIB/GZREAD      &MODLIB/GZWRITE     +
   103    103                                    &MODLIB/INFBACK     &MODLIB/INFFAST     +
   104    104                                    &MODLIB/INFLATE     &MODLIB/INFTREES    +
   105    105                                    &MODLIB/TREES       &MODLIB/UNCOMPR     +
   106    106                                    &MODLIB/ZUTIL)                          +
   107    107                             SRCFILE(&SRCLIB/&CTLFILE) SRCMBR(BNDSRC)       +
   108         -                          TEXT('ZLIB 1.2.7') TGTRLS(&TGTRLS)
          108  +                          TEXT('ZLIB 1.2.8') TGTRLS(&TGTRLS)
   109    109   
   110    110                ENDPGM

Changes to compat/zlib/as400/readme.txt.

     1         -        ZLIB version 1.2.7 for AS400 installation instructions
            1  +        ZLIB version 1.2.8 for AS400 installation instructions
     2      2   
     3      3   I) From an AS400 *SAVF file:
     4      4   
     5      5   1)      Unpacking archive to an AS400 save file
     6      6   
     7      7   On the AS400:
     8      8   

Changes to compat/zlib/as400/zlib.inc.

     1      1         *  ZLIB.INC - Interface to the general purpose compression library
     2      2         *
     3      3         *  ILE RPG400 version by Patrick Monnerat, DATASPHERE.
     4         -      *  Version 1.2.7
            4  +      *  Version 1.2.8
     5      5         *
     6      6         *
     7      7         *  WARNING:
     8      8         *     Procedures inflateInit(), inflateInit2(), deflateInit(),
     9      9         *         deflateInit2() and inflateBackInit() need to be called with
    10     10         *         two additional arguments:
    11     11         *         the package version string and the stream control structure.
................................................................................
    18     18         *
    19     19         **************************************************************************
    20     20         *                               Constants
    21     21         **************************************************************************
    22     22         *
    23     23         *  Versioning information.
    24     24         *
    25         -     D ZLIB_VERSION    C                   '1.2.7'
    26         -     D ZLIB_VERNUM     C                   X'1270'
           25  +     D ZLIB_VERSION    C                   '1.2.8'
           26  +     D ZLIB_VERNUM     C                   X'1280'
    27     27        D ZLIB_VER_MAJOR  C                   1
    28     28        D ZLIB_VER_MINOR  C                   2
    29     29        D ZLIB_VER_REVISION...
    30         -     D                 C                   7
           30  +     D                 C                   8
    31     31        D ZLIB_VER_SUBREVISION...
    32     32        D                 C                   0
    33     33         *
    34     34         *  Other equates.
    35     35         *
    36     36        D Z_NO_FLUSH      C                   0
    37     37        D Z_PARTIAL_FLUSH...
................................................................................
   355    355         *
   356    356        D inflateSetDictionary...
   357    357        D                 PR            10I 0 extproc('inflateSetDictionary')      Init. dictionary
   358    358        D  strm                               like(z_stream)                       Expansion stream
   359    359        D  dictionary                65535    const options(*varsize)              Dictionary bytes
   360    360        D  dictLength                   10U 0 value                                Dictionary length
   361    361         *
          362  +     D inflateGetDictionary...
          363  +     D                 PR            10I 0 extproc('inflateGetDictionary')      Get dictionary
          364  +     D  strm                               like(z_stream)                       Expansion stream
          365  +     D  dictionary                65535    options(*varsize)                    Dictionary bytes
          366  +     D  dictLength                   10U 0                                      Dictionary length
          367  +      *
   362    368        D inflateSync     PR            10I 0 extproc('inflateSync')               Sync. expansion
   363    369        D  strm                               like(z_stream)                       Expansion stream
   364    370         *
   365    371        D inflateCopy     PR            10I 0 extproc('inflateCopy')
   366    372        D  dest                               like(z_stream)                       Destination stream
   367    373        D  source                             like(z_stream)                       Source stream
   368    374         *

Changes to compat/zlib/compress.c.

    25     25       const Bytef *source;
    26     26       uLong sourceLen;
    27     27       int level;
    28     28   {
    29     29       z_stream stream;
    30     30       int err;
    31     31   
    32         -    stream.next_in = (Bytef*)source;
           32  +    stream.next_in = (z_const Bytef *)source;
    33     33       stream.avail_in = (uInt)sourceLen;
    34     34   #ifdef MAXSEG_64K
    35     35       /* Check for source > 64K on 16-bit machine: */
    36     36       if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
    37     37   #endif
    38     38       stream.next_out = dest;
    39     39       stream.avail_out = (uInt)*destLen;

Changes to compat/zlib/configure.

    66     66   includedir=${includedir-'${prefix}/include'}
    67     67   mandir=${mandir-'${prefix}/share/man'}
    68     68   shared_ext='.so'
    69     69   shared=1
    70     70   solo=0
    71     71   cover=0
    72     72   zprefix=0
           73  +zconst=0
    73     74   build64=0
    74     75   gcc=0
    75     76   old_cc="$CC"
    76     77   old_cflags="$CFLAGS"
    77     78   OBJC='$(OBJZ) $(OBJG)'
    78     79   PIC_OBJC='$(PIC_OBJZ) $(PIC_OBJG)'
           80  +
           81  +# leave this script, optionally in a bad way
           82  +leave()
           83  +{
           84  +  if test "$*" != "0"; then
           85  +    echo "** $0 aborting." | tee -a configure.log
           86  +  fi
           87  +  rm -f $test.[co] $test $test$shared_ext $test.gcno ./--version
           88  +  echo -------------------- >> configure.log
           89  +  echo >> configure.log
           90  +  echo >> configure.log
           91  +  exit $1
           92  +}
    79     93   
    80     94   # process command line options
    81     95   while test $# -ge 1
    82     96   do
    83     97   case "$1" in
    84     98       -h* | --help)
    85     99         echo 'usage:' | tee -a configure.log
    86         -      echo '  configure [--zprefix] [--prefix=PREFIX]  [--eprefix=EXPREFIX]' | tee -a configure.log
          100  +      echo '  configure [--const] [--zprefix] [--prefix=PREFIX]  [--eprefix=EXPREFIX]' | tee -a configure.log
    87    101         echo '    [--static] [--64] [--libdir=LIBDIR] [--sharedlibdir=LIBDIR]' | tee -a configure.log
    88    102         echo '    [--includedir=INCLUDEDIR] [--archs="-arch i386 -arch x86_64"]' | tee -a configure.log
    89    103           exit 0 ;;
    90    104       -p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;;
    91    105       -e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;;
    92    106       -l*=* | --libdir=*) libdir=`echo $1 | sed 's/.*=//'`; shift ;;
    93    107       --sharedlibdir=*) sharedlibdir=`echo $1 | sed 's/.*=//'`; shift ;;
................................................................................
   102    116       --solo) solo=1; shift ;;
   103    117       --cover) cover=1; shift ;;
   104    118       -z* | --zprefix) zprefix=1; shift ;;
   105    119       -6* | --64) build64=1; shift ;;
   106    120       -a*=* | --archs=*) ARCHS=`echo $1 | sed 's/.*=//'`; shift ;;
   107    121       --sysconfdir=*) echo "ignored option: --sysconfdir" | tee -a configure.log; shift ;;
   108    122       --localstatedir=*) echo "ignored option: --localstatedir" | tee -a configure.log; shift ;;
   109         -    *) echo "unknown option: $1"; echo "$0 --help for help" | tee -a configure.log; exit 1 ;;
          123  +    -c* | --const) zconst=1; shift ;;
          124  +    *)
          125  +      echo "unknown option: $1" | tee -a configure.log
          126  +      echo "$0 --help for help" | tee -a configure.log
          127  +      leave 1;;
   110    128       esac
   111    129   done
   112    130   
   113         -# define functions for testing compiler and library characteristics and logging the results
          131  +# temporary file name
   114    132   test=ztest$$
   115    133   
          134  +# put arguments in log, also put test file in log if used in arguments
   116    135   show()
   117    136   {
   118    137     case "$*" in
   119    138       *$test.c*)
   120    139         echo === $test.c === >> configure.log
   121    140         cat $test.c >> configure.log
   122    141         echo === >> configure.log;;
   123    142     esac
   124    143     echo $* >> configure.log
   125    144   }
   126    145   
   127         -cat > $test.c <<EOF
   128         -#error error
   129         -EOF
   130         -if ($CC -c $CFLAGS $test.c) 2>/dev/null; then
   131         -  try()
   132         -  {
   133         -    show $*
   134         -    test "`( $* ) 2>&1 | tee -a configure.log`" = ""
   135         -  }
   136         -  echo - using any output from compiler to indicate an error >> configure.log
   137         -else
   138         -  try()
   139         -  {
   140         -    show $*
   141         -    ( $* ) >> configure.log 2>&1
   142         -    ret=$?
   143         -    if test $ret -ne 0; then
   144         -      echo "(exit code "$ret")" >> configure.log
   145         -    fi
   146         -    return $ret
   147         -  }
   148         -fi
   149         -
   150         -tryboth()
   151         -{
   152         -  show $*
   153         -  got=`( $* ) 2>&1`
   154         -  ret=$?
   155         -  printf %s "$got" >> configure.log
   156         -  if test $ret -ne 0; then
   157         -    return $ret
   158         -  fi
   159         -  test "$got" = ""
   160         -}
   161         -
   162         -echo >> configure.log
   163         -
   164    146   # check for gcc vs. cc and set compile and link flags based on the system identified by uname
   165    147   cat > $test.c <<EOF
   166    148   extern int getchar();
   167    149   int hello() {return getchar();}
   168    150   EOF
   169    151   
   170    152   test -z "$CC" && echo Checking for ${CROSS_PREFIX}gcc... | tee -a configure.log
................................................................................
   175    157     *gcc*) gcc=1 ;;
   176    158     *clang*) gcc=1 ;;
   177    159   esac
   178    160   case `$cc -v 2>&1` in
   179    161     *gcc*) gcc=1 ;;
   180    162   esac
   181    163   
   182         -show $cc -c $cflags $test.c
   183         -if test "$gcc" -eq 1 && ($cc -c $cflags $test.c) >> configure.log 2>&1; then
          164  +show $cc -c $test.c
          165  +if test "$gcc" -eq 1 && ($cc -c $test.c) >> configure.log 2>&1; then
   184    166     echo ... using gcc >> configure.log
   185    167     CC="$cc"
   186    168     CFLAGS="${CFLAGS--O3} ${ARCHS}"
   187    169     SFLAGS="${CFLAGS--O3} -fPIC"
   188    170     LDFLAGS="${LDFLAGS} ${ARCHS}"
   189    171     if test $build64 -eq 1; then
   190    172       CFLAGS="${CFLAGS} -m64"
   191    173       SFLAGS="${SFLAGS} -m64"
   192    174     fi
   193    175     if test "${ZLIBGCCWARN}" = "YES"; then
          176  +    if test "$zconst" -eq 1; then
          177  +      CFLAGS="${CFLAGS} -Wall -Wextra -Wcast-qual -pedantic -DZLIB_CONST"
          178  +    else
   194    179       CFLAGS="${CFLAGS} -Wall -Wextra -pedantic"
   195    180     fi
          181  +  fi
   196    182     if test -z "$uname"; then
   197    183       uname=`(uname -s || echo unknown) 2>/dev/null`
   198    184     fi
   199    185     case "$uname" in
   200    186     Linux* | linux* | GNU | GNU/* | solaris*)
   201    187           LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,zlib.map"} ;;
   202    188     *BSD | *bsd* | DragonFly)
................................................................................
   204    190           LDCONFIG="ldconfig -m" ;;
   205    191     CYGWIN* | Cygwin* | cygwin* | OS/2*)
   206    192           EXE='.exe' ;;
   207    193     MINGW* | mingw*)
   208    194   # temporary bypass
   209    195           rm -f $test.[co] $test $test$shared_ext
   210    196           echo "Please use win32/Makefile.gcc instead." | tee -a configure.log
   211         -        exit 1
          197  +        leave 1
   212    198           LDSHARED=${LDSHARED-"$cc -shared"}
   213    199           LDSHAREDLIBC=""
   214    200           EXE='.exe' ;;
   215    201     QNX*)  # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4
   216    202            # (alain.bonnefoy@icbt.com)
   217    203                    LDSHARED=${LDSHARED-"$cc -shared -Wl,-hlibz.so.1"} ;;
   218    204     HP-UX*)
................................................................................
   227    213            esac ;;
   228    214     Darwin* | darwin*)
   229    215                shared_ext='.dylib'
   230    216                SHAREDLIB=libz$shared_ext
   231    217                SHAREDLIBV=libz.$VER$shared_ext
   232    218                SHAREDLIBM=libz.$VER1$shared_ext
   233    219                LDSHARED=${LDSHARED-"$cc -dynamiclib -install_name $libdir/$SHAREDLIBM -compatibility_version $VER1 -current_version $VER3"}
          220  +             if libtool -V 2>&1 | grep Apple > /dev/null; then
          221  +                 AR="libtool"
          222  +             else
   234    223                AR="/usr/bin/libtool"
          224  +             fi
   235    225                ARFLAGS="-o" ;;
   236    226     *)             LDSHARED=${LDSHARED-"$cc -shared"} ;;
   237    227     esac
   238    228   else
   239    229     # find system name and corresponding cc options
   240    230     CC=${CC-cc}
   241    231     gcc=0
................................................................................
   329    319   
   330    320   # destination names for shared library if not defined above
   331    321   SHAREDLIB=${SHAREDLIB-"libz$shared_ext"}
   332    322   SHAREDLIBV=${SHAREDLIBV-"libz$shared_ext.$VER"}
   333    323   SHAREDLIBM=${SHAREDLIBM-"libz$shared_ext.$VER1"}
   334    324   
   335    325   echo >> configure.log
          326  +
          327  +# define functions for testing compiler and library characteristics and logging the results
          328  +
          329  +cat > $test.c <<EOF
          330  +#error error
          331  +EOF
          332  +if ($CC -c $CFLAGS $test.c) 2>/dev/null; then
          333  +  try()
          334  +  {
          335  +    show $*
          336  +    test "`( $* ) 2>&1 | tee -a configure.log`" = ""
          337  +  }
          338  +  echo - using any output from compiler to indicate an error >> configure.log
          339  +else
          340  +try()
          341  +{
          342  +  show $*
          343  +  ( $* ) >> configure.log 2>&1
          344  +  ret=$?
          345  +  if test $ret -ne 0; then
          346  +    echo "(exit code "$ret")" >> configure.log
          347  +  fi
          348  +  return $ret
          349  +}
          350  +fi
          351  +
          352  +tryboth()
          353  +{
          354  +  show $*
          355  +  got=`( $* ) 2>&1`
          356  +  ret=$?
          357  +  printf %s "$got" >> configure.log
          358  +  if test $ret -ne 0; then
          359  +    return $ret
          360  +  fi
          361  +  test "$got" = ""
          362  +}
          363  +
          364  +cat > $test.c << EOF
          365  +int foo() { return 0; }
          366  +EOF
          367  +echo "Checking for obsessive-compulsive compiler options..." >> configure.log
          368  +if try $CC -c $CFLAGS $test.c; then
          369  +  :
          370  +else
          371  +  echo "Compiler error reporting is too harsh for $0 (perhaps remove -Werror)." | tee -a configure.log
          372  +  leave 1
          373  +fi
          374  +
          375  +echo >> configure.log
   336    376   
   337    377   # see if shared library build supported
          378  +cat > $test.c <<EOF
          379  +extern int getchar();
          380  +int hello() {return getchar();}
          381  +EOF
   338    382   if test $shared -eq 1; then
   339    383     echo Checking for shared library support... | tee -a configure.log
   340    384     # we must test in two steps (cc then ld), required at least on SunOS 4.x
   341    385     if try $CC -w -c $SFLAGS $test.c &&
   342    386        try $LDSHARED $SFLAGS -o $test$shared_ext $test.o; then
   343    387       echo Building shared library $SHAREDLIBV with $CC. | tee -a configure.log
   344    388     elif test -z "$old_cc" -a -z "$old_cflags"; then
................................................................................
   358    402     SHAREDLIBM=""
   359    403     echo Building static library $STATICLIB version $VER with $CC. | tee -a configure.log
   360    404   else
   361    405     ALL="static shared"
   362    406     TEST="all teststatic testshared"
   363    407   fi
   364    408   
   365         -echo >> configure.log
   366         -
   367    409   # check for underscores in external names for use by assembler code
   368    410   CPP=${CPP-"$CC -E"}
   369    411   case $CFLAGS in
   370    412     *ASMV*)
   371    413       echo >> configure.log
   372    414       show "$NM $test.o | grep _hello"
   373    415       if test "`$NM $test.o | grep _hello | tee -a configure.log`" = ""; then
................................................................................
   694    736       SFLAGS="$SFLAGS -DHAVE_HIDDEN"
   695    737       echo "Checking for attribute(visibility) support... Yes." | tee -a configure.log
   696    738     else
   697    739       echo "Checking for attribute(visibility) support... No." | tee -a configure.log
   698    740     fi
   699    741   fi
   700    742   
   701         -echo >> configure.log
   702         -
   703         -# find a four-byte unsiged integer type for crc calculations
   704         -cat > $test.c <<EOF
   705         -#include <stdio.h>
   706         -#define is32(n,t) for(n=1,k=0;n;n<<=1,k++);if(k==32){puts(t);return 0;}
   707         -int main() {
   708         -    int k;
   709         -    unsigned i;
   710         -    unsigned long l;
   711         -    unsigned short s;
   712         -    is32(i, "unsigned")
   713         -    is32(l, "unsigned long")
   714         -    is32(s, "unsigned short")
   715         -    return 1;
   716         -}
   717         -EOF
   718         -Z_U4=""
   719         -if try $CC $CFLAGS $test.c -o $test && Z_U4=`./$test` && test -n "$Z_U4"; then
   720         -  sed < zconf.h "/#define Z_U4/s/\/\* \.\/configure may/#define Z_U4 $Z_U4   \/* .\/configure put the/" > zconf.temp.h
   721         -  mv zconf.temp.h zconf.h
   722         -  echo "Looking for a four-byte integer type... Found." | tee -a configure.log
   723         -else
   724         -  echo "Looking for a four-byte integer type... Not found." | tee -a configure.log
   725         -fi
   726         -
   727         -# clean up files produced by running the compiler and linker
   728         -rm -f $test.[co] $test $test$shared_ext $test.gcno
   729         -
   730    743   # show the results in the log
   731    744   echo >> configure.log
   732    745   echo ALL = $ALL >> configure.log
   733    746   echo AR = $AR >> configure.log
   734    747   echo ARFLAGS = $ARFLAGS >> configure.log
   735    748   echo CC = $CC >> configure.log
   736    749   echo CFLAGS = $CFLAGS >> configure.log
................................................................................
   754    767   echo exec_prefix = $exec_prefix >> configure.log
   755    768   echo includedir = $includedir >> configure.log
   756    769   echo libdir = $libdir >> configure.log
   757    770   echo mandir = $mandir >> configure.log
   758    771   echo prefix = $prefix >> configure.log
   759    772   echo sharedlibdir = $sharedlibdir >> configure.log
   760    773   echo uname = $uname >> configure.log
   761         -echo -------------------- >> configure.log
   762         -echo >> configure.log
   763         -echo >> configure.log
   764    774   
   765    775   # udpate Makefile with the configure results
   766    776   sed < Makefile.in "
   767    777   /^CC *=/s#=.*#=$CC#
   768    778   /^CFLAGS *=/s#=.*#=$CFLAGS#
   769    779   /^SFLAGS *=/s#=.*#=$SFLAGS#
   770    780   /^LDFLAGS *=/s#=.*#=$LDFLAGS#
................................................................................
   812    822   /^sharedlibdir *=/s#=.*#=$sharedlibdir#
   813    823   /^includedir *=/s#=.*#=$includedir#
   814    824   /^mandir *=/s#=.*#=$mandir#
   815    825   /^LDFLAGS *=/s#=.*#=$LDFLAGS#
   816    826   " | sed -e "
   817    827   s/\@VERSION\@/$VER/g;
   818    828   " > zlib.pc
   819         -#
          829  +
          830  +# done
          831  +leave 0

Changes to compat/zlib/contrib/README.contrib.

    71     71           Example of the use of zlib
    72     72   
    73     73   untgz/      by Pedro A. Aranda Gutierrez <paag@tid.es>
    74     74           A very simple tar.gz file extractor using zlib
    75     75   
    76     76   vstudio/    by Gilles Vollant <info@winimage.com>
    77     77           Building a minizip-enhanced zlib with Microsoft Visual Studio
           78  +        Includes vc11 from kreuzerkrieg and vc12 from davispuh

Changes to compat/zlib/contrib/blast/blast.c.

     1      1   /* blast.c
     2         - * Copyright (C) 2003 Mark Adler
            2  + * Copyright (C) 2003, 2012 Mark Adler
     3      3    * For conditions of distribution and use, see copyright notice in blast.h
     4         - * version 1.1, 16 Feb 2003
            4  + * version 1.2, 24 Oct 2012
     5      5    *
     6      6    * blast.c decompresses data compressed by the PKWare Compression Library.
     7      7    * This function provides functionality similar to the explode() function of
     8      8    * the PKWare library, hence the name "blast".
     9      9    *
    10     10    * This decompressor is based on the excellent format description provided by
    11     11    * Ben Rudiak-Gould in comp.compression on August 13, 2001.  Interestingly, the
................................................................................
    18     18    */
    19     19   
    20     20   /*
    21     21    * Change history:
    22     22    *
    23     23    * 1.0  12 Feb 2003     - First version
    24     24    * 1.1  16 Feb 2003     - Fixed distance check for > 4 GB uncompressed data
           25  + * 1.2  24 Oct 2012     - Add note about using binary mode in stdio
           26  + *                      - Fix comparisons of differently signed integers
    25     27    */
    26     28   
    27     29   #include <setjmp.h>             /* for setjmp(), longjmp(), and jmp_buf */
    28     30   #include "blast.h"              /* prototype for blast() */
    29     31   
    30     32   #define local static            /* for local function definitions */
    31     33   #define MAXBITS 13              /* maximum code length */
................................................................................
   275    277    */
   276    278   local int decomp(struct state *s)
   277    279   {
   278    280       int lit;            /* true if literals are coded */
   279    281       int dict;           /* log2(dictionary size) - 6 */
   280    282       int symbol;         /* decoded symbol, extra bits for distance */
   281    283       int len;            /* length for copy */
   282         -    int dist;           /* distance for copy */
          284  +    unsigned dist;      /* distance for copy */
   283    285       int copy;           /* copy counter */
   284    286       unsigned char *from, *to;   /* copy pointers */
   285    287       static int virgin = 1;                              /* build tables once */
   286    288       static short litcnt[MAXBITS+1], litsym[256];        /* litcode memory */
   287    289       static short lencnt[MAXBITS+1], lensym[16];         /* lencode memory */
   288    290       static short distcnt[MAXBITS+1], distsym[64];       /* distcode memory */
   289    291       static struct huffman litcode = {litcnt, litsym};   /* length code */

Changes to compat/zlib/contrib/blast/blast.h.

     1      1   /* blast.h -- interface for blast.c
     2         -  Copyright (C) 2003 Mark Adler
     3         -  version 1.1, 16 Feb 2003
            2  +  Copyright (C) 2003, 2012 Mark Adler
            3  +  version 1.2, 24 Oct 2012
     4      4   
     5      5     This software is provided 'as-is', without any express or implied
     6      6     warranty.  In no event will the author be held liable for any damages
     7      7     arising from the use of this software.
     8      8   
     9      9     Permission is granted to anyone to use this software for any purpose,
    10     10     including commercial applications, and to alter it and redistribute it
................................................................................
    24     24   
    25     25   /*
    26     26    * blast() decompresses the PKWare Data Compression Library (DCL) compressed
    27     27    * format.  It provides the same functionality as the explode() function in
    28     28    * that library.  (Note: PKWare overused the "implode" verb, and the format
    29     29    * used by their library implode() function is completely different and
    30     30    * incompatible with the implode compression method supported by PKZIP.)
           31  + *
           32  + * The binary mode for stdio functions should be used to assure that the
           33  + * compressed data is not corrupted when read or written.  For example:
           34  + * fopen(..., "rb") and fopen(..., "wb").
    31     35    */
    32     36   
    33     37   
    34     38   typedef unsigned (*blast_in)(void *how, unsigned char **buf);
    35     39   typedef int (*blast_out)(void *how, unsigned char *buf, unsigned len);
    36     40   /* Definitions for input/output functions passed to blast().  See below for
    37     41    * what the provided functions need to do.

Changes to compat/zlib/contrib/delphi/ZLib.pas.

   148    148          InBytes = number of bytes in InBuf
   149    149     Out: OutBuf = ptr to user-allocated buffer to contain decompressed data
   150    150          BufSize = number of bytes in OutBuf   }
   151    151   procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
   152    152     const OutBuf: Pointer; BufSize: Integer);
   153    153   
   154    154   const
   155         -  zlib_version = '1.2.7';
          155  +  zlib_version = '1.2.8';
   156    156   
   157    157   type
   158    158     EZlibError = class(Exception);
   159    159     ECompressionError = class(EZlibError);
   160    160     EDecompressionError = class(EZlibError);
   161    161   
   162    162   implementation

Changes to compat/zlib/contrib/dotzlib/DotZLib/UnitTests.cs.

     1      1   //
     2         -//  Copyright Henrik Ravn 2004
            2  +// © Copyright Henrik Ravn 2004
     3      3   //
     4      4   // Use, modification and distribution are subject to the Boost Software License, Version 1.0.
     5      5   // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
     6      6   //
     7      7   
     8      8   using System;
     9      9   using System.Collections;
................................................................................
   152    152       public class InfoTests
   153    153       {
   154    154           #region Info tests
   155    155           [Test]
   156    156           public void Info_Version()
   157    157           {
   158    158               Info info = new Info();
   159         -            Assert.AreEqual("1.2.7", Info.Version);
          159  +            Assert.AreEqual("1.2.8", Info.Version);
   160    160               Assert.AreEqual(32, info.SizeOfUInt);
   161    161               Assert.AreEqual(32, info.SizeOfULong);
   162    162               Assert.AreEqual(32, info.SizeOfPointer);
   163    163               Assert.AreEqual(32, info.SizeOfOffset);
   164    164           }
   165    165           #endregion
   166    166       }

Changes to compat/zlib/contrib/infback9/infback9.c.

   218    218   z_stream FAR *strm;
   219    219   in_func in;
   220    220   void FAR *in_desc;
   221    221   out_func out;
   222    222   void FAR *out_desc;
   223    223   {
   224    224       struct inflate_state FAR *state;
   225         -    unsigned char FAR *next;    /* next input */
          225  +    z_const unsigned char FAR *next;    /* next input */
   226    226       unsigned char FAR *put;     /* next output */
   227    227       unsigned have;              /* available input */
   228    228       unsigned long left;         /* available output */
   229    229       inflate_mode mode;          /* current inflate mode */
   230    230       int lastblock;              /* true if processing last block */
   231    231       int wrap;                   /* true if the window has wrapped */
   232         -    unsigned long write;        /* window write index */
   233    232       unsigned char FAR *window;  /* allocated sliding window, if needed */
   234    233       unsigned long hold;         /* bit buffer */
   235    234       unsigned bits;              /* bits in bit buffer */
   236    235       unsigned extra;             /* extra bits needed */
   237    236       unsigned long length;       /* literal or length of data to copy */
   238    237       unsigned long offset;       /* distance back to copy string from */
   239    238       unsigned long copy;         /* number of stored or match bytes to copy */
................................................................................
   255    254           return Z_STREAM_ERROR;
   256    255       state = (struct inflate_state FAR *)strm->state;
   257    256   
   258    257       /* Reset the state */
   259    258       strm->msg = Z_NULL;
   260    259       mode = TYPE;
   261    260       lastblock = 0;
   262         -    write = 0;
   263    261       wrap = 0;
   264    262       window = state->window;
   265    263       next = strm->next_in;
   266    264       have = next != Z_NULL ? strm->avail_in : 0;
   267    265       hold = 0;
   268    266       bits = 0;
   269    267       put = window;

Changes to compat/zlib/contrib/infback9/inftree9.c.

     1      1   /* inftree9.c -- generate Huffman trees for efficient decoding
     2         - * Copyright (C) 1995-2012 Mark Adler
            2  + * Copyright (C) 1995-2013 Mark Adler
     3      3    * For conditions of distribution and use, see copyright notice in zlib.h
     4      4    */
     5      5   
     6      6   #include "zutil.h"
     7      7   #include "inftree9.h"
     8      8   
     9      9   #define MAXBITS 15
    10     10   
    11     11   const char inflate9_copyright[] =
    12         -   " inflate9 1.2.7 Copyright 1995-2012 Mark Adler ";
           12  +   " inflate9 1.2.8 Copyright 1995-2013 Mark Adler ";
    13     13   /*
    14     14     If you use the zlib library in a product, an acknowledgment is welcome
    15     15     in the documentation of your product. If for some reason you cannot
    16     16     include such an acknowledgment, I would appreciate that you keep this
    17     17     copyright string in the executable of your product.
    18     18    */
    19     19   
................................................................................
    60     60       static const unsigned short lbase[31] = { /* Length codes 257..285 base */
    61     61           3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17,
    62     62           19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115,
    63     63           131, 163, 195, 227, 3, 0, 0};
    64     64       static const unsigned short lext[31] = { /* Length codes 257..285 extra */
    65     65           128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
    66     66           130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
    67         -        133, 133, 133, 133, 144, 78, 68};
           67  +        133, 133, 133, 133, 144, 72, 78};
    68     68       static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
    69     69           1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49,
    70     70           65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073,
    71     71           4097, 6145, 8193, 12289, 16385, 24577, 32769, 49153};
    72     72       static const unsigned short dext[32] = { /* Distance codes 0..31 extra */
    73     73           128, 128, 128, 128, 129, 129, 130, 130, 131, 131, 132, 132,
    74     74           133, 133, 134, 134, 135, 135, 136, 136, 137, 137, 138, 138,

Changes to compat/zlib/contrib/minizip/configure.ac.

     1      1   #                                               -*- Autoconf -*-
     2      2   # Process this file with autoconf to produce a configure script.
     3      3   
     4         -AC_INIT([minizip], [1.2.7], [bugzilla.redhat.com])
            4  +AC_INIT([minizip], [1.2.8], [bugzilla.redhat.com])
     5      5   AC_CONFIG_SRCDIR([minizip.c])
     6      6   AM_INIT_AUTOMAKE([foreign])
     7      7   LT_INIT
     8      8   
     9      9   AC_MSG_CHECKING([whether to build example programs])
    10     10   AC_ARG_ENABLE([demos], AC_HELP_STRING([--enable-demos], [build example programs]))
    11     11   AM_CONDITIONAL([COND_DEMOS], [test "$enable_demos" = yes])

Changes to compat/zlib/contrib/minizip/crypt.h.

    28     28   */
    29     29   
    30     30   #define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
    31     31   
    32     32   /***********************************************************************
    33     33    * Return the next byte in the pseudo-random sequence
    34     34    */
    35         -static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
           35  +static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab)
    36     36   {
    37     37       unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
    38     38                        * unpredictable manner on 16-bit systems; not a problem
    39     39                        * with any known compiler so far, though */
    40     40   
    41     41       temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
    42     42       return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
    43     43   }
    44     44   
    45     45   /***********************************************************************
    46     46    * Update the encryption keys with the next byte of plain text
    47     47    */
    48         -static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
           48  +static int update_keys(unsigned long* pkeys,const z_crc_t* pcrc_32_tab,int c)
    49     49   {
    50     50       (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
    51     51       (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
    52     52       (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
    53     53       {
    54     54         register int keyshift = (int)((*(pkeys+1)) >> 24);
    55     55         (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
................................................................................
    58     58   }
    59     59   
    60     60   
    61     61   /***********************************************************************
    62     62    * Initialize the encryption keys and the random header according to
    63     63    * the given password.
    64     64    */
    65         -static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
           65  +static void init_keys(const char* passwd,unsigned long* pkeys,const z_crc_t* pcrc_32_tab)
    66     66   {
    67     67       *(pkeys+0) = 305419896L;
    68     68       *(pkeys+1) = 591751049L;
    69     69       *(pkeys+2) = 878082192L;
    70     70       while (*passwd != '\0') {
    71     71           update_keys(pkeys,pcrc_32_tab,(int)*passwd);
    72     72           passwd++;
................................................................................
    87     87   #    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
    88     88   #  endif
    89     89   
    90     90   static int crypthead(const char* passwd,      /* password string */
    91     91                        unsigned char* buf,      /* where to write header */
    92     92                        int bufSize,
    93     93                        unsigned long* pkeys,
    94         -                     const unsigned long* pcrc_32_tab,
           94  +                     const z_crc_t* pcrc_32_tab,
    95     95                        unsigned long crcForCrypting)
    96     96   {
    97     97       int n;                       /* index in random header */
    98     98       int t;                       /* temporary */
    99     99       int c;                       /* random byte */
   100    100       unsigned char header[RAND_HEAD_LEN-2]; /* random header */
   101    101       static unsigned calls = 0;   /* ensure different random header each time */

Changes to compat/zlib/contrib/minizip/iowin32.c.

    21     21   #define INVALID_HANDLE_VALUE (0xFFFFFFFF)
    22     22   #endif
    23     23   
    24     24   #ifndef INVALID_SET_FILE_POINTER
    25     25   #define INVALID_SET_FILE_POINTER ((DWORD)-1)
    26     26   #endif
    27     27   
           28  +
           29  +#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
           30  +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
           31  +#define IOWIN32_USING_WINRT_API 1
           32  +#endif
           33  +#endif
           34  +
    28     35   voidpf  ZCALLBACK win32_open_file_func  OF((voidpf opaque, const char* filename, int mode));
    29     36   uLong   ZCALLBACK win32_read_file_func  OF((voidpf opaque, voidpf stream, void* buf, uLong size));
    30     37   uLong   ZCALLBACK win32_write_file_func OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
    31     38   ZPOS64_T ZCALLBACK win32_tell64_file_func  OF((voidpf opaque, voidpf stream));
    32     39   long    ZCALLBACK win32_seek64_file_func  OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
    33     40   int     ZCALLBACK win32_close_file_func OF((voidpf opaque, voidpf stream));
    34     41   int     ZCALLBACK win32_error_file_func OF((voidpf opaque, voidpf stream));
................................................................................
    89     96   {
    90     97       const char* mode_fopen = NULL;
    91     98       DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
    92     99       HANDLE hFile = NULL;
    93    100   
    94    101       win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
    95    102   
          103  +#ifdef IOWIN32_USING_WINRT_API
          104  +#ifdef UNICODE
          105  +    if ((filename!=NULL) && (dwDesiredAccess != 0))
          106  +        hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
          107  +#else
          108  +    if ((filename!=NULL) && (dwDesiredAccess != 0))
          109  +    {
          110  +        WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
          111  +        MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
          112  +        hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
          113  +    }
          114  +#endif
          115  +#else
    96    116       if ((filename!=NULL) && (dwDesiredAccess != 0))
    97    117           hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
          118  +#endif
    98    119   
    99    120       return win32_build_iowin(hFile);
   100    121   }
   101    122   
   102    123   
   103    124   voidpf ZCALLBACK win32_open64_file_funcA (voidpf opaque,const void* filename,int mode)
   104    125   {
   105    126       const char* mode_fopen = NULL;
   106    127       DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
   107    128       HANDLE hFile = NULL;
   108    129   
   109    130       win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
   110    131   
          132  +#ifdef IOWIN32_USING_WINRT_API
          133  +    if ((filename!=NULL) && (dwDesiredAccess != 0))
          134  +    {
          135  +        WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
          136  +        MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
          137  +        hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
          138  +    }
          139  +#else
   111    140       if ((filename!=NULL) && (dwDesiredAccess != 0))
   112    141           hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
          142  +#endif
   113    143   
   114    144       return win32_build_iowin(hFile);
   115    145   }
   116    146   
   117    147   
   118    148   voidpf ZCALLBACK win32_open64_file_funcW (voidpf opaque,const void* filename,int mode)
   119    149   {
   120    150       const char* mode_fopen = NULL;
   121    151       DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
   122    152       HANDLE hFile = NULL;
   123    153   
   124    154       win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
   125    155   
          156  +#ifdef IOWIN32_USING_WINRT_API
          157  +    if ((filename!=NULL) && (dwDesiredAccess != 0))
          158  +        hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition,NULL);
          159  +#else
   126    160       if ((filename!=NULL) && (dwDesiredAccess != 0))
   127    161           hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
          162  +#endif
   128    163   
   129    164       return win32_build_iowin(hFile);
   130    165   }
   131    166   
   132    167   
   133    168   voidpf ZCALLBACK win32_open_file_func (voidpf opaque,const char* filename,int mode)
   134    169   {
   135    170       const char* mode_fopen = NULL;
   136    171       DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
   137    172       HANDLE hFile = NULL;
   138    173   
   139    174       win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
   140    175   
          176  +#ifdef IOWIN32_USING_WINRT_API
          177  +#ifdef UNICODE
          178  +    if ((filename!=NULL) && (dwDesiredAccess != 0))
          179  +        hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
          180  +#else
          181  +    if ((filename!=NULL) && (dwDesiredAccess != 0))
          182  +    {
          183  +        WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
          184  +        MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
          185  +        hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
          186  +    }
          187  +#endif
          188  +#else
   141    189       if ((filename!=NULL) && (dwDesiredAccess != 0))
   142    190           hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode,