#

 # This file is a Makefile for Tcl.  If it has the name "Makefile.in"

 # then it is a template for a Makefile;  to generate the actual Makefile,

 # run "./configure", which is a configuration script generated by the

 # "autoconf" program (constructs like "@foo@" will get replaced in the

 # actual Makefile.

 #

 # RCS: @(#) $Id: Makefile.in,v 1.68.2.7 2007/01/30 23:21:12 hobbs Exp $

 VERSION = @TCL_VERSION@

 #----------------------------------------------------------------

 # Things you can change to personalize the Makefile for your own

 # site (you can make these changes in either Makefile.in or

 # Makefile, but changes to Makefile will get lost if you re-run

 # the configuration script).

 #----------------------------------------------------------------

 # Default top-level directories in which to install architecture-

 # specific files (exec_prefix) and machine-independent files such

 # as scripts (prefix).  The values specified here may be overridden

 # at configure-time with the --exec-prefix and --prefix options

 # to the "configure" script.

 prefix			= @prefix@

 exec_prefix		= @exec_prefix@

 bindir			= @bindir@

 libdir			= @libdir@

 includedir		= @includedir@

 mandir			= @mandir@

 # The following definition can be set to non-null for special systems

 # like AFS with replication.  It allows the pathnames used for installation

 # to be different than those used for actually reference files at

 # run-time.  INSTALL_ROOT is prepended to $prefix and $exec_prefix

 # when installing files.

 INSTALL_ROOT	=

 # Directory from which applications will reference the library of Tcl

 # scripts (note: you can set the TCL_LIBRARY environment variable at

 # run-time to override this value):

 TCL_LIBRARY	= $(prefix)/lib/tcl$(VERSION)

 # Path to use at runtime to refer to LIB_INSTALL_DIR:

 LIB_RUNTIME_DIR		= $(libdir)

 # Directory in which to install the program tclsh:

 BIN_INSTALL_DIR		= $(INSTALL_ROOT)$(bindir)

 # Directory in which to install the .a or .so binary for the Tcl library:

 LIB_INSTALL_DIR		= $(INSTALL_ROOT)$(libdir)

 # Path name to use when installing library scripts.

 SCRIPT_INSTALL_DIR	= $(INSTALL_ROOT)$(TCL_LIBRARY)

 # Directory in which to install the include file tcl.h:

 INCLUDE_INSTALL_DIR	= $(INSTALL_ROOT)$(includedir)

 # Directory in which to (optionally) install the private tcl headers:

 PRIVATE_INCLUDE_INSTALL_DIR = $(INSTALL_ROOT)$(includedir)

 # Top-level directory in which to install manual entries:

 MAN_INSTALL_DIR		= $(INSTALL_ROOT)$(mandir)

 # Directory in which to install manual entry for tclsh:

 MAN1_INSTALL_DIR = $(MAN_INSTALL_DIR)/man1

 # Directory in which to install manual entries for Tcl's C library

 # procedures:

 MAN3_INSTALL_DIR = $(MAN_INSTALL_DIR)/man3

 # Directory in which to install manual entries for the built-in

 # Tcl commands:

 MANN_INSTALL_DIR = $(MAN_INSTALL_DIR)/mann

 # Libraries built with optimization switches have this additional extension

 TCL_DBGX = @TCL_DBGX@

 # warning flags

 CFLAGS_WARNING = @CFLAGS_WARNING@

 # The default switches for optimization or debugging

 CFLAGS_DEBUG    = @CFLAGS_DEBUG@

 CFLAGS_OPTIMIZE	= @CFLAGS_OPTIMIZE@

 # To change the compiler switches, for example to change from optimization to

 # debugging symbols, change the following line:

 #CFLAGS = 		$(CFLAGS_DEBUG)

 #CFLAGS = 		$(CFLAGS_OPTIMIZE)

 #CFLAGS = 		$(CFLAGS_DEBUG) $(CFLAGS_OPTIMIZE)

 CFLAGS = 		@CFLAGS@ @CFLAGS_DEFAULT@

 # To enable compilation debugging reverse the comment characters on

 # one of the following lines.

 COMPILE_DEBUG_FLAGS =

 #COMPILE_DEBUG_FLAGS = -DTCL_COMPILE_DEBUG

 #COMPILE_DEBUG_FLAGS = -DTCL_COMPILE_DEBUG -DTCL_COMPILE_STATS

 # Special compiler flags to use when building man2tcl on Windows.

 MAN2TCLFLAGS		= @MAN2TCLFLAGS@

 SRC_DIR			= @srcdir@

 ROOT_DIR		= @srcdir@/..

 GENERIC_DIR		= @srcdir@/../generic

 WIN_DIR			= @srcdir@

 COMPAT_DIR		= @srcdir@/../compat

 # Converts a POSIX path to a Windows native path.

 CYGPATH			= @CYGPATH@

 GENERIC_DIR_NATIVE	= $(shell $(CYGPATH) '$(GENERIC_DIR)' | sed 's!\\!/!g')

 WIN_DIR_NATIVE		= $(shell $(CYGPATH) '$(WIN_DIR)' | sed 's!\\!/!g')

 ROOT_DIR_NATIVE		= $(shell $(CYGPATH) '$(ROOT_DIR)' | sed 's!\\!/!g')

 LIBRARY_DIR		= $(ROOT_DIR_NATIVE)/library

 DLLSUFFIX		= @DLLSUFFIX@

 LIBSUFFIX		= @LIBSUFFIX@

 EXESUFFIX		= @EXESUFFIX@

 TCL_STUB_LIB_FILE	= @TCL_STUB_LIB_FILE@

 TCL_DLL_FILE		= @TCL_DLL_FILE@

 TCL_LIB_FILE		= @TCL_LIB_FILE@

 DDE_DLL_FILE		= tcldde$(DDEVER)${DLLSUFFIX}

 DDE_LIB_FILE		= tcldde$(DDEVER)${LIBSUFFIX}

 REG_DLL_FILE		= tclreg$(REGVER)${DLLSUFFIX}

 REG_LIB_FILE		= tclreg$(REGVER)${LIBSUFFIX}

 PIPE_DLL_FILE		= tclpip$(VER)${DLLSUFFIX}

 SHARED_LIBRARIES 	= $(TCL_DLL_FILE) $(TCL_STUB_LIB_FILE) \

 			  $(DDE_DLL_FILE) $(REG_DLL_FILE) $(PIPE_DLL_FILE)

 STATIC_LIBRARIES	= $(TCL_LIB_FILE) $(REG_LIB_FILE) $(DDE_LIB_FILE)

 # TCL_EXE is the name of a tclsh executable that is available *BEFORE*

 # running make for the first time. Certain build targets (make genstubs)

 # need it to be available on the PATH. This executable should *NOT* be

 # required just to do a normal build although it can be required to run

 # make dist.

 TCL_EXE			= tclsh

 TCLSH			= tclsh$(VER)${EXESUFFIX}

 TCLTEST			= tcltest${EXEEXT}

 CAT32			= cat32$(EXEEXT)

 MAN2TCL			= man2tcl$(EXEEXT)

 @SET_MAKE@

 # Setting the VPATH variable to a list of paths will cause the 

 # makefile to look into these paths when resolving .c to .obj

 # dependencies.

 VPATH = $(GENERIC_DIR):$(WIN_DIR):$(COMPAT_DIR)

 AR		= @AR@

 RANLIB		= @RANLIB@

 CC		= @CC@

 RC		= @RC@

 RES		= @RES@

 AC_FLAGS	= @EXTRA_CFLAGS@ @DEFS@

 CPPFLAGS	= @CPPFLAGS@

 LDFLAGS_DEBUG   = @LDFLAGS_DEBUG@

 LDFLAGS_OPTIMIZE = @LDFLAGS_OPTIMIZE@

 LDFLAGS		= @LDFLAGS@ @LDFLAGS_DEFAULT@

 LDFLAGS_CONSOLE	= @LDFLAGS_CONSOLE@

 LDFLAGS_WINDOW	= @LDFLAGS_WINDOW@

 EXEEXT		= @EXEEXT@

 OBJEXT		= @OBJEXT@

 STLIB_LD	= @STLIB_LD@

 SHLIB_LD	= @SHLIB_LD@

 SHLIB_LD_LIBS	= @SHLIB_LD_LIBS@ $(LIBS)

 SHLIB_CFLAGS	= @SHLIB_CFLAGS@

 SHLIB_SUFFIX	= @SHLIB_SUFFIX@

 VER		= @TCL_MAJOR_VERSION@@TCL_MINOR_VERSION@

 DOTVER		= @TCL_MAJOR_VERSION@.@TCL_MINOR_VERSION@

 DDEVER		= @TCL_DDE_MAJOR_VERSION@@TCL_DDE_MINOR_VERSION@

 DDEDOTVER	= @TCL_DDE_MAJOR_VERSION@.@TCL_DDE_MINOR_VERSION@

 REGVER		= @TCL_REG_MAJOR_VERSION@@TCL_REG_MINOR_VERSION@

 REGDOTVER	= @TCL_REG_MAJOR_VERSION@.@TCL_REG_MINOR_VERSION@

 LIBS		= @LIBS@

 RMDIR		= rm -rf

 MKDIR		= mkdir -p

 SHELL		= @SHELL@

 RM		= rm -f

 COPY		= cp

 CC_SWITCHES = ${CFLAGS} ${CFLAGS_WARNING} ${TCL_SHLIB_CFLAGS} \

 -I"${GENERIC_DIR_NATIVE}" -I"${WIN_DIR_NATIVE}" ${AC_FLAGS} \

 ${COMPILE_DEBUG_FLAGS}

 CC_OBJNAME = @CC_OBJNAME@

 CC_EXENAME = @CC_EXENAME@

 STUB_CC_SWITCHES = ${CFLAGS} ${CFLAGS_WARNING} ${SHLIB_CFLAGS} \

 -I"${GENERIC_DIR_NATIVE}" -I"${WIN_DIR_NATIVE}" ${AC_FLAGS} \

 ${COMPILE_DEBUG_FLAGS}

 TCLTEST_OBJS = \

 	tclTest.$(OBJEXT) \

 	tclTestObj.$(OBJEXT) \

 	tclTestProcBodyObj.$(OBJEXT) \

 	tclThreadTest.$(OBJEXT) \

 	tclWinTest.$(OBJEXT) \

 	testMain.$(OBJEXT)

 GENERIC_OBJS = \

 	regcomp.$(OBJEXT) \

 	regexec.$(OBJEXT) \

 	regfree.$(OBJEXT) \

 	regerror.$(OBJEXT) \

 	tclAlloc.$(OBJEXT) \

 	tclAsync.$(OBJEXT) \

 	tclBasic.$(OBJEXT) \

 	tclBinary.$(OBJEXT) \

 	tclCkalloc.$(OBJEXT) \

 	tclClock.$(OBJEXT) \

 	tclCmdAH.$(OBJEXT) \

 	tclCmdIL.$(OBJEXT) \

 	tclCmdMZ.$(OBJEXT) \

 	tclCompCmds.$(OBJEXT) \

 	tclCompExpr.$(OBJEXT) \

 	tclCompile.$(OBJEXT) \

 	tclDate.$(OBJEXT) \

 	tclEncoding.$(OBJEXT) \

 	tclEnv.$(OBJEXT) \

 	tclEvent.$(OBJEXT) \

 	tclExecute.$(OBJEXT) \

 	tclFCmd.$(OBJEXT) \

 	tclFileName.$(OBJEXT) \

 	tclGet.$(OBJEXT) \

 	tclHash.$(OBJEXT) \

 	tclHistory.$(OBJEXT) \

 	tclIndexObj.$(OBJEXT) \

 	tclInterp.$(OBJEXT) \

 	tclIO.$(OBJEXT) \

 	tclIOCmd.$(OBJEXT) \

 	tclIOGT.$(OBJEXT) \

 	tclIOSock.$(OBJEXT) \

 	tclIOUtil.$(OBJEXT) \

 	tclLink.$(OBJEXT) \

 	tclLiteral.$(OBJEXT) \

 	tclListObj.$(OBJEXT) \

 	tclLoad.$(OBJEXT) \

 	tclMain.$(OBJEXT) \

 	tclNamesp.$(OBJEXT) \

 	tclNotify.$(OBJEXT) \

 	tclObj.$(OBJEXT) \

 	tclPanic.$(OBJEXT) \

 	tclParse.$(OBJEXT) \

 	tclParseExpr.$(OBJEXT) \

 	tclPipe.$(OBJEXT) \

 	tclPkg.$(OBJEXT) \

 	tclPosixStr.$(OBJEXT) \

 	tclPreserve.$(OBJEXT) \

 	tclProc.$(OBJEXT) \

 	tclRegexp.$(OBJEXT) \

 	tclResolve.$(OBJEXT) \

 	tclResult.$(OBJEXT) \

 	tclScan.$(OBJEXT) \

 	tclStringObj.$(OBJEXT) \

 	tclStubInit.$(OBJEXT) \

 	tclStubLib.$(OBJEXT) \

 	tclThread.$(OBJEXT) \

 	tclThreadAlloc.$(OBJEXT) \

 	tclThreadJoin.$(OBJEXT) \

 	tclTimer.$(OBJEXT) \

 	tclUtf.$(OBJEXT) \

 	tclUtil.$(OBJEXT) \

 	tclVar.$(OBJEXT)

 WIN_OBJS = \

 	tclWin32Dll.$(OBJEXT) \

 	tclWinChan.$(OBJEXT) \

 	tclWinConsole.$(OBJEXT) \

 	tclWinSerial.$(OBJEXT) \

 	tclWinError.$(OBJEXT) \

 	tclWinFCmd.$(OBJEXT) \

 	tclWinFile.$(OBJEXT) \

 	tclWinInit.$(OBJEXT) \

 	tclWinLoad.$(OBJEXT) \

 	tclWinMtherr.$(OBJEXT) \

 	tclWinNotify.$(OBJEXT) \

 	tclWinPipe.$(OBJEXT) \

 	tclWinSock.$(OBJEXT) \

 	tclWinThrd.$(OBJEXT) \

 	tclWinTime.$(OBJEXT) 

 COMPAT_OBJS = \

 	strftime.$(OBJEXT) strtoll.$(OBJEXT) strtoull.$(OBJEXT)

 PIPE_OBJS = stub16.$(OBJEXT)

 DDE_OBJS = tclWinDde.$(OBJEXT)

 REG_OBJS = tclWinReg.$(OBJEXT)

 STUB_OBJS = tclStubLib.$(OBJEXT)

 TCLSH_OBJS = tclAppInit.$(OBJEXT)

 TCL_OBJS = ${GENERIC_OBJS} ${WIN_OBJS} ${COMPAT_OBJS}

 TCL_DOCS = "$(ROOT_DIR_NATIVE)"/doc/*.[13n]

 all: binaries libraries doc

 tcltest: $(TCLTEST)

 binaries: @LIBRARIES@ $(TCLSH)

 libraries:

 doc:

 winhelp: $(ROOT_DIR)/tools/man2help.tcl $(MAN2TCL)

 	TCL_LIBRARY="$(LIBRARY_DIR)"; export TCL_LIBRARY; \

 	./$(TCLSH) "$(ROOT_DIR_NATIVE)"/tools/man2help.tcl tcl "$(VER)" $(TCL_DOCS)

 	hcw /c /e tcl.hpj

 $(MAN2TCL): $(ROOT_DIR)/tools/man2tcl.c

 	$(CC) $(CFLAGS_OPTIMIZE) $(MAN2TCLFLAGS) -o $(MAN2TCL) "$(ROOT_DIR_NATIVE)"/tools/man2tcl.c

 $(TCLSH): $(TCL_LIB_FILE) $(TCL_STUB_LIB_FILE) $(TCLSH_OBJS) tclsh.$(RES)

 	$(CC) $(CFLAGS) $(TCLSH_OBJS) $(TCL_LIB_FILE) $(LIBS) \

         tclsh.$(RES) $(CC_EXENAME) $(LDFLAGS_CONSOLE)

 $(TCLTEST): $(TCL_LIB_FILE) $(TCLTEST_OBJS) $(CAT32) tclsh.$(RES)

 	$(CC) $(CFLAGS) $(TCLTEST_OBJS) $(TCL_LIB_FILE) $(LIBS) \

         tclsh.$(RES) $(CC_EXENAME) $(LDFLAGS_CONSOLE)

 cat32.$(OBJEXT): cat.c

 	$(CC) -c $(CC_SWITCHES) @DEPARG@ $(CC_OBJNAME)

 $(CAT32): cat32.$(OBJEXT)

 	$(CC) $(CFLAGS) cat32.$(OBJEXT) $(CC_EXENAME) $(LIBS) $(LDFLAGS_CONSOLE)

 # The following targets are configured by autoconf to generate either

 # a shared library or static library

 ${TCL_STUB_LIB_FILE}: ${STUB_OBJS}

 	@$(RM) ${TCL_STUB_LIB_FILE}

 	@MAKE_LIB@ ${STUB_OBJS}

 	@POST_MAKE_LIB@

 ${TCL_DLL_FILE}: ${TCL_OBJS} tcl.$(RES)

 	@$(RM) ${TCL_DLL_FILE}

 	@MAKE_DLL@ ${TCL_OBJS} tcl.$(RES) $(SHLIB_LD_LIBS)

 ${TCL_LIB_FILE}: ${TCL_OBJS}

 	@$(RM) ${TCL_LIB_FILE}

 	@MAKE_LIB@ ${TCL_OBJS}

 	@POST_MAKE_LIB@

 ${DDE_DLL_FILE}: ${DDE_OBJS} ${TCL_STUB_LIB_FILE}

 	@$(RM) ${DDE_DLL_FILE}

 	@MAKE_DLL@ ${DDE_OBJS} $(TCL_STUB_LIB_FILE) $(SHLIB_LD_LIBS)

 ${DDE_LIB_FILE}: ${DDE_OBJS} ${TCL_LIB_FILE}

 	@$(RM) ${DDE_LIB_FILE}

 	@MAKE_LIB@ ${DDE_OBJS} ${TCL_LIB_FILE}

 ${REG_DLL_FILE}: ${REG_OBJS} ${TCL_STUB_LIB_FILE}

 	@$(RM) ${REG_DLL_FILE}

 	@MAKE_DLL@ ${REG_OBJS} $(TCL_STUB_LIB_FILE) $(SHLIB_LD_LIBS)

 ${REG_LIB_FILE}: ${REG_OBJS} ${TCL_LIB_FILE}

 	@$(RM) ${REG_LIB_FILE}

 	@MAKE_LIB@ ${REG_OBJS} ${TCL_LIB_FILE}

 # PIPE_DLL_FILE is actually an executable, don't build it

 # like a DLL.

 ${PIPE_DLL_FILE}: ${PIPE_OBJS}

 	@$(RM) ${PIPE_DLL_FILE}

 	@MAKE_EXE@ $(CFLAGS) ${PIPE_OBJS} $(LIBS) $(LDFLAGS_CONSOLE)

 # Add the object extension to the implicit rules.  By default .obj is not

 # automatically added.

 .SUFFIXES: .${OBJEXT}

 .SUFFIXES: .$(RES)

 .SUFFIXES: .rc

 # Special case object targets

 tclWinInit.${OBJEXT}: tclWinInit.c

 	$(CC) -c $(CC_SWITCHES) -DBUILD_tcl $(EXTFLAGS) @DEPARG@ $(CC_OBJNAME)

 tclWinPipe.${OBJEXT}: tclWinPipe.c

 	$(CC) -c $(CC_SWITCHES) -DBUILD_tcl -DTCL_PIPE_DLL=\"$(PIPE_DLL_FILE)\" \

 	    $(EXTFLAGS) @DEPARG@ $(CC_OBJNAME)

 testMain.${OBJEXT}: tclAppInit.c

 	$(CC) -c $(CC_SWITCHES) -DTCL_TEST @DEPARG@ $(CC_OBJNAME)

 tclTest.${OBJEXT}: tclTest.c

 	$(CC) -c $(CC_SWITCHES) @DEPARG@ $(CC_OBJNAME)

 tclTestObj.${OBJEXT}: tclTestObj.c

 	$(CC) -c $(CC_SWITCHES) @DEPARG@ $(CC_OBJNAME)

 tclWinTest.${OBJEXT}: tclWinTest.c

 	$(CC) -c $(CC_SWITCHES) @DEPARG@ $(CC_OBJNAME)

 tclAppInit.${OBJEXT} : tclAppInit.c

 	$(CC) -c $(CC_SWITCHES) @DEPARG@ $(CC_OBJNAME)

 # The following objects should be built using the stub interfaces

 tclWinReg.${OBJEXT} : tclWinReg.c

 	$(CC) -c $(CC_SWITCHES) -DUSE_TCL_STUBS @DEPARG@ $(CC_OBJNAME)

 tclWinDde.${OBJEXT} : tclWinDde.c

 	$(CC) -c $(CC_SWITCHES) -DUSE_TCL_STUBS @DEPARG@ $(CC_OBJNAME)

 # The following objects are part of the stub library and should not

 # be built as DLL objects but none of the symbols should be exported

 tclStubLib.${OBJEXT}: tclStubLib.c

 	$(CC) -c $(CC_SWITCHES) -DSTATIC_BUILD @DEPARG@ $(CC_OBJNAME)

 # Implicit rule for all object files that will end up in the Tcl library

 .c.${OBJEXT}:

 	$(CC) -c $(CC_SWITCHES) -DBUILD_tcl @DEPARG@ $(CC_OBJNAME)

 .rc.$(RES):

 	$(RC) @RC_OUT@ $@ @RC_TYPE@ @RC_DEFINES@ @RC_INCLUDE@ "$(GENERIC_DIR_NATIVE)" @RC_INCLUDE@ "$(WIN_DIR_NATIVE)" @DEPARG@

 install: all install-binaries install-libraries install-doc

 install-binaries: binaries

 	@for i in "$(LIB_INSTALL_DIR)" "$(BIN_INSTALL_DIR)" ; \

 	    do \

 	    if [ ! -d $$i ] ; then \

 		echo "Making directory $$i"; \

 		$(MKDIR) $$i; \

 		chmod 755 $$i; \

 		else true; \

 		fi; \

 	    done;

 	@for i in dde1.2 reg1.1; \

 	    do \

 	    if [ ! -d $(LIB_INSTALL_DIR)/$$i ] ; then \

 		echo "Making directory $(LIB_INSTALL_DIR)/$$i"; \

 		$(MKDIR) $(LIB_INSTALL_DIR)/$$i; \

 		else true; \

 		fi; \

 	    done;

 	@for i in $(TCL_DLL_FILE) $(TCLSH) $(PIPE_DLL_FILE); \

 	    do \

 	    if [ -f $$i ]; then \

 		echo "Installing $$i to $(BIN_INSTALL_DIR)/"; \

 		$(COPY) $$i "$(BIN_INSTALL_DIR)"; \

 	    fi; \

 	    done

 	@for i in tclConfig.sh $(TCL_LIB_FILE) $(TCL_STUB_LIB_FILE); \

 	    do \

 	    if [ -f $$i ]; then \

 		echo "Installing $$i to $(LIB_INSTALL_DIR)/"; \

 		$(COPY) $$i "$(LIB_INSTALL_DIR)"; \

 	    fi; \

 	    done

 	@if [ -f $(DDE_DLL_FILE) ]; then \

 	    echo installing $(DDE_DLL_FILE); \

 	    $(COPY) $(DDE_DLL_FILE) $(LIB_INSTALL_DIR)/dde1.2; \

 	    $(COPY) $(ROOT_DIR)/library/dde/pkgIndex.tcl \

 		$(LIB_INSTALL_DIR)/dde1.2; \

 	    fi

 	@if [ -f $(DDE_LIB_FILE) ]; then \

 	    echo installing $(DDE_LIB_FILE); \

 	    $(COPY) $(DDE_LIB_FILE) $(LIB_INSTALL_DIR)/dde1.2; \

 	    fi

 	@if [ -f $(REG_DLL_FILE) ]; then \

 	    echo installing $(REG_DLL_FILE); \

 	    $(COPY) $(REG_DLL_FILE) $(LIB_INSTALL_DIR)/reg1.1; \

 	    $(COPY) $(ROOT_DIR)/library/reg/pkgIndex.tcl \

 		$(LIB_INSTALL_DIR)/reg1.1; \

 	    fi

 	@if [ -f $(REG_LIB_FILE) ]; then \

 	    echo installing $(REG_LIB_FILE); \

 	    $(COPY) $(REG_LIB_FILE) $(LIB_INSTALL_DIR)/reg1.1; \

 	    fi

 install-libraries: libraries

 	@for i in $(prefix)/lib $(INCLUDE_INSTALL_DIR) \

 		$(SCRIPT_INSTALL_DIR); \

 	    do \

 	    if [ ! -d $$i ] ; then \

 		echo "Making directory $$i"; \

 		$(MKDIR) $$i; \

 		else true; \

 		fi; \

 	    done;

 	@for i in http1.0 http2.5 opt0.4 encoding msgcat1.3 tcltest2.2; \

 	    do \

 	    if [ ! -d $(SCRIPT_INSTALL_DIR)/$$i ] ; then \

 		echo "Making directory $(SCRIPT_INSTALL_DIR)/$$i"; \

 		$(MKDIR) $(SCRIPT_INSTALL_DIR)/$$i; \

 		else true; \

 		fi; \

 	    done;

 	@echo "Installing header files";

 	@for i in "$(GENERIC_DIR)/tcl.h" "$(GENERIC_DIR)/tclDecls.h" \

 		"$(GENERIC_DIR)/tclPlatDecls.h" ; \

 	    do \

 	    $(COPY) "$$i" "$(INCLUDE_INSTALL_DIR)"; \

 	    done;

 	@echo "Installing library files to $(SCRIPT_INSTALL_DIR)";

 	@for i in $(ROOT_DIR)/library/*.tcl $(ROOT_DIR)/library/tclIndex; \

 	    do \

 	    $(COPY) "$$i" "$(SCRIPT_INSTALL_DIR)"; \

 	    done;

 	@echo "Installing library http1.0 directory";

 	@for j in $(ROOT_DIR)/library/http1.0/*.tcl; \

 	    do \

 	    $(COPY) "$$j" "$(SCRIPT_INSTALL_DIR)/http1.0"; \

 	    done;

 	@echo "Installing library http2.5 directory";

 	@for j in $(ROOT_DIR)/library/http/*.tcl; \

 	    do \

 	    $(COPY) "$$j" "$(SCRIPT_INSTALL_DIR)/http2.5"; \

 	    done;

 	@echo "Installing library opt0.4 directory";

 	@for j in $(ROOT_DIR)/library/opt/*.tcl; \

 	    do \

 	    $(COPY) "$$j" "$(SCRIPT_INSTALL_DIR)/opt0.4"; \

 	    done;

 	@echo "Installing library msgcat1.3 directory";

 	@for j in $(ROOT_DIR)/library/msgcat/*.tcl; \

 	    do \

 	    $(COPY) "$$j" "$(SCRIPT_INSTALL_DIR)/msgcat1.3"; \

 	    done;

 	@echo "Installing library tcltest2.2 directory";

 	@for j in $(ROOT_DIR)/library/tcltest/*.tcl; \

 	    do \

 	    $(COPY) "$$j" "$(SCRIPT_INSTALL_DIR)/tcltest2.2"; \

 	    done;

 	@echo "Installing encodings";

 	@for i in $(ROOT_DIR)/library/encoding/*.enc ; do \

 		$(COPY) "$$i" "$(SCRIPT_INSTALL_DIR)/encoding"; \

 	done;

 install-doc: doc

 # Optional target to install private headers

 install-private-headers: libraries

 	@for i in $(PRIVATE_INCLUDE_INSTALL_DIR); \

 	    do \

 	    if [ ! -d $$i ] ; then \

 		echo "Making directory $$i"; \

 		$(MKDIR) $$i; \

 		chmod 755 $$i; \

 		else true; \

 		fi; \

 	    done;

 	@echo "Installing private header files to $(PRIVATE_INCLUDE_INSTALL_DIR)/";

 	@for i in "$(GENERIC_DIR)/tclInt.h" "$(GENERIC_DIR)/tclIntDecls.h" \

 		"$(GENERIC_DIR)/tclIntPlatDecls.h" "$(GENERIC_DIR)/tclPort.h" \

 		"$(WIN_DIR)/tclWinPort.h" ; \

 	    do \

 	    $(COPY) "$$i" "$(PRIVATE_INCLUDE_INSTALL_DIR)"; \

 	    done;

 # Specifying TESTFLAGS on the command line is the standard way to pass

 # args to tcltest, ie:

 #	% make test TESTFLAGS="-verbose bps -file fileName.test"

 test: binaries $(TCLTEST)

 	TCL_LIBRARY="$(LIBRARY_DIR)"; export TCL_LIBRARY; \

 	./$(TCLTEST) "$(ROOT_DIR_NATIVE)/tests/all.tcl" $(TESTFLAGS) \

 	| ./$(CAT32)

 # Useful target to launch a built tcltest with the proper path,...

 runtest: binaries $(TCLTEST)

 	@TCL_LIBRARY="$(LIBRARY_DIR)"; export TCL_LIBRARY; \

 	./$(TCLTEST) $(TESTFLAGS) $(SCRIPT)

 # This target can be used to run tclsh from the build directory

 # via `make shell SCRIPT=foo.tcl`

 shell: binaries

 	@TCL_LIBRARY="$(LIBRARY_DIR)"; export TCL_LIBRARY; \

 	./$(TCLSH) $(SCRIPT)

 # This target can be used to run tclsh inside either gdb or insight

 gdb: binaries

 	@echo "set env TCL_LIBRARY=$(LIBRARY_DIR)" > gdb.run

 	gdb ./tclsh --command=gdb.run

 	rm gdb.run

 depend:

 Makefile: $(SRC_DIR)/Makefile.in

 	./config.status

 cleanhelp:

 	$(RM) *.hlp *.cnt *.GID *.rtf man2tcl.exe

 clean: cleanhelp

 	$(RM) *.lib *.a *.exp *.dll *.$(RES) *.${OBJEXT} *~ \#* TAGS a.out

 	$(RM) $(TCLSH) $(TCLTEST) $(CAT32)

 	$(RM) *.pch *.ilk *.pdb

 distclean: clean

 	$(RM) Makefile config.status config.cache config.log tclConfig.sh \

 		tcl.hpj

 #

 # Regenerate the stubs files.

 #

 $(GENERIC_DIR)/tclStubInit.c: $(GENERIC_DIR)/tcl.decls \

 		$(GENERIC_DIR)/tclInt.decls

 	@echo "Warning: tclStubInit.c may be out of date."

 	@echo "Developers may want to run \"make genstubs\" to regenerate."

 	@echo "This warning can be safely ignored, do not report as a bug!"

 genstubs:

 	$(TCL_EXE) "$(ROOT_DIR_NATIVE)\tools\genStubs.tcl" \

 	    "$(GENERIC_DIR_NATIVE)" \

 	    "$(GENERIC_DIR_NATIVE)\tcl.decls" \

             "$(GENERIC_DIR_NATIVE)\tclInt.decls"