Use compilation rules from rules.vc instead of defining own ones in makefile.

Updated to latest rules.vc and nmakehlp.c from Tcl repository

1 files changed, 944 insertions, 341 deletions

diff --git a/win/rules.vc b/win/rules.vc
index 6d9de03..be49672 100644
--- a/win/rules.vc
+++ b/win/rules.vc
@@ -9,24 +9,56 @@
 #

 # Copyright (c) 2001-2003 David Gravereaux.

 # Copyright (c) 2003-2008 Patrick Thoyts

+# Copyright (c) 2017      Ashok P. Nadkarni

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

 

 !ifndef _RULES_VC

 _RULES_VC = 1

 

-cc32		= $(CC)   # built-in default.

-link32		= link

-lib32		= lib

-rc32		= $(RC)   # built-in default.

-

-!ifndef INSTALLDIR

-### Assume the normal default.

-_INSTALLDIR	= C:\Program Files\Tcl

-!else

-### Fix the path separators.

-_INSTALLDIR	= $(INSTALLDIR:/=\)

+################################################################

+# Nmake is a pretty weak environment in syntax and capabilities

+# so this file is necessarily verbose. It's broken down into

+# the following parts.

+#

+# 0. Sanity check that compiler environment is set up.

+# 1. First define the external tools used for compiling, copying etc.

+#    as this is independent of everything else.

+# 2. Figure out our build structure in terms of the directory, whether

+#    we are building Tcl or an extension, etc.

+# 3. Determine the compiler and linker versions

+# 4. Build the nmakehlp helper application

+# 5. Determine the supported compiler options and features

+# 6. Parse the OPTS macro value for user-specified build configuration

+# 7. Parse the STATS macro value for statistics instrumentation

+# 8. Parse the CHECKS macro for additional compilation checks

+# 9. Extract Tcl, and possibly Tk, version numbers from the headers

+# 10. Based on this selected configuration, construct the output

+#     directory and file paths

+# 11. Construct the paths where the package is to be installed

+# 12. Set up the actual options passed to compiler and linker based

+#     on the information gathered above.

+# 13. Define some standard build targets and implicit rules.

+# 14. (For extensions only.) Compare the configuration of the target

+#     Tcl and the extensions and warn against discrepancies.

+#

+# One final note about the macro names used. They are as they are

+# for historical reasons. We would like legacy extensions to

+# continue to work with this make include file so be wary of

+# changing them for consistency or clarity.

+

+# 0. Sanity check compiler environment

+# Check to see we are configured to build with MSVC (MSDEVDIR, MSVCDIR or

+# VCINSTALLDIR) or with the MS Platform SDK (MSSDK or WindowsSDKDir)

+

+!if !defined(MSDEVDIR) && !defined(MSVCDIR) && !defined(VCINSTALLDIR) && !defined(MSSDK) && !defined(WINDOWSSDKDIR)

+MSG = ^

+Visual C++ compiler environment not initialized.

+!error $(MSG)

 !endif

 

+################################################################

+# 1. Define external programs being used

+

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

 # Set the proper copy method to avoid overwrite questions

 # to the user when copying files and selecting the right

@@ -35,18 +67,234 @@ _INSTALLDIR	= $(INSTALLDIR:/=\)
 

 RMDIR	= rmdir /S /Q

 ERRNULL  = 2>NUL

-!if ![ver | find "4.0" > nul]

-CPY	= echo y | xcopy /i >NUL

-COPY	= copy >NUL

-!else

 CPY	= xcopy /i /y >NUL

 COPY	= copy /y >NUL

-!endif

 MKDIR   = mkdir

 

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

-# Determine the host and target architectures and compiler version.

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

+# The ProgramFiles(x86) environment variable is not accessible

+# from nmake since it has the parenthesis which nmake does not like

+# within a macro name. So define our own in terms of the

+# ProgramFiles environment variable.

+# Note: env variables are always UPPER CASE in nmake

+!if defined(PROCESSOR_ARCHITECTURE) && "$(PROCESSOR_ARCHITECTURE)" == "AMD64"

+PROGRAMFILES_X86 = $(PROGRAMFILES) (x86)

+!else

+PROGRAMFILES_X86 = $(PROGRAMFILES)

+!endif

+

+

+######################################################################

+# 2. Figure out our build environment in terms of what we're building.

+#

+# (a) Tcl itself

+# (b) Tk

+# (c) a Tcl extension using libraries/includes from an *installed* Tcl

+# (d) a Tcl extension using libraries/includes from Tcl source directory

+#

+# This last is needed because some extensions still need

+# some Tcl interfaces that are not publicly exposed.

+#

+# The fragment will set the following macros:

+# ROOT - root of this module sources

+# COMPATDIR - source directory that holds compatibility sources

+# DOCDIR - source directory containing documentation files

+# GENERICDIR - platform-independent source directory

+# WINDIR - Windows-specific source directory

+# TOOLSDIR - directory containing build tools

+# _TCLDIR - root of the Tcl installation OR the Tcl sources. Not set

+#    when building Tcl itself.

+# _INSTALLDIR - native form of the installation path. For Tcl

+#    this will be the root of the Tcl installation. For extensions

+#    this will be the lib directory under the root.

+# TCLINSTALL  - set to 1 if _TCLDIR refers to

+#    headers and libraries from an installed Tcl, and 0 if built against

+#    Tcl sources. Not set when building Tcl itself. Yes, not very well

+#    named.

+# _TCL_H - native path to the tcl.h file

+#

+# If Tk is involved, also sets the following

+# _TKDIR - native form Tk installation OR Tk source. Not set if building

+#    Tk itself.

+# TKINSTALL - set 1 if _TKDIR refers to installed Tk and 0 if Tk sources

+# _TK_H - native path to the tk.h file

+

+# Root directory for sources and assumed subdirectories

+ROOT = $(MAKEDIR)\..

+# The following paths CANNOT have spaces in them as they appear on the

+# left side of implicit rules.

+!ifndef COMPATDIR

+COMPATDIR	= $(ROOT)\compat

+!endif

+!ifndef DOCDIR

+DOCDIR		= $(ROOT)\doc

+!endif

+!ifndef GENERICDIR

+GENERICDIR	= $(ROOT)\generic

+!endif

+!ifndef TOOLSDIR

+TOOLSDIR	= $(ROOT)\tools

+!endif

+# Do NOT enclose WINDIR in a !ifndef because Windows always defines

+# WINDIR env var to point to c:\windows!

+# TBD - This is a potentially dangerous conflict, rename WINDIR to

+# something else

+WINDIR		= $(ROOT)\win

+!ifndef RCDIR

+RCDIR           = $(WINDIR)\rc

+!endif

+

+# The target directory where the built packages and binaries will be installed.

+# INSTALLDIR is the (optional) path specified by the user.

+# _INSTALLDIR is INSTALLDIR using the backslash separator syntax

+!ifdef INSTALLDIR

+### Fix the path separators.

+_INSTALLDIR	= $(INSTALLDIR:/=\)

+!else

+### Assume the normal default.

+_INSTALLDIR	= C:\Program Files\Tcl

+!endif

+

+!if "$(PROJECT)" == "tcl" 

+

+# BEGIN Case 2(a) - Building Tcl itself

+

+# Only need to define _TCL_H

+_TCL_H = ..\generic\tcl.h

+

+# END Case 2(a) - Building Tcl itself

+

+!elseif "$(PROJECT)" == "tk"

+

+# BEGIN Case 2(b) - Building Tk

+

+TCLINSTALL = 0 # Tk always builds against Tcl source, not an installed Tcl

+!ifndef TCLDIR

+TCLDIR  = ../../tcl

+!endif

+_TCLDIR	= $(TCLDIR:/=\)

+_TCL_H  = $(_TCLDIR)\generic\tcl.h

+!if !exist("$(_TCL_H)")

+!error Could not locate tcl.h. Please set the TCLDIR macro to point to the Tcl *source* directory.

+!endif

+

+_TK_H = ..\generic\tk.h

+

+# END Case 2(b) - Building Tk

+

+!else

+

+# BEGIN Case 2(c) or (d) - Building an extension other than Tk

+

+# If command line has specified Tcl location through TCLDIR, use it

+# else default to the INSTALLDIR setting

+!ifdef TCLDIR

+

+_TCLDIR	= $(TCLDIR:/=\)

+!if exist("$(_TCLDIR)\include\tcl.h") # Case 2(c) with TCLDIR defined

+TCLINSTALL	= 1

+_TCL_H          = $(_TCLDIR)\include\tcl.h

+!elseif exist("$(_TCLDIR)\generic\tcl.h") # Case 2(d) with TCLDIR defined

+TCLINSTALL	= 0

+_TCL_H          = $(_TCLDIR)\generic\tcl.h

+!endif

+

+!else  # TCLDIR is not defined

