Fossil with Commonmark: Changes On Branch tcl-stubs

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

Changes In Branch tcl-stubs Excluding Merge-Ins

This is equivalent to a diff from c237195fa4 to 9562a16f6d

2013-09-16
22:51		Add support for compiling a Tcl-enabled Fossil using the private stubs mechanism. check-in: 955886f18c user: mistachkin tags: trunk
07:36		Fix a couple missed changes. Closed-Leaf check-in: 9562a16f6d user: mistachkin tags: tcl-stubs
07:31		Correct typo in auto.def. Improvements to the Tcl integration. check-in: 6e08e5ae64 user: mistachkin tags: tcl-stubs
07:26		merge fork check-in: fea040240f user: jan.nijtmans tags: trunk
07:24		Add new tcl target to Makefile.mingw. Only build what is necessary for building Fossil. check-in: c237195fa4 user: jan.nijtmans tags: trunk
06:04		Fix built-in TH1 command registration broken by the previous commit. check-in: 5d20065c4b user: mistachkin tags: trunk

Changes to Makefile.in.

Changes to auto.def.

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

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

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

Changes to src/main.c.

Changes to src/makemake.tcl.

Changes to src/th_tcl.c.

Changes to win/Makefile.mingw.

Changes to win/Makefile.mingw.mistachkin.

