#
# Makefile for compiling Tcl for OS/2 with EMX/GCC
#

### Build choices

# uncomment the following line to compile with symbols
#DEBUGGING=1

# Uncomment the following to make binaries that run only on Warp or higher
#TARGET_WARP=yes

# Format is OMF (.obj, debuggable by IPMD, TD, TDOS2, ....)
# or A.OUT (.o, debuggable by GDB/PMGDB)
#FORMAT = A.OUT
FORMAT = OMF

# Where to build target dist
DISTDIR = d:\TclTk805\TclTk

### End of build choices

# Version
TCLVER = 80
LONGVER = 8.0
FULLVERSION = 8.0.5
SHORTVERSION = 805

#
# Project directories
#
# TMPDIR = location where .$(OBJ) files should be stored during build
# TCLDIR = location of top of Tcl source hierarchy
#

ROOT    = ..
GENERIC_DIR = $(ROOT)/generic
OS2_DIR = $(ROOT)/os2
TMPDIR	= .
EMXDIR  = d:/emx

# Choose packing
ifdef TARGET_WARP
    # Warp 3 and higher
    EXEPACKING=/EXEPACK:2
    RESPACKING=-x2
    LXLITE=lxlite /ML1
#    LXLITE=echo lxlite /ML1
else
    # All 32bit versions of OS/2
    EXEPACKING=/EXEPACK
    RESPACKING=-x1
    LXLITE=lxlite /MR3
#    LXLITE=echo lxlite /MR3
endif

ifeq ($(FORMAT),A.OUT)
   ARCH=a
   OBJ=o
   OUTPUTFLAG=
   EXTRALINK =
   SOCKLIB = -lsocket
   # No space after definition
   RC = emxbind -br
else
   ARCH=lib
   OBJ=obj
   OUTPUTFLAG=-Zomf
   EXTRALINK = -Zlinker /FARCALLTRANSLATION -Zlinker /RUNFROMVDM -Zlinker /BASE:0x10000 -Zlinker /ALIGN:2 -Zlinker $(EXEPACKING)
   SOCKLIB = $(EMXDIR)/lib/socket.$(ARCH)
   # NB! space after definition!
   RC = rc -p $(RESPACKING) 
endif
RCPRE = rc -r -p $(RESPACKING) 


TCLBASE     = tcl$(TCLVER)
TCLLIB      = $(TCLBASE).$(ARCH)
TCLOMFLIB   = $(TCLBASE).lib
TCLARCHIVE  = $(TCLBASE).a
TCLDLL      = $(TCLBASE).dll
TCLSHPMBASE = tclpm$(TCLVER)
TCLSHPM     = $(TCLSHPMBASE).exe
TCLSHPMDEF  = $(TCLSHPMBASE).def
TCLSHBASE   = tclsh$(TCLVER)
TCLSH       = $(TCLSHBASE).exe
TCLSHDEF    = $(TCLSHBASE).def
TCLTESTBASE = tcltst$(TCLVER)
TCLTEST     = $(TCLTESTBASE).exe
TCLREGDLL   = tclreg$(TCLVER).dll
TCLREGDEF   = tclreg$(TCLVER).def

# GENTCLSH is used to generate the help file (INF file), should be in path
GENTCLSH = tclsh76
#GENTCLSH = tclsh80
IMPLIB  = emximp
CC      = gcc -c
LINK    = gcc
# Careful, there has to be a space after '-o' !
LINK_OUT = -o 
CP      = copy
RM      = del /f
MKDIR   = mkdir

EMXIMP  = emximp

DEFINES =       -D__OS2__ -DDLL_BUILD -DBUILD_tcl -DHAS_DIRENT -DHAS_STDARG \
		-D"wchar_t=unsigned short" -D_WCHAR_T