+

+!if exist("$(_INSTALLDIR)\include\tcl.h") # Case 2(c) for extensions with TCLDIR undefined

+TCLINSTALL	= 1

+TCLDIR          = $(_INSTALLDIR)

+_TCLDIR		= $(_INSTALLDIR)

+_TCL_H          = $(_INSTALLDIR)\include\tcl.h

+!elseif exist("..\..\tcl\generic\tcl.h")

+TCLINSTALL      = 0

+TCLDIR          = ..\..\tcl

+_TCLDIR         = $(TCLDIR)

+_TCL_H          = $(_TCLDIR)\generic\tcl.h

+!endif

+

+!endif # TCLDIR

+

+!ifndef _TCL_H

+MSG =^

+Failed to find tcl.h. The TCLDIR macro is set incorrectly or is not set and default path does not contain tcl.h.

+!error $(MSG)

+!endif

+

+# Now do the same to locate Tk headers and libs if project requires Tk

+!ifdef PROJECT_REQUIRES_TK

+

+!ifdef TKDIR

+

+_TKDIR = $(TKDIR:/=\)

+!if exist("$(_TKDIR)\include\tk.h")

+TKINSTALL      = 1

+_TK_H          = $(_TKDIR)\include\tk.h

+!elseif exist("$(_TKDIR)\generic\tk.h")

+TKINSTALL      = 0

+_TK_H          = $(_TKDIR)\generic\tk.h

+!endif

+

+!else # TKDIR not defined

+

+!if exist("$(_INSTALLDIR)\..\include\tk.h")

+TKINSTALL      = 1

+_TKDIR         = $(_INSTALLDIR)\..

+_TK_H          = $(_TKDIR)\include\tk.h

+TKDIR          = $(_TKDIR)

+!elseif exist("$(_TCLDIR)\include\tk.h")

+TKINSTALL      = 1

+_TKDIR         = $(_TCLDIR)

+_TK_H          = $(_TKDIR)\include\tk.h

+TKDIR          = $(_TKDIR)

+!endif

+

+!endif # TKDIR

+

+!ifndef _TK_H

+MSG =^

+Failed to find tk.h. The TKDIR macro is set incorrectly or is not set and default path does not contain tk.h.

+!error $(MSG)

+!endif

+

+!endif # PROJECT_REQUIRES_TK

+

+# If INSTALLDIR set to tcl installation root dir then reset to the

+# lib dir for installing extensions 

+!if exist("$(_INSTALLDIR)\include\tcl.h")

+_INSTALLDIR=$(_INSTALLDIR)\lib

+!endif

+

+# END Case 2(c) or (d) - Building an extension

+!endif # if $(PROJECT) == "tcl"

+

+################################################################

+# 3. Determine compiler version and architecture

+# In this section, we figure out the compiler version and the

+# architecture for which we are building. This sets the

+# following macros:

+# VCVERSION - the internal compiler version as 1200, 1400, 1910 etc.

+#     This is also printed by the compiler in dotted form 19.10 etc.

+# VCVER - the "marketing version", for example Visual C++ 6 for internal

+#     compiler version 1200. This is kept only for legacy reasons as it

+#     does not make sense for recent Microsoft compilers. Only used for

+#     output directory names.

+# ARCH - set to IX86 or AMD64 depending on 32- or 64-bit target

+# NATIVE_ARCH - set to IX86 or AMD64 for the host machine

+# MACHINE - same as $(ARCH) - legacy

+# _VC_MANIFEST_EMBED_{DLL,EXE} - commands for embedding a manifest if needed

+# CFG_ENCODING - set to an character encoding.

+#   TBD - this is passed to compiler as TCL_CFGVAL_ENCODING but can't

+#   see where it is used

+

+cc32		= $(CC)   # built-in default.

+link32		= link

+lib32		= lib

+rc32		= $(RC)   # built-in default.

+

+#----------------------------------------------------------------

+# Figure out the compiler architecture and version by writing

+# the C macros to a file, preprocessing them with the C

+# preprocessor and reading back the created file

 

 _HASH=^#

 _VC_MANIFEST_EMBED_EXE=

@@ -58,7 +306,7 @@ VCVER=0
     && ![echo $(_HASH)elif defined(_M_AMD64) >> vercl.x] \

     && ![echo ARCH=AMD64 >> vercl.x] \

     && ![echo $(_HASH)endif >> vercl.x] \

-    && ![cl -nologo -TC -P vercl.x $(ERRNULL)]

+    && ![$(cc32) -nologo -TC -P vercl.x $(ERRNULL)]

 !include vercl.i

 !if $(VCVERSION) < 1900

 !if ![echo VCVER= ^\> vercl.vc] \

@@ -75,6 +323,26 @@ VCVER = $(VCVERSION)
 !if ![del $(ERRNUL) /q/f vercl.x vercl.i vercl.vc]

 !endif

 

+#----------------------------------------------------------------

+# The MACHINE macro is used by legacy makefiles so set it as well

+!ifdef MACHINE

+!if "$(MACHINE)" == "x86"

+!undef MACHINE

+MACHINE = IX86

+!elseif "$(MACHINE)" == "x64"

+!undef MACHINE

+MACHINE = AMD64

+!endif

+!if "$(MACHINE)" != "$(ARCH)"

+!error Specified MACHINE macro $(MACHINE) does not match detected target architecture $(ARCH).

+!endif

+!else

+MACHINE=$(ARCH)

+!endif

+

+#------------------------------------------------------------

+# Figure out the *host* architecture by reading the registry

+

 !if ![reg query HKLM\Hardware\Description\System\CentralProcessor\0 /v Identifier | findstr /i x86]

 NATIVE_ARCH=IX86

 !else

@@ -87,29 +355,95 @@ _VC_MANIFEST_EMBED_EXE=if exist $@.manifest mt -nologo -manifest $@.manifest -ou
 _VC_MANIFEST_EMBED_DLL=if exist $@.manifest mt -nologo -manifest $@.manifest -outputresource:$@;2

 !endif

 

-!ifndef MACHINE

-MACHINE=$(ARCH)

-!endif

-

 !ifndef CFG_ENCODING

 CFG_ENCODING	= \"cp1252\"

 !endif

 

-!message ===============================================================================

+!message =====================================================================

 

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

-# build the helper app we need to overcome nmake's limiting

-# environment.

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

+################################################################

+# 4. Build the nmakehlp program

+# This is a helper app we need to overcome nmake's limiting

+# environment. We will call out to it to get various bits of

+# information about supported compiler options etc.

+#

+# Tcl itself will always use the nmakehlp.c program which is

+# in its own source. This is the "master" copy and kept updated.

+#

+# Extensions built against an installed Tcl will use the installed

+# copy of Tcl's nmakehlp.c if there is one and their own version

+# otherwise. In the latter case, they would also be using their own

+# rules.vc. Note that older versions of Tcl do not install nmakehlp.c

+# or rules.vc.

+#

+# Extensions built against Tcl sources will use the one from the Tcl source.

+#

+# This can all be overridden by defining the NMAKEHLPC macro to point

+# to the nmakehlp.c file to be used, either from the command line or

+# the containing makefile.

 

-!if !exist(nmakehlp.exe)

-!if [$(cc32) -nologo nmakehlp.c -link -subsystem:console > nul]

+!ifndef NMAKEHLPC

+# Default to the one in the current directory (the extension's own nmakehlp.c)

+NMAKEHLPC = nmakehlp.c

+

+!if "$(PROJECT)" != "tcl"

+!if $(TCLINSTALL)

+!if exist("$(_TCLDIR)\lib\nmake\nmakehlp.c")

+NMAKEHLPC = $(_TCLDIR)\lib\nmake\nmakehlp.c

 !endif

+!else # ! $(TCLINSTALL)

+!if exist("$(_TCLDIR)\win\nmakehlp.c")

+NMAKEHLPC = $(_TCLDIR)\win\nmakehlp.c

 !endif

+!endif # $(TCLINSTALL)

+!endif # $(PROJECT) != "tcl"

 

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

-# Test for compiler features

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

+!endif # NMAKEHLPC

+

+# We always build nmakehlp even if it exists since we do not know

+# what source it was built from.

+!message *** Using $(NMAKEHLPC)

+!if [$(cc32) -nologo "$(NMAKEHLPC)" -link -subsystem:console > nul]

+!endif

+

+################################################################

+# 5. Test for compiler features

+# Visual C++ compiler options have changed over the years. Check

+# which options are supported by the compiler in use.

+#

+# The following macros are set:

+# OPTIMIZATIONS - the compiler flags to be used for optimized builds

+# DEBUGFLAGS - the compiler flags to be used for debug builds

+# LINKERFLAGS - Flags passed to the linker 

+#

+# Note that these are the compiler settings *available*, not those

