Check-in [a1a14e0aba]
Overview
Comment:Integrated KitDLL into KitSH
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | merge-kitdll-kitsh-common
Files: files | file ages | folders
SHA1:a1a14e0aba5acda6ae55d5e56f2646cb7fb327b8
User & Date: rkeene on 2011-05-23 10:53:53
Other Links: manifest | tags
Context
2011-05-23
15:33
Corrected typo

Updated to weak zlib symbols

Updated to not link against stub archives for Tk as well as Tcl check-in: 75fa17d1eb user: rkeene tags: merge-kitdll-kitsh-common

10:53
Integrated KitDLL into KitSH check-in: a1a14e0aba user: rkeene tags: merge-kitdll-kitsh-common
03:14
More work on consolidating KitSH and KitDLL and supporting C-VFS check-in: df550ab43e user: rkeene tags: merge-kitdll-kitsh-common
Changes

Modified README from [6e46265709] to [f55796d36b].

    57     57   		a. KITCREATOR_PKGS='tk itcl'
    58     58   		b. export KITCREATOR_PKGS
    59     59   		c. ./kitcreator
    60     60   
    61     61   	9. Create a Tclkit with Metakit4 support, but using Zip for storage:
    62     62   		a. $ ./kitcreator --enable-kit-storage=zip
    63     63   
    64         -	10. Create a KitDLL without Metakit support (will not create a Tclkit
           64  +	10. Create a Tclkit with Metakit4 support, but using C-VFS for storage
           65  +		a. $ ./kitcreator --enable-kit-storage=cvfs
           66  +
           67  +	11. Create a KitDLL without Metakit support (will not create a Tclkit
    65     68   	    binary, just the library):
    66     69   		a. $ KITCREATOR_PKGS='tk itcl kitdll'
    67     70   		b. $ export KITCREATOR_PKGS
    68     71   		c. $ ./kitcreator
    69     72   
    70     73   Environment variables:
    71     74   	1. MAKE

Modified kitcreator from [fb76c24536] to [2e933cc686].

    18     18   if [ "$1" = "distclean" ]; then
    19     19   	shift
    20     20   
    21     21   	mode="distclean"
    22     22   fi
    23     23   
    24     24   # Define the list of all packages, for cleaning purposes
    25         -KITCREATOR_ALLPKGS="kitsh tcl tclvfs zlib tk itcl mk4tcl thread kitdll"
           25  +KITCREATOR_ALLPKGS="kitsh tcl tclvfs zlib tk itcl mk4tcl thread"
    26     26   for pkg in ${KITCREATOR_ALLPKGS}; do
    27     27   	rm -f "${pkg}/build.log"
    28     28   	rm -rf "${pkg}/out" "${pkg}/inst" "${pkg}/build"
    29     29   
    30     30   	rm -rf "${pkg}/src"/tmp-*
    31     31   
    32     32   	if [ "${mode}" = "distclean" ]; then
................................................................................
    98     98   else
    99     99   	KITCREATOR_RC="$(echo "$(pwd)/kitsh/buildsrc"/kitsh-*/kit.rc)"
   100    100   fi
   101    101   export KITCREATOR_ICON KITCREATOR_RC
   102    102   
   103    103   failedpkgs=""
   104    104   buildfailed="0"
   105         -for pkg in tcl tclvfs zlib ${KITCREATOR_PKGS} "${KITTARGET}"; do
          105  +for pkg in tcl tclvfs zlib ${KITCREATOR_PKGS} kitsh; do
   106    106   	echo -n "Building ${pkg} ..."
   107    107   
   108    108   	failed="0"
   109    109   	(
   110    110   		cd "${pkg}" >/dev/null 2>/dev/null || exit 1
   111    111   
   112    112   		./build.sh > build.log 2>&1 || exit 1
................................................................................
   135    135   	echo "Failed to build:${failedpkgs}"
   136    136   fi
   137    137   
   138    138   if [ "${buildfailed}" != "0" ]; then
   139    139   	echo 'WARNING: Build is likely incomplete or failed.' >&2
   140    140   fi
   141    141   
   142         -cp 'kitdll/build'/kitdll-*/libtclkit* . >/dev/null 2>/dev/null
          142  +cp 'kitsh/build'/kitsh-*/libtclkit* . >/dev/null 2>/dev/null
   143    143   cp 'kitsh/build'/kitsh-*/kit "tclkit-${TCLVERS}" >/dev/null 2>/dev/null
   144    144   
   145    145   exit "${buildfailed}"

Deleted kitdll/build.sh version [9d057a0710].

     1         -#! /bin/bash
     2         -
     3         -if [ ! -f 'build.sh' ]; then
     4         -	echo 'ERROR: This script must be run from the directory it is in' >&2
     5         -
     6         -	exit 1
     7         -fi
     8         -if [ -z "${TCLVERS}" ]; then
     9         -	echo 'ERROR: The TCLVERS environment variable is not set' >&2
    10         -
    11         -	exit 1
    12         -fi
    13         -
    14         -KITDLLVERS="0.0"
    15         -BUILDDIR="$(pwd)/build/kitdll-${KITDLLVERS}"
    16         -OUTDIR="$(pwd)/out"
    17         -INSTDIR="$(pwd)/inst"
    18         -OTHERPKGSDIR="$(pwd)/../"
    19         -export KITDLLVERS BUILDDIR OUTDIR INSTDIR OTHERPKGSDIR
    20         -
    21         -rm -rf 'build' 'out' 'inst'
    22         -mkdir 'out' 'inst' || exit 1
    23         -
    24         -(
    25         -	cp -r 'buildsrc' 'build'
    26         -	cd "${BUILDDIR}" || exit 1
    27         -
    28         -	# Fix up archives that Tcl gets wrong
    29         -	for archive in ../../../tcl/inst/lib/dde*/tcldde*.a ../../../tcl/inst/lib/reg*/tclreg*.a; do
    30         -		if [ ! -f "${archive}" ]; then
    31         -			continue
    32         -		fi
    33         -
    34         -		rm -rf __TEMP__
    35         -		(
    36         -			mkdir __TEMP__ || exit 1
    37         -			cd __TEMP__
    38         -
    39         -			## Patch archive name
    40         -			archive="../${archive}"
    41         -
    42         -			"${AR:-ar}" x "${archive}" || exit 1
    43         -
    44         -			rm -f "${archive}"
    45         -
    46         -			"${AR:-ar}" cr "${archive}" *.o || exit 1
    47         -			"${RANLIB:-ranlib}" "${archive}" || true
    48         -		)
    49         -	done
    50         -
    51         -	# Determine how we invoke a Tcl interpreter
    52         -	for testsh in "${TCLSH_NATIVE:-false}" "${TCLKIT:-tclkit}"; do
    53         -		if echo 'exit 0' | "${testsh}" >/dev/null 2>/dev/null; then
    54         -			TCLSH_NATIVE="${testsh}"
    55         -
    56         -			break
    57         -		fi
    58         -	done
    59         -
    60         -	# Cleanup, just incase the incoming directory was not pre-cleaned
    61         -	${MAKE:-make} distclean >/dev/null 2>/dev/null
    62         -	rm -rf "starpack.vfs"
    63         -
    64         -	# Create VFS directory
    65         -	mkdir "starpack.vfs"
    66         -	mkdir "starpack.vfs/lib"
    67         -
    68         -	## Copy in required built directories
    69         -	cp -r "${OTHERPKGSDIR}"/*/out/* 'starpack.vfs/'
    70         -
    71         -	## Rename the "vfs" package directory to what "boot.tcl" expects
    72         -	mv 'starpack.vfs/lib'/vfs* 'starpack.vfs/lib/vfs'
    73         -
    74         -	## Install "boot.tcl"
    75         -	cp 'boot.tcl' 'starpack.vfs/'
    76         -
    77         -	# Include extra objects as required
    78         -	## Initialize list of extra objects
    79         -	EXTRA_OBJS=""
    80         -
    81         -	## Figure out if zlib compiled (if not, the system zlib will be used and we
    82         -	## will need to have that present)
    83         -	ZLIBDIR="$(cd "${OTHERPKGSDIR}/zlib/inst" 2>/dev/null && pwd)"
    84         -	export ZLIBDIR
    85         -	if [ -n "${ZLIBDIR}" -a -f "${ZLIBDIR}/lib/libz.a" ]; then
    86         -		EXTRA_OBJS="${EXTRA_OBJS} ${ZLIBDIR}/lib/libz.a"
    87         -
    88         -		### Add lib directory for zlib
    89         -		LDFLAGS="${LDFLAGS} -L${ZLIBDIR}/lib"
    90         -		export LDFLAGS
    91         -
    92         -		### Add include directory for zlib
    93         -		CFLAGS="${CFLAGS} -I${ZLIBDIR}/include"
    94         -		CPPFLAGS="${CPPFLAGS} -I${ZLIBDIR}/include"
    95         -		export CFLAGS CPPFLAGS
    96         -	fi
    97         -
    98         -	## Tk Resources (needed for Win32 support)
    99         -	TKDIR="$(cd "${OTHERPKGSDIR}/tk/inst" && pwd)"
   100         -	TKRSRC="${TKDIR}/lib/tkbase.res.o"
   101         -	if [ -n "${TKDIR}" -a -f "${TKRSRC}" ]; then
   102         -		EXTRA_OBJS="${EXTRA_OBJS} ${TKRSRC}"
   103         -	fi
   104         -
   105         -	## Export to the environment, to be picked up by the "configure" script
   106         -	export EXTRA_OBJS
   107         -
   108         -	# Build KitDLL
   109         -	echo "Running: ./configure --with-tcl=\"${TCLCONFIGDIR}\" ${CONFIGUREEXTRA}"
   110         -	./configure --with-tcl="${TCLCONFIGDIR}" ${CONFIGUREEXTRA}
   111         -
   112         -	echo "Running: ${MAKE:-make}"
   113         -	${MAKE:-make} TCLSH_NATIVE="${TCLSH_NATIVE}" || exit 1
   114         -
   115         -	# Strip the KitDLL of debugging symbols, if possible
   116         -	"${STRIP:-strip}" -g libtclkit* >/dev/null 2>/dev/null
   117         -
   118         -	# Fix up Win32 DLL names
   119         -	## .DLL.A -> .LIB
   120         -	for file in libtclkit*.dll.a; do
   121         -		if [ ! -f "${file}" ]; then
   122         -			continue
   123         -		fi
   124         -
   125         -		newfile="$(basename "${file}" .dll.a).lib"
   126         -		mv "${file}" "${newfile}"
   127         -	done
   128         -
   129         -	## .DLL.DEF -> .DEF
   130         -	for file in libtclkit*.dll.def; do
   131         -		if [ ! -f "${file}" ]; then
   132         -			continue
   133         -		fi
   134         -
   135         -		newfile="$(basename "${file}" .dll.def).def"
   136         -		mv "${file}" "${newfile}"
   137         -	done
   138         -
   139         -	exit 0
   140         -) || exit 1
   141         -
   142         -exit 0

Deleted kitdll/buildsrc/kitdll-0.0/boot.tcl version [fdb0ceb95b].

     1         -proc tclInit {} {
     2         -	rename tclInit {}
     3         -
     4         -	global auto_path tcl_library tcl_libPath
     5         -	global tcl_version
     6         -  
     7         -	# Set path where to mount VFS
     8         -	set tcl_mountpoint "/.KITDLL_TCL"
     9         -
    10         -	set tcl_library [file join $tcl_mountpoint lib tcl$tcl_version]
    11         -	set tcl_libPath [list $tcl_library [file join $tcl_mountpoint lib]]
    12         -
    13         -	# get rid of a build residue
    14         -	unset -nocomplain ::tclDefaultLibrary
    15         -
    16         -	# the following code only gets executed once on startup
    17         -	if {[info exists ::initVFS]} {
    18         -		set vfsHandler [list ::vfs::kitdll::vfshandler tcl]
    19         -
    20         -		# alter path to find encodings
    21         -		if {[info tclversion] eq "8.4"} {
    22         -			load {} pwb
    23         -			librarypath [info library]
    24         -		} else {
    25         -			encoding dirs [list [file join [info library] encoding]] ;# TIP 258
    26         -		}
    27         -
    28         -		# fix system encoding, if it wasn't properly set up (200207.004 bug)
    29         -		if {[encoding system] eq "identity"} {
    30         -			if {[info exists ::tclkit_system_encoding] && $::tclkit_system_encoding != ""} {
    31         -				catch {
    32         -					encoding system $::tclkit_system_encoding
    33         -				}
    34         -			}
    35         -			unset -nocomplain ::tclkit_system_encoding
    36         -		}
    37         -
    38         -		# If we've still not been able to set the encoding, revert to Tclkit defaults
    39         -		if {[encoding system] eq "identity"} {
    40         -			catch {
    41         -				switch $::tcl_platform(platform) {
    42         -					windows		{ encoding system cp1252 }
    43         -					macintosh	{ encoding system macRoman }
    44         -				        default		{ encoding system iso8859-1 }
    45         -				}
    46         -			}
    47         -		}
    48         -
    49         -		# now remount the executable with the correct encoding
    50         -		vfs::filesystem unmount [lindex [::vfs::filesystem info] 0]
    51         -
    52         -		# Resolve symlinks
    53         -		set tcl_mountpoint [file dirname [file normalize [file join $tcl_mountpoint __dummy__]]]
    54         -
    55         -		set tcl_library [file join $tcl_mountpoint lib tcl$tcl_version]
    56         -		set tcl_libPath [list $tcl_library [file join $tcl_mountpoint lib]]
    57         -
    58         -		vfs::filesystem mount $tcl_mountpoint $vfsHandler
    59         -
    60         -	}
    61         -
    62         -	# load config settings file if present
    63         -	namespace eval ::vfs { variable tclkit_version 1 }
    64         -	catch { uplevel #0 [list source [file join $tcl_mountpoint config.tcl]] }
    65         -
    66         -	uplevel #0 [list source [file join $tcl_library init.tcl]]
    67         -  
    68         -	# reset auto_path, so that init.tcl's search outside of tclkit is cancelled
    69         -	set auto_path $tcl_libPath
    70         -
    71         -	# This loads everything needed for "clock scan" to work
    72         -	# "clock scan" is used within "vfs::zip", which may be
    73         -	# loaded before this is run causing the root VFS to break
    74         -	catch { clock scan }
    75         -
    76         -	# Load these, the original Tclkit does so it should be safe.
    77         -	foreach vfsfile [list vfsUtils vfslib] {
    78         -		uplevel #0 [list source [file join $tcl_mountpoint lib vfs ${vfsfile}.tcl]]
    79         -	}
    80         -
    81         -	# Set a maximum seek to avoid reading the entire DLL looking for a
    82         -	# zip header
    83         -	catch {
    84         -		package require vfs::zip
    85         -		set ::zip::max_header_seek 8192
    86         -	}
    87         -
    88         -	# Now that the initialization is complete, mount the user VFS if needed
    89         -	## Mount the VFS from the Shared Object
    90         -	if {[info exists ::initVFS] && [info exists ::tclKitFilename]} {
    91         -		catch {
    92         -			vfs::zip::Mount $::tclKitFilename "/.KITDLL_USER"
    93         -
    94         -			lappend auto_path [file normalize "/.KITDLL_USER/lib"]
    95         -		}
    96         -	}
    97         -
    98         -	## Mount the VFS from executable
    99         -	if {[info exists ::initVFS]} {
   100         -		catch {
   101         -			vfs::zip::Mount [info nameofexecutable] "/.KITDLL_APP"
   102         -
   103         -			lappend auto_path [file normalize "/.KITDLL_APP/lib"]
   104         -		}
   105         -	}
   106         -
   107         -	# Clean up
   108         -	unset -nocomplain ::zip::max_header_seek
   109         -
   110         -	# Clean up after the kitInit.c:preInitCmd
   111         -	unset -nocomplain ::initVFS ::tclKitFilename
   112         -}

Deleted kitdll/buildsrc/kitdll-0.0/kitInit.c version [d13061de12].

     1         -#ifdef KIT_INCLUDES_TK
     2         -#  include <tk.h>
     3         -#else
     4         -#  include <tcl.h>
     5         -#endif /* KIT_INCLUDES_TK */
     6         -
     7         -#ifdef _WIN32
     8         -#  define WIN32_LEAN_AND_MEAN
     9         -#  include <windows.h>
    10         -#  undef WIN32_LEAN_AND_MEAN
    11         -#endif /* _WIN32 */
    12         -
    13         -#ifdef HAVE_STRING_H
    14         -#  include <string.h>
    15         -#endif
    16         -#ifdef HAVE_STRINGS_H
    17         -#  include <strings.h>
    18         -#endif
    19         -#ifdef HAVE_DLFCN_H
    20         -#  include <dlfcn.h>
    21         -#endif
    22         -
    23         -#include "tclInt.h"
    24         -
    25         -#if defined(HAVE_TCL_GETENCODINGNAMEFROMENVIRONMENT) && defined(HAVE_TCL_SETSYSTEMENCODING)
    26         -#  define TCLKIT_CAN_SET_ENCODING 1
    27         -#endif
    28         -#if 10 * TCL_MAJOR_VERSION + TCL_MINOR_VERSION < 85
    29         -#  define TCLKIT_REQUIRE_TCLEXECUTABLENAME 1
    30         -#endif
    31         -#if 10 * TCL_MAJOR_VERSION + TCL_MINOR_VERSION < 85
    32         -#  define KIT_INCLUDES_PWB 1
    33         -#endif
    34         -#if 10 * TCL_MAJOR_VERSION + TCL_MINOR_VERSION < 86
    35         -#  define KIT_INCLUDES_ZLIB 1
    36         -#endif
    37         -
    38         -Tcl_AppInitProc Vfs_Init, Rechan_Init;
    39         -Tcl_AppInitProc Vfs_kitdll_data_tcl_Init;
    40         -#ifdef KIT_INCLUDES_MK4TCL
    41         -Tcl_AppInitProc Mk4tcl_Init;
    42         -#endif
    43         -#ifdef KIT_INCLUDES_PWB
    44         -Tcl_AppInitProc Pwb_Init;
    45         -#endif
    46         -#ifdef KIT_INCLUDES_ZLIB
    47         -Tcl_AppInitProc Zlib_Init;
    48         -#endif
    49         -#ifdef TCL_THREADS
    50         -Tcl_AppInitProc Thread_Init;
    51         -#endif
    52         -#ifdef _WIN32
    53         -Tcl_AppInitProc Dde_Init, Registry_Init;
    54         -#endif
    55         -
    56         -/*
    57         - * This Tcl code is invoked whenever Tcl_Init() is called on an
    58         - * interpreter.  It should mount up the VFS and make everything ready for
    59         - * that interpreter to do its job.
    60         - */
    61         -static char *preInitCmd =
    62         -"proc tclKitInit {} {\n"
    63         -	"rename tclKitInit {}\n"
    64         -#ifdef KIT_INCLUDES_ZLIB
    65         -	"catch { load {} zlib }\n"
    66         -#endif
    67         -	"load {} tclkit::init\n"
    68         -	"load {} rechan\n"
    69         -	"load {} vfs\n"
    70         -	"load {} vfs_kitdll_data_tcl\n"
    71         -#ifdef KIT_INCLUDES_MK4TCL
    72         -	"catch { load {} Mk4tcl }\n"
    73         -#endif
    74         -#include "vfs_kitdll.tcl.h"
    75         -	"if {![file exists \"/.KITDLL_TCL/boot.tcl\"]} {\n"
    76         -		"vfs::kitdll::Mount tcl /.KITDLL_TCL\n"
    77         -		"set ::initVFS 1\n"
    78         -	"}\n"
    79         -	"set f [open \"/.KITDLL_TCL/boot.tcl\"]\n"
    80         -	"set s [read $f]\n"
    81         -	"close $f\n"
    82         -	"::tclkit::init::initInterp\n"
    83         -	"rename ::tclkit::init::initInterp {}\n"
    84         -	"uplevel #0 $s\n"
    85         -#if defined(KIT_INCLUDES_TK) && defined(KIT_TK_VERSION)
    86         -	"package ifneeded Tk " KIT_TK_VERSION " {\n"
    87         -		"load {} Tk\n"
    88         -	"}\n"
    89         -#endif
    90         -#ifdef _WIN32
    91         -	"catch {load {} dde}\n"
    92         -	"catch {load {} registry}\n"
    93         -#endif /* _WIN32 */
    94         -"}\n"
    95         -"tclKitInit";
    96         -
    97         -#ifdef HAVE_ACCEPTABLE_DLADDR
    98         -/* Symbol to resolve against dladdr() */
    99         -static void _tclkit_dummy_func(void) {
   100         -	return;
   101         -}
   102         -
   103         -int main(int argc, char **argv);
   104         -#endif /* HAVE_ACCEPTABLE_DLADDR */
   105         -
   106         -/*
   107         - * This function will return a pathname we can open() to treat as a VFS,
   108         - * hopefully
   109         - */
   110         -static char *find_tclkit_dll_path(void) {
   111         -#ifdef HAVE_ACCEPTABLE_DLADDR
   112         -	Dl_info syminfo;
   113         -	int dladdr_ret;
   114         -#endif /* HAVE_ACCEPTABLE_DLADDR */
   115         -#ifdef _WIN32
   116         -	TCHAR modulename[8192];
   117         -	DWORD gmfn_ret;
   118         -#endif /* _WIN32 */
   119         -
   120         -#ifdef HAVE_ACCEPTABLE_DLADDR
   121         -	dladdr_ret = dladdr(&_tclkit_dummy_func, &syminfo);
   122         -	if (dladdr_ret != 0) {
   123         -		if (syminfo.dli_fname && syminfo.dli_fname[0] != '\0') {
   124         -			return(strdup(syminfo.dli_fname));
   125         -		}
   126         -	}
   127         -#endif /* HAVE_ACCEPTABLE_DLADDR */
   128         -
   129         -#ifdef _WIN32
   130         -	gmfn_ret = GetModuleFileName(TclWinGetTclInstance(), modulename, sizeof(modulename) / sizeof(modulename[0]) - 1);
   131         -
   132         -	if (gmfn_ret != 0) {
   133         -		return(strdup(modulename));
   134         -	}
   135         -#endif /* _WIN32 */
   136         -
   137         -	return(NULL);
   138         -}
   139         -
   140         -/* SetExecName --
   141         -	
   142         -   Hack to get around Tcl bug 1224888.
   143         -*/
   144         -static void SetExecName(Tcl_Interp *interp, const char *path) {
   145         -#ifdef TCLKIT_REQUIRE_TCLEXECUTABLENAME
   146         -	tclExecutableName = strdup(path);
   147         -#endif  
   148         -	Tcl_FindExecutable(path);
   149         -
   150         -	return;
   151         -}
   152         -	
   153         -static void FindAndSetExecName(Tcl_Interp *interp) {
   154         -	int len = 0;
   155         -	Tcl_Obj *execNameObj;
   156         -	Tcl_Obj *lobjv[1];
   157         -#ifdef HAVE_READLINK
   158         -	ssize_t readlink_ret;
   159         -	char exe_buf[4096];
   160         -#endif /* HAVE_READLINK */
   161         -#ifdef HAVE_ACCEPTABLE_DLADDR
   162         -	Dl_info syminfo;
   163         -	int dladdr_ret;
   164         -#endif /* HAVE_ACCEPTABLE_DLADDR */
   165         -
   166         -#ifdef HAVE_READLINK
   167         -	if (Tcl_GetNameOfExecutable() == NULL) {
   168         -		readlink_ret = readlink("/proc/self/exe", exe_buf, sizeof(exe_buf) - 1);
   169         -		
   170         -		if (readlink_ret > 0 && readlink_ret < (sizeof(exe_buf) - 1)) {
   171         -			exe_buf[readlink_ret] = '\0';
   172         -			
   173         -			SetExecName(interp, exe_buf);
   174         -			
   175         -			return;
   176         -		}
   177         -	}
   178         -	
   179         -	if (Tcl_GetNameOfExecutable() == NULL) {
   180         -		readlink_ret = readlink("/proc/curproc/file", exe_buf, sizeof(exe_buf) - 1);												 
   181         -
   182         -		if (readlink_ret > 0 && readlink_ret < (sizeof(exe_buf) - 1)) {
   183         -			exe_buf[readlink_ret] = '\0';
   184         -
   185         -			if (strcmp(exe_buf, "unknown") != 0) {
   186         -				SetExecName(interp, exe_buf);
   187         -
   188         -				return;
   189         -			}
   190         -		}
   191         -	}
   192         -#endif /* HAVE_READLINK */
   193         -
   194         -#ifdef HAVE_ACCEPTABLE_DLADDR
   195         -	if (Tcl_GetNameOfExecutable() == NULL) {
   196         -		dladdr_ret = dladdr(&main, &syminfo);
   197         -		if (dladdr_ret != 0) {
   198         -			SetExecName(interp, syminfo.dli_fname);
   199         -		}
   200         -	}
   201         -#endif /* HAVE_ACCEPTABLE_DLADDR */
   202         -
   203         -	if (Tcl_GetNameOfExecutable() == NULL) {
   204         -		lobjv[0] = Tcl_GetVar2Ex(interp, "argv0", NULL, TCL_GLOBAL_ONLY);
   205         -		execNameObj = Tcl_FSJoinToPath(Tcl_FSGetCwd(interp), 1, lobjv);
   206         -
   207         -		SetExecName(interp, Tcl_GetStringFromObj(execNameObj, &len));
   208         -
   209         -		return;
   210         -	}
   211         -
   212         -	return;
   213         -}
   214         -
   215         -
   216         -/*
   217         - * This function exists to allow C code to initialize a particular
   218         - * interpreter.
   219         - */
   220         -static int tclkit_init_initinterp(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
   221         -	char *kitdll_path;
   222         -#ifdef TCLKIT_CAN_SET_ENCODING
   223         -	Tcl_DString encodingName;
   224         -#endif /* TCLKIT_CAN_SET_ENCODING */
   225         -
   226         -
   227         -#ifdef _WIN32
   228         -	Tcl_SetVar(interp, "tcl_rcFileName", "~/tclkitrc.tcl", TCL_GLOBAL_ONLY);
   229         -#else   
   230         -	Tcl_SetVar(interp, "tcl_rcFileName", "~/.tclkitrc", TCL_GLOBAL_ONLY);
   231         -#endif
   232         -
   233         -	kitdll_path = find_tclkit_dll_path();
   234         -	if (kitdll_path != NULL) {
   235         -		Tcl_SetVar(interp, "tclKitFilename", kitdll_path, TCL_GLOBAL_ONLY);
   236         -
   237         -		free(kitdll_path);
   238         -	}
   239         -
   240         -	FindAndSetExecName(interp);
   241         -
   242         -#ifdef TCLKIT_CAN_SET_ENCODING
   243         -	/* Set the encoding from the Environment */
   244         -	Tcl_GetEncodingNameFromEnvironment(&encodingName);
   245         -	Tcl_SetSystemEncoding(NULL, Tcl_DStringValue(&encodingName));
   246         -	Tcl_SetVar(interp, "tclkit_system_encoding", Tcl_DStringValue(&encodingName), TCL_GLOBAL_ONLY);
   247         -	Tcl_DStringFree(&encodingName);
   248         -#endif  
   249         -
   250         -	return(TCL_OK);
   251         -}
   252         -
   253         -/*
   254         - * Create a package for initializing a particular interpreter.  This is
   255         - * our hook to have Tcl invoke C commands when creating an interpreter.
   256         - * The preInitCmd will load the package in the new interpreter and invoke
   257         - * this function.
   258         - */
   259         -int Tclkit_init_Init(Tcl_Interp *interp) {
   260         -	Tcl_Command tclCreatComm_ret;
   261         -	int tclPkgProv_ret;
   262         -
   263         -	tclCreatComm_ret = Tcl_CreateObjCommand(interp, "::tclkit::init::initInterp", tclkit_init_initinterp, NULL, NULL);
   264         -	if (!tclCreatComm_ret) {
   265         -		return(TCL_ERROR);
   266         -	}
   267         -
   268         -	tclPkgProv_ret = Tcl_PkgProvide(interp, "tclkit::init", "1.0");
   269         -
   270         -	return(tclPkgProv_ret);
   271         -}
   272         -
   273         -/*
   274         - * Initialize the Tcl system when we are loaded, that way Tcl functions
   275         - * are ready to be used when invoked.
   276         - */
   277         -void __attribute__((constructor)) _Tclkit_Init(void) {
   278         -	Tcl_StaticPackage(0, "tclkit::init", Tclkit_init_Init, NULL);
   279         -	Tcl_StaticPackage(0, "rechan", Rechan_Init, NULL);
   280         -	Tcl_StaticPackage(0, "vfs", Vfs_Init, NULL);
   281         -	Tcl_StaticPackage(0, "vfs_kitdll_data_tcl", Vfs_kitdll_data_tcl_Init, NULL);
   282         -#ifdef KIT_INCLUDES_ZLIB
   283         -        Tcl_StaticPackage(0, "zlib", Zlib_Init, NULL);
   284         -#endif
   285         -#ifdef KIT_INCLUDES_MK4TCL
   286         -	Tcl_StaticPackage(0, "Mk4tcl", Mk4tcl_Init, NULL);
   287         -#endif
   288         -#ifdef KIT_INCLUDES_PWB
   289         -	Tcl_StaticPackage(0, "pwb", Pwb_Init, NULL);
   290         -#endif
   291         -#ifdef TCL_THREADS
   292         -	Tcl_StaticPackage(0, "Thread", Thread_Init, NULL);
   293         -#endif
   294         -#ifdef _WIN32
   295         -	Tcl_StaticPackage(0, "dde", Dde_Init, NULL);
   296         -	Tcl_StaticPackage(0, "registry", Registry_Init, NULL);
   297         -#endif
   298         -#ifdef KIT_INCLUDES_TK
   299         -	Tcl_StaticPackage(0, "Tk", Tk_Init, Tk_SafeInit);
   300         -#endif  
   301         -
   302         -	TclSetPreInitScript(preInitCmd);
   303         -
   304         -	return;
   305         -}

Modified kitsh/build.sh from [2d7f94aadf] to [670c8d17c7].

    26     26   rm -rf 'build' 'out' 'inst'
    27     27   mkdir 'out' 'inst' || exit 1
    28     28   
    29     29   
    30     30   (
    31     31   	cp -r 'buildsrc' 'build'
    32     32   	cd "${BUILDDIR}" || exit 1
           33  +
           34  +	# Fix up archives that Tcl gets wrong
           35  +	for archive in ../../../tcl/inst/lib/dde*/tcldde*.a ../../../tcl/inst/lib/reg*/tclreg*.a; do
           36  +		if [ ! -f "${archive}" ]; then
           37  +			continue
           38  +		fi
           39  +
           40  +		rm -rf __TEMP__
           41  +		(
           42  +			mkdir __TEMP__ || exit 1
           43  +			cd __TEMP__
           44  +
           45  +			## Patch archive name
           46  +			archive="../${archive}"
           47  +
           48  +			"${AR:-ar}" x "${archive}" || exit 1
           49  +
           50  +			rm -f "${archive}"
           51  +
           52  +			"${AR:-ar}" cr "${archive}" *.o || exit 1
           53  +			"${RANLIB:-ranlib}" "${archive}" || true
           54  +		)
           55  +	done
           56  +
           57  +	# Determine how we invoke a Tcl interpreter
           58  +	for testsh in "${TCLSH_NATIVE:-false}" tclsh tclsh8.4 tclsh8.5 tclsh8.6 "${TCLKIT:-tclkit}"; do
           59  +		if echo 'exit 0' | "${testsh}" >/dev/null 2>/dev/null; then
           60  +			TCLSH_NATIVE="${testsh}"
           61  +
           62  +			break
           63  +		fi
           64  +	done
    33     65   
    34     66   	# Cleanup, just incase the incoming directory was not pre-cleaned
    35     67   	${MAKE:-make} distclean >/dev/null 2>/dev/null
           68  +	rm -rf 'starpack.vfs'
    36     69   
    37     70   	# Create VFS directory
    38     71   	mkdir "starpack.vfs"
    39     72   	mkdir "starpack.vfs/lib"
    40     73   
    41     74   	## Copy in all built directories
    42     75   	cp -r "${OTHERPKGSDIR}"/*/out/* 'starpack.vfs/'
................................................................................
    58     91   	# Copy user specified kit.rc and kit.ico in to build directory, if found
    59     92   	cp "${KITCREATOR_ICON}" "${BUILDDIR}/kit.ico"
    60     93   	cp "${KITCREATOR_RC}" "${BUILDDIR}/kit.rc"
    61     94   
    62     95   	# Include extra objects as required
    63     96   	## Initialize list of extra objects
    64     97   	EXTRA_OBJS=""
           98  +	export EXTRA_OBJS
    65     99   
    66    100   	## Tk Resources (needed for Win32 support) -- remove kit-found resources to prevent the symbols from being in conflict
    67    101   	TKDIR="$(cd "${OTHERPKGSDIR}/tk/inst" && pwd)"
    68    102   	TKRSRC="${TKDIR}/lib/tkbase.res.o"
    69    103   	if [ -n "${TKDIR}" -a -f "${TKRSRC}" ]; then
    70    104   		EXTRA_OBJS="${EXTRA_OBJS} ${TKRSRC}"
    71    105   
    72    106   		echo ' *** Removing "kit.rc" since we have Tk with its own resource file'
    73    107   
    74    108   		rm -f "${BUILDDIR}/kit.rc"
    75    109   	fi
    76    110   
    77         -	## Export to the environment, to be picked up by the "configure" script
    78         -	export EXTRA_OBJS
          111  +	# Determine if target is KitDLL or KitSH
          112  +	if [ "${KITTARGET}" = "kitdll" ]; then
          113  +		CONFIGUREEXTRA="${CONFIGUREEXTRA} --enable-kitdll"
          114  +	fi
    79    115   
    80         -	# Compile Kitsh
          116  +	# Compile Kit
    81    117   	if [ -z "${ZLIBDIR}" ]; then
    82    118   		echo "Running: ./configure --with-tcl=\"${TCLCONFIGDIR}\" ${CONFIGUREEXTRA}"
    83    119   
    84    120   		./configure --with-tcl="${TCLCONFIGDIR}" ${CONFIGUREEXTRA}
    85    121   	else
    86    122   		echo "Running: ./configure --with-tcl=\"${TCLCONFIGDIR}\" --with-zlib=\"${ZLIBDIR}\" ${CONFIGUREEXTRA}"
    87    123   
    88    124   		./configure --with-tcl="${TCLCONFIGDIR}" --with-zlib="${ZLIBDIR}" ${CONFIGUREEXTRA}
    89    125   	fi
    90    126   
    91         -	echo "Running: ${MAKE:-make}"
    92         -	${MAKE:-make} || exit 1
          127  +	echo "Running: ${MAKE:-make} TCLSH_NATIVE=\"${TCLSH_NATIVE}\""
          128  +	${MAKE:-make} TCLSH_NATIVE="${TCLSH_NATIVE}" || exit 1
    93    129   
    94    130   	# Strip the kit of all symbols, if possible
    95    131   	"${STRIP:-strip}" kit >/dev/null 2>/dev/null
          132  +	"${STRIP:-strip}" -g libtclkit* >/dev/null 2>/dev/null
          133  +
          134  +	# Fix up Win32 DLL names
          135  +	## .DLL.A -> .LIB
          136  +	for file in libtclkit*.dll.a; do
          137  +		if [ ! -f "${file}" ]; then
          138  +			continue
          139  +		fi
          140  +
          141  +		newfile="$(basename "${file}" .dll.a).lib"
          142  +		mv "${file}" "${newfile}"
          143  +	done
          144  +
          145  +	## .DLL.DEF -> .DEF
          146  +	for file in libtclkit*.dll.def; do
          147  +		if [ ! -f "${file}" ]; then
          148  +			continue
          149  +		fi
          150  +
          151  +		newfile="$(basename "${file}" .dll.def).def"
          152  +		mv "${file}" "${newfile}"
          153  +	done
          154  +
          155  +	# Determine name of created kit
          156  +	KITTARGET_NAME='__error__'
          157  +	if [ "${KITTARGET}" = "kitdll" ]; then
          158  +		## Find the library created
          159  +		for chkkittarget in libtclkit*.*; do
          160  +			if [ ! -f "${chkkittarget}" ]; then
          161  +				continue
          162  +			fi
          163  +
          164  +			if echo "${chkkittarget}" | egrep '\.(lib|def|a)$'; then
          165  +				continue
          166  +			fi
          167  +
          168  +			KITTARGET_NAME="${chkkittarget}"
          169  +
          170  +			break
          171  +		done
          172  +
          173  +		## Also create an executable named "kit" so that we can run it later
          174  +		${MAKE:-make} tclsh
          175  +		mv tclsh kit
          176  +	else
          177  +		## The executable is always named "kit"
          178  +		KITTARGET_NAME='kit'
          179  +	fi
          180  +	export KITTARGET_NAME
          181  +
          182  +	if [ "x${KITTARGET_NAME}" = 'x__error__' ]; then
          183  +		echo "Failed to locate kit target!" >&2
          184  +
          185  +		exit 1
          186  +	fi
    96    187   
    97    188   	# Intall VFS onto kit
    98    189   	## Determine if we have a Tclkit to do this work
    99    190   	TCLKIT="${TCLKIT:-tclkit}"
   100    191   	if echo 'exit 0' | "${TCLKIT}" >/dev/null 2>/dev/null; then
   101    192   		## Install using existing Tclkit
   102    193   		### Call installer
   103         -		echo "Running: \"${TCLKIT}\" installvfs.tcl kit starpack.vfs \"${ENABLECOMPRESSION}\""
   104         -		"${TCLKIT}" installvfs.tcl kit starpack.vfs "${ENABLECOMPRESSION}"
          194  +		echo "Running: \"${TCLKIT}\" installvfs.tcl \"${KITTARGET_NAME}\" starpack.vfs \"${ENABLECOMPRESSION}\""
          195  +		"${TCLKIT}" installvfs.tcl "${KITTARGET_NAME}" starpack.vfs "${ENABLECOMPRESSION}"
   105    196   	else
   106    197   		## Bootstrap (cannot cross-compile)
   107    198   		### Call installer
   108    199   		cp kit runkit
   109         -		echo "set argv [list kit starpack.vfs {${ENABLECOMPRESSION}}]" > setup.tcl
          200  +		echo "set argv [list {${KITTARGET_NAME}} starpack.vfs {${ENABLECOMPRESSION}}]" > setup.tcl
   110    201   		echo 'if {[catch { clock seconds }]} { proc clock args { return 0 } }' >> setup.tcl
   111    202   		echo 'source installvfs.tcl' >> setup.tcl
   112    203   
   113    204   		echo 'Running: echo | ./runkit'
   114         -		echo | ./runkit
          205  +		echo | ./runkit setup.tcl
   115    206   	fi
   116    207   
   117    208   	exit 0
   118    209   ) || exit 1
   119    210   
   120    211   exit 0

Modified kitsh/buildsrc/kitsh-0.0/Makefile.common.in from [3d3c56cfe6] to [6640ec3deb].

     6      6   WISH_CFLAGS = @WISH_CFLAGS@
     7      7   LDFLAGS = @LDFLAGS@
     8      8   SHOBJLDFLAGS = @SHOBJLDFLAGS@
     9      9   LIBS = @LIBS@
    10     10   ARCHS = @ARCHS@
    11     11   STRIPLIBS = @STRIPLIBS@ @EXTRA_OBJS@
    12     12   EXTRA_OBJS = @EXTRA_OBJS@
           13  +LDRUNPATH = @LDRUNPATH@
    13     14   EXTRA_KIT_DEPS = @EXTRA_KIT_DEPS@
           15  +EXTRA_VFS_OBJS = @EXTRA_VFS_OBJS@
    14     16   TCLSH_NATIVE = tclsh
    15     17   
    16     18   # Build targets
    17     19   ## VFS Build
    18     20   vfs_kitdll_data_tcl.o: vfs_kitdll_data_tcl.c
    19     21   vfs_kitdll_data_tcl.c: dir2c.tcl starpack.vfs vfs_kitdll_data.c
    20     22   	"$(TCLSH_NATIVE)" dir2c.tcl tcl starpack.vfs > vfs_kitdll_data_tcl.c
................................................................................
    39     41   kit.res.o: kit.rc kit.ico
    40     42   	$(RC) -o kit.res.o $(CPPFLAGS) kit.rc
    41     43   
    42     44   # Cleanup routines
    43     45   clean:
    44     46   	rm -f kit kit.res.o
    45     47   	rm -f libtclkit@KITDLL_LIB_VERSION@.@SHOBJEXT@
    46         -	rm -f $(OBJS)
           48  +	rm -f $(OBJS) $(EXTRA_OBJS) $(EXTRA_VFS_OBJS)
    47     49   	rm -f vfs_kitdll_data_tcl.c
    48     50   	rm -f vfs_kitdll.tcl.h
    49     51   	rm -f tclsh.o tclsh tclsh.exe
    50     52   	rm -f wish.o wish wish.exe
    51     53   
    52     54   distclean: clean
    53     55   	rm -f Makefile Makefile.in Makefile.common

Modified kitsh/buildsrc/kitsh-0.0/Makefile.kitdll.in from [d50a3331ee] to [291ff89745].

     1         -OBJS = vfs_kitdll_data_tcl.o kitInit.o rechan.o pwb.o zlib.o
            1  +OBJS = kitInit.o rechan.o pwb.o zlib.o
     2      2   
     3      3   # Default target
     4      4   all: libtclkit@KITDLL_LIB_VERSION@.@SHOBJEXT@
     5      5   
     6      6   -include Makefile.common
     7      7   
     8      8   ## DLL Build
     9         -libtclkit@KITDLL_LIB_VERSION@.@SHOBJEXT@: $(OBJS) $(EXTRA_KIT_DEPS) $(EXTRA_OBJS)
            9  +libtclkit@KITDLL_LIB_VERSION@.@SHOBJEXT@: $(OBJS) $(EXTRA_KIT_DEPS) $(EXTRA_OBJS) $(EXTRA_VFS_OBJS)
    10     10   	-for striplib in $(STRIPLIBS); do $(OBJCOPY) --weaken "$${striplib}"; done
    11         -	$(CC) $(CPPFLAGS) $(CFLAGS) -o libtclkit@KITDLL_LIB_VERSION@.@SHOBJEXT@ $(OBJS) $(EXTRA_OBJS) $(LDFLAGS) $(SHOBJLDFLAGS) @WHOLEARCHIVE@ $(ARCHS) @NOWHOLEARCHIVE@ $(LIBS)
           11  +	$(CC) $(CPPFLAGS) $(CFLAGS) -o libtclkit@KITDLL_LIB_VERSION@.@SHOBJEXT@ $(OBJS) $(EXTRA_OBJS) $(EXTRA_VFS_OBJS) $(LDFLAGS) $(SHOBJLDFLAGS) @WHOLEARCHIVE@ $(ARCHS) @NOWHOLEARCHIVE@ $(LIBS)
    12     12   
    13     13   # Test driver
    14     14   tclsh.o: tclsh.c
    15     15   tclsh: tclsh.o $(EXTRA_OBJS) libtclkit@KITDLL_LIB_VERSION@.@SHOBJEXT@
    16         -	$(CC) $(CPPFLAGS) $(CFLAGS) -o tclsh tclsh.o $(EXTRA_OBJS) -L. -ltclkit@KITDLL_LIB_VERSION@ -Wl,-rpath,.
           16  +	$(CC) $(CPPFLAGS) $(CFLAGS) -o tclsh tclsh.o $(EXTRA_OBJS) -L. -ltclkit@KITDLL_LIB_VERSION@ $(LDRUNPATH)
    17     17   
    18     18   wish.o: wish.c
    19     19   wish: wish.o $(EXTRA_OBJS) libtclkit@KITDLL_LIB_VERSION@.@SHOBJEXT@
    20         -	$(CC) $(CPPFLAGS) $(CFLAGS) $(WISH_CFLAGS) -o wish wish.o $(EXTRA_OBJS) -L. -ltclkit@KITDLL_LIB_VERSION@ -Wl,-rpath,.
           20  +	$(CC) $(CPPFLAGS) $(CFLAGS) $(WISH_CFLAGS) -o wish wish.o $(EXTRA_OBJS) -L. -ltclkit@KITDLL_LIB_VERSION@ $(LDRUNPATH)

Modified kitsh/buildsrc/kitsh-0.0/Makefile.tclkit.in from [fe7827b4fe] to [b723314153].

     1      1   OBJS = kitInit.o main.o pwb.o rechan.o zlib.o winMain.o
     2      2   
     3      3   all: kit
     4      4   
     5      5   -include Makefile.common
     6      6   
     7         -kit: $(OBJS) $(EXTRA_OBJS) $(EXTRA_KIT_DEPS) $(ARCHS)
     8         -	$(CC) $(CPPFLAGS) $(CFLAGS) -o kit $(OBJS) $(EXTRA_OBJS) $(ARCHS) $(LDFLAGS) $(LIBS)
            7  +kit: $(OBJS) $(EXTRA_OBJS) $(EXTRA_KIT_DEPS) $(EXTRA_VFS_OBJS) $(ARCHS)
            8  +	$(CC) $(CPPFLAGS) $(CFLAGS) -o kit $(OBJS) $(EXTRA_OBJS $(EXTRA_VFS_OBJS)) $(ARCHS) $(LDFLAGS) $(LIBS)

Modified kitsh/buildsrc/kitsh-0.0/aclocal.m4 from [4ab5fc6711] to [f5f5688875].

    33     33   
    34     34   	if test -f "${tclconfigsh}"; then
    35     35   		. "${tclconfigsh}"
    36     36   
    37     37   		CFLAGS="${CFLAGS} ${TCL_INCLUDE_SPEC} -I${TCL_SRC_DIR}/generic -I${tclconfigshdir}"
    38     38   		CPPFLAGS="${CPPFLAGS} ${TCL_INCLUDE_SPEC} -I${TCL_SRC_DIR}/generic -I${tclconfigshdir}"
    39     39   		LIBS="${LIBS} ${TCL_LIBS}"
           40  +
           41  +		KITDLL_LIB_VERSION=`echo "${TCL_VERSION}${TCL_PATCH_LEVEL}" | sed 's@\.@@g'`
    40     42   	fi
    41     43   
    42     44   	AC_SUBST(CFLAGS)
    43     45   	AC_SUBST(CPPFLAGS)
    44     46   	AC_SUBST(LIBS)
           47  +	AC_SUBST(KITDLL_LIB_VERSION)
    45     48   
    46     49   	AC_MSG_RESULT([$tclconfigsh])
    47     50   ])
    48     51   
    49     52   AC_DEFUN(DC_DO_TK, [
    50     53   	AC_MSG_CHECKING([path to tk])
    51     54   	AC_ARG_WITH(tk, AC_HELP_STRING([--with-tk], [directory containing tk configuration (tkConfig.sh)]), [], [
................................................................................
   149    152   	DC_DO_STATIC_LINK_LIB([C++ Library (Sun Studio)], [-lCstd -lCrun],, [
   150    153   		DC_DO_STATIC_LINK_LIB([C++ Library (UNIX)], [-lstdc++])
   151    154   	])
   152    155   ])
   153    156   
   154    157   AC_DEFUN(DC_FIND_TCLKIT_LIBS, [
   155    158   	DC_SETUP_TCL_PLAT_DEFS
          159  +
          160  +	dnl We will need this for the Tcl project, which we will always have
          161  +	DC_CHECK_FOR_WHOLE_ARCHIVE
   156    162   
   157    163   	for proj in mk4tcl tcl tclvfs tk; do
   158    164   		AC_MSG_CHECKING([for libraries required for ${proj}])
   159    165   
   160         -		libdir="../../../${proj}/inst"
   161         -		libfiles="`find "${libdir}" -name '*.a' 2>/dev/null | tr "\n" ' '`"
   162         -		libfilesnostub="`find "${libdir}" -name '*.a' 2>/dev/null | grep -v 'stub' | tr "\n" ' '`"
          166  +		projlibdir="../../../${proj}/inst"
          167  +		projlibfiles="`find "${projlibdir}" -name '*.a' 2>/dev/null | tr "\n" ' '`"
          168  +		projlibfilesnostub="`find "${projlibdir}" -name '*.a' 2>/dev/null | grep -v 'stub' | tr "\n" ' '`"
   163    169   
   164         -		ARCHS="${ARCHS} ${libfiles}"
          170  +		AC_MSG_RESULT([${projlibfilesnostub}])
   165    171   
   166         -		AC_MSG_RESULT([${libfiles}])
          172  +		hide_symbols="1"
   167    173   
   168         -		if test "${libfilesnostub}" != ""; then
          174  +		if test "${proj}" = "tcl"; then
          175  +			DC_TEST_WHOLE_ARCHIVE_SHARED_LIB([$ARCHS $projlibfilesnostub], [
          176  +				projlibfiles="${projlibfilesnostub}"
          177  +			], [
          178  +				DC_TEST_WHOLE_ARCHIVE_SHARED_LIB([$ARCHS $projlibfiles], [
          179  +					projlibfiles="${projlibfiles}"
          180  +				])
          181  +			])
          182  +
          183  +			hide_symbols="0"
          184  +		fi
          185  +
   169    186   			if test "${proj}" = "mk4tcl"; then
          187  +			if test -n "${projlibfiles}"; then
   170    188   				AC_DEFINE(KIT_INCLUDES_MK4TCL, [1], [Specify this if you link against mkt4tcl])
   171    189   
   172    190   				kc_cv_feature_kit_includes_mk4tcl='1'
   173    191   
   174    192   				DC_DO_STATIC_LINK_LIBCXX
   175    193   			fi
          194  +		fi
          195  +
   176    196   			if test "${proj}" = "tk"; then
          197  +			if test "${projlibfilesnostub}" != ""; then
   177    198   				DC_DO_TK
   178    199   				AC_DEFINE(KIT_INCLUDES_TK, [1], [Specify this if we link statically to Tk])
   179    200   				if test -n "${TK_VERSION}"; then
   180    201   					AC_DEFINE_UNQUOTED(KIT_TK_VERSION, "${TK_VERSION}${TK_PATCH_LEVEL}", [Specify the version of Tk])
   181    202   				fi
   182    203   
   183    204   				if test "$host_os" = "mingw32msvc" -o "$host_os" = "mingw32"; then
   184    205   					AC_DEFINE(KITSH_NEED_WINMAIN, [1], [Define if you need WinMain (Windows)])
   185    206   					CFLAGS="${CFLAGS} -mwindows"
   186    207   				fi
          208  +
          209  +				hide_symbols="0"
          210  +			fi
   187    211   			fi
          212  +
          213  +		ARCHS="${ARCHS} ${projlibfiles}"
          214  +
          215  +		if test "${hide_symbols}" = "1"; then
          216  +			STRIPLIBS="${STRIPLIBS} ${projlibfiles}"
   188    217   		fi
   189    218   	done
   190    219   
   191    220   	AC_SUBST(ARCHS)
          221  +	AC_SUBST(STRIPLIBS)
   192    222   ])
   193    223   
   194    224   AC_DEFUN(DC_SETUP_TCL_PLAT_DEFS, [
   195    225   	AC_CANONICAL_BUILD
   196    226   	AC_CANONICAL_HOST
   197    227     
   198    228   	AC_MSG_CHECKING(host operating system)
   199    229   	AC_MSG_RESULT($host_os)
   200    230     
   201    231   	case $host_os in
   202    232   		mingw32*)
   203    233   			CFLAGS="${CFLAGS} -mno-cygwin -mms-bitfields"
          234  +			WISH_CFLAGS="-mwindows"
   204    235   
   205    236   			dnl If we are building for Win32, we need to define "BUILD_tcl" so that
   206    237   			dnl TCL_STORAGE_CLASS gets defined as DLLEXPORT, to make static linking
   207    238   			dnl work
   208    239   			AC_DEFINE(BUILD_tcl, [1], [Define if you need to pretend to be building Tcl (Windows)])
   209    240   			AC_DEFINE(BUILD_tk, [1], [Define if you need to pretend to be building Tk (Windows)])
   210    241   			;;
   211    242   		cygwin*)
   212    243   			CFLAGS="${CFLAGS} -mms-bitfields"
          244  +			WISH_CFLAGS="-mwindows"
   213    245   			;;
   214    246   	esac
          247  +
          248  +	AC_SUBST(WISH_CFLAGS)
   215    249   ])
   216    250   
   217    251   AC_DEFUN(DC_STATIC_LIBGCC, [
   218    252   	AC_MSG_CHECKING([how to link statically against libgcc])
   219    253   
   220    254   	SAVELDFLAGS="${LDFLAGS}"
   221    255   	staticlibgcc=""
................................................................................
   404    438   		WHOLEARCHIVE=`echo "${wholearchive}" | cut -f 1 -d ' '`
   405    439   		NOWHOLEARCHIVE=`echo "${wholearchive}" | cut -f 2 -d ' '`
   406    440   	fi
   407    441   
   408    442   	AC_SUBST(WHOLEARCHIVE)
   409    443   	AC_SUBST(NOWHOLEARCHIVE)
   410    444   ])
          445  +
          446  +AC_DEFUN(DC_SETLDRUNPATH, [
          447  +	OLD_LDFLAGS="${LDFLAGS}"
          448  +
          449  +	for testldflags in "-Wl,-rpath -Wl,$1" "-Wl,-R -Wl,$1"; do
          450  +		LDFLAGS="${OLD_LDFLAGS} ${testldflags}"
          451  +		AC_TRY_LINK([#include <stdio.h>], [ return(0); ], [
          452  +			LDRUNPATH="$LDRUNPATH $testldflags"
          453  +
          454  +			break
          455  +		])
          456  +	done
          457  +
          458  +	LDFLAGS="${OLD_LDFLAGS}"
          459  +
          460  +	AC_SUBST(LDRUNPATH)
          461  +])

Modified kitsh/buildsrc/kitsh-0.0/boot.tcl from [f82ab7409d] to [4987d39e91].

     1      1   proc tclInit {} {
     2      2   	rename tclInit {}
     3      3   
     4      4   	global auto_path tcl_library tcl_libPath
     5      5   	global tcl_version tcl_rcFileName
     6      6     
     7         -	set noe [info nameofexecutable]
            7  +	set mountpoint [subst "$::TCLKIT_MOUNTPOINT_VAR"]
     8      8   
     9      9   	# Resolve symlinks
    10         -	set noe [file dirname [file normalize [file join $noe __dummy__]]]
           10  +	set mountpoint [file dirname [file normalize [file join $mountpoint __dummy__]]]
    11     11   
    12         -	set tcl_library [file join $noe lib tcl$tcl_version]
    13         -	set tcl_libPath [list $tcl_library [file join $noe lib]]
    14         -
    15         -	# get rid of a build residue
    16         -	unset -nocomplain ::tclDefaultLibrary
           12  +	set tcl_library [file join $mountpoint lib tcl$tcl_version]
           13  +	set tcl_libPath [list $tcl_library [file join $mountpoint lib]]
    17     14   
    18     15   	# the following code only gets executed once on startup
    19         -	if {[info exists tcl_rcFileName]} {
           16  +	if {[info exists ::TCLKIT_INITVFS]} {
           17  +		catch {
           18  +			load {} vfs
           19  +		}
           20  +
    20     21   		# lookup and emulate "source" of lib/vfs/{vfs*.tcl,mk4vfs.tcl}
    21     22   		switch -- $::tclKitStorage {
    22     23   			"mk4" {
    23         -				load {} vfs
    24         -
    25     24   				# must use raw MetaKit calls because VFS is not yet in place
    26     25   				set d [mk::select exe.dirs parent 0 name lib]
    27     26   				set d [mk::select exe.dirs parent $d name vfs]
    28     27       
    29     28   				foreach x {vfsUtils vfslib mk4vfs} {
    30     29   					set n [mk::select exe.dirs!$d.files name $x.tcl]
    31     30   					set s [mk::get exe.dirs!$d.files!$n contents]
................................................................................
    76     75   			}
    77     76   			"cvfs" {
    78     77   				set vfsHandler [list ::vfs::kitdll::vfshandler tcl]
    79     78   			}
    80     79   		}
    81     80   
    82     81   		# mount the executable, i.e. make all runtime files available
    83         -		vfs::filesystem mount $noe $vfsHandler
           82  +		vfs::filesystem mount $mountpoint $vfsHandler
    84     83   
    85     84   		# alter path to find encodings
    86     85   		if {[info tclversion] eq "8.4"} {
    87     86   			load {} pwb
    88     87   			librarypath [info library]
    89     88   		} else {
    90     89   			encoding dirs [list [file join [info library] encoding]] ;# TIP 258
................................................................................
    93     92   		# fix system encoding, if it wasn't properly set up (200207.004 bug)
    94     93   		if {[encoding system] eq "identity"} {
    95     94   			if {[info exists ::tclkit_system_encoding] && $::tclkit_system_encoding != ""} {
    96     95   				catch {
    97     96   					encoding system $::tclkit_system_encoding
    98     97   				}
    99     98   			}
   100         -			unset -nocomplain ::tclkit_system_encoding
   101     99   		}
   102    100   
   103    101   		# If we've still not been able to set the encoding, revert to Tclkit defaults
   104    102   		if {[encoding system] eq "identity"} {
   105    103   			catch {
   106    104   				switch $::tcl_platform(platform) {
   107    105   					windows		{ encoding system cp1252 }
   108    106   					macintosh	{ encoding system macRoman }
   109    107   				        default		{ encoding system iso8859-1 }
   110    108   				}
   111    109   			}
   112    110   		}
          111  +
          112  +		# Re-evaluate mountpoint with correct encoding set
          113  +		set mountpoint [subst "$::TCLKIT_MOUNTPOINT_VAR"]
   113    114   
   114    115   		# now remount the executable with the correct encoding
   115    116   		vfs::filesystem unmount [lindex [::vfs::filesystem info] 0]
   116    117   
   117         -		set noe [info nameofexecutable]
   118         -
   119    118   		# Resolve symlinks
   120         -		set noe [file dirname [file normalize [file join $noe __dummy__]]]
          119  +		set mountpoint [file dirname [file normalize [file join $mountpoint __dummy__]]]
          120  +
          121  +		set tcl_library [file join $mountpoint lib tcl$tcl_version]
          122  +		set tcl_libPath [list $tcl_library [file join $mountpoint lib]]
   121    123   
   122         -		set tcl_library [file join $noe lib tcl$tcl_version]
   123         -		set tcl_libPath [list $tcl_library [file join $noe lib]]
   124         -
   125         -		vfs::filesystem mount $noe $vfsHandler
          124  +		vfs::filesystem mount $mountpoint $vfsHandler
   126    125   	}
   127    126     
   128    127   	# load config settings file if present
   129    128   	namespace eval ::vfs { variable tclkit_version 1 }
   130         -	catch { uplevel #0 [list source [file join $noe config.tcl]] }
          129  +	catch { uplevel #0 [list source [file join $mountpoint config.tcl]] }
   131    130   
          131  +	# Perform expected initialization
   132    132   	uplevel #0 [list source [file join $tcl_library init.tcl]]
   133    133     
   134    134   	# reset auto_path, so that init.tcl's search outside of tclkit is cancelled
   135    135   	set auto_path $tcl_libPath
   136    136   
   137    137   	# This loads everything needed for "clock scan" to work
   138    138   	# "clock scan" is used within "vfs::zip", which may be
   139    139   	# loaded before this is run causing the root VFS to break
   140    140   	catch { clock scan }
          141  +
          142  +	if {$::TCLKIT_TYPE == "kitdll"} {
          143  +		# Set a maximum seek to avoid reading the entire file looking for a
          144  +		# zip header
          145  +		catch { 
          146  +			package require vfs::zip
          147  +			set ::zip::max_header_seek 8192
          148  +		}
          149  +
          150  +		# Now that the initialization is complete, mount the user VFS if needed
          151  +		## Mount the VFS from the Shared Object
          152  +		if {[info exists ::TCLKIT_INITVFS] && [info exists ::tclKitFilename]} {
          153  +			catch {
          154  +				vfs::zip::Mount $::tclKitFilename "/.KITDLL_USER"
          155  +
          156  +				lappend auto_path [file normalize "/.KITDLL_USER/lib"]
          157  +			}
          158  +		}
          159  +
          160  +		## Mount the VFS from executable
          161  +		if {[info exists ::TCLKIT_INITVFS]} {
          162  +			catch {
          163  +				vfs::zip::Mount [info nameofexecutable] "/.KITDLL_APP"
          164  +
          165  +				lappend auto_path [file normalize "/.KITDLL_APP/lib"]
          166  +			}
          167  +		}
          168  +
          169  +	}
   141    170   
   142    171   	# Cleanup
   143         -	unset ::tclKitStorage
   144         -	unset -nocomplain ::tclKitStorage_fd
          172  +	unset -nocomplain ::zip::max_header_seek
          173  +	unset -nocomplain ::TCLKIT_TYPE ::TCLKIT_INITVFS
          174  +	unset -nocomplain ::TCLKIT_MOUNTPOINT ::TCLKIT_VFSSOURCE ::TCLKIT_MOUNTPOINT_VAR ::TCLKIT_VFSSOURCE_VAR
          175  +	unset -nocomplain ::tclKitStorage ::tclKitStorage_fd ::tclKitFilename
          176  +	unset -nocomplain ::tclkit_system_encoding
   145    177   }

Modified kitsh/buildsrc/kitsh-0.0/configure.ac from [a84d1ae23f] to [b28720a899].

    29     29   AC_MSG_RESULT([$TARGET])
    30     30   
    31     31   dnl Find the appropriate libraries to link to
    32     32   AC_SEARCH_LIBS(acos, m,, [ AC_MSG_WARN([Couldn't find acos (normally in libm)!]) ])
    33     33   AC_SEARCH_LIBS(dlsym, dl,, [ AC_MSG_WARN([Couldn't find dlsym (normally in libdl)!]) ])
    34     34   
    35     35   AS_IF([test "$TARGET" = "tclkit"], [
           36  +	dnl We have Tclkit
           37  +
    36     38   	dnl Figure out how to statically link to libgcc, if needed
    37     39   	DC_STATIC_LIBGCC
    38     40   
    39     41   	dnl Specify local Appinit function
    40     42   	AC_DEFINE(DTK_LOCAL_APPINIT, [TclKit_AppInit], [Tclkit appinit function])
    41     43   ], [
    42     44   	dnl We have KitDLL
................................................................................
    43     45   
    44     46   	dnl Determine system information
    45     47   	DC_CHK_OS_INFO
    46     48   
    47     49   	dnl Determine how to create a shared object
    48     50   	DC_GET_SHOBJFLAGS
    49     51   
    50         -	dnl KitDLL always uses C-VFS
    51         -	AC_DEFINE([KIT_STORAGE_CVFS], [1], [Define if you are going to use C-VFS for kit storage])
           52  +	dnl Determine if we have "objcopy" available to weaken non-Tcl/Tk symbols
           53  +	AC_CHECK_TOOL(OBJCOPY, objcopy, [:])
    52     54   
    53     55   	dnl Define KitDLL usage
    54     56   	AC_DEFINE([TCLKIT_DLL], [1], [Define if you are using a KitDLL rather than a Tclkit])
    55     57   ])
           58  +
           59  +dnl Set linker rpath for tclsh/wish
           60  +DC_SETLDRUNPATH([.])
    56     61   
    57     62   dnl Find the appropriate Tcl headers and libraries
    58     63   DC_DO_TCL
    59     64   
    60     65   dnl Find archives we need to link to
    61     66   DC_FIND_TCLKIT_LIBS
    62     67   
    63     68   dnl Find extra objects we need to link as a part of "kit"
    64     69   AC_SUBST(EXTRA_OBJS)
           70  +AC_SUBST(EXTRA_VFS_OBJS)
    65     71   
    66     72   dnl Check for Windows Resource Compiler
    67     73   AC_CHECK_TOOL([RC], [windres], [false])
    68     74   
    69     75   dnl If we found the resource compiler, add "kit.res.o" to our list of objects to build
    70     76   dnl (as long as the source for such an object exists)
    71     77   AS_IF([test "$RC" != "false"], [
................................................................................
    99    105   AC_ARG_WITH(zlib, AC_HELP_STRING([--with-zlib], [directory containing zlib]), [
   100    106   	CPPFLAGS="${CPPFLAGS} -I${with_zlib}/include -I${with_zlib}"
   101    107   	CFLAGS="${CFLAGS} -I${with_zlib}/include -I${with_zlib}"
   102    108   	LDFLAGS="${LDFLAGS} -L${with_zlib}/lib -L${with_zlib}"
   103    109   ])
   104    110   
   105    111   dnl Only needed for Tclkit
   106         -AS_IF([test "$TARGET" = "tclkit"], [
   107    112   	DC_DO_STATIC_LINK_LIB(zlib, -lz,, [
   108    113   		DC_DO_STATIC_LINK_LIB(zlib, -lzlib,, [
   109    114   			AC_SEARCH_LIBS(inflate, z zlib,, [
   110    115   				AC_MSG_WARN([Couldn't find inflate (normally in zlib)!])
   111    116   			])
   112    117   		])
   113    118   	])
   114         -])
   115    119   
   116    120   dnl Determine which storage mechanism to use
   117    121   AC_MSG_CHECKING([which Tclkit Storage mechanism to use])
   118    122   
   119    123   storage_mech="auto"
   120    124   AC_ARG_ENABLE(kit-storage, AC_HELP_STRING([--enable-kit-storage={zip|mk4|cvfs}], [Specify storage mechanism to use for built-in VFS (default: auto)]), [
   121    125   	AS_CASE(["$enableval"],
................................................................................
   179    183   		AC_DEFINE([KIT_STORAGE_CVFS], [1], [Define if you are going to use C-VFS for kit storage])
   180    184   
   181    185   		dnl Define that C-VFS should be make [load]-able
   182    186   		AC_DEFINE([KITDLL_MAKE_LOADABLE], [1], [Specify that the C-VFS should be able to be loaded])
   183    187   
   184    188   		dnl Add appropriate dependencies
   185    189   		EXTRA_KIT_DEPS="vfs_kitdll.tcl.h"
          190  +		EXTRA_VFS_OBJS="${EXTRA_VFS_OBJS} vfs_kitdll_data_tcl.o"
   186    191   	]
   187    192   )
   188    193   
   189    194   AC_SUBST(EXTRA_KIT_DEPS)
   190    195   
   191    196   dnl Put correct Makefile template in place
   192    197   rm -f Makefile.in
   193    198   cp Makefile.${TARGET}.in Makefile.in
   194    199   
   195    200   dnl Produce output
   196    201   AC_OUTPUT(Makefile Makefile.common)

Modified kitsh/buildsrc/kitsh-0.0/installvfs.tcl from [2fb8a7d1f7] to [b17724e7c3].

    11     11   set kitfile [lindex $argv 0]
    12     12   set vfsdir [lindex $argv 1]
    13     13   if {[lindex $argv 2] != ""} {
    14     14   	set opt_compression [lindex $argv 2]
    15     15   }
    16     16   
    17     17   # Determine what storage mechanism is being used
    18         -set fd [open Makefile r]
           18  +set fd [open Makefile.common r]
    19     19   set data [read $fd]
    20     20   close $fd
    21     21   
    22     22   if {[string match "*KIT_STORAGE_ZIP*" $data]} {
    23     23   	set tclKitStorage zip
    24     24   }
    25     25   if {[string match "*KIT_STORAGE_MK4*" $data]} {

Modified kitsh/buildsrc/kitsh-0.0/kitInit.c from [ae720616f1] to [108a80f35a].

    82     82   #endif
    83     83   #ifdef _WIN32
    84     84   Tcl_AppInitProc	Dde_Init, Registry_Init;
    85     85   #endif
    86     86   
    87     87   #ifdef TCLKIT_DLL
    88     88   #  define TCLKIT_MOUNTPOINT "/.KITDLL_TCL"
           89  +#  define TCLKIT_VFSSOURCE "$::tclKitFilename"
    89     90   #else
    90     91   #  define TCLKIT_MOUNTPOINT "[info nameofexecutable]"
           92  +#  define TCLKIT_VFSSOURCE "[info nameofexecutable]"
    91     93   #endif /* TCLKIT_DLL */
    92     94   
    93     95   #ifdef HAVE_ACCEPTABLE_DLADDR
    94     96   #  ifdef KITSH_NEED_WINMAIN
    95     97   #    ifdef _WIN32_WCE
    96     98   int wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow);
    97     99   #    else
................................................................................
   139    141   	"catch { load {} zlib }\n"
   140    142   #endif
   141    143   #ifdef KIT_INCLUDES_MK4TCL
   142    144   	"catch { load {} Mk4tcl }\n"
   143    145   #endif
   144    146   #ifdef TCLKIT_DLL
   145    147   	"load {} tclkit::init\n"
   146         -#endif
          148  +	"::tclkit::init::initInterp\n"
          149  +	"rename ::tclkit::init::initInterp {}\n"
          150  +#endif /* TCLKIT_DLL */
   147    151   	"set bootfile [file join " TCLKIT_MOUNTPOINT " boot.tcl]\n"
   148    152   	"if {[file exists $bootfile]} {\n"
   149    153   		"catch {\n"
   150    154   			"set f [open $bootfile]\n"
   151    155   			"set s [read $f]\n"
   152    156   			"close $f\n"
   153    157   		"}\n"
   154    158   	"}\n"
   155    159   #ifdef KIT_STORAGE_MK4
   156    160   	"set ::tclKitStorage \"mk4\"\n"
   157    161   	"if {![info exists s]} {\n"
   158         -		"mk::file open exe [info nameofexecutable] -readonly\n"
          162  +		"mk::file open exe " TCLKIT_VFSSOURCE " -readonly\n"
   159    163   		"set n [mk::select exe.dirs!0.files name boot.tcl]\n"
   160    164   		"if {$n != \"\"} {\n"
   161    165   			"set s [mk::get exe.dirs!0.files!$n contents]\n"
   162    166   			"if {![string length $s]} { error \"empty boot.tcl\" }\n"
   163    167   			"catch {load {} zlib}\n"
   164    168   			"if {[mk::get exe.dirs!0.files!$n size] != [string length $s]} {\n"
   165    169   				"set s [zlib decompress $s]\n"
................................................................................
   169    173   #endif /* KIT_STORAGE_MK4 */
   170    174   #ifdef KIT_STORAGE_ZIP
   171    175   	"set ::tclKitStorage \"zip\"\n"
   172    176   	"catch { load {} vfs }\n"
   173    177   	"if {![info exists s]} {\n"
   174    178   #  include "zipvfs.tcl.h"
   175    179   		"catch {\n"
   176         -			"set ::tclKitStorage_fd [::zip::open [info nameofexecutable]]\n"
          180  +			"set ::tclKitStorage_fd [::zip::open " TCLKIT_VFSSOURCE "]\n"
   177    181   			"::zip::stat $::tclKitStorage_fd boot.tcl sb\n"
   178    182   			"seek $::tclKitStorage_fd $sb(ino)\n"
   179    183   			"::zip::Data $::tclKitStorage_fd sb s\n"
   180    184   		"}\n"
   181    185   	"}\n"
   182    186   #endif /* KIT_STORAGE_ZIP */
   183    187   #ifdef KIT_STORAGE_CVFS
................................................................................
   188    192   #include "vfs_kitdll.tcl.h"
   189    193   	"if {![info exists s]} {\n"
   190    194   		"catch {\n"
   191    195   			"set s [::vfs::kitdll::data::getData tcl boot.tcl]\n"
   192    196   		"}\n"
   193    197   	"}\n"
   194    198   #endif /* KIT_STORAGE_CVFS */
   195         -#ifdef TCLKIT_DLL
   196         -	"::tclkit::init::initInterp\n"
   197         -	"rename ::tclkit::init::initInterp {}\n"
   198         -#else
          199  +#ifndef TCLKIT_DLL
   199    200   	"if {![info exists s]} {\n"
   200    201   		"set f [open setup.tcl]\n"
   201    202   		"set s [read $f]\n"
   202    203   		"close $f\n"
   203    204   	"}\n"
          205  +#endif /* !TCLKIT_DLL */
          206  +#ifdef TCLKIT_DLL
          207  +	"set ::TCLKIT_TYPE \"kitdll\"\n"
          208  +#else
          209  +	"set ::TCLKIT_TYPE \"tclkit\"\n"
   204    210   #endif /* TCLKIT_DLL */
          211  +	"set ::TCLKIT_MOUNTPOINT " TCLKIT_MOUNTPOINT "\n"
          212  +	"set ::TCLKIT_VFSSOURCE " TCLKIT_VFSSOURCE "\n"
          213  +	"set ::TCLKIT_MOUNTPOINT_VAR {" TCLKIT_MOUNTPOINT "}\n"
          214  +	"set ::TCLKIT_VFSSOURCE_VAR {" TCLKIT_VFSSOURCE "}\n"
   205    215   	"uplevel #0 $s\n"
   206    216   #if defined(KIT_INCLUDES_TK) && defined(KIT_TK_VERSION)
   207    217   	"package ifneeded Tk " KIT_TK_VERSION " {\n"
   208    218   		"load {} Tk\n"
   209    219   	"}\n"
   210    220   #endif
   211    221   #ifdef _WIN32
................................................................................
   364    374   }
   365    375   
   366    376   static void _Tclkit_Interp_Init(Tcl_Interp *interp) {
   367    377   #ifdef TCLKIT_CAN_SET_ENCODING
   368    378   	Tcl_DString encodingName;
   369    379   #endif /* TCLKIT_CAN_SET_ENCODING */
   370    380   
          381  +#ifndef TCLKIT_DLL
   371    382   	/* the tcl_rcFileName variable only exists in the initial interpreter */
   372    383   #ifdef _WIN32
   373    384   	Tcl_SetVar(interp, "tcl_rcFileName", "~/tclkitrc.tcl", TCL_GLOBAL_ONLY);
   374    385   #else
   375    386   	Tcl_SetVar(interp, "tcl_rcFileName", "~/.tclkitrc", TCL_GLOBAL_ONLY);
   376         -#endif
          387  +#  endif /* _WIN32 */
          388  +#endif /* !TCLKIT_DLL */
          389  +	Tcl_SetVar(interp, "TCLKIT_INITVFS", "1", TCL_GLOBAL_ONLY);
   377    390   
   378    391   #ifdef TCLKIT_CAN_SET_ENCODING
   379    392   	/* Set the encoding from the Environment */
   380    393   	Tcl_GetEncodingNameFromEnvironment(&encodingName);
   381    394   	Tcl_SetSystemEncoding(NULL, Tcl_DStringValue(&encodingName));
   382    395   	Tcl_SetVar(interp, "tclkit_system_encoding", Tcl_DStringValue(&encodingName), 0);
   383    396   	Tcl_DStringFree(&encodingName);
   384         -#endif
          397  +#endif /* TCLKIT_CAN_SET_ENCODING */
   385    398   
   386    399   	/* Hack to get around Tcl bug 1224888.  This must be run here and
   387    400   	 * in LibraryPathObjCmd because this information is needed both
   388    401   	 * before and after that command is run. */
   389    402   	FindAndSetExecName(interp);
   390    403   
   391    404   	return;
   392    405   }
   393    406   
          407  +#ifndef TCLKIT_DLL
   394    408   int TclKit_AppInit(Tcl_Interp *interp) {
   395    409   #ifdef KIT_INCLUDES_TK
   396    410   #  ifdef _WIN32
   397    411   #    ifndef _WIN32_WCE
   398    412   	char msgBuf[2049];
   399    413   #    endif /* !_WIN32_WCE */
   400    414   #  endif /* _WIN32 */
................................................................................
   457    471   #    endif /* !_WIN32_WCE */
   458    472       /* we won't reach this, but we need the return */
   459    473   #  endif /* _WIN32 */
   460    474   #endif /* KIT_INCLUDES_TK */
   461    475   
   462    476   	return TCL_ERROR;
   463    477   }
          478  +#endif /* !TCLKIT_DLL */
   464    479   
   465    480   
   466    481   #ifdef TCLKIT_DLL
   467    482   #  ifdef HAVE_ACCEPTABLE_DLADDR
   468    483   /* Symbol to resolve against dladdr() */
   469    484   static void _tclkit_dummy_func(void) {
   470    485   	return;