STD_INCLUDES =  -I$(OS2_DIR) -I$(EMXDIR)/include
TCL_INCLUDES =  -I$(OS2_DIR) -I$(GENERIC_DIR)
INCLUDES =	$(STD_INCLUDES) $(TCL_INCLUDES)
LIBDIRS =	-L$(EMXDIR)/lib -L$(OS2_DIR)

ifndef DEBUGGING
  # these macros cause maximum optimization and no symbols
  CFLAGS =	-O -Wall -mprobe -m486 $(OUTPUTFLAG) -Zmtd -s $(DEFINES) $(INCLUDES)
else
  # these macros enable debugging
  CFLAGS =	-g -mprobe -m486 $(OUTPUTFLAG) -Zmtd -fhandle-exceptions \
  		$(DEFINES) $(DEBUGDEFINES) $(INCLUDES) -DVERBOSE -DTCL_DEBUG
endif
CC_SWITCHES =   $(CFLAGS)

ifndef DEBUGGING
  LNFLAGS_exe = $(OUTPUTFLAG) -Zmtd $(EXTRALINK) -lwrap -s
  LNFLAGS_dll = -mprobe -Zcrtdll -Zdll $(OUTPUTFLAG) -Zmt \
                $(EXTRALINK) -lm -lwrap -s
else
  LNFLAGS_exe = $(OUTPUTFLAG) -Zmtd $(EXTRALINK)
#  LNFLAGS_dll = -mprobe -Zcrtdll -Zdll $(OUTPUTFLAG) -Zmt $(EXTRALINK) -lm
  LNFLAGS_dll = -mprobe -Zcrtdll -Zdll $(OUTPUTFLAG) -Zmt $(EXTRALINK) -lm
endif

.SUFFIXES: .c .dll .$(ARCH) .$(OBJ) .exe

TCLSHPMOBJS = \
	tclOS2AppInit.$(OBJ)

TCLSHOBJS = \
	tclOS2AppInitC.$(OBJ)

# PM version
#TCLTESTOBJS = \
#	tclTest.$(OBJ) \
#	tclTestObj.$(OBJ) \
#	tclOS2Test.$(OBJ) \
#	testMain.$(OBJ)
# CLI version
TCLTESTOBJS = \
	tclTest.$(OBJ) \
	tclTestObj.$(OBJ) \
	tclOS2Test.$(OBJ) \
	testMainC.$(OBJ)

TCLCOMPATOBJS =


TCLOBJS = \
	tclOS2Alloc.$(OBJ) \
	tclOS2Chan.$(OBJ) \
	tclOS2Console.$(OBJ) \
	tclOS2Error.$(OBJ) \
	tclOS2FCmd.$(OBJ) \
	tclOS2File.$(OBJ) \
	tclOS2Init.$(OBJ) \
	tclOS2Load.$(OBJ) \
	tclOS2Main.$(OBJ) \
	tclOS2Mtherr.$(OBJ) \
	tclOS2Notify.$(OBJ) \
	tclOS2Pipe.$(OBJ) \
	tclOS2Sock.$(OBJ) \
	tclOS2Time.$(OBJ) \
	panic.$(OBJ) \
	regexp.$(OBJ) \
	tclAlloc.$(OBJ) \
	tclAsync.$(OBJ) \
	tclBasic.$(OBJ) \
	tclBinary.$(OBJ) \
	tclCkalloc.$(OBJ) \
	tclClock.$(OBJ) \
	tclCmdAH.$(OBJ) \
	tclCmdIL.$(OBJ) \
	tclCmdMZ.$(OBJ) \
	tclCompExpr.$(OBJ) \
	tclCompile.$(OBJ) \
	tclDate.$(OBJ) \
	tclEnv.$(OBJ) \
	tclEvent.$(OBJ) \
	tclExecute.$(OBJ) \
	tclFCmd.$(OBJ) \
	tclFileName.$(OBJ) \
	tclGet.$(OBJ) \
	tclHash.$(OBJ) \
	tclHistory.$(OBJ) \
	tclIndexObj.$(OBJ) \
	tclInterp.$(OBJ) \
	tclIO.$(OBJ) \
	tclIOCmd.$(OBJ) \
	tclIOSock.$(OBJ) \
	tclIOUtil.$(OBJ) \
	tclLink.$(OBJ) \
	tclListObj.$(OBJ) \
	tclLoad.$(OBJ) \
	tclNamesp.$(OBJ) \
	tclNotify.$(OBJ) \
	tclObj.$(OBJ) \
	tclParse.$(OBJ) \
	tclPipe.$(OBJ) \
	tclPkg.$(OBJ) \
	tclPosixStr.$(OBJ) \
	tclPreserve.$(OBJ) \
	tclProc.$(OBJ) \
	tclResolve.$(OBJ) \
	tclStringObj.$(OBJ) \
	tclTimer.$(OBJ) \
	tclUtil.$(OBJ) \
	tclVar.$(OBJ)