+# that will be *used*. The latter depends on the OPTS macro settings

+# which we have not yet parsed.

+#

+# Also note that some of the flags in OPTIMIZATIONS are not really

+# related to optimization. They are placed there only for legacy reasons

+# as some extensions expect them to be included in that macro.

+

+# -Op improves float consistency. Note only needed for older compilers

+# Newer compilers do not need or support this option.

+!if [nmakehlp -c -Op]

+FPOPTS  = -Op

+!endif

+

+# Strict floating point semantics - present in newer compilers in lieu of -Op

+!if [nmakehlp -c -fp:strict]

+FPOPTS  = $(FPOPTS) -fp:strict

+!endif

+

+!if "$(MACHINE)" == "IX86"

+### test for pentium errata

+!if [nmakehlp -c -QI0f]

+!message *** Compiler has 'Pentium 0x0f fix'

+FPOPTS  = $(FPOPTS) -QI0f

+!else

+!message *** Compiler does not have 'Pentium 0x0f fix'

+!endif

+!endif

 

 ### test for optimizations

 # /O2 optimization includes /Og /Oi /Ot /Oy /Ob2 /Gs /GF /Gy as per

@@ -120,84 +454,97 @@ CFG_ENCODING	= \"cp1252\"
 # default page size locals allocation probes and not what is implied

 # by an explicit /Gs option.

 

+OPTIMIZATIONS = $(FPOPTS)

+

 !if [nmakehlp -c -O2]

 !message *** Compiler has 'Optimizations'

-OPTIMIZING	= 1

-OPTIMIZATIONS   = -O2

+OPTIMIZING = 1

+OPTIMIZATIONS   = $(OPTIMIZATIONS) -O2

 !else

+# Legacy, really. All modern compilers support this

 !message *** Compiler does not have 'Optimizations'

-OPTIMIZING	= 0

-OPTIMIZATIONS   = 

-!endif

-

-# -Op improves float consistency. Note only needed for older compilers

-# Newer compilers do not need or support this option.

-!if [nmakehlp -c -Op]

-OPTIMIZATIONS  = $(OPTIMIZATIONS) -Op

-!endif

-

-# Strict floating point semantics - present in newer compilers in lieu of -Op

-!if [nmakehlp -c -fp:strict]

-OPTIMIZATIONS  = $(OPTIMIZATIONS) -fp:strict

+OPTIMIZING = 0

 !endif

 

-

+# Checks for buffer overflows in local arrays

 !if [nmakehlp -c -GS]

 OPTIMIZATIONS  = $(OPTIMIZATIONS) -GS

 !endif

 

+# Link time optimization. Note that this option (potentially) makes

+# generated libraries only usable by the specific VC++ version that

+# created it. Requires /LTCG linker option

 !if [nmakehlp -c -GL]

 OPTIMIZATIONS  = $(OPTIMIZATIONS) -GL

+CC_GL_OPT_ENABLED = 1

+!else

+# In newer compilers -GL and -YX are incompatible.

+!if [nmakehlp -c -YX]

+OPTIMIZATIONS  = $(OPTIMIZATIONS) -YX

 !endif

+!endif # [nmakehlp -c -GL]

 

-DEBUGFLAGS     =

+DEBUGFLAGS     = $(FPOPTS)

 

+# Run time error checks. Not available or valid in a release, non-debug build

+# RTC is for modern compilers, -GZ is legacy

 !if [nmakehlp -c -RTC1]

 DEBUGFLAGS     = $(DEBUGFLAGS) -RTC1

 !elseif [nmakehlp -c -GZ]

 DEBUGFLAGS     = $(DEBUGFLAGS) -GZ

 !endif

 

-COMPILERFLAGS  =-W3 /DUNICODE /D_UNICODE /D_ATL_XP_TARGETING

+#----------------------------------------------------------------

+# Linker flags

 

-# In v13 -GL and -YX are incompatible.

-!if [nmakehlp -c -YX]

-!if ![nmakehlp -c -GL]

-OPTIMIZATIONS  = $(OPTIMIZATIONS) -YX

-!endif

-!endif

-

-!if "$(MACHINE)" == "IX86"

-### test for pentium errata

-!if [nmakehlp -c -QI0f]

-!message *** Compiler has 'Pentium 0x0f fix'

-COMPILERFLAGS  = $(COMPILERFLAGS) -QI0f

-!else

-!message *** Compiler does not have 'Pentium 0x0f fix'

-!endif

-!endif

-

-!if "$(MACHINE)" == "IA64"

-### test for Itanium errata

-!if [nmakehlp -c -QIA64_Bx]

-!message *** Compiler has 'B-stepping errata workarounds'

-COMPILERFLAGS   = $(COMPILERFLAGS) -QIA64_Bx

-!else

-!message *** Compiler does not have 'B-stepping errata workarounds'

-!endif

+# LINKER_TESTFLAGS are for internal use when we call nmakehlp to test

+# if the linker supports a specific option. Without these flags link will

+# return "LNK1561: entry point must be defined" error compiling from VS-IDE:

+# They are not passed through to the actual application / extension

+# link rules.

+!ifndef LINKER_TESTFLAGS

+LINKER_TESTFLAGS = /DLL /NOENTRY /OUT:nmhlp-out.txt

 !endif

 

 LINKERFLAGS     =

 

-!if [nmakehlp -l -ltcg]

-LINKERFLAGS     =-ltcg

-!endif

-

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

-# Decode the options requested.

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

-

-!if "$(OPTS)" == "" || [nmakehlp -f "$(OPTS)" "none"]

+# If compiler has enabled link time optimization, linker must too with -ltcg

+!ifdef CC_GL_OPT_ENABLED

+!if [nmakehlp -l -ltcg $(LINKER_TESTFLAGS)]

+LINKERFLAGS     = $(LINKERFLAGS) -ltcg

+!endif

+!endif

+

+########################################################################

+# 6. Parse the OPTS macro to work out the requested build configuration.

+# Based on this, we will construct the actual switches to be passed to the

+# compiler and linker using the macros defined in the previous section.

+# The following macros are defined by this section based on OPTS

+# STATIC_BUILD - 0 -> Tcl is to be built as a shared library

+#                1 -> build as a static library and shell

+# TCL_THREADS - legacy but always 1 on Windows since winsock requires it.

+# DEBUG - 1 -> debug build, 0 -> release builds

+# SYMBOLS - 1 -> generate PDB's, 0 -> no PDB's

+# PROFILE - 1 -> generate profiling info, 0 -> no profiling

+# PGO     - 1 -> profile based optimization, 0 -> no

+# MSVCRT  - 1 -> link to dynamic C runtime even when building static Tcl build

+#           0 -> link to static C runtime for static Tcl build.

+#           Does not impact shared Tcl builds (STATIC_BUILD == 0)

+# LOIMPACT - 1 -> Ask Windows loader to aggressively trim the working set.

+#           Will reduce physical memory use at cost of performance.

+# TCL_USE_STATIC_PACKAGES - 1 -> statically link the registry and dde extensions

+#           in the Tcl shell. 0 -> keep them as shared libraries

+#           Does not impact shared Tcl builds.

+# USE_THREAD_ALLOC - 1 -> Use a shared global free pool for allocation.

+#           0 -> Use the non-thread allocator.

+# UNCHECKED - 1 -> when doing a debug build with symbols, use the release

+#           C runtime, 0 -> use the debug C runtime.

+# USE_STUBS - 1 -> compile to use stubs interfaces, 0 -> direct linking

+# CONFIG_CHECK - 1 -> check current build configuration against Tcl

+#           configuration (ignored for Tcl itself)

+# Further, LINKERFLAGS are modified based on above.

+

+# Default values for all the above

 STATIC_BUILD	= 0

 TCL_THREADS	= 1

 DEBUG		= 0

@@ -209,13 +556,29 @@ LOIMPACT	= 0
 TCL_USE_STATIC_PACKAGES	= 0

 USE_THREAD_ALLOC = 1

 UNCHECKED	= 0

+CONFIG_CHECK    = 1

+!if "$(PROJECT)" == "tcl"

+USE_STUBS       = 0

 !else

+USE_STUBS       = 1

+!endif

+

+# If OPTS is not empty AND does not contain "none" which turns off all OPTS

+# set the above macros based on OPTS content

+!if "$(OPTS)" != "" && ![nmakehlp -f "$(OPTS)" "none"]

+

+# OPTS are specified, parse them

+

 !if [nmakehlp -f $(OPTS) "static"]

 !message *** Doing static

 STATIC_BUILD	= 1

-!else

-STATIC_BUILD	= 0

 !endif

+

+!if [nmakehlp -f $(OPTS) "nostubs"]

+!message *** Not using stubs

+USE_STUBS	= 0

+!endif

+

 !if [nmakehlp -f $(OPTS) "nomsvcrt"]

 !message *** Doing nomsvcrt

 MSVCRT		= 0

