kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'remove-vs6-generator' 

b42866a3 Drop Visual Studio 6 generator
cd9ba3ec cmLocalVisualStudio7Generator: Fix name of helper function
This commit is contained in:
Brad King 2016-03-10 09:16:23 -05:00 committed by CMake Topic Stage
parent 030ec94780 b42866a34a
commit 1ed74b9d22
78 changed files with 67 additions and 4224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitattributes vendored
View File

@ -10,7 +10,6 @@ configure crlf=input
*.bat -crlf
*.bat.in -crlf
*.dsp -crlf
*.dsptemplate -crlf
*.dsw -crlf
*.pfx -crlf
*.png -crlf

2
Help/command/build_command.rst
View File

@ -35,7 +35,7 @@ compatibility. Use the first signature instead.
It sets the given ``<cachevariable>`` to a command-line string as
above but without the ``--target`` option.
The ``<makecommand>`` is ignored but should be the full path to
msdev, devenv, nmake, make or one of the end user build tools
devenv, nmake, make or one of the end user build tools
for legacy invocations.
.. note::

3
Help/command/include_external_msproject.rst
View File

@ -19,5 +19,4 @@ command to make things depend on the external project.
``TYPE``, ``GUID`` and ``PLATFORM`` are optional parameters that allow one to
specify the type of project, id (GUID) of the project and the name of
the target platform. This is useful for projects requiring values
other than the default (e.g. WIX projects). These options are not
supported by the Visual Studio 6 generator.
other than the default (e.g. WIX projects).

10
Help/generator/Visual Studio 6.rst
View File

@ -1,10 +1,6 @@
Visual Studio 6
---------------
Deprected. Generates Visual Studio 6 project files.
.. note::
This generator is deprecated and will be removed
in a future version of CMake. It will still be
possible to build with VS 6 tools using the
:generator:`NMake Makefiles` generator.
Removed. This once generated Visual Studio 6 project files, but the
generator has been removed since CMake 3.6. It is still possible to
build with VS 6 tools using the :generator:`NMake Makefiles` generator.

1
Help/manual/cmake-variables.7.rst
View File

@ -78,7 +78,6 @@ Variables that Provide Information
/variable/CMAKE_VS_DEVENV_COMMAND
/variable/CMAKE_VS_INTEL_Fortran_PROJECT_VERSION
/variable/CMAKE_VS_MSBUILD_COMMAND
/variable/CMAKE_VS_MSDEV_COMMAND
/variable/CMAKE_VS_NsightTegra_VERSION
/variable/CMAKE_VS_PLATFORM_NAME
/variable/CMAKE_VS_PLATFORM_TOOLSET

3
Help/prop_dir/COMPILE_DEFINITIONS.rst
View File

@ -17,8 +17,7 @@ This property will be initialized in each directory by its value in the
directory's parent.
CMake will automatically drop some definitions that are not supported
by the native build tool. The VS6 IDE does not support definition
values with spaces (but NMake does).
by the native build tool.
.. include:: /include/COMPILE_DEFINITIONS_DISCLAIMER.txt

5
Help/prop_sf/COMPILE_DEFINITIONS.rst
View File

@ -13,8 +13,7 @@ the name COMPILE_DEFINITIONS_<CONFIG> where <CONFIG> is an upper-case
name (ex. "COMPILE_DEFINITIONS_DEBUG").
CMake will automatically drop some definitions that are not supported
by the native build tool. The VS6 IDE does not support definition
values with spaces (but NMake does). Xcode does not support
per-configuration definitions on source files.
by the native build tool. Xcode does not support per-configuration
definitions on source files.
.. include:: /include/COMPILE_DEFINITIONS_DISCLAIMER.txt

3
Help/prop_tgt/COMPILE_DEFINITIONS.rst
View File

@ -11,8 +11,7 @@ automatically escape the value correctly for the native build system
values).
CMake will automatically drop some definitions that are not supported
by the native build tool. The VS6 IDE does not support definition
values with spaces (but NMake does).
by the native build tool.
.. include:: /include/COMPILE_DEFINITIONS_DISCLAIMER.txt

3
Help/prop_tgt/COMPILE_PDB_NOTE.txt
View File

@ -3,6 +3,3 @@
``/Fd`` compiler flag and are not the same as linker-generated
program database files specified by the ``/pdb`` linker flag.
Use the |PDB_XXX| property to specify the latter.
This property is not implemented by the :generator:`Visual Studio 6`
generator.

3
Help/prop_tgt/PDB_NOTE.txt
View File

@ -7,6 +7,3 @@
``/pdb`` linker flag and are not the same as compiler-generated
program database files specified by the ``/Fd`` compiler flag.
Use the |COMPILE_PDB_XXX| property to specify the latter.
This property is not implemented by the :generator:`Visual Studio 6`
generator.

4
Help/release/dev/remove-vs6-generator.rst Normal file
View File

@ -0,0 +1,4 @@
remove-vs6-generator
--------------------
* The :generator:`Visual Studio 6` generator has been removed.

1
Help/variable/CMAKE_CFG_INTDIR.rst
View File

@ -12,7 +12,6 @@ Example values:
::
$(IntDir) = Visual Studio 6
$(ConfigurationName) = Visual Studio 7, 8, 9
$(Configuration) = Visual Studio 10
$(CONFIGURATION) = Xcode

2
Help/variable/CMAKE_GENERATOR.rst
View File

@ -4,4 +4,4 @@ CMAKE_GENERATOR
The generator used to build the project. See :manual:`cmake-generators(7)`.
The name of the generator that is being used to generate the build
files. (e.g. ``Unix Makefiles``, ``Visual Studio 6``, etc.)
files. (e.g. ``Unix Makefiles``, ``Ninja``, etc.)

9
Help/variable/CMAKE_MAKE_PROGRAM.rst
View File

@ -34,12 +34,11 @@ to configure the project:
the CMake cache then CMake will use the specified value.
* The :ref:`Visual Studio Generators` set this to the full path to
``MSBuild.exe`` (VS >= 10), ``devenv.com`` (VS 7,8,9),
``VCExpress.exe`` (VS Express 8,9), or ``msdev.exe`` (VS 6).
``MSBuild.exe`` (VS >= 10), ``devenv.com`` (VS 7,8,9), or
``VCExpress.exe`` (VS Express 8,9).
(See also variables
:variable:`CMAKE_VS_MSBUILD_COMMAND`,
:variable:`CMAKE_VS_DEVENV_COMMAND`, and
:variable:`CMAKE_VS_MSDEV_COMMAND`.)
:variable:`CMAKE_VS_MSBUILD_COMMAND` and
:variable:`CMAKE_VS_DEVENV_COMMAND`.
These generators prefer to lookup the build tool at build time
rather than to store ``CMAKE_MAKE_PROGRAM`` in the CMake cache

2
Help/variable/CMAKE_MFC_FLAG.rst
View File

@ -5,7 +5,7 @@ Tell cmake to use MFC for an executable or dll.
This can be set in a ``CMakeLists.txt`` file and will enable MFC in the
application. It should be set to ``1`` for the static MFC library, and ``2``
for the shared MFC library. This is used in Visual Studio 6 and 7
for the shared MFC library. This is used in Visual Studio 7
project files. The CMakeSetup dialog used MFC and the ``CMakeLists.txt``
looks like this:

10
Help/variable/CMAKE_VS_MSDEV_COMMAND.rst
View File

@ -1,10 +0,0 @@
CMAKE_VS_MSDEV_COMMAND
----------------------
The :generator:`Visual Studio 6` generator sets this variable to the
``msdev.exe`` command installed with Visual Studio 6.
This variable is not defined by other generators even if ``msdev.exe``
is installed on the computer.
See also the :variable:`CMAKE_MAKE_PROGRAM` variable.

4
Modules/CMakeBackwardCompatibilityC.cmake
View File