TCLDLLOBJS = \
	$(TCLOBJS) \
	tclOS2Dll.$(OBJ)

#
# Targets
#

all:  $(TCLDLL) $(TCLSHPM) $(TCLSH) $(TCLREGDLL) $(TCLTEST)
test: $(TCLDLL) $(TCLTEST)
dlls:	$(TCLDLL) $(TCLREGDLL)
doc: tcl$(SHORTVERSION).inf

# OS/2 binaries:

tclOS2AppInit.$(OBJ): tclOS2AppInit.c
	$(CC) $(CC_SWITCHES) tclOS2AppInit.c
# CLI version
tclOS2AppInitC.$(OBJ): tclOS2AppInit.c
	$(CC) $(CC_SWITCHES) $(LINK_OUT)$@ -DCLI_VERSION tclOS2AppInit.c

tclOS2Alloc.$(OBJ): tclOS2Alloc.c
	$(CC) $(CC_SWITCHES) tclOS2Alloc.c
tclOS2Chan.$(OBJ): tclOS2Chan.c
	$(CC) $(CC_SWITCHES) tclOS2Chan.c
tclOS2Console.$(OBJ): tclOS2Console.c
	$(CC) $(CC_SWITCHES) tclOS2Console.c
tclOS2Dll.$(OBJ): tclOS2Dll.c
	$(CC) $(CC_SWITCHES) tclOS2Dll.c
tclOS2Error.$(OBJ): tclOS2Error.c
	$(CC) $(CC_SWITCHES) tclOS2Error.c
tclOS2FCmd.$(OBJ): tclOS2FCmd.c
	$(CC) $(CC_SWITCHES) tclOS2FCmd.c
tclOS2File.$(OBJ): tclOS2File.c
	$(CC) $(CC_SWITCHES) tclOS2File.c
tclOS2Init.$(OBJ): tclOS2Init.c
	$(CC) $(CC_SWITCHES) tclOS2Init.c
tclOS2Load.$(OBJ): tclOS2Load.c
	$(CC) $(CC_SWITCHES) tclOS2Load.c
tclOS2Main.$(OBJ): tclOS2Main.c
	$(CC) $(CC_SWITCHES) tclOS2Main.c
tclOS2Mtherr.$(OBJ): tclOS2Mtherr.c
	$(CC) $(CC_SWITCHES) tclOS2Mtherr.c
tclOS2Notify.$(OBJ): tclOS2Notify.c
	$(CC) $(CC_SWITCHES) tclOS2Notify.c
tclOS2Pipe.$(OBJ): tclOS2Pipe.c
	$(CC) $(CC_SWITCHES) tclOS2Pipe.c
tclOS2Sock.$(OBJ): tclOS2Sock.c
	$(CC) $(CC_SWITCHES) tclOS2Sock.c
tclOS2Stubs.$(OBJ): tclOS2Stubs.c
	$(CC) $(CC_SWITCHES) tclOS2Stubs.c