@@ -230,39 +593,40 @@ MSVCRT		= 1
 MSVCRT		= 0

 !endif

 !endif

-!endif

+!endif # [nmakehlp -f $(OPTS) "nomsvcrt"]

+

 !if [nmakehlp -f $(OPTS) "staticpkg"] && $(STATIC_BUILD)

 !message *** Doing staticpkg

 TCL_USE_STATIC_PACKAGES	= 1

 !else

 TCL_USE_STATIC_PACKAGES	= 0

 !endif

+

 !if [nmakehlp -f $(OPTS) "nothreads"]

-!message *** Compile explicitly for non-threaded tcl

-TCL_THREADS	= 0

-USE_THREAD_ALLOC= 0

-!else

-TCL_THREADS	= 1

-USE_THREAD_ALLOC= 1

+!error Option "nothreads" no longer supported. Threads required for sockets, registry and dde to work.

 !endif

+

 !if [nmakehlp -f $(OPTS) "symbols"]

 !message *** Doing symbols

 DEBUG		= 1

 !else

 DEBUG		= 0

 !endif

+

 !if [nmakehlp -f $(OPTS) "pdbs"]

 !message *** Doing pdbs

 SYMBOLS		= 1

 !else

 SYMBOLS		= 0

 !endif

+

 !if [nmakehlp -f $(OPTS) "profile"]

 !message *** Doing profile

 PROFILE		= 1

 !else

 PROFILE		= 0

 !endif

+

 !if [nmakehlp -f $(OPTS) "pgi"]

 !message *** Doing profile guided optimization instrumentation

 PGO		= 1

@@ -272,44 +636,192 @@ PGO		= 2
 !else

 PGO		= 0

 !endif

+

 !if [nmakehlp -f $(OPTS) "loimpact"]

 !message *** Doing loimpact

 LOIMPACT	= 1

 !else

 LOIMPACT	= 0

 !endif

+

+# TBD - should get rid of this option

 !if [nmakehlp -f $(OPTS) "thrdalloc"]

 !message *** Doing thrdalloc

 USE_THREAD_ALLOC = 1

 !endif

+

+# TBD - should get rid of this option

 !if [nmakehlp -f $(OPTS) "tclalloc"]

 !message *** Doing tclalloc

 USE_THREAD_ALLOC = 0

 !endif

+

 !if [nmakehlp -f $(OPTS) "unchecked"]

 !message *** Doing unchecked

 UNCHECKED = 1

 !else

 UNCHECKED = 0

 !endif

+

+!if [nmakehlp -f $(OPTS) "noconfigcheck"]

+CONFIG_CHECK = 1

+!else

+CONFIG_CHECK = 0

 !endif

 

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

-# Figure-out how to name our intermediate and output directories.

-# We wouldn't want different builds to use the same .obj files

-# by accident.

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

+!endif # "$(OPTS)" != ""  && ... parsing of OPTS

+

+# Set linker flags based on above

 

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

-# Naming convention:

+!if $(PGO) > 1

+!if [nmakehlp -l -ltcg:pgoptimize $(LINKER_TESTFLAGS)]

+LINKERFLAGS	= $(LINKERFLAGS:-ltcg=) -ltcg:pgoptimize

+!else

+MSG=^

+This compiler does not support profile guided optimization.

+!error $(MSG)

+!endif

+!elseif $(PGO) > 0

+!if [nmakehlp -l -ltcg:pginstrument $(LINKER_TESTFLAGS)]

+LINKERFLAGS	= $(LINKERFLAGS:-ltcg=) -ltcg:pginstrument

+!else

+MSG=^

+This compiler does not support profile guided optimization.

+!error $(MSG)

+!endif

+!endif

+

+################################################################

+# 7. Parse the STATS macro to configure code instrumentation

+# The following macros are set by this section:

+# TCL_MEM_DEBUG - 1 -> enables memory allocation instrumentation

+#                 0 -> disables

+# TCL_COMPILE_DEBUG - 1 -> enables byte compiler logging

+#                     0 -> disables

+

+# Default both are off

+TCL_MEM_DEBUG	    = 0

+TCL_COMPILE_DEBUG   = 0

+

+!if "$(STATS)" != "" && ![nmakehlp -f "$(STATS)" "none"]

+

+!if [nmakehlp -f $(STATS) "memdbg"]

+!message *** Doing memdbg

+TCL_MEM_DEBUG	    = 1

+!else

+TCL_MEM_DEBUG	    = 0

+!endif

+

+!if [nmakehlp -f $(STATS) "compdbg"]

+!message *** Doing compdbg

+TCL_COMPILE_DEBUG   = 1

+!else

+TCL_COMPILE_DEBUG   = 0

+!endif

+

+!endif

+

+####################################################################

+# 8. Parse the CHECKS macro to configure additional compiler checks

+# The following macros are set by this section:

+# WARNINGS - compiler switches that control the warnings level

+# TCL_NO_DEPRECATED - 1 -> disable support for deprecated functions

+#                     0 -> enable deprecated functions

+

+# Defaults - Permit deprecated functions and warning level 3

+TCL_NO_DEPRECATED	    = 0

+WARNINGS		    = -W3

+

+!if "$(CHECKS)" != "" && ![nmakehlp -f "$(CHECKS)" "none"]

+

+!if [nmakehlp -f $(CHECKS) "nodep"]

+!message *** Doing nodep check

+TCL_NO_DEPRECATED	    = 1

+!endif

+

+!if [nmakehlp -f $(CHECKS) "fullwarn"]

+!message *** Doing full warnings check

+WARNINGS		    = -W4

+!if [nmakehlp -l -warn:3 $(LINKER_TESTFLAGS)]

+LINKERFLAGS		    = $(LINKERFLAGS) -warn:3

+!endif

+!endif

+

+!if [nmakehlp -f $(CHECKS) "64bit"] && [nmakehlp -c -Wp64]

+!message *** Doing 64bit portability warnings

+WARNINGS		    = $(WARNINGS) -Wp64

+!endif

+

+!endif

+

+################################################################

+# 9. Extract various version numbers from tcl headers

+# Sets the following macros:

+# TCL_MAJOR_VERSION

+# TCL_MINOR_VERSION

+# TCL_PATCH_LEVEL

+# TCL_VERSION

+# TK_MAJOR_VERSION

+# TK_MINOR_VERSION

+# TK_PATCH_LEVEL

+# TK_VERSION

+#--------------------------------------------------------------

+

+!if [echo REM = This file is generated from rules.vc > versions.vc]

+!endif

+!if [echo TCL_MAJOR_VERSION = \>> versions.vc] \

+   && [nmakehlp -V "$(_TCL_H)" TCL_MAJOR_VERSION >> versions.vc]

+!endif

+!if [echo TCL_MINOR_VERSION = \>> versions.vc] \

+   && [nmakehlp -V "$(_TCL_H)" TCL_MINOR_VERSION >> versions.vc]

+!endif

+!if [echo TCL_PATCH_LEVEL = \>> versions.vc] \

+   && [nmakehlp -V "$(_TCL_H)" TCL_PATCH_LEVEL >> versions.vc]

+!endif

+

+!if defined(_TK_H)

+!if [echo TK_MAJOR_VERSION = \>> versions.vc] \

+   && [nmakehlp -V $(_TK_H) TK_MAJOR_VERSION >> versions.vc]

+!endif

+!if [echo TK_MINOR_VERSION = \>> versions.vc] \

+   && [nmakehlp -V $(_TK_H) TK_MINOR_VERSION >> versions.vc]

+!endif

+!if [echo TK_PATCH_LEVEL = \>> versions.vc] \

+   && [nmakehlp -V $(_TK_H) TK_PATCH_LEVEL >> versions.vc]

+!endif

+!endif # _TK_H

+

+!include versions.vc

+

+TCL_VERSION	= $(TCL_MAJOR_VERSION)$(TCL_MINOR_VERSION)

+!if defined(_TK_H)

+TK_VERSION	= $(TK_MAJOR_VERSION)$(TK_MINOR_VERSION)

+!endif

+

+

+################################################################

+# 10. Construct output directory and file paths

+# Figure-out how to name our intermediate and output directories.

+# In order to avoid inadvertent mixing of object files built using

+# different compilers, build configurations etc.,

+#

+# Naming convention (suffixes):

 #   t = full thread support.

-#   s = static library (as opposed to an

-#	import library)

-#   g = linked to the debug enabled C

-#	run-time.

-#   x = special static build when it

-#	links to the dynamic C run-time.

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

+#   s = static library (as opposed to an import library)

+#   g = linked to the debug enabled C run-time.

+#   x = special static build when it links to the dynamic C run-time.

+#

+# The following macros are set in this section:

+# SUFX - the suffix to use for binaries based on above naming convention