1 2 3 4 5 6 7 8 9 ~~10 11~~ 12 13 14 15 16 17 18	1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20	- - + + + +	# System autoconfiguration. Try: ./configure --help use cc cc-lib options { with-openssl:path\|auto\|none => {Look for openssl in the given path, or auto or none} with-zlib:path => {Look for zlib in the given path} with-tcl:path => {Enable Tcl integration, with Tcl in the specified path} ~~with-tcl-stubs=0 => {Enable Tcl integration via stubs mechanism} internal-sqlite=1 => {Don't use the internal ~~sql~~ite, use the system one}~~ with-tcl-stubs=0 => {Enable Tcl integration via stubs library mechanism} with-tcl-private-stubs=0 => {Enable Tcl integration via private stubs mechanism} internal-sqlite=1 => {Don't use the internal SQLite, use the system one} static=0 => {Link a static executable} lineedit=1 => {Disable line editing} fossil-debug=0 => {Build with fossil debugging enabled} json=0 => {Build with fossil JSON API enabled} } # sqlite wants these types if possible
︙
112 113 114 115 116 117 118 ~~119~~ 120 121 122 123 124 125 126 ~~127 128 129 130 131 132 133 134~~ 135 136 137 138 139 ~~140~~ 141 142 143 144 145 146 147	114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157	+ + + + - + + - - - - - - - - + + + + + + + + + + - + +	array set tclconfig [parse-tclconfig-sh $tclpath] set msg "at $tclpath" } if {![info exists tclconfig(TCL_INCLUDE_SPEC)]} { user-error "Cannot find Tcl $msg" } set tclstubs [opt-bool with-tcl-stubs] set tclprivatestubs [opt-bool with-tcl-private-stubs] if {$tclprivatestubs} { define FOSSIL_ENABLE_TCL_PRIVATE_STUBS define USE_TCL_STUBS ~~if {$tclstubs && $tclconfig(TCL_SUPPORTS_STUBS)} {~~ } elseif {$tclstubs && $tclconfig(TCL_SUPPORTS_STUBS)} { set libs "$tclconfig(TCL_STUB_LIB_SPEC)" define FOSSIL_ENABLE_TCL_STUBS define USE_TCL_STUBS } else { set libs "$tclconfig(TCL_LIB_SPEC) $tclconfig(TCL_LIBS)" } set cflags $tclconfig(TCL_INCLUDE_SPEC) if {!$tclprivatestubs} { cc-with [list -cflags $cflags -libs $libs] { if {$tclstubs} { if {![cc-check-functions Tcl_InitStubs]} { user-error "Cannot find a usable Tcl stubs library $msg" } } else { if {![cc-check-functions Tcl_CreateInterp]} { user-error "Cannot find a usable Tcl library $msg" cc-with [list -cflags $cflags -libs $libs] { if {$tclstubs} { if {![cc-check-functions Tcl_InitStubs]} { user-error "Cannot find a usable Tcl stubs library $msg" } } else { if {![cc-check-functions Tcl_CreateInterp]} { user-error "Cannot find a usable Tcl library $msg" } } } } set version $tclconfig(TCL_VERSION)$tclconfig(TCL_PATCH_LEVEL) msg-result "Found Tcl $version at $tclconfig(TCL_PREFIX)" if {!$tclprivatestubs} { ~~define-append LIBS $libs~~ define-append LIBS $libs } define-append EXTRA_CFLAGS $cflags define-append EXTRA_LDFLAGS $tclconfig(TCL_LD_FLAGS) define FOSSIL_ENABLE_TCL } # Helper for openssl checking proc check-for-openssl {msg {cflags {}}} {
︙

︙
389 390 391 392 393 394 395 ~~396~~ 397 398 399 400 401 402 403 404 405	389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409	- + + + + +	# # FOSSIL_ENABLE_SSL = 1 #### Enable scripting support via Tcl/Tk # # FOSSIL_ENABLE_TCL = 1 ~~#### Load Tcl using the stubs mechanism~~ #### Load Tcl using the stubs library mechanism # # FOSSIL_ENABLE_TCL_STUBS = 1 #### Load Tcl using the private stubs mechanism # # FOSSIL_ENABLE_TCL_PRIVATE_STUBS = 1 #### Use the Tcl source directory instead of the install directory? # This is useful when Tcl has been compiled statically with MinGW. # FOSSIL_TCL_SOURCE = 1 #### Check if the workaround for the MinGW command line handling needs to
︙
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462	452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468	+ +	# TCLINCDIR = $(TCLDIR)/include TCLLIBDIR = $(TCLDIR)/lib #### Tcl: Which Tcl library do we want to use (8.4, 8.5, 8.6, etc)? # ifdef FOSSIL_ENABLE_TCL_STUBS ifndef FOSSIL_ENABLE_TCL_PRIVATE_STUBS LIBTCL = -ltclstub86 endif TCLTARGET = libtclstub86.a else LIBTCL = -ltcl86 TCLTARGET = binaries endif #### C Compile and options for use in building executables that
︙
512 513 514 515 516 517 518 519 520 521 522 523 524 525	518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535	+ + + +	ifdef FOSSIL_ENABLE_TCL TCC += -DFOSSIL_ENABLE_TCL=1 RCC += -DFOSSIL_ENABLE_TCL=1 # Either statically linked or via stubs ifdef FOSSIL_ENABLE_TCL_STUBS TCC += -DFOSSIL_ENABLE_TCL_STUBS=1 -DUSE_TCL_STUBS RCC += -DFOSSIL_ENABLE_TCL_STUBS=1 -DUSE_TCL_STUBS ifdef FOSSIL_ENABLE_TCL_PRIVATE_STUBS TCC += -DFOSSIL_ENABLE_TCL_PRIVATE_STUBS=1 RCC += -DFOSSIL_ENABLE_TCL_PRIVATE_STUBS=1 endif else TCC += -DSTATIC_BUILD RCC += -DSTATIC_BUILD endif endif # With JSON support
︙

︙
117 118 119 120 121 122 123 124 125 126 127 128 129 130 ~~131~~ 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160	117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221	+ + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +	# endif /* defined(_WIN32) / # ifndef TCL_FINDEXECUTABLE_NAME # define TCL_FINDEXECUTABLE_NAME "_Tcl_FindExecutable" # endif # ifndef TCL_CREATEINTERP_NAME # define TCL_CREATEINTERP_NAME "_Tcl_CreateInterp" # endif # ifndef TCL_DELETEINTERP_NAME # define TCL_DELETEINTERP_NAME "_Tcl_DeleteInterp" # endif #endif / defined(USE_TCL_STUBS) / / The function types for Tcl_FindExecutable and Tcl_CreateInterp are needed when the Tcl library is being loaded dynamically by a stubs-enabled application (i.e. the inverse of using a stubs-enabled package). These are the only Tcl API functions that MUST be called prior to being able to call Tcl_InitStubs (i.e. because it requires a Tcl interpreter). Tcl_InitStubs (i.e. because it requires a Tcl interpreter). For complete cleanup if the Tcl stubs initialization fails somehow, the Tcl_DeleteInterp function type is also required. / typedef void (tcl_FindExecutableProc) (const char argv0); typedef Tcl_Interp (tcl_CreateInterpProc) (void); typedef void (tcl_DeleteInterpProc) (Tcl_Interp interp); /* The function types for the "hook" functions to be called before and after a TH1 command makes a call to evaluate a Tcl script. If the "pre" function returns anything but TH_OK, then evaluation of the Tcl script is skipped and that value is used as the return code. If the "post" function returns anything other than its rc argument, that will become the new return code for the command. / typedef int (tcl_NotifyProc) ( void pContext, /* The context for this notification. / Th_Interp interp, /* The TH1 interpreter being used. / void ctx, /* The original TH1 command context. / int argc, / Number of arguments for the TH1 command. / const char argv, / Array of arguments for the TH1 command. / int argl, /* Array of lengths for the TH1 command arguments. / int rc / Recommended notification return value. / ); / Are we using our own private implementation of the Tcl stubs mechanism? If this is enabled, it prevents the user from having to link against the Tcl ** stubs library for the target platform, which may not be readily available. / #if defined(FOSSIL_ENABLE_TCL_PRIVATE_STUBS) / HACK: Using some preprocessor magic and a private static variable, redirect the Tcl API calls [found within this file] to the function pointers that will be contained in our private Tcl stubs table. This takes advantage of the fact that the Tcl headers always define the Tcl API ** functions in terms of the "tclStubsPtr" variable. / #define tclStubsPtr privateTclStubsPtr static const TclStubs tclStubsPtr = NULL; /* Create a Tcl interpreter structure that mirrors just enough fields to get it up and running successfully with our private implementation of the Tcl ** stubs mechanism. / struct PrivateTclInterp { char result; Tcl_FreeProc freeProc; int errorLine; const struct TclStubs stubTable; }; /* Fossil can now be compiled without linking to the actual Tcl stubs library. In that case, this function will be used to perform those steps that would ** normally be performed within the Tcl stubs library. / static int initTclStubs( Th_Interp interp, Tcl_Interp tclInterp ){ tclStubsPtr = ((struct PrivateTclInterp )tclInterp)->stubTable; if( !tclStubsPtr \|\| (tclStubsPtr->magic!=TCL_STUB_MAGIC) ){ Th_ErrorMessage(interp, "could not initialize Tcl stubs: incompatible mechanism", (const char )"", 0); return TH_ERROR; } / NOTE: At this point, the Tcl API functions should be available. / if( Tcl_PkgRequireEx(tclInterp, "Tcl", "8.4", 0, (void )&tclStubsPtr)==0 ){ Th_ErrorMessage(interp, "could not initialize Tcl stubs: incompatible version", (const char )"", 0); return TH_ERROR; } return TH_OK; } #endif / Creates and initializes a Tcl interpreter for use with the specified TH1 interpreter. Stores the created Tcl interpreter in the Tcl context supplied by the caller. This must be declared here because quite a few functions in this file need to use it before it can be defined. / static int createTclInterp(Th_Interp interp, void *pContext);
︙
187 188 189 190 191 192 193 194 195 196 197 198 199 200	248 249 250 251 252 253 254 255 256 257 258 259 260 261 262	+	/ struct TclContext { int argc; / Number of original arguments. / char argv; / Full copy of the original arguments. / void library; /* The Tcl library module handle. / tcl_FindExecutableProc xFindExecutable; /* Tcl_FindExecutable() pointer. / tcl_CreateInterpProc xCreateInterp; /* Tcl_CreateInterp() pointer. / tcl_DeleteInterpProc xDeleteInterp; /* Tcl_DeleteInterp() pointer. / Tcl_Interp interp; /* The on-demand created Tcl interpreter. / char setup; /* The optional Tcl setup script. / tcl_NotifyProc xPreEval; /* Optional, called before Tcl_Eval(). / void pPreContext; / Optional, provided to xPreEval(). / tcl_NotifyProc xPostEval; /* Optional, called after Tcl_Eval(). / void pPostContext; / Optional, provided to xPostEval(). */ };
︙
524 525 526 527 528 529 530 ~~531~~ 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553	586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617	- + + +	the function pointers provided by the caller with the statically linked functions. / static int loadTcl( Th_Interp interp, void pLibrary, tcl_FindExecutableProc pxFindExecutable, ~~tcl_CreateInterpProc pxCreateInterp~~ tcl_CreateInterpProc pxCreateInterp, tcl_DeleteInterpProc *pxDeleteInterp ){ #if defined(USE_TCL_STUBS) char fileName[] = TCL_LIBRARY_NAME; #endif if( !pLibrary \|\| !pxFindExecutable \|\| !pxCreateInterp ){ Th_ErrorMessage(interp, "invalid Tcl loader argument(s)", (const char )"", 0); return TH_ERROR; } #if defined(USE_TCL_STUBS) do { void library = dlopen(fileName, RTLD_NOW \| RTLD_GLOBAL); if( library ){ tcl_FindExecutableProc xFindExecutable; tcl_CreateInterpProc xCreateInterp; tcl_DeleteInterpProc xDeleteInterp; const char procName = TCL_FINDEXECUTABLE_NAME; xFindExecutable = (tcl_FindExecutableProc )dlsym(library, procName + 1); if( !xFindExecutable ){ xFindExecutable = (tcl_FindExecutableProc *)dlsym(library, procName); } if( !xFindExecutable ){ Th_ErrorMessage(interp,
︙
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589	625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666	+ + + + + + + + + + + + +	xCreateInterp = (tcl_CreateInterpProc )dlsym(library, procName); } if( !xCreateInterp ){ Th_ErrorMessage(interp, "could not locate Tcl_CreateInterp", (const char )"", 0); dlclose(library); return TH_ERROR; } procName = TCL_DELETEINTERP_NAME; xDeleteInterp = (tcl_DeleteInterpProc )dlsym(library, procName + 1); if( !xDeleteInterp ){ xDeleteInterp = (tcl_DeleteInterpProc )dlsym(library, procName); } if( !xDeleteInterp ){ Th_ErrorMessage(interp, "could not locate Tcl_DeleteInterp", (const char )"", 0); dlclose(library); return TH_ERROR; } pLibrary = library; pxFindExecutable = xFindExecutable; pxCreateInterp = xCreateInterp; pxDeleteInterp = xDeleteInterp; return TH_OK; } } while( --fileName[TCL_MINOR_OFFSET]>'3' ); / Tcl 8.4+ / Th_ErrorMessage(interp, "could not load Tcl shared library \"" TCL_LIBRARY_NAME "\"", (const char )"", 0); return TH_ERROR; #else pLibrary = 0; pxFindExecutable = Tcl_FindExecutable; pxCreateInterp = Tcl_CreateInterp; pxDeleteInterp = Tcl_DeleteInterp; return TH_OK; #endif } /* Sets the "argv0", "argc", and "argv" script variables in the Tcl interpreter based on the supplied command line arguments.
︙
661 662 663 664 665 666 667 ~~668~~ 669 670 671 672 673 674 675 676 677 ~~678~~ 679 ~~680 681 682~~ 683 ~~684~~ 685 686 687 688 689 690 691 692	738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786	- + - + + + + + + + + + + + - - - + + + + + + + + + - + +	"invalid Tcl context", (const char )"", 0); return TH_ERROR; } if ( tclContext->interp ){ return TH_OK; } if( loadTcl(interp, &tclContext->library, &tclContext->xFindExecutable, ~~&tclContext->xCreateInterp)!=TH_OK ){~~ &tclContext->xCreateInterp, &tclContext->xDeleteInterp)!=TH_OK ){ return TH_ERROR; } argc = tclContext->argc; argv = tclContext->argv; if( argc>0 && argv ){ argv0 = argv[0]; } tclContext->xFindExecutable(argv0); tclInterp = tclContext->xCreateInterp(); ~~if( !tclInterp \|\|~~ if( !tclInterp ){ Th_ErrorMessage(interp, "could not create Tcl interpreter", (const char )"", 0); return TH_ERROR; } #if defined(USE_TCL_STUBS) #if defined(FOSSIL_ENABLE_TCL_PRIVATE_STUBS) if( initTclStubs(interp, tclInterp)!=TH_OK ){ tclContext->xDeleteInterp(tclInterp); return TH_ERROR; } #else ~~!Tcl_InitStubs(tclInterp, "8.4", 0) \|\| #endif Tcl_InterpDeleted(tclInterp) ){~~ if( !Tcl_InitStubs(tclInterp, "8.4", 0) ){ Th_ErrorMessage(interp, "could not initialize Tcl stubs", (const char )"", 0); tclContext->xDeleteInterp(tclInterp); return TH_ERROR; } #endif / defined(FOSSIL_ENABLE_TCL_PRIVATE_STUBS) / #endif / defined(USE_TCL_STUBS) / if( Tcl_InterpDeleted(tclInterp) ){ Th_ErrorMessage(interp, ~~"~~could not create~~ Tcl interpreter", (const char )"", 0);~~ "Tcl interpreter appears to be deleted", (const char )"", 0); tclContext->xDeleteInterp(tclInterp); / TODO: Redundant? */ return TH_ERROR; } tclContext->interp = tclInterp; if( Tcl_Init(tclInterp)!=TCL_OK ){ Th_ErrorMessage(interp, "Tcl initialization error:", Tcl_GetStringResult(tclInterp), -1); Tcl_DeleteInterp(tclInterp); tclContext->interp = tclInterp = 0;
︙

︙
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66	50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70	- + + + + +	# # FOSSIL_ENABLE_SSL = 1 #### Enable scripting support via Tcl/Tk # # FOSSIL_ENABLE_TCL = 1 ~~#### Load Tcl using the stubs mechanism~~ #### Load Tcl using the stubs library mechanism # # FOSSIL_ENABLE_TCL_STUBS = 1 #### Load Tcl using the private stubs mechanism # # FOSSIL_ENABLE_TCL_PRIVATE_STUBS = 1 #### Use the Tcl source directory instead of the install directory? # This is useful when Tcl has been compiled statically with MinGW. # FOSSIL_TCL_SOURCE = 1 #### Check if the workaround for the MinGW command line handling needs to
︙
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123	113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129	+ +	# TCLINCDIR = $(TCLDIR)/include TCLLIBDIR = $(TCLDIR)/lib #### Tcl: Which Tcl library do we want to use (8.4, 8.5, 8.6, etc)? # ifdef FOSSIL_ENABLE_TCL_STUBS ifndef FOSSIL_ENABLE_TCL_PRIVATE_STUBS LIBTCL = -ltclstub86 endif TCLTARGET = libtclstub86.a else LIBTCL = -ltcl86 TCLTARGET = binaries endif #### C Compile and options for use in building executables that
︙
173 174 175 176 177 178 179 180 181 182 183 184 185 186	179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196	+ + + +	ifdef FOSSIL_ENABLE_TCL TCC += -DFOSSIL_ENABLE_TCL=1 RCC += -DFOSSIL_ENABLE_TCL=1 # Either statically linked or via stubs ifdef FOSSIL_ENABLE_TCL_STUBS TCC += -DFOSSIL_ENABLE_TCL_STUBS=1 -DUSE_TCL_STUBS RCC += -DFOSSIL_ENABLE_TCL_STUBS=1 -DUSE_TCL_STUBS ifdef FOSSIL_ENABLE_TCL_PRIVATE_STUBS TCC += -DFOSSIL_ENABLE_TCL_PRIVATE_STUBS=1 RCC += -DFOSSIL_ENABLE_TCL_PRIVATE_STUBS=1 endif else TCC += -DSTATIC_BUILD RCC += -DSTATIC_BUILD endif endif # With JSON support
︙

︙
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66	50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70	- + + + + +	# FOSSIL_ENABLE_SSL = 1 #### Enable scripting support via Tcl/Tk # FOSSIL_ENABLE_TCL = 1 ~~#### Load Tcl using the stubs mechanism~~ #### Load Tcl using the stubs library mechanism # FOSSIL_ENABLE_TCL_STUBS = 1 #### Load Tcl using the private stubs mechanism # # FOSSIL_ENABLE_TCL_PRIVATE_STUBS = 1 #### Use the Tcl source directory instead of the install directory? # This is useful when Tcl has been compiled statically with MinGW. # FOSSIL_TCL_SOURCE = 1 #### Check if the workaround for the MinGW command line handling needs to
︙
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123	113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129	+ +	# TCLINCDIR = $(TCLDIR)/include TCLLIBDIR = $(TCLDIR)/lib #### Tcl: Which Tcl library do we want to use (8.4, 8.5, 8.6, etc)? # ifdef FOSSIL_ENABLE_TCL_STUBS ifndef FOSSIL_ENABLE_TCL_PRIVATE_STUBS LIBTCL = -ltclstub86 endif TCLTARGET = libtclstub86.a else LIBTCL = -ltcl86 TCLTARGET = binaries endif #### C Compile and options for use in building executables that
︙
173 174 175 176 177 178 179 180 181 182 183 184 185 186	179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196	+ + + +	ifdef FOSSIL_ENABLE_TCL TCC += -DFOSSIL_ENABLE_TCL=1 RCC += -DFOSSIL_ENABLE_TCL=1 # Either statically linked or via stubs ifdef FOSSIL_ENABLE_TCL_STUBS TCC += -DFOSSIL_ENABLE_TCL_STUBS=1 -DUSE_TCL_STUBS RCC += -DFOSSIL_ENABLE_TCL_STUBS=1 -DUSE_TCL_STUBS ifdef FOSSIL_ENABLE_TCL_PRIVATE_STUBS TCC += -DFOSSIL_ENABLE_TCL_PRIVATE_STUBS=1 RCC += -DFOSSIL_ENABLE_TCL_PRIVATE_STUBS=1 endif else TCC += -DSTATIC_BUILD RCC += -DSTATIC_BUILD endif endif # With JSON support
︙
























































































































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