tclOS2Test.$(OBJ): tclOS2Test.c
	$(CC) $(CC_SWITCHES) tclOS2Test.c
tclOS2Time.$(OBJ): tclOS2Time.c
	$(CC) $(CC_SWITCHES) tclOS2Time.c

# Generic binaries:

panic.$(OBJ): $(GENERIC_DIR)/panic.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/panic.c

regexp.$(OBJ): $(GENERIC_DIR)/regexp.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/regexp.c

#tcl2c.$(OBJ): $(GENERIC_DIR)/tcl2c.c
#	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tcl2c.c
tcl2c.$(OBJ): tcl2c.c
	$(CC) $(CC_SWITCHES) tcl2c.c

#tclAlloc.$(OBJ): $(GENERIC_DIR)/tclAlloc.c
#	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclAlloc.c
tclAlloc.$(OBJ): tclAlloc.c
	$(CC) $(CC_SWITCHES) tclAlloc.c

tclAsync.$(OBJ): $(GENERIC_DIR)/tclAsync.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclAsync.c

tclBasic.$(OBJ): $(GENERIC_DIR)/tclBasic.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclBasic.c

tclBinary.$(OBJ): $(GENERIC_DIR)/tclBinary.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclBinary.c

tclCkalloc.$(OBJ): $(GENERIC_DIR)/tclCkalloc.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclCkalloc.c

tclClock.$(OBJ): $(GENERIC_DIR)/tclClock.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclClock.c

#tclCmdAH.$(OBJ): $(GENERIC_DIR)/tclCmdAH.c
#	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclCmdAH.c
tclCmdAH.$(OBJ): tclCmdAH.c
	$(CC) $(CC_SWITCHES) tclCmdAH.c

tclCmdIL.$(OBJ): $(GENERIC_DIR)/tclCmdIL.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclCmdIL.c

tclCmdMZ.$(OBJ): $(GENERIC_DIR)/tclCmdMZ.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclCmdMZ.c

tclCompExpr.$(OBJ): $(GENERIC_DIR)/tclCompExpr.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclCompExpr.c

tclCompile.$(OBJ): $(GENERIC_DIR)/tclCompile.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclCompile.c

tclDate.$(OBJ): $(GENERIC_DIR)/tclDate.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclDate.c

tclEnv.$(OBJ): $(GENERIC_DIR)/tclEnv.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclEnv.c

tclEvent.$(OBJ): $(GENERIC_DIR)/tclEvent.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclEvent.c

tclExecute.$(OBJ): $(GENERIC_DIR)/tclExecute.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclExecute.c

tclFCmd.$(OBJ): $(GENERIC_DIR)/tclFCmd.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclFCmd.c

#tclFileName.$(OBJ): $(GENERIC_DIR)/tclFileName.c
#	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclFileName.c
tclFileName.$(OBJ): tclFileName.c
	$(CC) $(CC_SWITCHES) tclFileName.c

tclGet.$(OBJ): $(GENERIC_DIR)/tclGet.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclGet.c

tclHash.$(OBJ): $(GENERIC_DIR)/tclHash.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclHash.c

tclHistory.$(OBJ): $(GENERIC_DIR)/tclHistory.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclHistory.c

tclIndexObj.$(OBJ): $(GENERIC_DIR)/tclIndexObj.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclIndexObj.c

tclInterp.$(OBJ): $(GENERIC_DIR)/tclInterp.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclInterp.c

tclIO.$(OBJ): $(GENERIC_DIR)/tclIO.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclIO.c

tclIOCmd.$(OBJ): $(GENERIC_DIR)/tclIOCmd.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclIOCmd.c

tclIOSock.$(OBJ): $(GENERIC_DIR)/tclIOSock.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclIOSock.c

tclIOUtil.$(OBJ): $(GENERIC_DIR)/tclIOUtil.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclIOUtil.c

tclLink.$(OBJ): $(GENERIC_DIR)/tclLink.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclLink.c