+# BUILDDIRTOP - the toplevel default output directory

+#      is of the form {Release,Debug}[_AMD64][_COMPILERVERSION]

+# TMP_DIR - directory where object files are created

+# OUT_DIR - directory where output executables are created

+# STUBPREFIX - name of the stubs library for this project

+# Both TMP_DIR and OUT_DIR are defaulted only if not defined by the

+# parent makefile (or command line). The default values are

+# based on BUILDDIRTOP.

+

 SUFX	    = tsgx

 

 !if $(DEBUG)

@@ -362,80 +874,146 @@ OUT_DIR	    = $(TMP_DIR)
 !endif

 !endif

 

+# The name of the stubs library for the project being built

+STUBPREFIX      = $(PROJECT)stub

 

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

-# Decode the statistics requested.

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

+# Set up paths to various Tcl executables and libraries needed by extensions

+!if "$(PROJECT)" == "tcl"

 

-!if "$(STATS)" == "" || [nmakehlp -f "$(STATS)" "none"]

-TCL_MEM_DEBUG	    = 0

-TCL_COMPILE_DEBUG   = 0

-!else

-!if [nmakehlp -f $(STATS) "memdbg"]

-!message *** Doing memdbg

-TCL_MEM_DEBUG	    = 1

-!else

-TCL_MEM_DEBUG	    = 0

-!endif

-!if [nmakehlp -f $(STATS) "compdbg"]

-!message *** Doing compdbg

-TCL_COMPILE_DEBUG   = 1

-!else

-TCL_COMPILE_DEBUG   = 0

-!endif

-!endif

+TCLSHNAME       = $(PROJECT)sh$(TCL_VERSION)$(SUFX).exe

+TCLSH		= $(OUT_DIR)\$(TCLSHNAME)

+TCLIMPLIB	= $(OUT_DIR)\$(PROJECT)$(VERSION)$(SUFX).lib

+TCLLIBNAME	= $(PROJECT)$(VERSION)$(SUFX).$(EXT)

+TCLLIB		= $(OUT_DIR)\$(TCLLIBNAME)

 

+TCLSTUBLIBNAME	= $(STUBPREFIX)$(VERSION).lib

+TCLSTUBLIB	= $(OUT_DIR)\$(TCLSTUBLIBNAME)

+TCL_INCLUDES    = -I"$(WINDIR)" -I"$(GENERICDIR)"

 

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

-# Decode the checks requested.

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

+!else # $(PROJECT) is not "tcl"

 

-!if "$(CHECKS)" == "" || [nmakehlp -f "$(CHECKS)" "none"]

-TCL_NO_DEPRECATED	    = 0

-WARNINGS		    = -W3

-!else

-!if [nmakehlp -f $(CHECKS) "nodep"]

-!message *** Doing nodep check

-TCL_NO_DEPRECATED	    = 1

-!else

-TCL_NO_DEPRECATED	    = 0

+!if $(TCLINSTALL) # Building against an installed Tcl

+

+TCLSH		= $(_TCLDIR)\bin\tclsh$(TCL_VERSION)$(SUFX).exe

+!if !exist($(TCLSH)) && $(TCL_THREADS)

+TCLSH           = $(_TCLDIR)\bin\tclsh$(TCL_VERSION)t$(SUFX).exe

 !endif

-!if [nmakehlp -f $(CHECKS) "fullwarn"]

-!message *** Doing full warnings check

-WARNINGS		    = -W4

-!if [nmakehlp -l -warn:3]

-LINKERFLAGS		    = $(LINKERFLAGS) -warn:3

+TCLSTUBLIB	= $(_TCLDIR)\lib\tclstub$(TCL_VERSION).lib

+TCLIMPLIB	= $(_TCLDIR)\lib\tcl$(TCL_VERSION)$(SUFX).lib

+TCL_LIBRARY	= $(_TCLDIR)\lib

+TCLREGLIB	= $(_TCLDIR)\lib\tclreg13$(SUFX:t=).lib

+TCLDDELIB	= $(_TCLDIR)\lib\tcldde14$(SUFX:t=).lib

+TCLTOOLSDIR	= \must\have\tcl\sources\to\build\this\target

+TCL_INCLUDES    = -I"$(_TCLDIR)\include"

+

+!else # Building against Tcl sources

+

+TCLSH		= $(_TCLDIR)\win\$(BUILDDIRTOP)\tclsh$(TCL_VERSION)$(SUFX).exe

+!if !exist($(TCLSH)) && $(TCL_THREADS)

+TCLSH		= $(_TCLDIR)\win\$(BUILDDIRTOP)\tclsh$(TCL_VERSION)t$(SUFX).exe

 !endif

+TCLSTUBLIB	= $(_TCLDIR)\win\$(BUILDDIRTOP)\tclstub$(TCL_VERSION).lib

+TCLIMPLIB	= $(_TCLDIR)\win\$(BUILDDIRTOP)\tcl$(TCL_VERSION)$(SUFX).lib

+TCL_LIBRARY	= $(_TCLDIR)\library

+TCLREGLIB	= $(_TCLDIR)\win\$(BUILDDIRTOP)\tclreg13$(SUFX:t=).lib

+TCLDDELIB	= $(_TCLDIR)\win\$(BUILDDIRTOP)\tcldde14$(SUFX:t=).lib

+TCLTOOLSDIR	= $(_TCLDIR)\tools

+TCL_INCLUDES	= -I"$(_TCLDIR)\generic" -I"$(_TCLDIR)\win"

+

+!endif # TCLINSTALL

+

+!endif $(PROJECT) != "tcl"

+

+# We need a tclsh that will run on the host machine as part of the build.

+# IX86 runs on all architectures.

+!ifndef TCLSH_NATIVE

+!if "$(MACHINE)" == "IX86" || "$(MACHINE)" == "$(NATIVE_ARCH)"

+TCLSH_NATIVE	= $(TCLSH)

 !else

-WARNINGS		    = -W3

-!endif

-!if [nmakehlp -f $(CHECKS) "64bit"] && [nmakehlp -c -Wp64]

-!message *** Doing 64bit portability warnings

-WARNINGS		    = $(WARNINGS) -Wp64

+!error You must explicitly set TCLSH_NATIVE for cross-compilation

 !endif

 !endif

 

-!if $(PGO) > 1

-!if [nmakehlp -l -ltcg:pgoptimize]

-LINKERFLAGS	= $(LINKERFLAGS:-ltcg=) -ltcg:pgoptimize

+# Do the same for Tk and Tk extensions that require the Tk libraries

+!if "$(PROJECT)" == "tk"

+

+WISHNAMEPREFIX = wish

+WISH 		= $(OUT_DIR)\$(WISHNAMEPREFIX)$(TK_VERSION)$(SUFX).exe

+TKSTUBLIBNAME	= $(STUBPREFIX)$(TK_VERSION).lib

+TKSTUBLIB	= $(OUT_DIR)\$(TKSTUBLIBNAME)

+TKIMPLIB	= $(OUT_DIR)\$(PROJECT)$(TK_VERSION)$(SUFX).lib

+TKLIBNAME	= $(PROJECT)$(TK_VERSION)$(SUFX).$(EXT)

+TKLIB		= $(OUT_DIR)\$(TKLIBNAME)

+TK_INCLUDES    = -I"$(WINDIR)" -I"$(GENERICDIR)"

+

+!elseif defined(PROJECT_REQUIRES_TK)

+

+!if $(TKINSTALL) # Building against installed Tk

+

+WISH		= $(_TKDIR)\bin\wish$(TK_VERSION)$(SUFX).exe

+TKSTUBLIB	= $(_TKDIR)\lib\tkstub$(TK_VERSION).lib

+TKIMPLIB	= $(_TKDIR)\lib\tk$(TK_VERSION)$(SUFX).lib

+TK_INCLUDES     = -I"$(_TKDIR)\include"

+

+!else # Building against Tk sources

+

+WISH		= $(_TKDIR)\win\$(BUILDDIRTOP)\wish$(TCL_VERSION)$(SUFX).exe

+TKSTUBLIB	= $(_TKDIR)\win\$(BUILDDIRTOP)\tkstub$(TCL_VERSION).lib

+TKIMPLIB	= $(_TKDIR)\win\$(BUILDDIRTOP)\tk$(TCL_VERSION)$(SUFX).lib

+TK_INCLUDES     = -I"$(_TKDIR)\generic" -I"$(_TKDIR)\win" -I"$(_TKDIR)\xlib"

+

+!endif # TKINSTALL

+

+!endif # PROJECT_REQUIRES_TK

+

+

+###################################################################

+# 11. Construct the paths for the installation directories

+# The following macros get defined in this section:

+# LIB_INSTALL_DIR - where libraries should be installed

+# BIN_INSTALL_DIR - where the executables should be installed

