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: |
a44b4aa5ac323392f58ccf10938dd6ba |
| 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
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