tclListObj.$(OBJ): $(GENERIC_DIR)/tclListObj.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclListObj.c

tclLoad.$(OBJ): $(GENERIC_DIR)/tclLoad.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclLoad.c

tclNamesp.$(OBJ): $(GENERIC_DIR)/tclNamesp.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclNamesp.c

tclNotify.$(OBJ): $(GENERIC_DIR)/tclNotify.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclNotify.c

tclObj.$(OBJ): $(GENERIC_DIR)/tclObj.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclObj.c

tclParse.$(OBJ): $(GENERIC_DIR)/tclParse.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclParse.c

tclPipe.$(OBJ): $(GENERIC_DIR)/tclPipe.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclPipe.c

tclPkg.$(OBJ): $(GENERIC_DIR)/tclPkg.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclPkg.c

tclPosixStr.$(OBJ): $(GENERIC_DIR)/tclPosixStr.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclPosixStr.c

tclPreserve.$(OBJ): $(GENERIC_DIR)/tclPreserve.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclPreserve.c

tclProc.$(OBJ): $(GENERIC_DIR)/tclProc.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclProc.c

tclResolve.$(OBJ): $(GENERIC_DIR)/tclResolve.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclResolve.c

tclStringObj.$(OBJ): $(GENERIC_DIR)/tclStringObj.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclStringObj.c

#tclTest.$(OBJ): $(GENERIC_DIR)/tclTest.c
#	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclTest.c
tclTest.$(OBJ): tclTest.c
	$(CC) $(CC_SWITCHES) tclTest.c

tclTestObj.$(OBJ): $(GENERIC_DIR)/tclTestObj.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclTestObj.c

tclTimer.$(OBJ): $(GENERIC_DIR)/tclTimer.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclTimer.c

tclUtil.$(OBJ): $(GENERIC_DIR)/tclUtil.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclUtil.c

tclVar.$(OBJ): $(GENERIC_DIR)/tclVar.c
	$(CC) $(CC_SWITCHES) $(GENERIC_DIR)/tclVar.c

# compat binaries

fixstrtod.$(OBJ): $(COMPAT_DIR)/fixstrtod.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/fixstrtod.c

gettod.$(OBJ): $(COMPAT_DIR)/gettod.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/gettod.c

getcwd.$(OBJ): $(COMPAT_DIR)/getcwd.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/getcwd.c

opendir.$(OBJ): $(COMPAT_DIR)/opendir.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/opendir.c

strncasecmp.$(OBJ): $(COMPAT_DIR)/strncasecmp.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/strncasecmp.c

strstr.$(OBJ): $(COMPAT_DIR)/strstr.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/strstr.c

strtod.$(OBJ): $(COMPAT_DIR)/strtod.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/strtod.c

strtol.$(OBJ): $(COMPAT_DIR)/strtol.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/strtol.c

strtoul.$(OBJ): $(COMPAT_DIR)/strtoul.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/strtoul.c

tmpnam.$(OBJ): $(COMPAT_DIR)/tmpnam.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/tmpnam.c

waitpid.$(OBJ): $(COMPAT_DIR)/waitpid.c
	$(CC) $(CC_SWITCHES) $(COMPAT_DIR)/waitpid.c


# Implicit Targets

.c.$(OBJ):
	$(CC) -DDLL_BUILD -DBUILD_tcl $(CC_SWITCHES) $<

#.dll.$(ARCH):
#	$(IMPLIB) -c $@ $<

.rc.res:
	$(RCPRE) -i$(INCLUDES) $<

#
# Special case object file targets
#

testMain.$(OBJ) : tclOS2AppInit.c
	$(CC) -DTCL_TEST $(CC_SWITCHES) $(LINK_OUT)$@ tclOS2AppInit.c

# CLI version
testMainC.$(OBJ) : tclOS2AppInit.c
	$(CC) -DTCL_TEST -DCLI_VERSION $(CC_SWITCHES) $(LINK_OUT)$@ tclOS2AppInit.c