@ -17,10 +17,6 @@ if(CMAKE_GENERATOR MATCHES "Visual Studio 7")
include(CMakeVS7BackwardCompatibility)
set(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
endif()
if(CMAKE_GENERATOR MATCHES "Visual Studio 6")
include(CMakeVS6BackwardCompatibility)
set(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
endif()
if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
# Old CMake versions did not support OS X universal binaries anyway,

13
Modules/CMakeDetermineCompilerId.cmake
View File

@ -149,11 +149,7 @@ Id flags: ${testflags}
")
# Compile the compiler identification source.
if(CMAKE_GENERATOR STREQUAL "Visual Studio 6" AND
lang STREQUAL "Fortran")
set(CMAKE_${lang}_COMPILER_ID_RESULT 1)
set(CMAKE_${lang}_COMPILER_ID_OUTPUT "No Intel Fortran in VS 6")
elseif("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([0-9]+)")
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([0-9]+)")
set(vs_version ${CMAKE_MATCH_1})
set(id_platform ${CMAKE_VS_PLATFORM_NAME})
set(id_lang "${lang}")
@ -179,13 +175,10 @@ Id flags: ${testflags}
elseif(NOT "${vs_version}" VERSION_LESS 10)
set(v 10)
set(ext vcxproj)
elseif(NOT "${vs_version}" VERSION_LESS 7)
else()
set(id_version ${vs_version}.00)
set(v 7)
set(ext vcproj)
else()
set(v 6)
set(ext dsp)
endif()
if(CMAKE_VS_PLATFORM_TOOLSET)
if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android")
@ -239,8 +232,6 @@ Id flags: ${testflags}
)
elseif(CMAKE_VS_DEVENV_COMMAND)
set(command "${CMAKE_VS_DEVENV_COMMAND}" "CompilerId${lang}.${ext}" "/build" "Debug")
elseif(CMAKE_VS_MSDEV_COMMAND)
set(command "${CMAKE_VS_MSDEV_COMMAND}" "CompilerId${lang}.${ext}" "/make")
else()
set(command "")
endif()

26
Modules/CMakeVS6BackwardCompatibility.cmake
View File

@ -1,26 +0,0 @@
#=============================================================================
# Copyright 2002-2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
# hard code these for fast backwards compatibility tests
set (CMAKE_SIZEOF_INT 4 CACHE INTERNAL "Size of int data type")
set (CMAKE_SIZEOF_LONG 4 CACHE INTERNAL "Size of long data type")
set (CMAKE_SIZEOF_VOID_P 4 CACHE INTERNAL "Size of void* data type")
set (CMAKE_SIZEOF_CHAR 1 CACHE INTERNAL "Size of char data type")
set (CMAKE_SIZEOF_SHORT 2 CACHE INTERNAL "Size of short data type")
set (CMAKE_SIZEOF_FLOAT 4 CACHE INTERNAL "Size of float data type")
set (CMAKE_SIZEOF_DOUBLE 8 CACHE INTERNAL "Size of double data type")
set (CMAKE_NO_ANSI_FOR_SCOPE 1 CACHE INTERNAL
"Does the compiler support ansi for scope.")
set (CMAKE_USE_WIN32_THREADS TRUE CACHE BOOL "Use the win32 thread library.")
set (CMAKE_WORDS_BIGENDIAN 0 CACHE INTERNAL "endianness of bytes")

3
Modules/CTest.cmake
View File

@ -230,9 +230,6 @@ if(BUILD_TESTING)
get_filename_component(DART_CXX_NAME
"${CMAKE_MAKE_PROGRAM}" ${DART_NAME_COMPONENT})
endif()
if(DART_CXX_NAME MATCHES "msdev")
set(DART_CXX_NAME "vs60")
endif()
if(DART_CXX_NAME MATCHES "devenv")
GET_VS_VERSION_STRING("${CMAKE_GENERATOR}" DART_CXX_NAME)
endif()

48
Modules/CompilerId/VS-6.dsp.in
View File

@ -1,48 +0,0 @@
# Microsoft Developer Studio Project File - Name="CompilerId@id_lang@" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# TARGTYPE "Win32 (x86) Application" 0x0101
CFG=CompilerId@id_lang@ - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "CompilerId@id_lang@.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "CompilerId@id_lang@.mak" CFG="CompilerId@id_lang@ - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "CompilerId@id_lang@ - Win32 Debug" (based on "Win32 (x86) Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
CPP=cl.exe
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "."
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD CPP /nologo /MDd /c
LINK32=link.exe
# ADD LINK32 /nologo /version:0.0 /subsystem:console /machine:x86 /out:"CompilerId@id_lang@.exe" /IGNORE:4089
# Begin Special Build Tool
SOURCE="$(InputPath)"
PostBuild_Cmds=for %%i in (@id_cl@) do @echo CMAKE_@id_lang@_COMPILER=%%~$PATH:i
# End Special Build Tool
# Begin Target
# Name "CompilerId@id_lang@ - Win32 Debug"
# Begin Group "Source Files"
# Begin Source File
SOURCE="@id_src@"
# End Source File
# End Group
# End Target
# End Project

4
Modules/Platform/Windows-MSVC.cmake
View File

@ -47,10 +47,6 @@ else()
endif()
set(CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS 1)
if(CMAKE_GENERATOR MATCHES "Visual Studio 6")
set (CMAKE_NO_BUILD_TYPE 1)
set(CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS 0) # not implemented for VS6
endif()
if(NOT CMAKE_NO_BUILD_TYPE AND CMAKE_GENERATOR MATCHES "Visual Studio")
set (CMAKE_NO_BUILD_TYPE 1)
endif()

3
Modules/Platform/Windows-df.cmake
View File

@ -30,9 +30,6 @@ set(CMAKE_Fortran_LINK_EXECUTABLE
set(CMAKE_CREATE_WIN32_EXE /winapp)
set(CMAKE_CREATE_CONSOLE_EXE )
if(CMAKE_GENERATOR MATCHES "Visual Studio 6")
set (CMAKE_NO_BUILD_TYPE 1)
endif()
if(CMAKE_GENERATOR MATCHES "Visual Studio 7" OR CMAKE_GENERATOR MATCHES "Visual Studio 8")
set (CMAKE_NO_BUILD_TYPE 1)
endif()

4
Source/CMakeLists.txt
View File

@ -452,8 +452,6 @@ if (WIN32)
cmGlobalNMakeMakefileGenerator.h
cmGlobalJOMMakefileGenerator.cxx
cmGlobalJOMMakefileGenerator.h
cmGlobalVisualStudio6Generator.cxx
cmGlobalVisualStudio6Generator.h
cmGlobalVisualStudio71Generator.cxx
cmGlobalVisualStudio71Generator.h
cmGlobalVisualStudio7Generator.cxx
@ -481,8 +479,6 @@ if (WIN32)
cmIDEFlagTable.h
cmIDEOptions.cxx
cmIDEOptions.h
cmLocalVisualStudio6Generator.cxx
cmLocalVisualStudio6Generator.h
cmLocalVisualStudio7Generator.cxx
cmLocalVisualStudio7Generator.h
cmLocalVisualStudioGenerator.cxx

5
Source/cmGlobalGenerator.h
View File

@ -241,11 +241,6 @@ public:
*/
virtual void FindMakeProgram(cmMakefile*);
#if defined(_WIN32) && !defined(__CYGWIN__)
/** Is this the Visual Studio 6 generator? */
bool IsForVS6() const { return this->GetName() == "Visual Studio 6"; }
#endif
///! Find a target by name by searching the local generators.
cmTarget* FindTarget(const std::string& name,
bool excludeAliases = false) const;

1
Source/cmGlobalNinjaGenerator.cxx
View File

@ -642,7 +642,6 @@ void cmGlobalNinjaGenerator
// cmGlobalUnixMakefileGenerator3
// cmGlobalGhsMultiGenerator
// cmGlobalVisualStudio10Generator
// cmGlobalVisualStudio6Generator
// cmGlobalVisualStudio7Generator
// cmGlobalXCodeGenerator
// Called by:

451
Source/cmGlobalVisualStudio6Generator.cxx
View File

@ -1,451 +0,0 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmGlobalVisualStudio6Generator.h"
#include "cmLocalVisualStudio6Generator.h"
#include "cmMakefile.h"
#include "cmake.h"
#include "cmGeneratedFileStream.h"
#include <cmsys/FStream.hxx>
// Utility function to make a valid VS6 *.dsp filename out
// of a CMake target name:
//
std::string GetVS6TargetName(const std::string& targetName)
{
std::string name(targetName);
// Eliminate hyphens. VS6 cannot handle hyphens in *.dsp filenames...
// Replace them with underscores.
//
cmSystemTools::ReplaceString(name, "-", "_");
return name;
}
cmGlobalVisualStudio6Generator::cmGlobalVisualStudio6Generator(cmake* cm)
: cmGlobalVisualStudioGenerator(cm)
{
this->MSDevCommandInitialized = false;
this->Version = VS6;
}
void cmGlobalVisualStudio6Generator
::EnableLanguage(std::vector<std::string>const& lang,
cmMakefile *mf,
bool optional)
{
mf->AddDefinition("CMAKE_GENERATOR_RC", "rc");
mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
this->GenerateConfigurations(mf);
this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
}
void cmGlobalVisualStudio6Generator::GenerateConfigurations(cmMakefile* mf)
{
std::string fname= mf->GetRequiredDefinition("CMAKE_ROOT");
const char* def= mf->GetDefinition( "MSPROJECT_TEMPLATE_DIRECTORY");
if(def)
{
fname = def;
}
else
{
fname += "/Templates";
}
fname += "/CMakeVisualStudio6Configurations.cmake";
if(!mf->ReadDependentFile(fname.c_str()))
{
cmSystemTools::Error("Cannot open ", fname.c_str(),
". Please copy this file from the main "
"CMake/Templates directory and edit it for "
"your build configurations.");
}
else if(!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
{
cmSystemTools::Error("CMAKE_CONFIGURATION_TYPES not set by ",
fname.c_str(),
". Please copy this file from the main "
"CMake/Templates directory and edit it for "
"your build configurations.");
}
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudio6Generator::FindMakeProgram(cmMakefile* mf)
{
this->cmGlobalVisualStudioGenerator::FindMakeProgram(mf);
mf->AddDefinition("CMAKE_VS_MSDEV_COMMAND",
this->GetMSDevCommand().c_str());
}
//----------------------------------------------------------------------------
std::string const& cmGlobalVisualStudio6Generator::GetMSDevCommand()
{
if(!this->MSDevCommandInitialized)
{
this->MSDevCommandInitialized = true;
this->MSDevCommand = this->FindMSDevCommand();
}
return this->MSDevCommand;
}
//----------------------------------------------------------------------------
std::string cmGlobalVisualStudio6Generator::FindMSDevCommand()
{
std::string vscmd;
std::string vskey = this->GetRegistryBase() + "\\Setup;VsCommonDir";
if(cmSystemTools::ReadRegistryValue(vskey.c_str(), vscmd,
cmSystemTools::KeyWOW64_32))
{
cmSystemTools::ConvertToUnixSlashes(vscmd);
vscmd += "/MSDev98/Bin/";
}
vscmd += "msdev.exe";
return vscmd;
}
//----------------------------------------------------------------------------
void
cmGlobalVisualStudio6Generator::GenerateBuildCommand(
std::vector<std::string>& makeCommand,
const std::string& makeProgram,
const std::string& projectName,
const std::string& /*projectDir*/,
const std::string& targetName,
const std::string& config,
bool /*fast*/, bool /*verbose*/,
std::vector<std::string> const& makeOptions
)
{
// now build the test
makeCommand.push_back(
this->SelectMakeProgram(makeProgram, this->GetMSDevCommand())
);
makeCommand.push_back(std::string(projectName)+".dsw");
makeCommand.push_back("/MAKE");
std::string targetArg;
bool clean = false;
std::string realTarget = targetName;
if ( realTarget == "clean" )
{
clean = true;
realTarget = "ALL_BUILD";
}
if (!realTarget.empty())
{
targetArg += realTarget;
}
else
{
targetArg += "ALL_BUILD";
}
targetArg += " - ";
if(!config.empty())
{
targetArg += config;
}
else
{
targetArg += "Debug";
}
makeCommand.push_back(targetArg);
if(clean)
{
makeCommand.push_back("/CLEAN");
}
else
{
makeCommand.push_back("/BUILD");
}
makeCommand.insert(makeCommand.end(),
makeOptions.begin(), makeOptions.end());
}
///! Create a local generator appropriate to this Global Generator
cmLocalGenerator *
cmGlobalVisualStudio6Generator::CreateLocalGenerator(cmMakefile* mf)
{
return new cmLocalVisualStudio6Generator(this, mf);
}
void cmGlobalVisualStudio6Generator::Generate()
{
// first do the superclass method
this->cmGlobalVisualStudioGenerator::Generate();
// Now write out the DSW
this->OutputDSWFile();
if (!this->CMakeInstance->GetIsInTryCompile())
{
const char* cmakeWarnVS6 =
this->CMakeInstance->GetState()->GetCacheEntryValue("CMAKE_WARN_VS6");
if (!cmakeWarnVS6 || !cmSystemTools::IsOff(cmakeWarnVS6))
{
this->CMakeInstance->IssueMessage(
cmake::WARNING,
"The \"Visual Studio 6\" generator is deprecated "
"and will be removed in a future version of CMake."
"\n"
"Add CMAKE_WARN_VS6=OFF to the cache to disable this warning."
);
}
}
}
// Write a DSW file to the stream
void cmGlobalVisualStudio6Generator
::WriteDSWFile(std::ostream& fout,cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators)
{
// Write out the header for a DSW file
this->WriteDSWHeader(fout);
// Collect all targets under this root generator and the transitive
// closure of their dependencies.
TargetDependSet projectTargets;
TargetDependSet originalTargets;
this->GetTargetSets(projectTargets, originalTargets, root, generators);
OrderedTargetDependSet orderedProjectTargets(projectTargets, "ALL_BUILD");
for(OrderedTargetDependSet::const_iterator
tt = orderedProjectTargets.begin();
tt != orderedProjectTargets.end(); ++tt)
{
cmGeneratorTarget const* target = *tt;
if(target->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
// Write the project into the DSW file
const char* expath = target->GetProperty("EXTERNAL_MSPROJECT");
if(expath)
{
std::string project = target->GetName();
std::string location = expath;
this->WriteExternalProject(fout, project.c_str(),
location.c_str(), target->GetUtilities());
}
else
{
std::string dspname = GetVS6TargetName(target->GetName());
std::string dir =
target->GetLocalGenerator()->GetCurrentBinaryDirectory();
dir = root->Convert(dir.c_str(), cmLocalGenerator::START_OUTPUT);
this->WriteProject(fout, dspname.c_str(), dir.c_str(), target);
}
}
// Write the footer for the DSW file
this->WriteDSWFooter(fout);
}
void cmGlobalVisualStudio6Generator
::OutputDSWFile(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators)
{
if(generators.empty())
{
return;
}
std::string fname = root->GetMakefile()->GetCurrentBinaryDirectory();
fname += "/";
fname += root->GetProjectName();
fname += ".dsw";
cmsys::ofstream fout(fname.c_str());
if(!fout)
{
cmSystemTools::Error("Error can not open DSW file for write: ",
fname.c_str());
cmSystemTools::ReportLastSystemError("");
return;
}
this->WriteDSWFile(fout, root, generators);
}
// output the DSW file
void cmGlobalVisualStudio6Generator::OutputDSWFile()
{
std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
{
this->OutputDSWFile(it->second[0], it->second);
}
}
// Write a dsp file into the DSW file,
// Note, that dependencies from executables to
// the libraries it uses are also done here
void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
const std::string& dspname,
const char* dir,
const cmGeneratorTarget *target)
{
fout << "#########################################################"
"######################\n\n";
fout << "Project: \"" << dspname << "\"="
<< dir << "\\" << dspname << ".dsp - Package Owner=<4>\n\n";
fout << "Package=<5>\n{{{\n}}}\n\n";
fout << "Package=<4>\n";
fout << "{{{\n";
VSDependSet const& depends = this->VSTargetDepends[target];
for(VSDependSet::const_iterator di = depends.begin();
di != depends.end(); ++di)
{
const char* name = di->c_str();
fout << "Begin Project Dependency\n";
fout << "Project_Dep_Name " << GetVS6TargetName(name) << "\n";
fout << "End Project Dependency\n";
}
fout << "}}}\n\n";
UtilityDependsMap::iterator ui = this->UtilityDepends.find(target);
if(ui != this->UtilityDepends.end())
{
const char* uname = ui->second.c_str();
fout << "Project: \"" << uname << "\"="
<< dir << "\\" << uname << ".dsp - Package Owner=<4>\n\n";
fout <<
"Package=<5>\n{{{\n}}}\n\n"
"Package=<4>\n"
"{{{\n"
"Begin Project Dependency\n"
"Project_Dep_Name " << dspname << "\n"
"End Project Dependency\n"
"}}}\n\n";
;
}
}
// Write a dsp file into the DSW file,
// Note, that dependencies from executables to
// the libraries it uses are also done here
void cmGlobalVisualStudio6Generator::WriteExternalProject(std::ostream& fout,
const std::string& name,
const char* location,
const std::set<std::string>& dependencies)
{
fout << "#########################################################"
"######################\n\n";
fout << "Project: \"" << name << "\"="
<< location << " - Package Owner=<4>\n\n";
fout << "Package=<5>\n{{{\n}}}\n\n";
fout << "Package=<4>\n";
fout << "{{{\n";
std::set<std::string>::const_iterator i, end;
// write dependencies.
i = dependencies.begin();
end = dependencies.end();
for(;i!= end; ++i)
{
fout << "Begin Project Dependency\n";
fout << "Project_Dep_Name " << GetVS6TargetName(*i) << "\n";
fout << "End Project Dependency\n";
}
fout << "}}}\n\n";
}
// Standard end of dsw file
void cmGlobalVisualStudio6Generator::WriteDSWFooter(std::ostream& fout)
{
fout << "######################################################"
"#########################\n\n";
fout << "Global:\n\n";
fout << "Package=<5>\n{{{\n}}}\n\n";
fout << "Package=<3>\n{{{\n}}}\n\n";
fout << "#####################################################"
"##########################\n\n";
}
// ouput standard header for dsw file
void cmGlobalVisualStudio6Generator::WriteDSWHeader(std::ostream& fout)
{
fout << "Microsoft Developer Studio Workspace File, Format Version 6.00\n";
fout << "# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!\n\n";
}
//----------------------------------------------------------------------------
std::string
cmGlobalVisualStudio6Generator::WriteUtilityDepend(
const cmGeneratorTarget *target)
{
std::string pname = target->GetName();
pname += "_UTILITY";
pname = GetVS6TargetName(pname.c_str());
std::string fname =
target->GetLocalGenerator()->GetCurrentBinaryDirectory();
fname += "/";
fname += pname;
fname += ".dsp";
cmGeneratedFileStream fout(fname.c_str());
fout.SetCopyIfDifferent(true);
fout <<
"# Microsoft Developer Studio Project File - Name=\""
<< pname << "\" - Package Owner=<4>\n"
"# Microsoft Developer Studio Generated Build File, Format Version 6.00\n"
"# ** DO NOT EDIT **\n"
"\n"
"# TARGTYPE \"Win32 (x86) Generic Project\" 0x010a\n"
"\n"
"CFG=" << pname << " - Win32 Debug\n"
"!MESSAGE \"" << pname << " - Win32 Debug\""
" (based on \"Win32 (x86) Generic Project\")\n"
"!MESSAGE \"" << pname << " - Win32 Release\" "
"(based on \"Win32 (x86) Generic Project\")\n"
"!MESSAGE \"" << pname << " - Win32 MinSizeRel\" "
"(based on \"Win32 (x86) Generic Project\")\n"
"!MESSAGE \"" << pname << " - Win32 RelWithDebInfo\" "
"(based on \"Win32 (x86) Generic Project\")\n"
"\n"
"# Begin Project\n"
"# Begin Target\n"
"# Name \"" << pname << " - Win32 Debug\"\n"
"# Name \"" << pname << " - Win32 Release\"\n"
"# Name \"" << pname << " - Win32 MinSizeRel\"\n"
"# Name \"" << pname << " - Win32 RelWithDebInfo\"\n"
"# End Target\n"
"# End Project\n"
;
return pname;
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudio6Generator
::GetDocumentation(cmDocumentationEntry& entry)
{
entry.Name = cmGlobalVisualStudio6Generator::GetActualName();
entry.Brief = "Deprecated. Generates Visual Studio 6 project files.";
}
//----------------------------------------------------------------------------
void
cmGlobalVisualStudio6Generator
::AppendDirectoryForConfig(const std::string& prefix,
const std::string& config,
const std::string& suffix,
std::string& dir)
{
if(!config.empty())
{
dir += prefix;
dir += config;
dir += suffix;
}
}

113
Source/cmGlobalVisualStudio6Generator.h
View File

@ -1,113 +0,0 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef cmGlobalVisualStudio6Generator_h
#define cmGlobalVisualStudio6Generator_h
#include "cmGlobalVisualStudioGenerator.h"
#include "cmGlobalGeneratorFactory.h"
/** \class cmGlobalVisualStudio6Generator
* \brief Write a Unix makefiles.
*
* cmGlobalVisualStudio6Generator manages UNIX build process for a tree
*/
class cmGlobalVisualStudio6Generator : public cmGlobalVisualStudioGenerator
{
public:
cmGlobalVisualStudio6Generator(cmake* cm);
static cmGlobalGeneratorFactory* NewFactory() {
return new cmGlobalGeneratorSimpleFactory
<cmGlobalVisualStudio6Generator>(); }
///! Get the name for the generator.
virtual std::string GetName() const {
return cmGlobalVisualStudio6Generator::GetActualName();}
static std::string GetActualName() {return "Visual Studio 6";}
/** Get the documentation entry for this generator. */
static void GetDocumentation(cmDocumentationEntry& entry);
/**
* Utilized by the generator factory to determine if this generator
* supports toolsets.
*/
static bool SupportsToolset() { return false; }
///! Create a local generator appropriate to this Global Generator
virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile* mf);
/**
* Try to determine system information such as shared library
* extension, pthreads, byte order etc.
*/
virtual void EnableLanguage(std::vector<std::string>const& languages,
cmMakefile *, bool optional);
/**
* Try running cmake and building a file. This is used for dynalically
* loaded commands, not as part of the usual build process.
*/
virtual void GenerateBuildCommand(
std::vector<std::string>& makeCommand,
const std::string& makeProgram,
const std::string& projectName,
const std::string& projectDir,
const std::string& targetName,
const std::string& config,
bool fast, bool verbose,
std::vector<std::string> const& makeOptions = std::vector<std::string>()
);
/**
* Generate the DSW workspace file.
*/
virtual void OutputDSWFile();
virtual void OutputDSWFile(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
virtual void WriteDSWFile(std::ostream& fout,
cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
/** Append the subdirectory for the given configuration. */
virtual void AppendDirectoryForConfig(const std::string& prefix,
const std::string& config,
const std::string& suffix,
std::string& dir);
///! What is the configurations directory variable called?
virtual const char* GetCMakeCFGIntDir() const { return "$(IntDir)"; }
virtual void FindMakeProgram(cmMakefile*);
protected:
virtual void Generate();
virtual const char* GetIDEVersion() { return "6.0"; }
private:
virtual std::string GetVSMakeProgram() { return this->GetMSDevCommand(); }
void GenerateConfigurations(cmMakefile* mf);
void WriteDSWFile(std::ostream& fout);
void WriteDSWHeader(std::ostream& fout);
void WriteProject(std::ostream& fout,
const std::string& name, const char* path,
cmGeneratorTarget const* t);
void WriteExternalProject(std::ostream& fout,
const std::string& name, const char* path,
const std::set<std::string>& dependencies);
void WriteDSWFooter(std::ostream& fout);
virtual std::string WriteUtilityDepend(const cmGeneratorTarget *target);
std::string MSDevCommand;
bool MSDevCommandInitialized;
std::string const& GetMSDevCommand();
std::string FindMSDevCommand();
};
#endif

1
Source/cmGlobalVisualStudioGenerator.h
View File

@ -26,7 +26,6 @@ public:
/** Known versions of Visual Studio. */
enum VSVersion
{
VS6 = 60,
VS7 = 70,
VS71 = 71,
VS8 = 80,

2
Source/cmLocalGenerator.cxx
View File

@ -2455,7 +2455,7 @@ void cmLocalGenerator::JoinDefines(const std::set<std::string>& defines,
else
{
// Make the definition appear properly on the command line. Use
// -DNAME="value" instead of -D"NAME=value" to help VS6 parser.
// -DNAME="value" instead of -D"NAME=value" for historical reasons.
std::string::size_type eq = defineIt->find("=");
def += defineIt->substr(0, eq);
if(eq != defineIt->npos)

2002
Source/cmLocalVisualStudio6Generator.cxx
View File

File diff suppressed because it is too large Load Diff

105
Source/cmLocalVisualStudio6Generator.h
View File

@ -1,105 +0,0 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef cmLocalVisualStudio6Generator_h
#define cmLocalVisualStudio6Generator_h
#include "cmLocalVisualStudioGenerator.h"
class cmSourceFile;
class cmSourceGroup;
class cmCustomCommand;
/** \class cmLocalVisualStudio6Generator
* \brief Write a LocalUnix makefiles.
*
* cmLocalVisualStudio6Generator produces a LocalUnix makefile from its
* member this->Makefile.
*/
class cmLocalVisualStudio6Generator : public cmLocalVisualStudioGenerator
{
public:
///! Set cache only and recurse to false by default.
cmLocalVisualStudio6Generator(cmGlobalGenerator* gg, cmMakefile* mf);
virtual ~cmLocalVisualStudio6Generator();
virtual void AddCMakeListsRules();
/**
* Generate the makefile for this directory.
*/
virtual void Generate();
void OutputDSPFile();
enum BuildType {STATIC_LIBRARY, DLL, EXECUTABLE, WIN32_EXECUTABLE, UTILITY};
/**
* Specify the type of the build: static, dll, or executable.
*/
void SetBuildType(BuildType, const std::string& libName, cmGeneratorTarget*);
virtual
std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
virtual std::string
ComputeLongestObjectDirectory(cmGeneratorTarget const*) const;
private:
std::string DSPHeaderTemplate;
std::string DSPFooterTemplate;
void CreateSingleDSP(const std::string& lname, cmGeneratorTarget* tgt);
void WriteDSPFile(std::ostream& fout, const std::string& libName,
cmGeneratorTarget* tgt);
void WriteDSPBeginGroup(std::ostream& fout,
const char* group,
const char* filter);
void WriteDSPEndGroup(std::ostream& fout);
void WriteDSPHeader(std::ostream& fout, const std::string& libName,
cmGeneratorTarget* tgt, std::vector<cmSourceGroup> &sgs);
void WriteDSPFooter(std::ostream& fout);
void AddDSPBuildRule(cmGeneratorTarget* tgt);
void WriteCustomRule(std::ostream& fout,
const char* source,
const cmCustomCommand& command,
const char* flags);
void AddUtilityCommandHack(cmGeneratorTarget* target, int count,
std::vector<std::string>& depends,
const cmCustomCommand& origCommand);
void WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target,
std::ostream &fout, const std::string& libName);
class EventWriter;
friend class EventWriter;
cmsys::auto_ptr<cmCustomCommand>
MaybeCreateOutputDir(cmGeneratorTarget *target, const std::string& config);
std::string CreateTargetRules(cmGeneratorTarget* target,
const std::string& configName,
const std::string& libName);
void ComputeLinkOptions(cmGeneratorTarget* target,
const std::string& configName,
const std::string extraOptions,
std::string& options);
void OutputObjects(cmGeneratorTarget* target, const char* tool,
std::string& options);
std::string GetTargetIncludeOptions(cmGeneratorTarget* target,
const std::string& config);
std::vector<std::string> Configurations;
std::string GetConfigName(std::string const& configuration) const;
// Special definition check for VS6.
virtual bool CheckDefinition(std::string const& define) const;
};
#endif

6
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -25,7 +25,7 @@
#include <ctype.h> // for isspace
static bool cmLVS6G_IsFAT(const char* dir);
static bool cmLVS7G_IsFAT(const char* dir);
class cmLocalVisualStudio7GeneratorInternals
{
@ -999,7 +999,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
// Check if we need the FAT32 workaround.
// Check the filesystem type where the target will be written.
if (cmLVS6G_IsFAT(target->GetDirectory(configName).c_str()))
if (cmLVS7G_IsFAT(target->GetDirectory(configName).c_str()))
{
// Add a flag telling the manifest tool to use a workaround
// for FAT32 file systems, which can cause an empty manifest
@ -2365,7 +2365,7 @@ std::string cmLocalVisualStudio7Generator
//----------------------------------------------------------------------------
#include <windows.h>
static bool cmLVS6G_IsFAT(const char* dir)
static bool cmLVS7G_IsFAT(const char* dir)
{
if(dir[0] && dir[1] == ':')
{

28
Source/cmMakefile.cxx
View File

@ -733,26 +733,6 @@ void cmMakefile::ConfigureFinalPass()
"with CMake 2.4 or later. For compatibility with older versions please "
"use any CMake 2.8.x release or lower.");
}
#if defined(_WIN32) && !defined(__CYGWIN__)
// Do old-style link dependency analysis only for CM_USE_OLD_VS6.
if(this->GetGlobalGenerator()->IsForVS6())
{
for (cmTargets::iterator l = this->Targets.begin();
l != this->Targets.end(); l++)
{
if (l->second.GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
// Erase any cached link information that might have been comptued
// on-demand during the configuration. This ensures that build
// system generation uses up-to-date information even if other cache
// invalidation code in this source file is buggy.
l->second.AnalyzeLibDependenciesForVS6(*this);
}
}
#endif
}
//----------------------------------------------------------------------------
@ -1334,14 +1314,6 @@ bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove)
return false;
}
// VS6 IDE does not support definition values with spaces in
// combination with '"', '$', or ';'.
if((this->GetGlobalGenerator()->GetName() == "Visual Studio 6") &&
(def.find(" ") != def.npos && def.find_first_of("\"$;") != def.npos))
{
return false;
}
// Definitions with non-trivial values require a policy check.
static cmsys::RegularExpression
trivial("^[-/]D[A-Za-z_][A-Za-z0-9_]*(=[A-Za-z0-9_.]+)?$");

298
Source/cmTarget.cxx
View File

@ -55,9 +55,6 @@ public:
cmTarget::cmTarget()
{
this->Makefile = 0;
#if defined(_WIN32) && !defined(__CYGWIN__)
this->LinkLibrariesForVS6Analyzed = false;
#endif
this->HaveInstallRule = false;
this->DLLPlatform = false;
this->IsAndroid = false;
@ -699,9 +696,6 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
cmTarget::LibraryID tmp;
tmp.first = lib;
tmp.second = llt;
#if defined(_WIN32) && !defined(__CYGWIN__)
this->LinkLibrariesForVS6.push_back( tmp );
#endif
this->OriginalLinkLibraries.push_back(tmp);
// Add the explicit dependency information for this target. This is
@ -811,298 +805,6 @@ cmBacktraceRange cmTarget::GetLinkImplementationBacktraces() const
return cmMakeRange(this->Internal->LinkImplementationPropertyBacktraces);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
//----------------------------------------------------------------------------
void
cmTarget::AnalyzeLibDependenciesForVS6( const cmMakefile& mf )
{
// There are two key parts of the dependency analysis: (1)
// determining the libraries in the link line, and (2) constructing
// the dependency graph for those libraries.
//
// The latter is done using the cache entries that record the
// dependencies of each library.
//
// The former is a more thorny issue, since it is not clear how to
// determine if two libraries listed on the link line refer to the a
// single library or not. For example, consider the link "libraries"
// /usr/lib/libtiff.so -ltiff
// Is this one library or two? The solution implemented here is the
// simplest (and probably the only practical) one: two libraries are
// the same if their "link strings" are identical. Thus, the two
// libraries above are considered distinct. This also means that for
// dependency analysis to be effective, the CMake user must specify
// libraries build by his project without using any linker flags or
// file extensions. That is,
// LINK_LIBRARIES( One Two )
// instead of
// LINK_LIBRARIES( -lOne ${binarypath}/libTwo.a )
// The former is probably what most users would do, but it never
// hurts to document the assumptions. :-) Therefore, in the analysis
// code, the "canonical name" of a library is simply its name as
// given to a LINK_LIBRARIES command.
//
// Also, we will leave the original link line intact; we will just add any
// dependencies that were missing.
//
// There is a problem with recursive external libraries
// (i.e. libraries with no dependency information that are
// recursively dependent). We must make sure that the we emit one of
// the libraries twice to satisfy the recursion, but we shouldn't
// emit it more times than necessary. In particular, we must make
// sure that handling this improbable case doesn't cost us when
// dealing with the common case of non-recursive libraries. The
// solution is to assume that the recursion is satisfied at one node
// of the dependency tree. To illustrate, assume libA and libB are
// extrenal and mutually dependent. Suppose libX depends on
// libA, and libY on libA and libX. Then
// TARGET_LINK_LIBRARIES( Y X A B A )
// TARGET_LINK_LIBRARIES( X A B A )
// TARGET_LINK_LIBRARIES( Exec Y )
// would result in "-lY -lX -lA -lB -lA". This is the correct way to
// specify the dependencies, since the mutual dependency of A and B
// is resolved *every time libA is specified*.
//
// Something like
// TARGET_LINK_LIBRARIES( Y X A B A )
// TARGET_LINK_LIBRARIES( X A B )
// TARGET_LINK_LIBRARIES( Exec Y )
// would result in "-lY -lX -lA -lB", and the mutual dependency
// information is lost. This is because in some case (Y), the mutual
// dependency of A and B is listed, while in another other case (X),
// it is not. Depending on which line actually emits A, the mutual
// dependency may or may not be on the final link line. We can't
// handle this pathalogical case cleanly without emitting extra
// libraries for the normal cases. Besides, the dependency
// information for X is wrong anyway: if we build an executable
// depending on X alone, we would not have the mutual dependency on
// A and B resolved.
//
// IMPROVEMENTS:
// -- The current algorithm will not always pick the "optimal" link line
// when recursive dependencies are present. It will instead break the
// cycles at an aribtrary point. The majority of projects won't have
// cyclic dependencies, so this is probably not a big deal. Note that
// the link line is always correct, just not necessary optimal.
{
// Expand variables in link library names. This is for backwards
// compatibility with very early CMake versions and should
// eventually be removed. This code was moved here from the end of
// old source list processing code which was called just before this
// method.
for(LinkLibraryVectorType::iterator p = this->LinkLibrariesForVS6.begin();
p != this->LinkLibrariesForVS6.end(); ++p)
{
this->Makefile->ExpandVariablesInString(p->first, true, true);
}
}
// The dependency map.
DependencyMap dep_map;
// 1. Build the dependency graph
//
for(LinkLibraryVectorType::reverse_iterator lib
= this->LinkLibrariesForVS6.rbegin();
lib != this->LinkLibrariesForVS6.rend(); ++lib)
{
this->GatherDependenciesForVS6( mf, *lib, dep_map);
}
// 2. Remove any dependencies that are already satisfied in the original
// link line.
//
for(LinkLibraryVectorType::iterator lib = this->LinkLibrariesForVS6.begin();
lib != this->LinkLibrariesForVS6.end(); ++lib)
{
for( LinkLibraryVectorType::iterator lib2 = lib;
lib2 != this->LinkLibrariesForVS6.end(); ++lib2)
{
this->DeleteDependencyForVS6( dep_map, *lib, *lib2);
}
}
// 3. Create the new link line by simply emitting any dependencies that are
// missing. Start from the back and keep adding.
//
std::set<DependencyMap::key_type> done, visited;
std::vector<DependencyMap::key_type> newLinkLibrariesForVS6;
for(LinkLibraryVectorType::reverse_iterator lib =
this->LinkLibrariesForVS6.rbegin();
lib != this->LinkLibrariesForVS6.rend(); ++lib)
{
// skip zero size library entries, this may happen
// if a variable expands to nothing.
if (!lib->first.empty())
{
this->EmitForVS6( *lib, dep_map, done, visited, newLinkLibrariesForVS6 );
}
}
// 4. Add the new libraries to the link line.
//
for( std::vector<DependencyMap::key_type>::reverse_iterator k =
newLinkLibrariesForVS6.rbegin();
k != newLinkLibrariesForVS6.rend(); ++k )
{
// get the llt from the dep_map
this->LinkLibrariesForVS6.push_back( std::make_pair(k->first,k->second) );
}
this->LinkLibrariesForVS6Analyzed = true;
}
//----------------------------------------------------------------------------
void cmTarget::InsertDependencyForVS6( DependencyMap& depMap,
const LibraryID& lib,
const LibraryID& dep)
{
depMap[lib].push_back(dep);
}
//----------------------------------------------------------------------------
void cmTarget::DeleteDependencyForVS6( DependencyMap& depMap,
const LibraryID& lib,
const LibraryID& dep)
{
// Make sure there is an entry in the map for lib. If so, delete all
// dependencies to dep. There may be repeated entries because of
// external libraries that are specified multiple times.
DependencyMap::iterator map_itr = depMap.find( lib );
if( map_itr != depMap.end() )
{
DependencyList& depList = map_itr->second;
DependencyList::iterator begin =
std::remove(depList.begin(), depList.end(), dep);
depList.erase(begin, depList.end());
}
}
//----------------------------------------------------------------------------
void cmTarget::EmitForVS6(const LibraryID lib,
const DependencyMap& dep_map,
std::set<LibraryID>& emitted,
std::set<LibraryID>& visited,
DependencyList& link_line )
{
// It's already been emitted
if( emitted.find(lib) != emitted.end() )
{
return;
}
// Emit the dependencies only if this library node hasn't been
// visited before. If it has, then we have a cycle. The recursion
// that got us here should take care of everything.
if( visited.insert(lib).second )
{
if( dep_map.find(lib) != dep_map.end() ) // does it have dependencies?
{
const DependencyList& dep_on = dep_map.find( lib )->second;
DependencyList::const_reverse_iterator i;
// To cater for recursive external libraries, we must emit
// duplicates on this link line *unless* they were emitted by
// some other node, in which case we assume that the recursion
// was resolved then. We making the simplifying assumption that
// any duplicates on a single link line are on purpose, and must
// be preserved.
// This variable will keep track of the libraries that were
// emitted directly from the current node, and not from a
// recursive call. This way, if we come across a library that
// has already been emitted, we repeat it iff it has been
// emitted here.
std::set<DependencyMap::key_type> emitted_here;
for( i = dep_on.rbegin(); i != dep_on.rend(); ++i )
{
if( emitted_here.find(*i) != emitted_here.end() )
{
// a repeat. Must emit.
emitted.insert(*i);
link_line.push_back( *i );
}
else
{
// Emit only if no-one else has
if( emitted.find(*i) == emitted.end() )
{
// emit dependencies
this->EmitForVS6( *i, dep_map, emitted, visited, link_line );
// emit self
emitted.insert(*i);
emitted_here.insert(*i);
link_line.push_back( *i );
}
}
}
}
}
}
//----------------------------------------------------------------------------
void cmTarget::GatherDependenciesForVS6( const cmMakefile& mf,
const LibraryID& lib,
DependencyMap& dep_map)
{
// If the library is already in the dependency map, then it has
// already been fully processed.
if( dep_map.find(lib) != dep_map.end() )
{
return;
}
const char* deps = mf.GetDefinition( lib.first+"_LIB_DEPENDS" );
if( deps && strcmp(deps,"") != 0 )
{
// Make sure this library is in the map, even if it has an empty
// set of dependencies. This distinguishes the case of explicitly
// no dependencies with that of unspecified dependencies.
dep_map[lib];
// Parse the dependency information, which is a set of
// type, library pairs separated by ";". There is always a trailing ";".
cmTargetLinkLibraryType llt = GENERAL_LibraryType;
std::string depline = deps;
std::string::size_type start = 0;
std::string::size_type end;
end = depline.find( ";", start );
while( end != std::string::npos )
{
std::string l = depline.substr( start, end-start );
if(!l.empty())
{
if (l == "debug")
{
llt = DEBUG_LibraryType;
}
else if (l == "optimized")
{
llt = OPTIMIZED_LibraryType;
}
else if (l == "general")
{
llt = GENERAL_LibraryType;
}
else
{
LibraryID lib2(l,llt);
this->InsertDependencyForVS6( dep_map, lib, lib2);
this->GatherDependenciesForVS6( mf, lib2, dep_map);
llt = GENERAL_LibraryType;
}
}
start = end+1; // skip the ;
end = depline.find( ";", start );
}
// cannot depend on itself
this->DeleteDependencyForVS6( dep_map, lib, lib);
}
}
#endif
//----------------------------------------------------------------------------
static bool whiteListedInterfaceProperty(const std::string& prop)
{

64
Source/cmTarget.h
View File

@ -245,13 +245,6 @@ public:
cmStringRange GetLinkImplementationEntries() const;
cmBacktraceRange GetLinkImplementationBacktraces() const;
#if defined(_WIN32) && !defined(__CYGWIN__)
const LinkLibraryVectorType &GetLinkLibrariesForVS6() const {
return this->LinkLibrariesForVS6;}
void AnalyzeLibDependenciesForVS6( const cmMakefile& mf );
#endif
struct StrictTargetComparison {
bool operator()(cmTarget const* t1, cmTarget const* t2) const;
};
@ -259,57 +252,6 @@ public:
private:
bool HandleLocationPropertyPolicy(cmMakefile* context) const;
#if defined(_WIN32) && !defined(__CYGWIN__)
/**
* A list of direct dependencies. Use in conjunction with DependencyMap.
*/
typedef std::vector< LibraryID > DependencyList;
/**
* This map holds the dependency graph. map[x] returns a set of
* direct dependencies of x. Note that the direct depenencies are
* ordered. This is necessary to handle direct dependencies that
* themselves have no dependency information.
*/
typedef std::map< LibraryID, DependencyList > DependencyMap;
/**
* Inserts \a dep at the end of the dependency list of \a lib.
*/
void InsertDependencyForVS6( DependencyMap& depMap,
const LibraryID& lib,
const LibraryID& dep);
/*
* Deletes \a dep from the dependency list of \a lib.
*/
void DeleteDependencyForVS6( DependencyMap& depMap,
const LibraryID& lib,
const LibraryID& dep);
/**
* Emits the library \a lib and all its dependencies into link_line.
* \a emitted keeps track of the libraries that have been emitted to
* avoid duplicates--it is more efficient than searching
* link_line. \a visited is used detect cycles. Note that \a
* link_line is in reverse order, in that the dependencies of a
* library are listed before the library itself.
*/
void EmitForVS6( const LibraryID lib,
const DependencyMap& dep_map,
std::set<LibraryID>& emitted,
std::set<LibraryID>& visited,
DependencyList& link_line);
/**
* Finds the dependencies for \a lib and inserts them into \a
* dep_map.
*/
void GatherDependenciesForVS6( const cmMakefile& mf,
const LibraryID& lib,
DependencyMap& dep_map);
#endif
const char* GetSuffixVariableInternal(bool implib) const;
const char* GetPrefixVariableInternal(bool implib) const;
@ -338,9 +280,6 @@ private:
std::vector<std::pair<TLLSignature, cmListFileContext> > TLLCommands;
LinkLibraryVectorType PrevLinkedLibraries;
LinkLibraryVectorType OriginalLinkLibraries;
#if defined(_WIN32) && !defined(__CYGWIN__)
LinkLibraryVectorType LinkLibrariesForVS6;
#endif
cmMakefile* Makefile;
cmTargetInternalPointer Internal;
cmState::TargetType TargetTypeValue;
@ -351,9 +290,6 @@ private:
bool IsImportedTarget;
bool ImportedGloballyVisible;
bool BuildInterfaceIncludesAppended;
#if defined(_WIN32) && !defined(__CYGWIN__)
bool LinkLibrariesForVS6Analyzed;
#endif
std::string ProcessSourceItemCMP0049(const std::string& s);

4
Source/cmake.cxx
View File

@ -51,7 +51,6 @@
// include the generator
#if defined(_WIN32) && !defined(__CYGWIN__)
# if !defined(CMAKE_BOOT_MINGW)
# include "cmGlobalVisualStudio6Generator.h"
# include "cmGlobalVisualStudio7Generator.h"
# include "cmGlobalVisualStudio71Generator.h"
# include "cmGlobalVisualStudio8Generator.h"
@ -1429,7 +1428,6 @@ int cmake::ActualConfigure()
const char* GeneratorName;
};
VSRegistryEntryName version[] = {
{"6.0", "Visual Studio 6"},
{"7.0", "Visual Studio 7"},
{"7.1", "Visual Studio 7 .NET 2003"},
{"8.0", "Visual Studio 8 2005"},
@ -1838,8 +1836,6 @@ void cmake::AddDefaultGenerators()
cmGlobalVisualStudio71Generator::NewFactory());
this->Generators.push_back(
cmGlobalVisualStudio7Generator::NewFactory());
this->Generators.push_back(
cmGlobalVisualStudio6Generator::NewFactory());
this->Generators.push_back(
cmGlobalBorlandMakefileGenerator::NewFactory());
this->Generators.push_back(

7
Source/cmakemain.cxx
View File

@ -461,13 +461,6 @@ static int do_build(int ac, char const* const* av)
return 1;
}
// Hack for vs6 that passes ".\Debug" as "$(IntDir)" value:
//
if (cmSystemTools::StringStartsWith(config.c_str(), ".\\"))
{
config = config.substr(2);
}
cmake cm;
return cm.Build(dir, target, config, nativeOptions, clean);
#endif

3
Templates/CMakeVisualStudio6Configurations.cmake
View File

@ -1,3 +0,0 @@
# When the dll templates are changed, this list should be
# updated with the list of possible configurations.
set(CMAKE_CONFIGURATION_TYPES Debug Release MinSizeRel RelWithDebInfo)

4
Templates/DLLFooter.dsptemplate
View File

@ -1,4 +0,0 @@
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

192
Templates/DLLHeader.dsptemplate
View File

@ -1,192 +0,0 @@
# Microsoft Developer Studio Project File - Name="OUTPUT_LIBNAME" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=OUTPUT_LIBNAME - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "OUTPUT_LIBNAME.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "OUTPUT_LIBNAME.mak" CFG="OUTPUT_LIBNAME - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "OUTPUT_LIBNAME - Win32 MinSizeRel" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "OUTPUT_LIBNAME - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "OUTPUT_LIBNAME - Win32 RelWithDebInfo" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "OUTPUT_LIBNAME - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# ITK DSP Header file
# This file is read by the build system of itk, and is used as the top part of
# a microsoft project dsp header file
# IF this is in a dsp file, then it is not the header, but has
# already been used, so do not edit here...
# variables to REPLACE
#
# BUILD_INCLUDES == include path
# EXTRA_DEFINES == compiler defines
# OUTPUT_DIRECTORY == override in output directory
# OUTPUT_LIBNAME == name of output library
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "OUTPUT_LIBNAME - Win32 Release"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_RELEASE"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "_WINDOWS" /D "_USRDLL" OUTPUT_LIBNAME_EXPORTS /FD /c
# ADD CPP /nologo /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /FD /c
# ADD CPP BUILD_INCLUDES_RELEASE EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_RELEASE
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_RELEASE /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_RELEASE
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /dll /machine:I386
# ADD LINK32 /nologo /dll TARGET_VERSION_FLAG /machine:I386 /out:"OUTPUT_DIRECTORY_RELEASE/OUTPUT_NAME_RELEASE" TARGET_IMPLIB_FLAG_RELEASE
CM_MULTILINE_OPTIONS_RELEASE
CMAKE_CUSTOM_RULE_CODE_RELEASE
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 Debug"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "OUTPUT_DIRECTORY_DEBUG"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" OUTPUT_LIBNAME_EXPORTS /FD /c
# ADD CPP /nologo /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_USRDLL" /FD /c
# ADD CPP BUILD_INCLUDES_DEBUG EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_DEBUG
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC BUILD_INCLUDES_DEBUG /l 0x409 /d "_DEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_DEBUG
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 /nologo /dll TARGET_VERSION_FLAG /debug /machine:I386 /out:"OUTPUT_DIRECTORY_DEBUG/OUTPUT_NAME_DEBUG" /pdbtype:sept TARGET_IMPLIB_FLAG_DEBUG
CM_MULTILINE_OPTIONS_DEBUG
CMAKE_CUSTOM_RULE_CODE_DEBUG
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 MinSizeRel"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "MinSizeRel"
# PROP BASE Intermediate_Dir "MinSizeRel"
# PROP BASE Ignore_Export_Lib 0
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_MINSIZEREL"
# PROP Intermediate_Dir "MinSizeRel"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /FD /c OUTPUT_LIBNAME_EXPORTS
# SUBTRACT BASE CPP /YX
# ADD CPP /nologo /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /FD /c
# ADD CPP BUILD_INCLUDES_MINSIZEREL EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_MINSIZEREL
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_MINSIZEREL /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_MINSIZEREL
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /dll /machine:I386
# ADD LINK32 /nologo /dll TARGET_VERSION_FLAG /machine:I386 /out:"OUTPUT_DIRECTORY_MINSIZEREL/OUTPUT_NAME_MINSIZEREL" TARGET_IMPLIB_FLAG_MINSIZEREL
CM_MULTILINE_OPTIONS_MINSIZEREL
CMAKE_CUSTOM_RULE_CODE_MINSIZEREL
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 RelWithDebInfo"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "RelWithDebInfo"
# PROP BASE Intermediate_Dir "RelWithDebInfo"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_RELWITHDEBINFO"
# PROP Intermediate_Dir "RelWithDebInfo"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "_WINDOWS" /D "_USRDLL" OUTPUT_LIBNAME_EXPORTS /FD /c
# ADD CPP /nologo /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /FD /c
# ADD CPP BUILD_INCLUDES_RELWITHDEBINFO EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_RELWITHDEBINFO
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_RELWITHDEBINFO /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_RELWITHDEBINFO
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /dll /machine:I386 /pdbtype:sept
# ADD LINK32 /nologo /dll TARGET_VERSION_FLAG /debug /machine:I386 /pdbtype:sept /out:"OUTPUT_DIRECTORY_RELWITHDEBINFO/OUTPUT_NAME_RELWITHDEBINFO" TARGET_IMPLIB_FLAG_RELWITHDEBINFO
CM_MULTILINE_OPTIONS_RELWITHDEBINFO
CMAKE_CUSTOM_RULE_CODE_RELWITHDEBINFO
!ENDIF
# Begin Target
# Name "OUTPUT_LIBNAME - Win32 Release"
# Name "OUTPUT_LIBNAME - Win32 Debug"
# Name "OUTPUT_LIBNAME - Win32 MinSizeRel"
# Name "OUTPUT_LIBNAME - Win32 RelWithDebInfo"

4
Templates/EXEFooter.dsptemplate
View File

@ -1,4 +0,0 @@
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

183
Templates/EXEHeader.dsptemplate
View File

@ -1,183 +0,0 @@
# Microsoft Developer Studio Project File - Name="pcbuilder" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# CM DSP Header file
# This file is read by the build system of cm, and is used as the top part of
# a microsoft project dsp header file
# IF this is in a dsp file, then it is not the header, but has
# already been used, so do not edit here...
# variables to REPLACE
#
# BUILD_INCLUDES == include path
# OUTPUT_DIRECTORY == override in output directory
# EXTRA_DEFINES == compiler defines
# OUTPUT_LIBNAME == name of output library
# CM_LIBRARIES == libraries linked in
# TARGTYPE "Win32 (x86) Application" 0x0103
CFG=OUTPUT_LIBNAME - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "OUTPUT_LIBNAME.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "OUTPUT_LIBNAME.mak" CFG="OUTPUT_LIBNAME - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "OUTPUT_LIBNAME - Win32 MinSizeRel" (based on "Win32 (x86) Application")
!MESSAGE "OUTPUT_LIBNAME - Win32 Release" (based on "Win32 (x86) Application")
!MESSAGE "OUTPUT_LIBNAME - Win32 RelWithDebInfo" (based on "Win32 (x86) Application")
!MESSAGE "OUTPUT_LIBNAME - Win32 Debug" (based on "Win32 (x86) Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "OUTPUT_LIBNAME - Win32 Release"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_RELEASE"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /FD /c
# ADD CPP /nologo /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /FD /c
# ADD CPP BUILD_INCLUDES_RELEASE EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_RELEASE
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_RELEASE /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_RELEASE
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:console /machine:I386 /IGNORE:4089
# ADD LINK32 /nologo /subsystem:console /machine:I386 /IGNORE:4089 TARGET_VERSION_FLAG
# ADD LINK32 /out:"OUTPUT_DIRECTORY_RELEASE\OUTPUT_NAME_RELEASE" TARGET_IMPLIB_FLAG_RELEASE
CM_MULTILINE_OPTIONS_RELEASE
CMAKE_CUSTOM_RULE_CODE_RELEASE
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 Debug"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "OUTPUT_DIRECTORY_DEBUG"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /FD /GZ /c
# ADD CPP /nologo /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /FD /GZ /c
# ADD CPP BUILD_INCLUDES_DEBUG EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_DEBUG
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC BUILD_INCLUDES_DEBUG /l 0x409 /d "_DEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_DEBUG
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /IGNORE:4089
# ADD LINK32 /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /IGNORE:4089 TARGET_VERSION_FLAG
# ADD LINK32 /out:"OUTPUT_DIRECTORY_DEBUG\OUTPUT_NAME_DEBUG" TARGET_IMPLIB_FLAG_DEBUG
CM_MULTILINE_OPTIONS_DEBUG
CMAKE_CUSTOM_RULE_CODE_DEBUG
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 MinSizeRel"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "MinSizeRel"
# PROP BASE Intermediate_Dir "MinSizeRel"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_MINSIZEREL"
# PROP Intermediate_Dir "MinSizeRel"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /FD /c
# ADD CPP /nologo /D "WIN32" BUILD_INCLUDES_MINSIZEREL EXTRA_DEFINES /D "NDEBUG" /D "_CONSOLE" /FD /c
# ADD CPP BUILD_INCLUDES_MINSIZEREL EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_MINSIZEREL
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_MINSIZEREL /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_MINSIZEREL
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:console /machine:I386 /IGNORE:4089
# ADD LINK32 /nologo /subsystem:console /machine:I386 /IGNORE:4089 TARGET_VERSION_FLAG
# ADD LINK32 /out:"OUTPUT_DIRECTORY_MINSIZEREL\OUTPUT_NAME_MINSIZEREL" TARGET_IMPLIB_FLAG_MINSIZEREL
CM_MULTILINE_OPTIONS_MINSIZEREL
CMAKE_CUSTOM_RULE_CODE_MINSIZEREL
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 RelWithDebInfo"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "RelWithDebInfo"
# PROP BASE Intermediate_Dir "RelWithDebInfo"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_RELWITHDEBINFO"
# PROP Intermediate_Dir "RelWithDebInfo"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /FD /c
# ADD CPP /nologo /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /FD /c
# ADD CPP BUILD_INCLUDES_RELWITHDEBINFO EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_RELWITHDEBINFO
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_RELWITHDEBINFO /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_RELWITHDEBINFO
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:console /debug /machine:I386 /IGNORE:4089
# ADD LINK32 /nologo /subsystem:console /debug /machine:I386 /IGNORE:4089 TARGET_VERSION_FLAG
# ADD LINK32 /out:"OUTPUT_DIRECTORY_RELWITHDEBINFO\OUTPUT_NAME_RELWITHDEBINFO" TARGET_IMPLIB_FLAG_RELWITHDEBINFO
CM_MULTILINE_OPTIONS_RELWITHDEBINFO
CMAKE_CUSTOM_RULE_CODE_RELWITHDEBINFO
!ENDIF
# Begin Target
# Name "OUTPUT_LIBNAME - Win32 Release"
# Name "OUTPUT_LIBNAME - Win32 Debug"
# Name "OUTPUT_LIBNAME - Win32 MinSizeRel"
# Name "OUTPUT_LIBNAME - Win32 RelWithDebInfo"

187
Templates/EXEWinHeader.dsptemplate
View File

@ -1,187 +0,0 @@
# Microsoft Developer Studio Project File - Name="pcbuilder" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# CM DSP Header file
# This file is read by the build system of cm, and is used as the top part of
# a microsoft project dsp header file
# IF this is in a dsp file, then it is not the header, but has
# already been used, so do not edit here...
# variables to REPLACE
#
# BUILD_INCLUDES == include path
# OUTPUT_DIRECTORY == override in output directory
# EXTRA_DEFINES == compiler defines
# OUTPUT_LIBNAME == name of output library
# CM_LIBRARIES == libraries linked in
# TARGTYPE "Win32 (x86) Application" 0x0101
CFG=OUTPUT_LIBNAME - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "OUTPUT_LIBNAME.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "OUTPUT_LIBNAME.mak" CFG="OUTPUT_LIBNAME - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "OUTPUT_LIBNAME - Win32 MinSizeRel" (based on "Win32 (x86) Application")
!MESSAGE "OUTPUT_LIBNAME - Win32 Release" (based on "Win32 (x86) Application")
!MESSAGE "OUTPUT_LIBNAME - Win32 RelWithDebInfo" (based on "Win32 (x86) Application")
!MESSAGE "OUTPUT_LIBNAME - Win32 Debug" (based on "Win32 (x86) Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "OUTPUT_LIBNAME - Win32 Release"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_RELEASE"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c
# ADD CPP /nologo /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c
# ADD CPP BUILD_INCLUDES_RELEASE EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_RELEASE
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_RELEASE /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_RELEASE
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:windows /machine:I386 /IGNORE:4089
# ADD LINK32 /nologo /subsystem:windows /machine:I386 /IGNORE:4089 TARGET_VERSION_FLAG
# ADD LINK32 /out:"OUTPUT_DIRECTORY_RELEASE\OUTPUT_NAME_RELEASE" TARGET_IMPLIB_FLAG_RELEASE
CM_MULTILINE_OPTIONS_RELEASE
CMAKE_CUSTOM_RULE_CODE_RELEASE
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 Debug"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "OUTPUT_DIRECTORY_DEBUG"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FD /c
# ADD CPP /nologo /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FD /GZ /c
# ADD CPP BUILD_INCLUDES_DEBUG EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_DEBUG
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC BUILD_INCLUDES_DEBUG /l 0x409 /d "_DEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_DEBUG
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept /IGNORE:4089
# ADD LINK32 /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept /IGNORE:4089 TARGET_VERSION_FLAG
# ADD LINK32 /out:"OUTPUT_DIRECTORY_DEBUG\OUTPUT_NAME_DEBUG" TARGET_IMPLIB_FLAG_DEBUG
CM_MULTILINE_OPTIONS_DEBUG
CMAKE_CUSTOM_RULE_CODE_DEBUG
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 MinSizeRel"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "MinSizeRel"
# PROP BASE Intermediate_Dir "MinSizeRel"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_MINSIZEREL"
# PROP Intermediate_Dir "MinSizeRel"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c
# ADD CPP /nologo /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c
# ADD CPP BUILD_INCLUDES_MINSIZEREL EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_MINSIZEREL
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_MINSIZEREL /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_MINSIZEREL
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:windows /machine:I386 /pdbtype:sept /IGNORE:4089
# ADD LINK32 /nologo /subsystem:windows /machine:I386 /pdbtype:sept /IGNORE:4089 TARGET_VERSION_FLAG
# ADD LINK32 /out:"OUTPUT_DIRECTORY_MINSIZEREL\OUTPUT_NAME_MINSIZEREL" TARGET_IMPLIB_FLAG_MINSIZEREL
CM_MULTILINE_OPTIONS_MINSIZEREL
CMAKE_CUSTOM_RULE_CODE_MINSIZEREL
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 RelWithDebInfo"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "RelWithDebInfo"
# PROP BASE Intermediate_Dir "RelWithDebInfo"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_RELWITHDEBINFO"
# PROP Intermediate_Dir "RelWithDebInfo"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c
# ADD CPP /nologo /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c
# ADD CPP BUILD_INCLUDES_RELWITHDEBINFO EXTRA_DEFINES OUTPUT_LIBNAME_EXPORTS
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_RELWITHDEBINFO
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_RELWITHDEBINFO /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_RELWITHDEBINFO
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:windows /machine:I386 /IGNORE:4089
# ADD LINK32 /nologo /subsystem:windows /debug /machine:I386 /IGNORE:4089 TARGET_VERSION_FLAG
# ADD LINK32 /out:"OUTPUT_DIRECTORY_RELWITHDEBINFO\OUTPUT_NAME_RELWITHDEBINFO" TARGET_IMPLIB_FLAG_RELWITHDEBINFO
CM_MULTILINE_OPTIONS_RELWITHDEBINFO
CMAKE_CUSTOM_RULE_CODE_RELWITHDEBINFO
!ENDIF
# Begin Target
# Name "OUTPUT_LIBNAME - Win32 Release"
# Name "OUTPUT_LIBNAME - Win32 Debug"
# Name "OUTPUT_LIBNAME - Win32 MinSizeRel"
# Name "OUTPUT_LIBNAME - Win32 RelWithDebInfo"

2
Templates/UtilityFooter.dsptemplate
View File

@ -1,2 +0,0 @@
# End Target
# End Project

95
Templates/UtilityHeader.dsptemplate
View File

@ -1,95 +0,0 @@
# Microsoft Developer Studio Project File - Name="OUTPUT_LIBNAME" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Generic Project" 0x010a
CFG=OUTPUT_LIBNAME - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "OUTPUT_LIBNAME.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "OUTPUT_LIBNAME.mak" CFG="OUTPUT_LIBNAME - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "OUTPUT_LIBNAME - Win32 MinSizeRel" (based on "Win32 (x86) Generic Project")
!MESSAGE "OUTPUT_LIBNAME - Win32 Release" (based on "Win32 (x86) Generic Project")
!MESSAGE "OUTPUT_LIBNAME - Win32 RelWithDebInfo" (based on "Win32 (x86) Generic Project")
!MESSAGE "OUTPUT_LIBNAME - Win32 Debug" (based on "Win32 (x86) Generic Project")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
MTL=midl.exe
!IF "$(CFG)" == "OUTPUT_LIBNAME - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
CMAKE_CUSTOM_RULE_CODE_RELEASE
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
CMAKE_CUSTOM_RULE_CODE_DEBUG
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 MinSizeRel"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "MinSizeRel"
# PROP BASE Intermediate_Dir "MinSizeRel"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Intermediate_Dir "MinSizeRel"
# PROP Target_Dir ""
CMAKE_CUSTOM_RULE_CODE_MINSIZEREL
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 RelWithDebInfo"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "RelWithDebInfo"
# PROP BASE Intermediate_Dir "RelWithDebInfo"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Intermediate_Dir "RelWithDebInfo"
# PROP Target_Dir ""
CMAKE_CUSTOM_RULE_CODE_RELWITHDEBINFO
!ENDIF
# Begin Target
# Name "OUTPUT_LIBNAME - Win32 Release"
# Name "OUTPUT_LIBNAME - Win32 Debug"
# Name "OUTPUT_LIBNAME - Win32 MinSizeRel"
# Name "OUTPUT_LIBNAME - Win32 RelWithDebInfo"

4
Templates/staticLibFooter.dsptemplate
View File

@ -1,4 +0,0 @@
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

173
Templates/staticLibHeader.dsptemplate
View File

@ -1,173 +0,0 @@
# Microsoft Developer Studio Project File - Name="OUTPUT_LIBNAME" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# CMAKE DSP Header file
# This file is read by the CMAKE, and is used as the top part of
# a microsoft project dsp header file
# IF this is in a dsp file, then it is not the header, but has
# already been used, so do not edit in that case.
# variables to REPLACE
#
# BUILD_INCLUDES == include path
# EXTRA_DEFINES == compiler defines
# OUTPUT_DIRECTORY == override in output directory
# OUTPUT_LIBNAME == name of output library
# TARGTYPE "Win32 (x86) Static Library" 0x0104
CFG=OUTPUT_LIBNAME - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "OUTPUT_LIBNAME.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "OUTPUT_LIBNAME.mak" CFG="OUTPUT_LIBNAME - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "OUTPUT_LIBNAME - Win32 MinSizeRel" (based on "Win32 (x86) Static Library")
!MESSAGE "OUTPUT_LIBNAME - Win32 Release" (based on "Win32 (x86) Static Library")
!MESSAGE "OUTPUT_LIBNAME - Win32 RelWithDebInfo" (based on "Win32 (x86) Static Library")
!MESSAGE "OUTPUT_LIBNAME - Win32 Debug" (based on "Win32 (x86) Static Library")
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "OUTPUT_LIBNAME - Win32 Release"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_RELEASE"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "NDEBUG" /D "_LIB" /FD /c
# ADD CPP /nologo /D "NDEBUG" /D "WIN32" /D "_LIB" /FD /c
# ADD CPP BUILD_INCLUDES_RELEASE EXTRA_DEFINES
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_RELEASE
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_RELEASE /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_RELEASE
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo /out:"OUTPUT_DIRECTORY_RELEASE/OUTPUT_NAME_RELEASE" CM_STATIC_LIB_ARGS_RELEASE
CMAKE_CUSTOM_RULE_CODE_RELEASE
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 Debug"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "OUTPUT_DIRECTORY_DEBUG"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "_DEBUG" /D "_LIB" /FD /c
# ADD CPP /nologo /D "_DEBUG" /D "WIN32" /D "_LIB" /FD /GZ /c
# ADD CPP BUILD_INCLUDES_DEBUG EXTRA_DEFINES
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_DEBUG
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC BUILD_INCLUDES_DEBUG /l 0x409 /d "_DEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_DEBUG
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo /out:"OUTPUT_DIRECTORY_DEBUG/OUTPUT_NAME_DEBUG" CM_STATIC_LIB_ARGS_DEBUG
CMAKE_CUSTOM_RULE_CODE_DEBUG
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 MinSizeRel"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "MinSizeRel"
# PROP BASE Intermediate_Dir "MinSizeRel"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_MINSIZEREL"
# PROP Intermediate_Dir "MinSizeRel"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_USRDLL" /D "_ATL_DLL" /FD /c
# ADD CPP /nologo /D "NDEBUG" /D "_ATL_DLL" /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /FD /c
# ADD CPP BUILD_INCLUDES_MINSIZEREL EXTRA_DEFINES
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_MINSIZEREL
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_MINSIZEREL /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_MINSIZEREL
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo /out:"OUTPUT_DIRECTORY_MINSIZEREL/OUTPUT_NAME_MINSIZEREL" CM_STATIC_LIB_ARGS_MINSIZEREL
CMAKE_CUSTOM_RULE_CODE_MINSIZEREL
!ELSEIF "$(CFG)" == "OUTPUT_LIBNAME - Win32 RelWithDebInfo"
# PROP BASE Use_MFC CMAKE_MFC_FLAG
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "RelWithDebInfo"
# PROP BASE Intermediate_Dir "RelWithDebInfo"
# PROP BASE Target_Dir ""
# PROP Use_MFC CMAKE_MFC_FLAG
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "OUTPUT_DIRECTORY_RELWITHDEBINFO"
# PROP Intermediate_Dir "RelWithDebInfo"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /D "WIN32" /D "NDEBUG" /D "_LIB" /FD /c
# ADD CPP /nologo /D "NDEBUG" /D "WIN32" /D "_LIB" /FD /c
# ADD CPP BUILD_INCLUDES_RELWITHDEBINFO EXTRA_DEFINES
# ADD CPP CMAKE_CXX_FLAGS
# ADD CPP CMAKE_CXX_FLAGS_RELWITHDEBINFO
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC BUILD_INCLUDES_RELWITHDEBINFO /l 0x409 /d "NDEBUG"
# ADD RSC COMPILE_DEFINITIONS
# ADD RSC COMPILE_DEFINITIONS_RELWITHDEBINFO
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo /out:"OUTPUT_DIRECTORY_RELWITHDEBINFO/OUTPUT_NAME_RELWITHDEBINFO" CM_STATIC_LIB_ARGS_RELWITHDEBINFO
CMAKE_CUSTOM_RULE_CODE_RELWITHDEBINFO
!ENDIF
# Begin Target
# Name "OUTPUT_LIBNAME - Win32 Release"
# Name "OUTPUT_LIBNAME - Win32 Debug"
# Name "OUTPUT_LIBNAME - Win32 MinSizeRel"
# Name "OUTPUT_LIBNAME - Win32 RelWithDebInfo"

5
Tests/BuildDepends/CMakeLists.txt
View File

@ -42,7 +42,7 @@ list(APPEND _cmake_options "-DTEST_LINK_DEPENDS=${TEST_LINK_DEPENDS}")
list(APPEND _cmake_options "-DCMAKE_FORCE_DEPFILES=1")
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio ([^6789]|[6789][0-9])")
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio ([^789]|[789][0-9])")
set(TEST_MULTI3 1)
list(APPEND _cmake_options "-DTEST_MULTI3=1")
endif()
@ -304,9 +304,6 @@ message("Run result: ${runResult} Output: \"${out}\"")
if("${out}" STREQUAL "HEADER_STRING: ninja changed ")
message("Worked!")
elseif(CMAKE_GENERATOR STREQUAL "Visual Studio 6")
# Tolerate failure because VS 6 does not seem to recompile ninjadep.cpp
# when the "dir/header.h" it includes changes.
else()
message(SEND_ERROR "Project did not rebuild properly. Output[${out}]\n"
" expected [HEADER_STRING: ninja changed]")

9
Tests/CMakeLists.txt
View File

@ -624,8 +624,8 @@ if(BUILD_TESTING)
endif()
# test for correct sub-project generation
# not implemented in VS 6, VS 7.0, Xcode, or Ninja
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio [67]$|Xcode|Ninja")
# not implemented in VS 7.0, Xcode, or Ninja
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio 7$|Xcode|Ninja")
# run cmake and configure all of SubProject
# but only build the independent executable car
add_test(SubProject ${CMAKE_CTEST_COMMAND}
@ -1875,7 +1875,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release
endif()
if(MSVC AND NOT MSVC_VERSION LESS 1310
AND NOT CMAKE_GENERATOR MATCHES "Visual Studio [67]( |$)"
AND NOT CMAKE_GENERATOR MATCHES "Visual Studio 7( |$)"
AND (NOT CMAKE_GENERATOR MATCHES "Visual Studio [89]( |$)"
OR CMAKE_SIZEOF_VOID_P EQUAL 4)
)
@ -1887,7 +1887,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release
ADD_TEST_MACRO(SBCS SBCS)
endif()
if(NOT "${CMAKE_GENERATOR}" MATCHES "Visual Studio [6789]( |$)"
if(NOT "${CMAKE_GENERATOR}" MATCHES "Visual Studio [789]( |$)"
AND NOT CMAKE_GENERATOR_TOOLSET)
ADD_TEST_MACRO(VSWindowsFormsResx VSWindowsFormsResx)
endif()
@ -1916,7 +1916,6 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release
if(CMake_TEST_DEVENV)
# The test (and tested property) works with .sln files, so it's skipped when:
# * Using VS6, which doesn't use .sln files
# * cmake --build is set up to use MSBuild, since the MSBuild invocation does not use the .sln file
set(_last_test "")
foreach(config ${CMAKE_CONFIGURATION_TYPES})

5
Tests/CompileDefinitions/CMakeLists.txt
View File

@ -1,11 +1,6 @@
cmake_minimum_required(VERSION 2.8)
project(CompileDefinitions)
if ("${CMAKE_GENERATOR}" STREQUAL "Visual Studio 6")
add_definitions(-DNO_SPACES_IN_DEFINE_VALUES)
set(NO_SPACES_IN_DEFINE_VALUES 1)
endif()
# Use compile flags to tell executables which config is built
# without depending on the compile definitions functionality.
foreach(c DEBUG RELEASE RELWITHDEBINFO MINSIZEREL)

10
Tests/CustomCommand/wrapper.cxx
View File

@ -16,18 +16,12 @@ int main(int argc, char *argv[])
fprintf(fp,"int wrapped_help() { return 5; }\n");
fclose(fp);
#ifdef CMAKE_INTDIR
/* The VS6 IDE passes a leading ".\\" in its variable expansion. */
# if defined(_MSC_VER) && _MSC_VER == 1200
# define CFG_DIR ".\\" CMAKE_INTDIR
# else
# define CFG_DIR CMAKE_INTDIR
# endif
const char* cfg = (argc >= 4)? argv[3] : "";
if(strcmp(cfg, CFG_DIR) != 0)
if(strcmp(cfg, CMAKE_INTDIR) != 0)
{
fprintf(stderr,
"Did not receive expected configuration argument:\n"
" expected [" CFG_DIR "]\n"
" expected [" CMAKE_INTDIR "]\n"
" received [%s]\n", cfg);
return 1;
}

10
Tests/ExportImport/Export/CMakeLists.txt
View File

@ -79,12 +79,6 @@ set_property(TARGET testLib7 PROPERTY OUTPUT_NAME_DEBUG testLib7D-$<CONFIG>)
set_property(TARGET testLib7 PROPERTY OUTPUT_NAME_RELEASE testLib7R-$<CONFIG>)
set_property(TARGET testLib7 PROPERTY OUTPUT_NAME testLib7-$<CONFIG>)
# Work-around: Visual Studio 6 does not support per-target object files.
set(VS6)
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio 6")
set(VS6 1)
endif()
# Test using the target_link_libraries command to set the
# LINK_INTERFACE_LIBRARIES* properties. We construct two libraries
# providing the same two symbols. In each library one of the symbols
@ -93,8 +87,8 @@ endif()
# configuration in which it is built. If the proper library is not
# used via the link interface the import test will fail to link.
add_library(testLib4lib STATIC testLib4lib.c)
add_library(testLib4libdbg STATIC testLib4libopt.c testLib4libdbg${VS6}.c)
add_library(testLib4libopt STATIC testLib4libdbg.c testLib4libopt${VS6}.c)
add_library(testLib4libdbg STATIC testLib4libopt.c testLib4libdbg.c)
add_library(testLib4libopt STATIC testLib4libdbg.c testLib4libopt.c)
set_property(TARGET testLib4libdbg PROPERTY COMPILE_DEFINITIONS LIB_DBG)
set_property(TARGET testLib4libopt PROPERTY COMPILE_DEFINITIONS LIB_OPT)
target_link_libraries(testLib4

1
Tests/ExportImport/Export/testLib4libdbg1.c
View File

@ -1 +0,0 @@
#include "testLib4libdbg.c"

1
Tests/ExportImport/Export/testLib4libopt1.c
View File

@ -1 +0,0 @@
#include "testLib4libopt.c"

12
Tests/ExternalProjectLocal/CMakeLists.txt
View File

@ -23,18 +23,6 @@ set_property(DIRECTORY PROPERTY EP_STEP_TARGETS configure build test)
if(NOT DEFINED can_build_tutorial_step5)
set(can_build_tutorial_step5 1)
# Tutorial Step5 cannot build correctly using Visual Studio 6
# on Windows 98 if the path of its build tree exceeds 72
# characters in length... So don't attempt to build it
# in a long path on Win98:
#
if(CMAKE_SYSTEM STREQUAL "Windows-4.10")
string(LENGTH "${binary_base}/TutorialStep5-Local" n)
if(n GREATER 72)
set(can_build_tutorial_step5 0)
endif()
endif()
# The ExternalProject builds of Tutorial Step5 cannot be built
# correctly 2nd and later times in an in-source build...
# (because the CMakeCache.txt from the real in-source build of

5
Tests/ExternalProjectSubdir/CMakeLists.txt
View File

@ -3,11 +3,8 @@ project(ExternalProjectSubdir NONE)
include(ExternalProject)
# Remove the custom target output to be sure it runs in an
# incremental test. Skip this on VS 6 because it sometimes
# re-runs CMake after the custom command runs.
if(NOT CMAKE_GENERATOR STREQUAL "Visual Studio 6")
# incremental test.
file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/PreSubdir1.txt)
endif()
add_custom_target(PreSubdir1
COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/PreSubdir1.txt

5
Tests/ObjectLibrary/A/CMakeLists.txt
View File

@ -12,11 +12,8 @@ add_custom_command(
)
# Remove the custom command output to be sure it runs in an
# incremental test. Skip this on VS 6 because it sometimes
# re-runs CMake after the custom command runs.
if(NOT CMAKE_GENERATOR STREQUAL "Visual Studio 6")
# incremental test.
file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/a.cmake)
endif()
add_custom_command(
OUTPUT a.cmake
COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/a.cmake

6
Tests/ObjectLibrary/B/CMakeLists.txt
View File

@ -1,8 +1,4 @@
project(ObjectLibraryB C)
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio 6")
# VS 6 generator does not use per-target object locations.
set(vs6 _vs6)
endif()
# Add -fPIC so objects can be used in shared libraries.
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
@ -11,7 +7,7 @@ add_library(B OBJECT b1.c b2.c)
target_include_directories(B PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_compile_definitions(B PUBLIC B_DEF)
add_library(Bexport OBJECT b1${vs6}.c b2${vs6}.c)
add_library(Bexport OBJECT b1.c b2.c)
set_property(TARGET Bexport PROPERTY COMPILE_DEFINITIONS Bexport)
target_include_directories(Bexport PRIVATE $<TARGET_PROPERTY:B,INTERFACE_INCLUDE_DIRECTORIES>)
target_compile_definitions(Bexport PRIVATE $<TARGET_PROPERTY:B,INTERFACE_COMPILE_DEFINITIONS>)

1
Tests/ObjectLibrary/B/b1_vs6.c
View File

@ -1 +0,0 @@
#include "b1.c"

1
Tests/ObjectLibrary/B/b2_vs6.c
View File

@ -1 +0,0 @@
#include "b2.c"

4
Tests/ObjectLibrary/CMakeLists.txt
View File

@ -16,8 +16,8 @@ add_custom_command(TARGET UseCshared POST_BUILD COMMAND ${CMAKE_COMMAND} -P ${CM
add_executable(UseCinternal main.c c.c $<TARGET_OBJECTS:A> $<TARGET_OBJECTS:B>)
if("${CMAKE_GENERATOR}" MATCHES "^Visual Studio (6|7|7 .NET 2003)$")
# VS 6 and 7 generators do not add objects as sources so we need a
if("${CMAKE_GENERATOR}" MATCHES "^Visual Studio (7|7 .NET 2003)$")
# VS 7 generators do not add objects as sources so we need a
# dummy object to convince the IDE to build the targets below.
set(dummy dummy.obj) # In MinGW: gcc -c dummy.c -o dummy.obj
elseif("${CMAKE_GENERATOR}" MATCHES "Xcode")

5
Tests/PDBDirectoryAndName/CMakeLists.txt
View File

@ -74,11 +74,6 @@ endif()
#-----------------------------------------------------------------------------
# Check that PDB files actually appear where expected.
# The PDB_NAME and PDB_OUTPUT_DIRECTORY options do not work in VS 6.
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio 6")
return()
endif()
set(pdbs "")
foreach(t ${my_targets})
get_property(pdb_name TARGET ${t} PROPERTY PDB_NAME)

6
Tests/PrecompiledHeader/CMakeLists.txt
View File

@ -17,14 +17,8 @@ else()
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/PCH)
endif()
# The VS6 IDE does not support renaming .pch files with /Fp.
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio 6")
set(PCH_USE_INCLUDE_DIR 1)
set(PCH_FILE)
else()
set(PCH_USE_INCLUDE_DIR 0)
set(PCH_FILE "\"/Fp${PCH_DIR}/foo_precompiled.pch\"")
endif()
# Choose between an explicit include path and using /I during
# precompilation. The /I form is used to test that the PCH is

23
Tests/Preprocess/CMakeLists.txt
View File

@ -10,9 +10,6 @@ project(Preprocess)
if("${CMAKE_GENERATOR}" MATCHES "Xcode")
set(PP_XCODE 1)
endif()
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio 6")
set(PP_VS6 1)
endif()
if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles")
set(PP_UMAKE 1)
endif()
@ -60,10 +57,6 @@ if(NOT BORLAND AND NOT PP_VS70)
set(SEMICOLON "\;")
endif()
if(NOT PP_VS6)
# VS 6 IDE: spaces and '"', '$', or ';'
# The project parser cannot handle spaces if there are quotes.
# Since we test passing in a quoted string, we cannot have spaces.
set(STRING_EXTRA "${STRING_EXTRA} ")
if(NOT PP_BORLAND AND NOT PP_WATCOM)
@ -74,7 +67,6 @@ if(NOT PP_VS6)
# invoked from the command line.
set(STRING_EXTRA "${STRING_EXTRA} ")
endif()
endif()
if(NOT PP_VS)
# VS: ,
@ -201,14 +193,10 @@ endif()
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DPREPROCESS_DEBUG")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DPREPROCESS_DEBUG")
# Inform the test if it built from Xcode or VS6 IDE.
# Inform the test if it built from Xcode.
if(PP_XCODE)
set(PREPROCESS_XCODE 1)
endif()
if(PP_VS6)
set(PREPROCESS_VS6 1)
set(VS6 _vs6)
endif()
# Test old-style definitions.
add_definitions(-DOLD_DEF -DOLD_EXPR=2)
@ -220,7 +208,7 @@ if(NOT "${OLD_DEFS}" STREQUAL "${OLD_DEFS_EXPECTED}")
message(SEND_ERROR "add_definitions not converted to directory property!")
endif()
add_executable(Preprocess preprocess.c preprocess${VS6}.cxx)
add_executable(Preprocess preprocess.c preprocess.cxx)
set(FILE_PATH "${Preprocess_SOURCE_DIR}/file_def.h")
set(TARGET_PATH "${Preprocess_SOURCE_DIR}/target_def.h")
@ -236,17 +224,14 @@ foreach(c "" "_DEBUG" "_RELEASE")
PROPERTY COMPILE_DEFINITIONS${c} "TARGET_DEF${c}"
)
set_property(
SOURCE preprocess.c preprocess${VS6}.cxx
SOURCE preprocess.c preprocess.cxx
PROPERTY COMPILE_DEFINITIONS${c} "FILE_DEF${c}"
)
endforeach()
# Add definitions with values.
if(NOT PREPROCESS_VS6)
# The path might have spaces, which VS6 does not support.
set(DEF_TARGET_PATH "TARGET_PATH=\"${TARGET_PATH}\"")
set(DEF_FILE_PATH "FILE_PATH=\"${FILE_PATH}\"")
endif()
set_property(
TARGET Preprocess
APPEND PROPERTY COMPILE_DEFINITIONS
@ -255,7 +240,7 @@ set_property(
${DEF_TARGET_PATH}
)
set_property(
SOURCE preprocess.c preprocess${VS6}.cxx
SOURCE preprocess.c preprocess.cxx
APPEND PROPERTY COMPILE_DEFINITIONS
"FILE_STRING=\"${STRING_VALUE}${SEMICOLON}\""
"FILE_EXPR=${EXPR}"

6
Tests/Preprocess/preprocess.h.in
View File

@ -2,12 +2,6 @@
#define STRING_VALUE "@STRING_VALUE@"
#define EXPR @EXPR@
#cmakedefine PREPROCESS_XCODE
#cmakedefine PREPROCESS_VS6
#ifdef PREPROCESS_VS6
# define FILE_PATH "@FILE_PATH@"
# define TARGET_PATH "@TARGET_PATH@"
#endif
/* Declarations and macros shared by all sources. */
#define TO_STRING(x) TO_STRING0(x)

3
Tests/Preprocess/preprocess_vs6.cxx
View File

@ -1,3 +0,0 @@
// The VS6 IDE does not support object name configuration so we need a
// source file with a different name. Include the real source file.
#include "preprocess.cxx"

4
Tests/RunCMake/AutoExportDll/RunCMakeTest.cmake
View File

@ -6,8 +6,8 @@ file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}")
# configure the AutoExport test
run_cmake(AutoExport)
unset(RunCMake_TEST_OPTIONS)
# don't run this test on VS 6 as it is not supported
if("${RunCMake_GENERATOR}" MATCHES "Visual Studio 6|Watcom WMake|Borland Makefiles")
# don't run this test on Watcom or Borland make as it is not supported
if("${RunCMake_GENERATOR}" MATCHES "Watcom WMake|Borland Makefiles")
return()
endif()
# we build debug so the say.exe will be found in Debug/say.exe for

2
Tests/RunCMake/BuildDepends/RunCMakeTest.cmake
View File

@ -30,7 +30,7 @@ function(run_BuildDepends CASE)
endfunction()
run_BuildDepends(C-Exe)
if(NOT RunCMake_GENERATOR MATCHES "Visual Studio [67]|Xcode")
if(NOT RunCMake_GENERATOR MATCHES "Visual Studio 7|Xcode")
if(RunCMake_GENERATOR MATCHES "Visual Studio 10")
# VS 10 forgets to re-link when a manifest changes
set(run_BuildDepends_skip_step_2 1)

4
Tests/RunCMake/CMakeLists.txt
View File

@ -232,12 +232,12 @@ if(PKG_CONFIG_FOUND)
add_RunCMake_test(FindPkgConfig)
endif()
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio [^6]")
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
add_RunCMake_test(include_external_msproject)
add_RunCMake_test(SolutionGlobalSections)
endif()
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([^6789]|[6789][0-9])")
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([^789]|[789][0-9])")
add_RunCMake_test(VS10Project)
endif()

0
Tests/RunCMake/CommandLine/DeprecateVS6-WARN-OFF.cmake
View File

5
Tests/RunCMake/CommandLine/DeprecateVS6-WARN-ON-stderr.txt
View File

@ -1,5 +0,0 @@
^CMake Warning:
The "Visual Studio 6" generator is deprecated and will be removed in a
future version of CMake.
Add CMAKE_WARN_VS6=OFF to the cache to disable this warning.$

0
Tests/RunCMake/CommandLine/DeprecateVS6-WARN-ON.cmake
View File

7
Tests/RunCMake/CommandLine/RunCMakeTest.cmake
View File

@ -72,12 +72,7 @@ if(RunCMake_GENERATOR STREQUAL "Ninja")
unset(RunCMake_TEST_NO_CLEAN)
endif()
if(RunCMake_GENERATOR STREQUAL "Visual Studio 6")
set(RunCMake_WARN_VS6 1)
run_cmake(DeprecateVS6-WARN-ON)
unset(RunCMake_WARN_VS6)
run_cmake(DeprecateVS6-WARN-OFF)
elseif(RunCMake_GENERATOR STREQUAL "Visual Studio 7")
if(RunCMake_GENERATOR STREQUAL "Visual Studio 7")
set(RunCMake_WARN_VS70 1)
run_cmake(DeprecateVS70-WARN-ON)
unset(RunCMake_WARN_VS70)

3
Tests/RunCMake/RunCMake.cmake
View File

@ -51,9 +51,6 @@ function(run_cmake test)
if(APPLE)
list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_POLICY_DEFAULT_CMP0025=NEW)
endif()
if(RunCMake_GENERATOR STREQUAL "Visual Studio 6" AND NOT RunCMake_WARN_VS6)
list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_WARN_VS6=OFF)
endif()
if(RunCMake_GENERATOR STREQUAL "Visual Studio 7" AND NOT RunCMake_WARN_VS70)
list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_WARN_VS70=OFF)
endif()

4
Tests/TryCompile/CMakeLists.txt
View File

@ -108,9 +108,7 @@ endif()
# try to compile a file that should compile
set(_c_flags "${CMAKE_C_FLAGS}")
if(CMAKE_GENERATOR STREQUAL "Visual Studio 6")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D \"TESTDEF\"")
elseif(WATCOM)
if(WATCOM)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -dTESTDEF")
else()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} \"-DTESTDEF\"")

7
Tests/VSExternalInclude/CMakeLists.txt
View File

@ -1,13 +1,10 @@
cmake_minimum_required (VERSION 2.6)
project(VSExternalInclude)
if(${CMAKE_GENERATOR} MATCHES "Visual Studio 6")
set(PROJECT_EXT dsp)
else()
set(PROJECT_EXT vcproj)
endif()
if(${CMAKE_GENERATOR} MATCHES "Visual Studio 1[0124]")
set(PROJECT_EXT vcxproj)
else()
set(PROJECT_EXT vcproj)
endif()
# make sure directories exists

6
Tests/VSMidl/src/CMakeLists.txt
View File

@ -1,12 +1,6 @@
cmake_minimum_required(VERSION 2.8)
project(VSMidl)
if(MSVC_VERSION GREATER 1200)
include_directories("${CMAKE_CURRENT_BINARY_DIR}/\$(IntDir)")
else()
# midl generated headers end up directly in CMAKE_CURRENT_BINARY_DIR with
# VS6 builds.
include_directories("${CMAKE_CURRENT_BINARY_DIR}")
endif()
add_executable(VSMidl main.cpp test.idl)