+# DOC_INSTALL_DIR - where documentation should be installed

+# SCRIPT_INSTALL_DIR - where scripts should be installed

+# INCLUDE_INSTALL_DIR - where C include files should be installed

+!if "$(PROJECT)" == "tcl" || "$(PROJECT)" == "tk"

+LIB_INSTALL_DIR		= $(_INSTALLDIR)\lib

+BIN_INSTALL_DIR		= $(_INSTALLDIR)\bin

+DOC_INSTALL_DIR		= $(_INSTALLDIR)\doc

+!if "$(PROJECT)" == "tcl"

+SCRIPT_INSTALL_DIR	= $(_INSTALLDIR)\lib\$(PROJECT)$(TCL_MAJOR_VERSION).$(TCL_MINOR_VERSION)

 !else

-MSG=^

-This compiler does not support profile guided optimization.

-!error $(MSG)

+SCRIPT_INSTALL_DIR	= $(_INSTALLDIR)\lib\$(PROJECT)$(TK_MAJOR_VERSION).$(TK_MINOR_VERSION)

 !endif

-!elseif $(PGO) > 0

-!if [nmakehlp -l -ltcg:pginstrument]

-LINKERFLAGS	= $(LINKERFLAGS:-ltcg=) -ltcg:pginstrument

+INCLUDE_INSTALL_DIR	= $(_INSTALLDIR)\include

 !else

-MSG=^

-This compiler does not support profile guided optimization.

-!error $(MSG)

-!endif

-!endif

-

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

-# Set our defines now armed with our options.

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

+PRJ_INSTALL_DIR         = $(_INSTALLDIR)\$(PROJECT)$(DOTVERSION)

+LIB_INSTALL_DIR		= $(PRJ_INSTALL_DIR)

+BIN_INSTALL_DIR		= $(PRJ_INSTALL_DIR)

+DOC_INSTALL_DIR		= $(PRJ_INSTALL_DIR)

+SCRIPT_INSTALL_DIR	= $(PRJ_INSTALL_DIR)

+INCLUDE_INSTALL_DIR	= $(_TCLDIR)\include

+!endif

+

+###################################################################

+# 12. Set up actual options to be passed to the compiler and linker

+# Now we have all the information we need, set up the actual flags and

+# options that we will pass to the compiler and linker. The main

+# makefile should use these in combination with whatever other flags

+# and switches are specific to it.

+# The following macros are defined, names are for historical compatibility:

+# OPTDEFINES - /Dxxx C macro flags based on user-specified OPTS

+# COMPILERFLAGS - /Dxxx C macro flags independent of any configuration opttions

+# crt - Compiler switch that selects the appropriate C runtime

+# cdebug - Compiler switches related to debug AND optimizations

+# cwarn - Compiler switches that set warning levels

+# cflags - complete compiler switches (subsumes cdebug and cwarn)

+# ldebug - Linker switches controlling debug information and optimization

+# lflags - complete linker switches (subsumes ldebug) except subsystem type

+# dlllflags - complete linker switches to build DLLs (subsumes lflags)

+# conlflags - complete linker switches for console program (subsumes lflags)

+# guilflags - complete linker switches for GUI program (subsumes lflags)

+# baselibs - minimum Windows libraries required. Parent makefile can

+#    define PRJ_LIBS before including rules.rc if additional libs are needed

 

 OPTDEFINES	= -DTCL_CFGVAL_ENCODING=$(CFG_ENCODING) -DSTDC_HEADERS

 

@@ -458,6 +1036,17 @@ OPTDEFINES	= $(OPTDEFINES) -DSTATIC_BUILD
 OPTDEFINES	= $(OPTDEFINES) -DTCL_NO_DEPRECATED

 !endif

 

+!if $(USE_STUBS)

+# Note we do not define USE_TCL_STUBS even when building tk since some

+# test targets in tk do not use stubs

+!if "$(PROJECT)" != "tcl"

+USE_STUBS_DEFS  = -DUSE_TCL_STUBS -DUSE_TCLOO_STUBS

+!ifdef PROJECT_REQUIRES_TK

+USE_STUBS_DEFS  = $(USE_STUBS_DEFS) -DUSE_TK_STUBS

+!endif

+!endif

+!endif # USE_STUBS

+

 !if !$(DEBUG)

 OPTDEFINES	= $(OPTDEFINES) -DNDEBUG

 !if $(OPTIMIZING)

@@ -467,227 +1056,243 @@ OPTDEFINES	= $(OPTDEFINES) -DTCL_CFG_OPTIMIZED
 !if $(PROFILE)

 OPTDEFINES	= $(OPTDEFINES) -DTCL_CFG_PROFILED

 !endif

-!if "$(MACHINE)" == "IA64" || "$(MACHINE)" == "AMD64"

+!if "$(MACHINE)" == "AMD64"

 OPTDEFINES	= $(OPTDEFINES) -DTCL_CFG_DO64BIT

 !endif

 !if $(VCVERSION) < 1300

 OPTDEFINES	= $(OPTDEFINES) -DNO_STRTOI64

 !endif

 

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

-# Locate the Tcl headers to build against

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

-

-!if "$(PROJECT)" == "tcl"

-

-_TCL_H          = ..\generic\tcl.h

+# UNICODE - Use the wide char Windows API.

+# _ATL_XP_TARGETING - Newer SDK's need this to build for XP

+COMPILERFLAGS  = /DUNICODE /D_UNICODE /D_ATL_XP_TARGETING

 

+# crt picks the C run time based on selected OPTS

+!if $(MSVCRT)

+!if $(DEBUG) && !$(UNCHECKED)

+crt = -MDd

 !else

-

-# If INSTALLDIR set to tcl root dir then reset to the lib dir.

-!if exist("$(_INSTALLDIR)\include\tcl.h")

-_INSTALLDIR=$(_INSTALLDIR)\lib

+crt = -MD

 !endif

-

-!if !defined(TCLDIR)

-!if exist("$(_INSTALLDIR)\..\include\tcl.h")

-TCLINSTALL	= 1

-_TCLDIR		= $(_INSTALLDIR)\..

-_TCL_H          = $(_INSTALLDIR)\..\include\tcl.h

-TCLDIR          = $(_INSTALLDIR)\..

 !else

-MSG=^

-Failed to find tcl.h.  Set the TCLDIR macro.

-!error $(MSG)

-!endif

+!if $(DEBUG) && !$(UNCHECKED)

+crt = -MTd

 !else

-_TCLDIR	= $(TCLDIR:/=\)

-!if exist("$(_TCLDIR)\include\tcl.h")

-TCLINSTALL	= 1

-_TCL_H          = $(_TCLDIR)\include\tcl.h

-!elseif exist("$(_TCLDIR)\generic\tcl.h")

-TCLINSTALL	= 0

-_TCL_H          = $(_TCLDIR)\generic\tcl.h

-!else

-MSG =^

-Failed to find tcl.h.  The TCLDIR macro does not appear correct.

-!error $(MSG)

-!endif

+crt = -MT

 !endif

 !endif

 

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

-# Extract various version numbers from tcl headers

-# The generated file is then included in the makefile.

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

+# cdebug includes compiler options for debugging as well as optimization.

+!if $(DEBUG)

 

-!if [echo REM = This file is generated from rules.vc > versions.vc]

-!endif

-!if [echo TCL_MAJOR_VERSION = \>> versions.vc] \

-   && [nmakehlp -V "$(_TCL_H)" TCL_MAJOR_VERSION >> versions.vc]

-!endif

-!if [echo TCL_MINOR_VERSION = \>> versions.vc] \

-   && [nmakehlp -V "$(_TCL_H)" TCL_MINOR_VERSION >> versions.vc]

-!endif

-!if [echo TCL_PATCH_LEVEL = \>> versions.vc] \

-   && [nmakehlp -V "$(_TCL_H)" TCL_PATCH_LEVEL >> versions.vc]

-!endif

+# In debugging mode, optimizations need to be disabled

+cdebug = -Zi -Od $(DEBUGFLAGS)

 

-# If building the tcl core then we need additional package versions

-!if "$(PROJECT)" == "tcl"

-!if [echo PKG_HTTP_VER = \>> versions.vc] \

-   && [nmakehlp -V ..\library\http\pkgIndex.tcl http >> versions.vc]

-!endif

-!if [echo PKG_TCLTEST_VER = \>> versions.vc] \

-   && [nmakehlp -V ..\library\tcltest\pkgIndex.tcl tcltest >> versions.vc]

-!endif

-!if [echo PKG_MSGCAT_VER = \>> versions.vc] \

-   && [nmakehlp -V ..\library\msgcat\pkgIndex.tcl msgcat >> versions.vc]

-!endif

-!if [echo PKG_PLATFORM_VER = \>> versions.vc] \

-   && [nmakehlp -V ..\library\platform\pkgIndex.tcl "platform " >> versions.vc]