#
# Executable targets
#

$(TCLDLL): $(TCLDLLOBJS) $(TCLBASE).def $(TCLBASE).res
	$(LINK) $(LINK_OUT)$@ $(LNFLAGS_dll) $(TCLDLLOBJS) $(TCLBASE).def $(SOCKLIB)
	$(RC)$(TCLBASE).res $(TCLDLL)
ifndef DEBUGGING
	-$(LXLITE) $(TCLDLL)
endif

$(TCLREGDLL): tclOS2Reg.$(OBJ) $(TCLLIB) $(TCLREGDEF) $(TCLBASE).res
	$(LINK) $(LINK_OUT)$@ $(LNFLAGS_dll) tclOS2Reg.$(OBJ) $(TCLLIB) $(TCLREGDEF)
	$(RC)$(TCLBASE).res $(TCLREGDLL)
ifndef DEBUGGING
	-$(LXLITE) $(TCLREGDLL)
endif

$(TCLBASE).res: $(TCLBASE).rc
	$(RCPRE) $(TCLBASE).rc


$(TCLSHPM): $(TCLSHPMOBJS) $(TCLLIB) $(TCLSHPMDEF) $(TCLSHPMBASE).res
	$(LINK) $(LINK_OUT)$@ $(LNFLAGS_exe) $(TCLSHPMOBJS) $(TCLLIB) $(TCLSHPMDEF)
	$(RC)$(TCLSHPMBASE).res $(TCLSHPM)
ifndef DEBUGGING
	-$(LXLITE) $(TCLSHPM)
endif

$(TCLSH): $(TCLSHOBJS) $(TCLLIB) $(TCLSHDEF) $(TCLSHBASE).res
	$(LINK) $(LINK_OUT)$@ $(LNFLAGS_exe) $(TCLSHOBJS) $(TCLLIB) $(TCLSHDEF)
	$(RC)$(TCLSHBASE).res $(TCLSH)
ifndef DEBUGGING
	-$(LXLITE) $(TCLSH)
endif

$(TCLSHPMBASE).res: $(TCLSHPMBASE).rc
	$(RCPRE) $(TCLSHPMBASE).rc

$(TCLSHBASE).res: $(TCLSHBASE).rc
	$(RCPRE) $(TCLSHBASE).rc

#PM version
#$(TCLTEST): $(TCLTESTOBJS) $(TCLLIB) $(TCLSHPMDEF) $(TCLSHPMBASE).res
#	$(LINK) $(LINK_OUT)$@ $(LNFLAGS_exe) $(TCLTESTOBJS) $(TCLLIB) \
#		$(TCLSHPMDEF)
#	$(RC)$(TCLSHPMBASE).res $(TCLTEST)
#ifndef DEBUGGING
#	-$(LXLITE) $(TCLTEST)
#endif
#CLI version
$(TCLTEST): $(TCLTESTOBJS) $(TCLLIB) $(TCLSHDEF) $(TCLSHBASE).res
	$(LINK) $(LINK_OUT)$@ $(LNFLAGS_exe) $(TCLTESTOBJS) $(TCLLIB) \
		$(TCLSHDEF)
	$(RC)$(TCLSHBASE).res $(TCLTEST)
ifndef DEBUGGING
	-$(LXLITE) $(TCLTEST)
endif

$(TCLOMFLIB): $(TCLBASE).imp
	$(IMPLIB) -o $(TCLOMFLIB) $(TCLBASE).imp

$(TCLBASE).imp: $(TCLBASE).def
	$(IMPLIB) $(LINK_OUT)$@ $(TCLBASE).def

$(TCLARCHIVE): $(TCLBASE).imp
	$(EMXIMP) -o $(TCLARCHIVE) $(TCLBASE).imp

# The following rule automatically generates a tcl<version>.def file containing
# an export entry for every public symbol in the tcl<version>.dll library.

$(TCLBASE).def: $(TCLBASE)def.base $(TCLDLLOBJS)
	type $(TCLBASE)def.base > $(TCLBASE).def
	emxexp -o $(TCLDLLOBJS) >> $(TCLBASE).def

# make documentation
tcl$(SHORTVERSION).inf: tcl$(SHORTVERSION).ipf
	ipfc /inf tcl$(SHORTVERSION).ipf

tcl$(SHORTVERSION).ipf: man2tcl.exe ..\doc\registry.n
	$(GENTCLSH) man2ipf.tcl tcl $(FULLVERSION) \
		../../tcl$(FULLVERSION)/doc \
		../../tk$(FULLVERSION)/doc \
		/oratcl-2.5/doc/oratcl.man
man2tcl.exe: man2tcl.c
	gcc $(OUTPUTFLAG) man2tcl.c $(LINK_OUT)$@

..\doc\registry.n: registry.n
	copy registry.n ..\doc

# Always make an a.out archive when creating distribution
aoutarchive: $(TCLARCHIVE)
	-$(CP) $(TCLARCHIVE) $(DISTDIR)\lib

# distribution
dist: all doc aoutarchive
# test for writability
	$(CP) Makefile $(DISTDIR)
	$(RM) $(DISTDIR)\Makefile
	-$(MKDIR) $(DISTDIR)\bin
	-$(CP) $(TCLSH) $(DISTDIR)\bin
	-$(CP) $(TCLSHPM) $(DISTDIR)\bin
	-$(CP) $(TCLDLL) $(DISTDIR)\bin
	-$(CP) $(TCLREGDLL) $(DISTDIR)\bin
	-$(CP) $(TCLTEST) $(DISTDIR)\bin
	-$(CP) man2tcl.exe $(DISTDIR)\bin
	-$(MKDIR) $(DISTDIR)\doc
	-$(CP) tcl$(SHORTVERSION).inf $(DISTDIR)\doc
	-$(MKDIR) $(DISTDIR)\include
	-$(CP) ..\generic\tcl.h $(DISTDIR)\include
	-$(MKDIR) $(DISTDIR)\lib
	-$(CP) $(TCLLIB) $(DISTDIR)\lib
	-$(MKDIR) $(DISTDIR)\lib\tcl$(LONGVER)
	-$(CP) ..\library\\* $(DISTDIR)\lib\tcl$(LONGVER)
	-$(MKDIR) $(DISTDIR)\lib\tcl$(LONGVER)\http1.0
	-$(CP) ..\library\http1.0\\* $(DISTDIR)\lib\tcl$(LONGVER)\http1.0
	-$(MKDIR) $(DISTDIR)\lib\tcl$(LONGVER)\http2.0
	-$(CP) ..\library\http2.0\\* $(DISTDIR)\lib\tcl$(LONGVER)\http2.0
	-$(MKDIR) $(DISTDIR)\lib\tcl$(LONGVER)\opt0.1
	-$(CP) ..\library\opt0.1\\* $(DISTDIR)\lib\tcl$(LONGVER)\opt0.1
	-$(CP) man2ipf.tcl $(DISTDIR)\doc
	-$(CP) man2ipf2.tcl $(DISTDIR)\doc

# remove all generated files
clean:
	-$(RM) $(TCLBASE).def $(TCLBASE) $(TCLLIB) $(TCLDLL) $(TCLBASE).res
	-$(RM) $(TCLSHPMBASE) $(TCLSHPM) $(TCLSHPMBASE).map $(TCLSHPMBASE).res
	-$(RM) $(TCLSHBASE) $(TCLSH) $(TCLSHBASE).map $(TCLSHBASE).res
	-$(RM) $(TCLTESTBASE) $(TCLTEST) $(TCLTESTBASE).map $(TCLTESTBASE).res
	-$(RM) *.$(OBJ)