-!endif

-!if [echo PKG_SHELL_VER = \>> versions.vc] \

-   && [nmakehlp -V ..\library\platform\pkgIndex.tcl "platform::shell" >> versions.vc]

-!endif

-!if [echo PKG_DDE_VER = \>> versions.vc] \

-   && [nmakehlp -V ..\library\dde\pkgIndex.tcl "dde " >> versions.vc]

+!else

+

+cdebug = $(OPTIMIZATIONS)

+!if $(SYMBOLS)

+cdebug = $(cdebug) -Zi

 !endif

-!if [echo PKG_REG_VER =\>> versions.vc] \

-   && [nmakehlp -V ..\library\reg\pkgIndex.tcl registry >> versions.vc]

+

+!endif # $(DEBUG)

+

+# cwarn includes default warning levels.

+cwarn = $(WARNINGS)

+

+!if "$(MACHINE)" == "AMD64"

+# Disable pointer<->int warnings related to cast between different sizes

+# There are a gadzillion of these due to use of ClientData and

+# clutter up compiler

+# output increasing chance of a real warning getting lost. So disable them.

+# Eventually some day, Tcl will be 64-bit clean.

+cwarn = $(cwarn) -wd4311 -wd4312

 !endif

+

+!if $(DEBUG)

+# Turn warnings into errors

+cwarn = $(cwarn) -WX

 !endif

 

-!include versions.vc

+# These flags are defined roughly in the order of the pre-reform

+# rules.vc/makefile.vc to help visually compare that the pre- and

+# post-reform build logs

 

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

-# Setup tcl version dependent stuff headers

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

+# cflags contains generic flags used for building practically all object files

+cflags = -nologo -c $(COMPILERFLAGS) $(cwarn) -Fp$(TMP_DIR)^\ $(cdebug)

 

-!if "$(PROJECT)" != "tcl"

+# appcflags contains $(cflags) and flags for building the application

+# object files (e.g. tclsh, or wish) pkgcflags contains $(cflags) plus

+# flags used for building shared object files The two differ in the

+# BUILD_$(PROJECT) macro which should be defined only for the shared

+# library *implementation* and not for its caller interface

 

-TCL_VERSION	= $(TCL_MAJOR_VERSION)$(TCL_MINOR_VERSION)

+appcflags = $(cflags) $(crt) $(TCL_INCLUDES) $(TK_INCLUDES) $(PRJ_INCLUDES) $(TCL_DEFINES) $(PRJ_DEFINES) $(OPTDEFINES) $(USE_STUBS_DEFS)

+appcflags_nostubs = $(cflags) $(crt) $(TCL_INCLUDES) $(TK_INCLUDES) $(PRJ_INCLUDES) $(TCL_DEFINES) $(PRJ_DEFINES) $(OPTDEFINES)

+pkgcflags = $(appcflags) /DBUILD_$(PROJECT)

+pkgcflags_nostubs = $(appcflags_nostubs) /DBUILD_$(PROJECT)

 

-!if $(TCLINSTALL)

-TCLSH		= "$(_TCLDIR)\bin\tclsh$(TCL_VERSION)$(SUFX).exe"

-!if !exist($(TCLSH))

-TCLSH           = "$(_TCLDIR)\bin\tclsh$(TCL_VERSION)$(SUFX:x=).exe"

-!endif

-TCLSTUBLIB	= "$(_TCLDIR)\lib\tclstub$(TCL_VERSION).lib"

-TCLIMPLIB	= "$(_TCLDIR)\lib\tcl$(TCL_VERSION)$(SUFX).lib"

-!if !exist($(TCLIMPLIB))

-TCLIMPLIB	= "$(_TCLDIR)\lib\tcl$(TCL_VERSION)$(SUFX:x=).lib"

-!endif

-TCL_LIBRARY	= $(_TCLDIR)\lib

-TCLREGLIB	= "$(_TCLDIR)\lib\tclreg13$(SUFX:t=).lib"

-TCLDDELIB	= "$(_TCLDIR)\lib\tcldde14$(SUFX:t=).lib"

-TCLTOOLSDIR	= \must\have\tcl\sources\to\build\this\target

-TCL_INCLUDES    = -I"$(_TCLDIR)\include"

+# stubscflags contains $(cflags) plus flags used for building a stubs

+# library for the package.  Note: -DSTATIC_BUILD is defined in

+# $(OPTDEFINES) only if the OPTS configuration indicates a static

+# library. However the stubs library is ALWAYS static hence included

+# here irrespective of the OPTS setting.

+

+stubscflags = $(cflags) $(PRJ_DEFINES) $(OPTDEFINES) -Zl -DSTATIC_BUILD $(TCL_INCLUDES) $(TK_INCLUDES) $(PRJ_INCLUDES)

+

+# Link flags 

+

+!if $(DEBUG)

+ldebug	= -debug -debugtype:cv

 !else

-TCLSH		= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tclsh$(TCL_VERSION)$(SUFX).exe"

-!if !exist($(TCLSH))

-TCLSH		= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tclsh$(TCL_VERSION)$(SUFX:x=).exe"

+ldebug	= -release -opt:ref -opt:icf,3

+!if $(SYMBOLS)

+ldebug	= $(ldebug) -debug -debugtype:cv

 !endif

-TCLSTUBLIB	= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tclstub$(TCL_VERSION).lib"

-TCLIMPLIB	= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tcl$(TCL_VERSION)$(SUFX).lib"

-!if !exist($(TCLIMPLIB))

-TCLIMPLIB	= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tcl$(TCL_VERSION)$(SUFX:x=).lib"

-!endif

-TCL_LIBRARY	= $(_TCLDIR)\library

-TCLREGLIB	= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tclreg13$(SUFX:t=).lib"

-TCLDDELIB	= "$(_TCLDIR)\win\$(BUILDDIRTOP)\tcldde14$(SUFX:t=).lib"

-TCLTOOLSDIR	= $(_TCLDIR)\tools

-TCL_INCLUDES	= -I"$(_TCLDIR)\generic" -I"$(_TCLDIR)\win"

 !endif

 

+# Note: Profiling is currently only possible with the Visual Studio Enterprise

+!if $(PROFILE)

+ldebug= $(ldebug) -profile

 !endif

 

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

-# Locate the Tk headers to build against

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

+### Declarations common to all linker versions 

+lflags	= -nologo -machine:$(MACHINE) $(LINKERFLAGS) $(ldebug)

 

-!if "$(PROJECT)" == "tk"

-_TK_H          = ..\generic\tk.h

-_INSTALLDIR    = $(_INSTALLDIR)\..

+!if $(MSVCRT) && !($(DEBUG) && !$(UNCHECKED)) && $(VCVERSION) >= 1900

+lflags	= $(lflags) -nodefaultlib:libucrt.lib

 !endif

 

-!ifdef PROJECT_REQUIRES_TK

-!if !defined(TKDIR)

-!if exist("$(_INSTALLDIR)\..\include\tk.h")

-TKINSTALL      = 1

-_TKDIR         = $(_INSTALLDIR)\..

-_TK_H          = $(_TKDIR)\include\tk.h

-TKDIR          = $(_TKDIR)

-!elseif exist("$(_TCLDIR)\include\tk.h")

-TKINSTALL      = 1

-_TKDIR         = $(_TCLDIR)

-_TK_H          = $(_TKDIR)\include\tk.h

-TKDIR          = $(_TKDIR)

-!endif

-!else

-_TKDIR = $(TKDIR:/=\)

-!if exist("$(_TKDIR)\include\tk.h")

-TKINSTALL      = 1

-_TK_H          = $(_TKDIR)\include\tk.h

-!elseif exist("$(_TKDIR)\generic\tk.h")

-TKINSTALL      = 0

-_TK_H          = $(_TKDIR)\generic\tk.h

-!else

-MSG =^

-Failed to find tk.h. The TKDIR macro does not appear correct.

-!error $(MSG)

+# Old linkers (Visual C++ 6 in particular) will link for fast loading

+# on Win98. Since we do not support Win98 any more, we specify nowin98

+# as recommended for NT and later. However, this is only required by

+# IX86 on older compilers and only needed if we are not doing a static build.

+

+!if "$(MACHINE)" == "IX86" && !$(STATIC_BUILD)

+!if [nmakehlp -l -opt:nowin98 $(LINKER_TESTFLAGS)]

+# Align sections for PE size savings.

+lflags	= $(lflags) -opt:nowin98

 !endif

 !endif

+

+!if $(LOIMPACT)

+lflags	= $(lflags) -ws:aggressive

 !endif

 

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

-# Extract Tk version numbers

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

+dlllflags = $(lflags) -dll

+conlflags = $(lflags) -subsystem:console

+guilflags = $(lflags) -subsystem:windows

 

-!if defined(PROJECT_REQUIRES_TK) || "$(PROJECT)" == "tk"

+# Libraries that are required for every image.

+# Extensions should define any additional libraries with $(PRJ_LIBS)

+winlibs   = kernel32.lib advapi32.lib

 

-!if [echo TK_MAJOR_VERSION = \>> versions.vc] \

-   && [nmakehlp -V $(_TK_H) TK_MAJOR_VERSION >> versions.vc]

+# Avoid 'unresolved external symbol __security_cookie' errors.

+# c.f. http://support.microsoft.com/?id=894573

+!if "$(MACHINE)" == "AMD64"

+!if $(VCVERSION) > 1399 && $(VCVERSION) < 1500

+winlibs   = $(winlibs) bufferoverflowU.lib

 !endif

-!if [echo TK_MINOR_VERSION = \>> versions.vc] \

-   && [nmakehlp -V $(_TK_H) TK_MINOR_VERSION >> versions.vc]

 !endif

-!if [echo TK_PATCH_LEVEL = \>> versions.vc] \

-   && [nmakehlp -V $(_TK_H) TK_PATCH_LEVEL >> versions.vc]

+

+baselibs = $(winlibs) $(PRJ_LIBS)

+

+!if $(MSVCRT) && !($(DEBUG) && !$(UNCHECKED)) && $(VCVERSION) >= 1900

+baselibs   = $(baselibs) ucrt.lib

 !endif

 

-!include versions.vc

+################################################################

+# 3. Define common make targets and implicit rules

 

-TK_DOTVERSION	= $(TK_MAJOR_VERSION).$(TK_MINOR_VERSION)

-TK_VERSION	= $(TK_MAJOR_VERSION)$(TK_MINOR_VERSION)

+!ifndef DEFAULT_BUILD_TARGET

+DEFAULT_BUILD_TARGET = all

+!endif

+

+default_target: $(DEFAULT_BUILD_TARGET)

+

+clean:

+	@echo Cleaning $(TMP_DIR)\* ...

+	@if exist $(TMP_DIR)\nul $(RMDIR) $(TMP_DIR)

+	@echo Cleaning $(WINDIR)\nmakehlp.obj, nmakehlp.exe ...

+	@if exist $(WINDIR)\nmakehlp.obj del $(WINDIR)\nmakehlp.obj

+	@if exist $(WINDIR)\nmakehlp.exe del $(WINDIR)\nmakehlp.exe

+	@echo Cleaning $(WINDIR)\_junk.pch ...

+	@if exist $(WINDIR)\_junk.pch del $(WINDIR)\_junk.pch

+	@echo Cleaning $(WINDIR)\vercl.x, vercl.i ...

+	@if exist $(WINDIR)\vercl.x del $(WINDIR)\vercl.x

+	@if exist $(WINDIR)\vercl.i del $(WINDIR)\vercl.i

+	@echo Cleaning $(WINDIR)\versions.vc, version.vc ...

+	@if exist $(WINDIR)\versions.vc del $(WINDIR)\versions.vc

+	@if exist $(WINDIR)\version.vc del $(WINDIR)\version.vc

+

+realclean: hose

+

+hose:

+	@echo Hosing $(OUT_DIR)\* ...

+	@if exist $(OUT_DIR)\nul $(RMDIR) $(OUT_DIR)

+

+# Implicit rule definitions - only for building library objects. For stubs and main

+# application, the master makefile should define explicit rules.

 

-!if "$(PROJECT)" != "tk"

-!if $(TKINSTALL)

-WISH		= "$(_TKDIR)\bin\wish$(TK_VERSION)$(SUFX).exe"

-!if !exist($(WISH))

-WISH		= "$(_TKDIR)\bin\wish$(TK_VERSION)$(SUFX:x=).exe"

+{$(WINDIR)}.c{$(TMP_DIR)}.obj::

+	$(cc32) $(pkgcflags) -Fo$(TMP_DIR)\ @<<

+$<

+<<

+

+{$(GENERICDIR)}.c{$(TMP_DIR)}.obj::

+	$(cc32) $(pkgcflags) -Fo$(TMP_DIR)\ @<<

+$<

+<<

+

+{$(COMPATDIR)}.c{$(TMP_DIR)}.obj::

+	$(cc32) $(pkgcflags) -Fo$(TMP_DIR)\ @<<

+$<

+<<

+

+.SUFFIXES:

+.SUFFIXES:.c .rc

+

+MAKELIBCMD = $(lib32) -nologo $(LINKERFLAGS) -out:$@

+MAKEDLLCMD = $(link32) $(dlllflags) -out:$@ $(baselibs)

+MAKECONCMD = $(link32) $(conlflags) -out:$@ $(baselibs)

+MAKEGUICMD = $(link32) $(guilflags) -out:$@ $(baselibs)

+

+################################################################

+# 14. Sanity check selected options against Tcl build options

+# When building an extension, certain configuration options should

+# match the ones used when Tcl was built. Here we check and

+# warn on a mismatch.

+!if "$(PROJECT)" != "tcl"

+

+!if $(TCLINSTALL) # Building against an installed Tcl

+!if exist("$(_TCLDIR)\lib\nmake\tcl.nmake")

+TCLNMAKECONFIG = "$(_TCLDIR)\lib\nmake\tcl.nmake"

 !endif

-TKSTUBLIB	= "$(_TKDIR)\lib\tkstub$(TK_VERSION).lib"

-TKIMPLIB	= "$(_TKDIR)\lib\tk$(TK_VERSION)$(SUFX).lib"

-!if !exist($(TKIMPLIB))

-TKIMPLIB	= "$(_TKDIR)\win\$(BUILDDIRTOP)\tk$(TCL_VERSION)$(SUFX:x=).lib"

+!else # ! $(TCLINSTALL) - building against Tcl source

+!if exist("$(OUT_DIR)\tcl.nmake")

+TCLNMAKECONFIG = "$(OUT_DIR)\tcl.nmake"

 !endif

-TK_INCLUDES     = -I"$(_TKDIR)\include"

-!else

-WISH		= "$(_TKDIR)\win\$(BUILDDIRTOP)\wish$(TCL_VERSION)$(SUFX).exe"

-!if !exist($(WISH))

-WISH		= "$(_TKDIR)\win\$(BUILDDIRTOP)\wish$(TCL_VERSION)$(SUFX:x=).exe"

+!endif # TCLINSTALL

+

+!if $(CONFIG_CHECK)

+!ifdef TCLNMAKECONFIG

+!include $(TCLMAKECONFIG)

+

+!if defined(CORE_MACHINE) && $(CORE_MACHINE) != $(MACHINE)

+!error ERROR: Build target ($(MACHINE)) does not match the Tcl library architecture ($(CORE_MACHINE)).

 !endif

-TKSTUBLIB	= "$(_TKDIR)\win\$(BUILDDIRTOP)\tkstub$(TCL_VERSION).lib"

-TKIMPLIB	= "$(_TKDIR)\win\$(BUILDDIRTOP)\tk$(TCL_VERSION)$(SUFX).lib"

-!if !exist($(TKIMPLIB))

-TKIMPLIB	= "$(_TKDIR)\win\$(BUILDDIRTOP)\tk$(TCL_VERSION)$(SUFX:x=).lib"

+!if defined(CORE_USE_THREAD_ALLOC) && $(CORE_USE_THREAD_ALLOC) != $(USE_THREAD_ALLOC)

+!message WARNING: Value of USE_THREAD_ALLOC ($(USE_THREAD_ALLOC)) does not match its Tcl core value ($(CORE_USE_THREAD_ALLOC)).

 !endif

-TK_INCLUDES     = -I"$(_TKDIR)\generic" -I"$(_TKDIR)\win" -I"$(_TKDIR)\xlib"

+!if defined(CORE_DEBUG) && $(CORE_DEBUG) != $(DEBUG)

+!message WARNING: Value of DEBUG ($(DEBUG)) does not match its Tcl library configuration ($(DEBUG)).

 !endif

 !endif

 

-!endif

+!endif # TCLNMAKECONFIG

+

+!endif # $(PROJECT) ==  "tcl"

+

 

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

 # Display stats being used.

@@ -699,7 +1304,5 @@ TK_INCLUDES     = -I"$(_TKDIR)\generic" -I"$(_TKDIR)\win" -I"$(_TKDIR)\xlib"
 !message *** Optional defines are '$(OPTDEFINES)'

 !message *** Compiler version $(VCVER). Target machine is $(MACHINE)

 !message *** Host architecture is $(NATIVE_ARCH)

-!message *** Compiler options '$(COMPILERFLAGS) $(OPTIMIZATIONS) $(DEBUGFLAGS) $(WARNINGS)'

-!message *** Link options '$(LINKERFLAGS)'

 

-!endif

+!endif # ifdef _RULES_VC