2001-01-11 22:47:38 +03:00
/*=========================================================================
Program : Insight Segmentation & Registration Toolkit
Module : $ RCSfile $
Language : C + +
Date : $ Date $
Version : $ Revision $
2002-01-21 23:30:43 +03:00
Copyright ( c ) 2002 Insight Consortium . All rights reserved .
See ITKCopyright . txt or http : //www.itk.org/HTML/Copyright.htm for details.
2001-01-11 22:47:38 +03:00
2002-01-21 23:30:43 +03:00
This software is distributed WITHOUT ANY WARRANTY ; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE . See the above copyright notices for more information .
2001-01-11 22:47:38 +03:00
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
2001-01-05 19:41:20 +03:00
# include "cmUnixMakefileGenerator.h"
# include "cmMakefile.h"
# include "cmStandardIncludes.h"
2000-09-18 17:19:38 +04:00
# include "cmSystemTools.h"
2001-04-25 01:33:09 +04:00
# include "cmSourceFile.h"
2001-01-05 19:41:20 +03:00
# include "cmMakeDepend.h"
2001-04-12 23:34:09 +04:00
# include "cmCacheManager.h"
2001-06-04 19:34:22 +04:00
# include "cmGeneratedFileStream.h"
2001-01-05 19:41:20 +03:00
2001-05-08 02:11:16 +04:00
cmUnixMakefileGenerator : : cmUnixMakefileGenerator ( )
2001-11-30 18:41:08 +03:00
: m_SharedLibraryExtension ( " $(SHLIB_SUFFIX) " ) ,
m_ObjectFileExtension ( " .o " ) ,
2001-11-14 18:21:59 +03:00
m_ExecutableExtension ( " " ) ,
m_StaticLibraryExtension ( " .a " ) ,
m_LibraryPrefix ( " lib " )
2001-05-08 02:11:16 +04:00
{
m_CacheOnly = false ;
m_Recurse = false ;
}
2001-09-15 00:26:56 +04:00
cmUnixMakefileGenerator : : ~ cmUnixMakefileGenerator ( )
{
}
2001-01-05 19:41:20 +03:00
void cmUnixMakefileGenerator : : GenerateMakefile ( )
{
2002-05-22 17:48:33 +04:00
// for backwards compatibility if niether c or cxx is
// enabled, the enable cxx
if ( ! ( this - > GetLanguageEnabled ( " C " ) | |
this - > GetLanguageEnabled ( " CXX " ) ) )
{
this - > EnableLanguage ( " CXX " ) ;
}
2001-06-14 01:03:49 +04:00
// suppoirt override in output directories
if ( m_Makefile - > GetDefinition ( " LIBRARY_OUTPUT_PATH " ) )
{
m_LibraryOutputPath = m_Makefile - > GetDefinition ( " LIBRARY_OUTPUT_PATH " ) ;
2001-08-28 18:57:25 +04:00
if ( m_LibraryOutputPath . size ( ) )
2001-06-14 01:03:49 +04:00
{
2001-08-28 18:57:25 +04:00
if ( m_LibraryOutputPath [ m_LibraryOutputPath . size ( ) - 1 ] ! = ' / ' )
{
m_LibraryOutputPath + = " / " ;
}
if ( ! cmSystemTools : : MakeDirectory ( m_LibraryOutputPath . c_str ( ) ) )
{
cmSystemTools : : Error ( " Error failed create "
" LIBRARY_OUTPUT_PATH directory: " ,
m_LibraryOutputPath . c_str ( ) ) ;
}
m_Makefile - > AddLinkDirectory ( m_LibraryOutputPath . c_str ( ) ) ;
2001-06-14 01:03:49 +04:00
}
}
if ( m_Makefile - > GetDefinition ( " EXECUTABLE_OUTPUT_PATH " ) )
{
2001-08-28 18:57:25 +04:00
m_ExecutableOutputPath =
m_Makefile - > GetDefinition ( " EXECUTABLE_OUTPUT_PATH " ) ;
if ( m_ExecutableOutputPath . size ( ) )
2001-06-14 01:03:49 +04:00
{
2001-08-28 18:57:25 +04:00
if ( m_ExecutableOutputPath [ m_ExecutableOutputPath . size ( ) - 1 ] ! = ' / ' )
{
m_ExecutableOutputPath + = " / " ;
}
if ( ! cmSystemTools : : MakeDirectory ( m_ExecutableOutputPath . c_str ( ) ) )
{
cmSystemTools : : Error ( " Error failed to create "
" EXECUTABLE_OUTPUT_PATH directory: " ,
m_ExecutableOutputPath . c_str ( ) ) ;
}
m_Makefile - > AddLinkDirectory ( m_ExecutableOutputPath . c_str ( ) ) ;
2001-06-14 01:03:49 +04:00
}
}
2001-08-28 18:57:25 +04:00
2001-06-14 01:03:49 +04:00
2001-05-08 02:11:16 +04:00
if ( m_CacheOnly )
{
// Generate the cache only stuff
this - > GenerateCacheOnly ( ) ;
// if recurse then generate for all sub- makefiles
if ( m_Recurse )
{
this - > RecursiveGenerateCacheOnly ( ) ;
}
}
// normal makefile output
else
{
// Generate depends
cmMakeDepend md ;
md . SetMakefile ( m_Makefile ) ;
2001-07-17 23:09:16 +04:00
md . GenerateMakefileDependencies ( ) ;
2001-06-12 17:00:21 +04:00
this - > ProcessDepends ( md ) ;
2001-05-08 02:11:16 +04:00
// output the makefile fragment
2001-05-16 23:15:21 +04:00
this - > OutputMakefile ( " Makefile " ) ;
2001-05-08 02:11:16 +04:00
}
2001-01-05 19:41:20 +03:00
}
2001-06-12 17:00:21 +04:00
void cmUnixMakefileGenerator : : ProcessDepends ( const cmMakeDepend & md )
{
// Now create cmDependInformation objects for files in the directory
cmTargets & tgts = m_Makefile - > GetTargets ( ) ;
for ( cmTargets : : iterator l = tgts . begin ( ) ; l ! = tgts . end ( ) ; l + + )
{
2002-03-29 18:06:30 +03:00
std : : vector < cmSourceFile * > & classes = l - > second . GetSourceFiles ( ) ;
for ( std : : vector < cmSourceFile * > : : iterator i = classes . begin ( ) ;
2001-06-12 17:00:21 +04:00
i ! = classes . end ( ) ; + + i )
{
2002-03-29 18:06:30 +03:00
if ( ! ( * i ) - > GetIsAHeaderFileOnly ( ) )
2001-06-12 17:00:21 +04:00
{
// get the depends
const cmDependInformation * info =
2002-03-29 18:06:30 +03:00
md . GetDependInformationForSourceFile ( * ( * i ) ) ;
2001-06-12 18:59:40 +04:00
// Delete any hints from the source file's dependencies.
2002-03-29 18:06:30 +03:00
( * i ) - > GetDepends ( ) . erase ( ( * i ) - > GetDepends ( ) . begin ( ) , ( * i ) - > GetDepends ( ) . end ( ) ) ;
2001-06-12 18:59:40 +04:00
// Now add the real dependencies for the file.
2001-06-12 17:00:21 +04:00
if ( info )
{
2001-07-17 23:09:16 +04:00
for ( cmDependInformation : : DependencySet : : const_iterator d =
info - > m_DependencySet . begin ( ) ;
d ! = info - > m_DependencySet . end ( ) ; + + d )
2001-06-12 17:00:21 +04:00
{
2001-06-21 23:02:52 +04:00
// Make sure the full path is given. If not, the dependency was
// not found.
2001-07-17 23:09:16 +04:00
if ( ( * d ) - > m_FullPath ! = " " )
2001-06-21 23:02:52 +04:00
{
2002-03-29 18:06:30 +03:00
( * i ) - > GetDepends ( ) . push_back ( ( * d ) - > m_FullPath ) ;
2001-06-21 23:02:52 +04:00
}
2001-06-12 17:00:21 +04:00
}
}
}
}
}
}
2000-08-29 23:26:29 +04:00
2000-09-12 13:30:35 +04:00
// This is where CMakeTargets.make is generated
2001-01-05 19:41:20 +03:00
void cmUnixMakefileGenerator : : OutputMakefile ( const char * file )
2000-08-29 23:26:29 +04:00
{
2001-02-19 23:13:48 +03:00
// Create sub directories fro aux source directories
std : : vector < std : : string > & auxSourceDirs =
m_Makefile - > GetAuxSourceDirectories ( ) ;
2001-01-05 19:41:20 +03:00
if ( auxSourceDirs . size ( ) )
2000-09-21 21:45:08 +04:00
{
// For the case when this is running as a remote build
// on unix, make the directory
2001-01-05 19:41:20 +03:00
for ( std : : vector < std : : string > : : iterator i = auxSourceDirs . begin ( ) ;
i ! = auxSourceDirs . end ( ) ; + + i )
2000-09-21 21:45:08 +04:00
{
2001-06-18 23:32:08 +04:00
if ( i - > c_str ( ) [ 0 ] ! = ' / ' )
{
std : : string dir = m_Makefile - > GetCurrentOutputDirectory ( ) ;
if ( dir . size ( ) & & dir [ dir . size ( ) - 1 ] ! = ' / ' )
{
dir + = " / " ;
}
dir + = * i ;
cmSystemTools : : MakeDirectory ( dir . c_str ( ) ) ;
}
else
{
cmSystemTools : : MakeDirectory ( i - > c_str ( ) ) ;
}
2000-09-21 21:45:08 +04:00
}
}
2001-06-04 19:34:22 +04:00
// Create a stream that writes to a temporary file
// then does a copy at the end. This is to allow users
// to hit control-c during the make of the makefile
cmGeneratedFileStream tempFile ( file ) ;
tempFile . SetAlwaysCopy ( true ) ;
std : : ostream & fout = tempFile . GetStream ( ) ;
2000-08-29 23:26:29 +04:00
if ( ! fout )
{
2001-01-05 19:41:20 +03:00
cmSystemTools : : Error ( " Error can not open for write: " , file ) ;
2000-08-29 23:26:29 +04:00
return ;
}
2001-05-16 23:15:21 +04:00
fout < < " # CMAKE generated Makefile, DO NOT EDIT! \n "
2001-11-14 02:23:45 +03:00
< < " # Generated by \" " < < this - > GetName ( ) < < " \" "
< < " Generator, CMake Version "
< < cmMakefile : : GetMajorVersion ( ) < < " . "
< < cmMakefile : : GetMinorVersion ( ) < < " \n "
2001-05-16 23:15:21 +04:00
< < " # Generated from the following files: \n # "
< < m_Makefile - > GetHomeOutputDirectory ( ) < < " /CMakeCache.txt \n " ;
std : : vector < std : : string > lfiles = m_Makefile - > GetListFiles ( ) ;
// sort the array
std : : sort ( lfiles . begin ( ) , lfiles . end ( ) , std : : less < std : : string > ( ) ) ;
// remove duplicates
std : : vector < std : : string > : : iterator new_end =
std : : unique ( lfiles . begin ( ) , lfiles . end ( ) ) ;
lfiles . erase ( new_end , lfiles . end ( ) ) ;
for ( std : : vector < std : : string > : : const_iterator i = lfiles . begin ( ) ;
i ! = lfiles . end ( ) ; + + i )
{
fout < < " # " < < i - > c_str ( ) < < " \n " ;
}
fout < < " \n \n " ;
2001-12-20 23:46:37 +03:00
fout < < " # Suppresses display of executed commands \n " ;
fout < < " .SILENT: \n " ;
2002-01-16 23:53:29 +03:00
fout < < " # disable some common implicit rules to speed things up \n " ;
2002-01-16 01:21:54 +03:00
fout < < " .SUFFIXES: \n " ;
2002-01-21 19:39:00 +03:00
fout < < " .SUFFIXES:.hpuxmakemusthaverule \n " ;
2001-05-16 23:15:21 +04:00
// create a make variable with all of the sources for this Makefile
// for depend purposes.
fout < < " CMAKE_MAKEFILE_SOURCES = " ;
for ( std : : vector < std : : string > : : const_iterator i = lfiles . begin ( ) ;
i ! = lfiles . end ( ) ; + + i )
{
2002-02-22 21:38:33 +03:00
fout < < " " < < this - > ConvertToOutputPath ( i - > c_str ( ) ) ;
2001-05-16 23:15:21 +04:00
}
// Add the cache to the list
2001-11-22 01:45:01 +03:00
std : : string cacheFile = m_Makefile - > GetHomeOutputDirectory ( ) ;
cacheFile + = " /CMakeCache.txt " ;
2002-02-22 21:38:33 +03:00
fout < < " " < < this - > ConvertToOutputPath ( cacheFile . c_str ( ) ) ;
2001-11-22 01:45:01 +03:00
fout < < " \n \n \n " ;
2001-05-16 23:15:21 +04:00
this - > OutputMakeVariables ( fout ) ;
2001-11-07 22:44:22 +03:00
// Set up the default target as the VERY first target, so that make with no arguments will run it
2001-12-29 01:00:05 +03:00
this - >
OutputMakeRule ( fout ,
2002-01-02 19:54:50 +03:00
" Default target executed when no arguments are given to make, first make sure cmake.depends exists, cmake.check_depends is up-to-date, check the sources, then build the all target " ,
2001-12-29 01:00:05 +03:00
" default_target " ,
0 ,
2002-05-29 17:56:33 +04:00
" $(MAKE) $(MAKESILENT) cmake.depends " ,
" $(MAKE) $(MAKESILENT) cmake.check_depends " ,
" $(MAKE) $(MAKESILENT) -f cmake.check_depends " ,
" $(MAKE) $(MAKESILENT) all " ) ;
2001-12-29 01:00:05 +03:00
2001-04-11 22:59:02 +04:00
this - > OutputTargetRules ( fout ) ;
2001-08-29 18:46:59 +04:00
this - > OutputDependLibs ( fout ) ;
2001-04-11 22:59:02 +04:00
this - > OutputTargets ( fout ) ;
2001-02-19 23:13:48 +03:00
this - > OutputSubDirectoryRules ( fout ) ;
2001-05-22 21:22:30 +04:00
std : : string dependName = m_Makefile - > GetStartOutputDirectory ( ) ;
dependName + = " /cmake.depends " ;
2001-05-16 23:15:21 +04:00
if ( ! this - > m_CacheOnly )
{
std : : ofstream dependout ( dependName . c_str ( ) ) ;
if ( ! dependout )
{
cmSystemTools : : Error ( " Error can not open for write: " , dependName . c_str ( ) ) ;
return ;
}
2001-12-11 23:59:33 +03:00
dependout < < " # .o dependencies in this directory. " < < std : : endl ;
2001-12-29 01:00:05 +03:00
std : : string checkDepend = m_Makefile - > GetStartOutputDirectory ( ) ;
checkDepend + = " /cmake.check_depends " ;
std : : ofstream checkdependout ( checkDepend . c_str ( ) ) ;
if ( ! checkdependout )
{
cmSystemTools : : Error ( " Error can not open for write: " , checkDepend . c_str ( ) ) ;
return ;
}
checkdependout < < " # This file is used as a tag file, that all sources depend on. If a source changes, then the rule to rebuild this file will cause cmake.depends to be rebuilt. " < < std : : endl ;
// if there were any depends output, then output the check depends
// information inot checkdependout
if ( this - > OutputObjectDepends ( dependout ) )
{
this - > OutputCheckDepends ( checkdependout ) ;
}
else
{
2001-12-31 19:54:14 +03:00
checkdependout < < " all: \n \t @echo cmake.depends is up-to-date \n " ;
2001-12-29 01:00:05 +03:00
}
2001-05-16 23:15:21 +04:00
}
2001-03-03 00:04:26 +03:00
this - > OutputCustomRules ( fout ) ;
2001-05-16 23:15:21 +04:00
this - > OutputMakeRules ( fout ) ;
2001-05-23 19:53:37 +04:00
this - > OutputInstallRules ( fout ) ;
2001-05-16 23:15:21 +04:00
// only add the depend include if the depend file exists
if ( cmSystemTools : : FileExists ( dependName . c_str ( ) ) )
{
2001-11-16 01:11:26 +03:00
this - > OutputIncludeMakefile ( fout , " cmake.depends " ) ;
2001-05-16 23:15:21 +04:00
}
2001-02-19 23:13:48 +03:00
}
2001-11-16 01:11:26 +03:00
void cmUnixMakefileGenerator : : OutputIncludeMakefile ( std : : ostream & fout ,
const char * file )
{
fout < < " include " < < file < < " \n " ;
}
std : : string
2001-12-01 01:20:43 +03:00
cmUnixMakefileGenerator : : GetOutputExtension ( const char * )
2001-11-16 01:11:26 +03:00
{
return m_ObjectFileExtension ;
}
2001-05-16 23:15:21 +04:00
2001-06-27 23:13:26 +04:00
2001-04-11 22:59:02 +04:00
// Output the rules for any targets
void cmUnixMakefileGenerator : : OutputTargetRules ( std : : ostream & fout )
2001-02-19 23:13:48 +03:00
{
2001-04-11 22:59:02 +04:00
// for each target add to the list of targets
fout < < " TARGETS = " ;
const cmTargets & tgts = m_Makefile - > GetTargets ( ) ;
2001-05-05 01:00:22 +04:00
// list libraries first
2001-04-11 22:59:02 +04:00
for ( cmTargets : : const_iterator l = tgts . begin ( ) ;
l ! = tgts . end ( ) ; l + + )
2001-02-19 23:13:48 +03:00
{
2001-07-02 23:38:02 +04:00
if ( l - > second . IsInAll ( ) )
2001-04-11 22:59:02 +04:00
{
2001-11-22 01:45:01 +03:00
std : : string path = m_LibraryOutputPath + m_LibraryPrefix ;
2001-07-02 23:38:02 +04:00
if ( l - > second . GetType ( ) = = cmTarget : : STATIC_LIBRARY )
2001-05-16 23:15:21 +04:00
{
2001-11-22 01:45:01 +03:00
path = path + l - > first + m_StaticLibraryExtension ;
fout < < " \\ \n "
2002-02-22 21:38:33 +03:00
< < this - > ConvertToOutputPath ( path . c_str ( ) ) ;
2001-05-16 23:15:21 +04:00
}
2001-07-02 23:38:02 +04:00
else if ( l - > second . GetType ( ) = = cmTarget : : SHARED_LIBRARY )
2001-05-16 23:15:21 +04:00
{
2001-11-22 01:45:01 +03:00
path = path + l - > first +
m_Makefile - > GetDefinition ( " CMAKE_SHLIB_SUFFIX " ) ;
fout < < " \\ \n "
2002-02-22 21:38:33 +03:00
< < this - > ConvertToOutputPath ( path . c_str ( ) ) ;
2001-05-16 23:15:21 +04:00
}
2001-08-29 02:02:59 +04:00
else if ( l - > second . GetType ( ) = = cmTarget : : MODULE_LIBRARY )
{
2001-11-22 01:45:01 +03:00
path = path + l - > first +
m_Makefile - > GetDefinition ( " CMAKE_MODULE_SUFFIX " ) ;
fout < < " \\ \n "
2002-02-22 21:38:33 +03:00
< < this - > ConvertToOutputPath ( path . c_str ( ) ) ;
2001-08-29 02:02:59 +04:00
}
2001-04-11 22:59:02 +04:00
}
2001-04-12 23:34:09 +04:00
}
// executables
for ( cmTargets : : const_iterator l = tgts . begin ( ) ;
l ! = tgts . end ( ) ; l + + )
{
2001-05-11 18:53:17 +04:00
if ( ( l - > second . GetType ( ) = = cmTarget : : EXECUTABLE | |
l - > second . GetType ( ) = = cmTarget : : WIN32_EXECUTABLE ) & &
l - > second . IsInAll ( ) )
2001-05-05 01:00:22 +04:00
{
2001-11-22 01:45:01 +03:00
std : : string path = m_ExecutableOutputPath + l - > first +
m_ExecutableExtension ;
2002-02-22 21:38:33 +03:00
fout < < " \\ \n " < < this - > ConvertToOutputPath ( path . c_str ( ) ) ;
2001-05-05 01:00:22 +04:00
}
}
// list utilities last
for ( cmTargets : : const_iterator l = tgts . begin ( ) ;
l ! = tgts . end ( ) ; l + + )
{
if ( l - > second . GetType ( ) = = cmTarget : : UTILITY & &
l - > second . IsInAll ( ) )
2001-04-11 22:59:02 +04:00
{
2001-05-05 01:00:22 +04:00
fout < < " \\ \n " < < l - > first . c_str ( ) ;
2001-04-11 22:59:02 +04:00
}
2001-02-19 23:13:48 +03:00
}
2001-04-11 22:59:02 +04:00
fout < < " \n \n " ;
// get the classes from the source lists then add them to the groups
for ( cmTargets : : const_iterator l = tgts . begin ( ) ;
l ! = tgts . end ( ) ; l + + )
2001-02-19 23:13:48 +03:00
{
2002-03-29 18:06:30 +03:00
std : : vector < cmSourceFile * > classes = l - > second . GetSourceFiles ( ) ;
2001-05-23 19:53:37 +04:00
if ( classes . begin ( ) ! = classes . end ( ) )
2001-02-19 23:13:48 +03:00
{
2002-02-21 23:55:20 +03:00
fout < < this - > CreateMakeVariable ( l - > first . c_str ( ) , " _SRC_OBJS " ) < < " = " ;
2002-03-29 18:06:30 +03:00
for ( std : : vector < cmSourceFile * > : : iterator i = classes . begin ( ) ;
2002-02-21 23:55:20 +03:00
i ! = classes . end ( ) ; i + + )
{
2002-03-29 18:06:30 +03:00
if ( ! ( * i ) - > IsAHeaderFileOnly ( ) )
2002-02-21 23:55:20 +03:00
{
2002-03-29 18:06:30 +03:00
std : : string outExt ( this - > GetOutputExtension ( ( * i ) - > GetSourceExtension ( ) . c_str ( ) ) ) ;
2002-02-21 23:55:20 +03:00
if ( outExt . size ( ) )
{
2002-03-29 18:06:30 +03:00
fout < < " \\ \n " < < this - > ConvertToOutputPath ( ( * i ) - > GetSourceName ( ) . c_str ( ) )
2002-02-21 23:55:20 +03:00
< < outExt . c_str ( ) < < " " ;
}
}
}
fout < < " \n \n " ;
fout < < this - > CreateMakeVariable ( l - > first . c_str ( ) , " _SRC_OBJS_QUOTED " ) < < " = " ;
2002-03-29 18:06:30 +03:00
for ( std : : vector < cmSourceFile * > : : iterator i = classes . begin ( ) ;
2002-02-21 23:55:20 +03:00
i ! = classes . end ( ) ; i + + )
{
2002-03-29 18:06:30 +03:00
if ( ! ( * i ) - > IsAHeaderFileOnly ( ) )
2002-02-21 23:55:20 +03:00
{
2002-03-29 18:06:30 +03:00
std : : string outExt ( this - > GetOutputExtension ( ( * i ) - > GetSourceExtension ( ) . c_str ( ) ) ) ;
2002-02-21 23:55:20 +03:00
if ( outExt . size ( ) )
{
2002-03-29 18:06:30 +03:00
fout < < " \\ \n \" " < < this - > ConvertToOutputPath ( ( * i ) - > GetSourceName ( ) . c_str ( ) )
2002-02-21 23:55:20 +03:00
< < outExt . c_str ( ) < < " \" " ;
}
}
}
fout < < " \n \n " ;
2001-02-19 23:13:48 +03:00
}
2001-04-11 22:59:02 +04:00
}
2001-05-16 23:15:21 +04:00
fout < < " CLEAN_OBJECT_FILES = " ;
for ( cmTargets : : const_iterator l = tgts . begin ( ) ;
l ! = tgts . end ( ) ; l + + )
{
2002-03-29 18:06:30 +03:00
std : : vector < cmSourceFile * > classes = l - > second . GetSourceFiles ( ) ;
2001-05-23 19:53:37 +04:00
if ( classes . begin ( ) ! = classes . end ( ) )
{
2002-02-21 23:55:20 +03:00
fout < < " $( " < < this - > CreateMakeVariable ( l - > first . c_str ( ) , " _SRC_OBJS " )
< < " ) " ;
2001-05-23 19:53:37 +04:00
}
2001-05-16 23:15:21 +04:00
}
2001-08-29 18:46:59 +04:00
fout < < " \n \n " ;
2001-04-11 22:59:02 +04:00
}
2001-04-12 17:55:08 +04:00
/**
* Output the linking rules on a command line . For executables ,
* targetLibrary should be a NULL pointer . For libraries , it should point
* to the name of the library . This will not link a library against itself .
*/
void cmUnixMakefileGenerator : : OutputLinkLibraries ( std : : ostream & fout ,
2001-04-30 18:44:00 +04:00
const char * targetLibrary ,
const cmTarget & tgt )
2001-04-11 22:59:02 +04:00
{
2001-06-06 06:54:42 +04:00
// Try to emit each search path once
std : : set < std : : string > emitted ;
2001-06-08 08:18:54 +04:00
// Embed runtime search paths if possible and if required.
2001-07-02 23:38:02 +04:00
bool outputRuntime = true ;
2001-06-08 08:18:54 +04:00
std : : string runtimeFlag ;
std : : string runtimeSep ;
std : : vector < std : : string > runtimeDirs ;
2002-04-26 20:21:13 +04:00
bool cxx = tgt . HasCxx ( ) ;
if ( ! cxx )
2001-06-08 08:18:54 +04:00
{
2002-04-26 20:43:08 +04:00
// if linking a c executable use the C runtime flag as cc
// may not be the same program that creates shared libaries
// and may have different flags
2002-04-26 20:21:13 +04:00
if ( tgt . GetType ( ) = = cmTarget : : EXECUTABLE )
2002-04-08 21:36:18 +04:00
{
2002-04-26 20:21:13 +04:00
if ( m_Makefile - > GetDefinition ( " CMAKE_C_SHLIB_RUNTIME_FLAG " ) )
{
runtimeFlag = m_Makefile - > GetDefinition ( " CMAKE_C_SHLIB_RUNTIME_FLAG " ) ;
}
}
else
{
if ( m_Makefile - > GetDefinition ( " CMAKE_SHLIB_RUNTIME_FLAG " ) )
{
runtimeFlag = m_Makefile - > GetDefinition ( " CMAKE_SHLIB_RUNTIME_FLAG " ) ;
}
2002-04-08 21:36:18 +04:00
}
if ( m_Makefile - > GetDefinition ( " CMAKE_SHLIB_RUNTIME_SEP " ) )
{
runtimeSep = m_Makefile - > GetDefinition ( " CMAKE_SHLIB_RUNTIME_SEP " ) ;
}
2001-06-08 08:18:54 +04:00
}
2002-04-08 21:36:18 +04:00
else
2001-06-08 08:18:54 +04:00
{
2002-04-08 21:36:18 +04:00
if ( m_Makefile - > GetDefinition ( " CMAKE_CXX_SHLIB_RUNTIME_FLAG " ) )
{
runtimeFlag = m_Makefile - > GetDefinition ( " CMAKE_CXX_SHLIB_RUNTIME_FLAG " ) ;
}
if ( m_Makefile - > GetDefinition ( " CMAKE_CXX_SHLIB_RUNTIME_SEP " ) )
{
runtimeSep = m_Makefile - > GetDefinition ( " CMAKE_CXX_SHLIB_RUNTIME_SEP " ) ;
}
2001-06-08 08:18:54 +04:00
}
2002-04-08 21:36:18 +04:00
2001-06-08 08:18:54 +04:00
// concatenate all paths or no?
bool runtimeConcatenate = ( runtimeSep ! = " " ) ;
2001-12-21 08:01:02 +03:00
if ( runtimeFlag = = " " | | m_Makefile - > IsOn ( " CMAKE_SKIP_RPATH " ) )
2001-06-08 08:18:54 +04:00
{
outputRuntime = false ;
}
2001-06-15 18:35:06 +04:00
// Some search paths should never be emitted
emitted . insert ( " " ) ;
emitted . insert ( " /usr/lib " ) ;
2001-04-11 22:59:02 +04:00
// collect all the flags needed for linking libraries
2001-06-08 08:18:54 +04:00
std : : string linkLibs ;
2002-05-01 22:00:21 +04:00
const std : : vector < std : : string > & libdirs = tgt . GetLinkDirectories ( ) ;
for ( std : : vector < std : : string > : : const_iterator libDir = libdirs . begin ( ) ;
2001-05-10 19:20:16 +04:00
libDir ! = libdirs . end ( ) ; + + libDir )
2001-04-11 22:59:02 +04:00
{
2002-02-22 21:38:33 +03:00
std : : string libpath = this - > ConvertToOutputPath ( libDir - > c_str ( ) ) ;
2001-06-14 01:03:49 +04:00
if ( emitted . insert ( libpath ) . second )
2001-04-11 22:59:02 +04:00
{
2001-06-14 01:03:49 +04:00
std : : string : : size_type pos = libDir - > find ( " -L " ) ;
if ( ( pos = = std : : string : : npos | | pos > 0 )
& & libDir - > find ( " ${ " ) = = std : : string : : npos )
2001-05-23 01:49:18 +04:00
{
2001-06-14 01:03:49 +04:00
linkLibs + = " -L " ;
if ( outputRuntime )
2001-06-06 06:54:42 +04:00
{
2001-06-14 01:03:49 +04:00
runtimeDirs . push_back ( libpath ) ;
2001-06-06 06:54:42 +04:00
}
2001-05-23 01:49:18 +04:00
}
2001-06-14 01:03:49 +04:00
linkLibs + = libpath ;
linkLibs + = " " ;
2001-04-11 22:59:02 +04:00
}
}
2001-11-13 23:54:41 +03:00
2001-04-11 22:59:02 +04:00
std : : string librariesLinked ;
2001-04-30 18:44:00 +04:00
const cmTarget : : LinkLibraries & libs = tgt . GetLinkLibraries ( ) ;
2001-05-10 19:20:16 +04:00
for ( cmTarget : : LinkLibraries : : const_iterator lib = libs . begin ( ) ;
lib ! = libs . end ( ) ; + + lib )
2001-04-11 22:59:02 +04:00
{
2001-04-12 17:55:08 +04:00
// Don't link the library against itself!
2001-05-10 19:20:16 +04:00
if ( targetLibrary & & ( lib - > first = = targetLibrary ) ) continue ;
2001-04-27 00:22:53 +04:00
// don't look at debug libraries
2001-05-10 19:20:16 +04:00
if ( lib - > second = = cmTarget : : DEBUG ) continue ;
2001-05-16 23:15:21 +04:00
// skip zero size library entries, this may happen
// if a variable expands to nothing.
if ( lib - > first . size ( ) = = 0 ) continue ;
// if it is a full path break it into -L and -l
2002-04-30 16:09:41 +04:00
cmRegularExpression reg ( " ([ \t ]* \\ -l) | ( [ \ t ] * \ \ - framework ) | ( \ \ $ { ) " );
2001-05-19 00:45:53 +04:00
if ( lib - > first . find ( ' / ' ) ! = std : : string : : npos
& & ! reg . find ( lib - > first ) )
2001-04-11 22:59:02 +04:00
{
2001-05-09 22:53:32 +04:00
std : : string dir , file ;
2001-05-10 19:20:16 +04:00
cmSystemTools : : SplitProgramPath ( lib - > first . c_str ( ) ,
2001-05-09 22:53:32 +04:00
dir , file ) ;
2002-02-22 21:38:33 +03:00
std : : string libpath = this - > ConvertToOutputPath ( dir . c_str ( ) ) ;
2001-06-15 18:35:06 +04:00
if ( emitted . insert ( libpath ) . second )
2001-05-23 01:49:18 +04:00
{
2001-06-15 18:35:06 +04:00
linkLibs + = " -L " ;
linkLibs + = libpath ;
linkLibs + = " " ;
if ( outputRuntime )
2001-06-06 06:54:42 +04:00
{
2001-06-15 18:35:06 +04:00
runtimeDirs . push_back ( libpath ) ;
2001-06-06 06:54:42 +04:00
}
2001-05-23 01:49:18 +04:00
}
2001-09-28 18:40:14 +04:00
cmRegularExpression libname ( " lib(.*) ( \ \ . so | \ \ . sl | \ \ . a | \ \ . dylib ) . * " ) ;
cmRegularExpression libname_noprefix ( " (.*) ( \ \ . so | \ \ . sl | \ \ . a | \ \ . dylib ) . * " ) ;
2001-05-22 00:10:20 +04:00
if ( libname . find ( file ) )
2001-05-11 22:39:30 +04:00
{
2001-05-25 22:27:30 +04:00
librariesLinked + = " -l " ;
2001-05-22 00:10:20 +04:00
file = libname . match ( 1 ) ;
2001-05-25 22:27:30 +04:00
librariesLinked + = file ;
librariesLinked + = " " ;
2001-05-11 22:39:30 +04:00
}
2001-07-10 21:57:35 +04:00
else if ( libname_noprefix . find ( file ) )
{
librariesLinked + = " -l " ;
file = libname_noprefix . match ( 1 ) ;
librariesLinked + = file ;
librariesLinked + = " " ;
}
2001-05-09 22:53:32 +04:00
}
2001-05-16 23:15:21 +04:00
// not a full path, so add -l name
2001-05-09 22:53:32 +04:00
else
{
2001-05-19 00:45:53 +04:00
if ( ! reg . find ( lib - > first ) )
2001-05-09 22:53:32 +04:00
{
librariesLinked + = " -l " ;
}
2001-05-10 19:20:16 +04:00
librariesLinked + = lib - > first ;
2001-05-09 22:53:32 +04:00
librariesLinked + = " " ;
2001-04-11 22:59:02 +04:00
}
}
2001-06-06 06:54:42 +04:00
2001-04-11 22:59:02 +04:00
linkLibs + = librariesLinked ;
2001-04-12 17:55:08 +04:00
fout < < linkLibs ;
2001-06-08 08:18:54 +04:00
if ( outputRuntime & & runtimeDirs . size ( ) > 0 )
{
2001-06-12 22:15:22 +04:00
// For the runtime search directories, do a "-Wl,-rpath,a:b:c" or
// a "-R a -R b -R c" type link line
2001-06-08 08:18:54 +04:00
fout < < runtimeFlag ;
std : : vector < std : : string > : : iterator itr = runtimeDirs . begin ( ) ;
fout < < * itr ;
+ + itr ;
for ( ; itr ! = runtimeDirs . end ( ) ; + + itr )
{
if ( runtimeConcatenate )
{
fout < < runtimeSep < < * itr ;
}
else
{
fout < < " " < < runtimeFlag < < * itr ;
}
}
fout < < " " ;
}
2001-04-11 22:59:02 +04:00
}
2001-04-12 17:55:08 +04:00
2001-12-07 18:58:06 +03:00
std : : string cmUnixMakefileGenerator : : CreateTargetRules ( const cmTarget & target ,
const char * targetName )
{
std : : string customRuleCode = " " ;
bool initNext = false ;
for ( std : : vector < cmCustomCommand > : : const_iterator cr =
target . GetCustomCommands ( ) . begin ( ) ;
cr ! = target . GetCustomCommands ( ) . end ( ) ; + + cr )
{
cmCustomCommand cc ( * cr ) ;
cc . ExpandVariables ( * m_Makefile ) ;
if ( cc . GetSourceName ( ) = = targetName )
{
if ( initNext )
{
customRuleCode + = " \n \t " ;
}
else
{
initNext = true ;
}
2002-02-22 21:38:33 +03:00
std : : string command = this - > ConvertToOutputPath ( cc . GetCommand ( ) . c_str ( ) ) ;
2001-12-07 18:58:06 +03:00
customRuleCode + = command + " " + cc . GetArguments ( ) ;
}
}
return customRuleCode ;
}
2001-11-02 02:37:28 +03:00
void cmUnixMakefileGenerator : : OutputSharedLibraryRule ( std : : ostream & fout ,
const char * name ,
const cmTarget & t )
{
std : : string target = m_LibraryOutputPath + " lib " + name + " $(SHLIB_SUFFIX) " ;
2001-11-05 23:39:37 +03:00
std : : string depend = " $( " ;
2002-02-21 23:55:20 +03:00
depend + = this - > CreateMakeVariable ( name , " _SRC_OBJS " ) ;
depend + = " ) $( " + this - > CreateMakeVariable ( name , " _DEPEND_LIBS " ) + " ) " ;
2001-12-18 18:21:59 +03:00
std : : string command = " $(RM) lib " ;
2001-11-02 02:37:28 +03:00
command + = name ;
command + = " $(SHLIB_SUFFIX) " ;
2002-04-03 00:43:23 +04:00
std : : string command2 ;
if ( t . HasCxx ( ) )
{
2002-04-08 21:36:18 +04:00
command2 = " $(CMAKE_CXX_LINK_SHARED) $(CMAKE_CXX_SHLIB_LINK_FLAGS) "
" $(CMAKE_CXX_SHLIB_BUILD_FLAGS) $(CMAKE_CXX_FLAGS) -o \\ \n " ;
2002-04-03 00:43:23 +04:00
}
else
{
2002-04-08 21:36:18 +04:00
command2 = " $(CMAKE_C_LINK_SHARED) $(CMAKE_SHLIB_LINK_FLAGS) "
" $(CMAKE_SHLIB_BUILD_FLAGS) -o \\ \n " ;
2002-04-03 00:43:23 +04:00
}
2001-11-02 02:37:28 +03:00
command2 + = " \t " ;
2002-02-22 23:40:44 +03:00
std : : string libName = m_LibraryOutputPath + " lib " + std : : string ( name ) + " $(SHLIB_SUFFIX) " ;
libName = this - > ConvertToOutputPath ( libName . c_str ( ) ) ;
command2 + = libName + " \\ \n " ;
2002-02-21 23:55:20 +03:00
command2 + = " \t $( " + this - > CreateMakeVariable ( name , " _SRC_OBJS " ) + " ) " ;
2002-06-19 23:21:49 +04:00
cmStringStream linklibs ;
2001-11-02 02:37:28 +03:00
this - > OutputLinkLibraries ( linklibs , name , t ) ;
command2 + = linklibs . str ( ) ;
2001-12-07 18:58:06 +03:00
std : : string customCommands = this - > CreateTargetRules ( t , name ) ;
const char * cc = 0 ;
if ( customCommands . size ( ) > 0 )
{
cc = customCommands . c_str ( ) ;
}
2001-11-02 02:37:28 +03:00
this - > OutputMakeRule ( fout , " rules for a shared library " ,
target . c_str ( ) ,
depend . c_str ( ) ,
command . c_str ( ) ,
2001-12-07 18:58:06 +03:00
command2 . c_str ( ) ,
cc ) ;
2001-11-02 02:37:28 +03:00
}
void cmUnixMakefileGenerator : : OutputModuleLibraryRule ( std : : ostream & fout ,
const char * name ,
const cmTarget & t )
{
std : : string target = m_LibraryOutputPath + " lib " + std : : string ( name ) + " $(MODULE_SUFFIX) " ;
2001-11-05 23:39:37 +03:00
std : : string depend = " $( " ;
2002-02-21 23:55:20 +03:00
depend + = this - > CreateMakeVariable ( name , " _SRC_OBJS " )
+ " ) $( " + this - > CreateMakeVariable ( name , " _DEPEND_LIBS " ) + " ) " ;
2001-12-18 18:21:59 +03:00
std : : string command = " $(RM) lib " + std : : string ( name ) + " $(MODULE_SUFFIX) " ;
2002-04-03 00:43:23 +04:00
std : : string command2 ;
if ( t . HasCxx ( ) )
{
2002-04-12 00:58:43 +04:00
command2 = " $(CMAKE_CXX_LINK_SHARED) $(CMAKE_CXX_MODULE_LINK_FLAGS) "
" $(CMAKE_CXX_MODULE_BUILD_FLAGS) $(CMAKE_CXX_FLAGS) -o \\ \n " ;
2002-04-03 00:43:23 +04:00
}
else
{
2002-04-08 21:36:18 +04:00
command2 = " $(CMAKE_C_LINK_SHARED) $(CMAKE_SHLIB_LINK_FLAGS) "
" $(CMAKE_SHLIB_BUILD_FLAGS) -o \\ \n " ;
2002-04-03 00:43:23 +04:00
}
2001-11-02 02:37:28 +03:00
command2 + = " \t " ;
2002-02-22 23:40:44 +03:00
std : : string libName = m_LibraryOutputPath + " lib " + std : : string ( name ) + " $(MODULE_SUFFIX) " ;
libName = this - > ConvertToOutputPath ( libName . c_str ( ) ) ;
command2 + = libName + " \\ \n " ;
2002-02-21 23:55:20 +03:00
command2 + = " \t $( " + this - > CreateMakeVariable ( name , " _SRC_OBJS " ) + " ) " ;
2002-06-19 23:21:49 +04:00
cmStringStream linklibs ;
2001-11-02 02:37:28 +03:00
this - > OutputLinkLibraries ( linklibs , std : : string ( name ) . c_str ( ) , t ) ;
command2 + = linklibs . str ( ) ;
2001-12-07 18:58:06 +03:00
std : : string customCommands = this - > CreateTargetRules ( t , name ) ;
const char * cc = 0 ;
if ( customCommands . size ( ) > 0 )
{
cc = customCommands . c_str ( ) ;
}
2001-11-02 02:37:28 +03:00
this - > OutputMakeRule ( fout , " rules for a shared module library " ,
target . c_str ( ) ,
depend . c_str ( ) ,
command . c_str ( ) ,
2001-12-07 18:58:06 +03:00
command2 . c_str ( ) ,
cc ) ;
2001-11-02 02:37:28 +03:00
}
void cmUnixMakefileGenerator : : OutputStaticLibraryRule ( std : : ostream & fout ,
const char * name ,
2001-12-07 18:58:06 +03:00
const cmTarget & t )
2001-11-02 02:37:28 +03:00
{
std : : string target = m_LibraryOutputPath + " lib " + std : : string ( name ) + " .a " ;
2002-02-22 23:40:44 +03:00
target = this - > ConvertToOutputPath ( target . c_str ( ) ) ;
2001-11-05 23:39:37 +03:00
std : : string depend = " $( " ;
2002-02-21 23:55:20 +03:00
depend + = this - > CreateMakeVariable ( name , " _SRC_OBJS " ) + " ) " ;
2002-04-04 20:01:41 +04:00
std : : string command ;
if ( t . HasCxx ( ) )
{
command = " $(CMAKE_CXX_AR) $(CMAKE_CXX_AR_ARGS) " ;
}
else
{
command = " $(CMAKE_AR) $(CMAKE_AR_ARGS) " ;
}
2002-02-22 23:40:44 +03:00
command + = target ;
command + = " $( " ;
2002-02-21 23:55:20 +03:00
command + = this - > CreateMakeVariable ( name , " _SRC_OBJS " ) + " ) " ;
2001-11-05 23:39:37 +03:00
std : : string command2 = " $(CMAKE_RANLIB) " ;
2002-02-22 23:40:44 +03:00
command2 + = target ;
2001-11-02 02:37:28 +03:00
std : : string comment = " rule to build static library: " ;
comment + = name ;
2001-12-07 18:58:06 +03:00
std : : string customCommands = this - > CreateTargetRules ( t , name ) ;
const char * cc = 0 ;
if ( customCommands . size ( ) > 0 )
{
cc = customCommands . c_str ( ) ;
}
2001-11-02 02:37:28 +03:00
this - > OutputMakeRule ( fout ,
comment . c_str ( ) ,
target . c_str ( ) ,
depend . c_str ( ) ,
command . c_str ( ) ,
2001-12-07 18:58:06 +03:00
command2 . c_str ( ) ,
cc ) ;
2001-11-02 02:37:28 +03:00
}
void cmUnixMakefileGenerator : : OutputExecutableRule ( std : : ostream & fout ,
const char * name ,
2001-12-01 01:20:43 +03:00
const cmTarget & t )
2001-11-02 02:37:28 +03:00
{
std : : string target = m_ExecutableOutputPath + name ;
2001-11-05 23:39:37 +03:00
std : : string depend = " $( " ;
2002-02-21 23:55:20 +03:00
depend + = this - > CreateMakeVariable ( name , " _SRC_OBJS " )
+ " ) $( " + this - > CreateMakeVariable ( name , " _DEPEND_LIBS " ) + " ) " ;
2002-04-03 00:43:23 +04:00
std : : string command ;
if ( t . HasCxx ( ) )
{
command =
2002-04-08 21:36:18 +04:00
" $(CMAKE_CXX_COMPILER) $(CMAKE_CXX_SHLIB_LINK_FLAGS) $(CMAKE_CXX_FLAGS) " ;
2002-04-03 00:43:23 +04:00
}
else
{
command =
2002-04-26 20:21:13 +04:00
" $(CMAKE_C_COMPILER) $(CMAKE_C_SHLIB_LINK_FLAGS) $(CMAKE_C_FLAGS) " ;
2002-04-03 00:43:23 +04:00
}
2002-02-21 23:55:20 +03:00
command + = " $( " + this - > CreateMakeVariable ( name , " _SRC_OBJS " ) + " ) " ;
2002-06-19 23:21:49 +04:00
cmStringStream linklibs ;
2001-11-02 02:37:28 +03:00
this - > OutputLinkLibraries ( linklibs , 0 , t ) ;
command + = linklibs . str ( ) ;
2002-02-22 23:40:44 +03:00
std : : string outputFile = m_ExecutableOutputPath + name ;
command + = " -o " + this - > ConvertToOutputPath ( outputFile . c_str ( ) ) ;
2001-11-02 02:37:28 +03:00
std : : string comment = " rule to build executable: " ;
comment + = name ;
2001-12-07 18:58:06 +03:00
std : : string customCommands = this - > CreateTargetRules ( t , name ) ;
const char * cc = 0 ;
if ( customCommands . size ( ) > 0 )
{
cc = customCommands . c_str ( ) ;
}
2001-11-02 02:37:28 +03:00
this - > OutputMakeRule ( fout ,
comment . c_str ( ) ,
target . c_str ( ) ,
depend . c_str ( ) ,
2001-12-07 18:58:06 +03:00
command . c_str ( ) ,
cc ) ;
2001-11-02 02:37:28 +03:00
}
2002-04-11 18:29:51 +04:00
void cmUnixMakefileGenerator : : OutputUtilityRule ( std : : ostream & fout ,
const char * name ,
const cmTarget & t )
{
std : : string customCommands = this - > CreateTargetRules ( t , name ) ;
const char * cc = 0 ;
if ( customCommands . size ( ) > 0 )
{
cc = customCommands . c_str ( ) ;
}
std : : string comment = " Rule to build Utility " ;
comment + = name ;
2002-04-23 19:33:28 +04:00
std : : string depends ;
const std : : vector < cmCustomCommand > & ccs = t . GetCustomCommands ( ) ;
for ( std : : vector < cmCustomCommand > : : const_iterator i = ccs . begin ( ) ;
i ! = ccs . end ( ) ; + + i )
{
const std : : vector < std : : string > & dep = i - > GetDepends ( ) ;
for ( std : : vector < std : : string > : : const_iterator d = dep . begin ( ) ;
d ! = dep . end ( ) ; + + d )
{
2002-04-23 20:18:51 +04:00
depends + = " \\ \n " ;
depends + = * d ;
2002-04-23 19:33:28 +04:00
}
}
2002-04-11 18:29:51 +04:00
this - > OutputMakeRule ( fout ,
comment . c_str ( ) ,
name ,
2002-04-23 19:33:28 +04:00
depends . c_str ( ) ,
2002-04-11 18:29:51 +04:00
cc ) ;
}
2001-11-02 02:37:28 +03:00
2001-04-11 22:59:02 +04:00
void cmUnixMakefileGenerator : : OutputTargets ( std : : ostream & fout )
{
// for each target
const cmTargets & tgts = m_Makefile - > GetTargets ( ) ;
for ( cmTargets : : const_iterator l = tgts . begin ( ) ;
l ! = tgts . end ( ) ; l + + )
{
2001-11-02 02:37:28 +03:00
switch ( l - > second . GetType ( ) )
2001-07-02 23:38:02 +04:00
{
2001-11-02 02:37:28 +03:00
case cmTarget : : STATIC_LIBRARY :
this - > OutputStaticLibraryRule ( fout , l - > first . c_str ( ) , l - > second ) ;
break ;
case cmTarget : : SHARED_LIBRARY :
this - > OutputSharedLibraryRule ( fout , l - > first . c_str ( ) , l - > second ) ;
break ;
case cmTarget : : MODULE_LIBRARY :
this - > OutputModuleLibraryRule ( fout , l - > first . c_str ( ) , l - > second ) ;
break ;
case cmTarget : : EXECUTABLE :
case cmTarget : : WIN32_EXECUTABLE :
this - > OutputExecutableRule ( fout , l - > first . c_str ( ) , l - > second ) ;
break ;
2001-11-13 20:38:53 +03:00
case cmTarget : : UTILITY :
2002-04-11 18:29:51 +04:00
this - > OutputUtilityRule ( fout , l - > first . c_str ( ) , l - > second ) ;
break ;
2001-11-13 23:54:41 +03:00
// This is handled by the OutputCustomRules method
2001-11-13 20:38:53 +03:00
case cmTarget : : INSTALL_FILES :
2001-11-13 23:54:41 +03:00
// This is handled by the OutputInstallRules method
2001-11-13 20:38:53 +03:00
case cmTarget : : INSTALL_PROGRAMS :
2001-11-13 23:54:41 +03:00
// This is handled by the OutputInstallRules method
2001-11-13 20:38:53 +03:00
break ;
2001-04-11 22:59:02 +04:00
}
2001-02-19 23:13:48 +03:00
}
}
2001-11-02 02:37:28 +03:00
2001-08-29 18:46:59 +04:00
// For each target that is an executable or shared library, generate
// the "<name>_DEPEND_LIBS" variable listing its library dependencies.
void cmUnixMakefileGenerator : : OutputDependLibs ( std : : ostream & fout )
2001-02-19 23:13:48 +03:00
{
2001-08-29 18:46:59 +04:00
// Build a set of libraries that will be linked into any target in
// this directory.
std : : set < std : : string > used ;
// for each target
const cmTargets & tgts = m_Makefile - > GetTargets ( ) ;
for ( cmTargets : : const_iterator l = tgts . begin ( ) ;
l ! = tgts . end ( ) ; l + + )
2001-02-19 23:13:48 +03:00
{
2001-08-29 18:46:59 +04:00
// Each dependency should only be emitted once per target.
std : : set < std : : string > emitted ;
if ( ( l - > second . GetType ( ) = = cmTarget : : SHARED_LIBRARY )
| | ( l - > second . GetType ( ) = = cmTarget : : MODULE_LIBRARY )
| | ( l - > second . GetType ( ) = = cmTarget : : EXECUTABLE )
| | ( l - > second . GetType ( ) = = cmTarget : : WIN32_EXECUTABLE ) )
2001-02-19 23:13:48 +03:00
{
2002-02-21 23:55:20 +03:00
fout < < this - > CreateMakeVariable ( l - > first . c_str ( ) , " _DEPEND_LIBS " ) < < " = " ;
2001-08-29 18:46:59 +04:00
// A library should not depend on itself!
emitted . insert ( l - > first ) ;
// Now, look at all link libraries specific to this target.
const cmTarget : : LinkLibraries & tlibs = l - > second . GetLinkLibraries ( ) ;
for ( cmTarget : : LinkLibraries : : const_iterator lib = tlibs . begin ( ) ;
lib ! = tlibs . end ( ) ; + + lib )
2001-06-14 01:03:49 +04:00
{
2001-08-29 18:46:59 +04:00
// Record that this library was used.
used . insert ( lib - > first ) ;
// Don't emit the same library twice for this target.
if ( emitted . insert ( lib - > first ) . second )
{
// Output this dependency.
this - > OutputLibDepend ( fout , lib - > first . c_str ( ) ) ;
}
2001-05-16 23:15:21 +04:00
}
2002-01-17 23:46:04 +03:00
// Now, look at all utilities specific to this target.
2002-05-09 17:33:52 +04:00
const std : : set < cmStdString > & tutils = l - > second . GetUtilities ( ) ;
for ( std : : set < cmStdString > : : const_iterator util = tutils . begin ( ) ;
2002-01-17 23:46:04 +03:00
util ! = tutils . end ( ) ; + + util )
{
// Record that this utility was used.
used . insert ( * util ) ;
// Don't emit the same utility twice for this target.
if ( emitted . insert ( * util ) . second )
{
// Output this dependency.
this - > OutputExeDepend ( fout , util - > c_str ( ) ) ;
}
}
2001-08-29 18:46:59 +04:00
fout < < " \n " ;
2001-02-19 23:13:48 +03:00
}
}
2001-08-29 18:46:59 +04:00
fout < < " \n " ;
// Loop over the libraries used and make sure there is a rule to
// build them in this makefile. If the library is in another
// directory, add a rule to jump to that directory and make sure it
// exists.
for ( std : : set < std : : string > : : const_iterator lib = used . begin ( ) ;
lib ! = used . end ( ) ; + + lib )
2001-05-16 23:15:21 +04:00
{
// loop over the list of directories that the libraries might
// be in, looking for an ADD_LIBRARY(lib...) line. This would
// be stored in the cache
2001-08-29 18:46:59 +04:00
const char * cacheValue = m_Makefile - > GetDefinition ( lib - > c_str ( ) ) ;
2001-06-14 01:50:09 +04:00
// if cache and not the current directory add a rule, to
// jump into the directory and build for the first time
2001-11-28 15:15:04 +03:00
if ( cacheValue & &
( ! this - > SamePath ( m_Makefile - > GetCurrentOutputDirectory ( ) , cacheValue ) ) )
2001-05-16 23:15:21 +04:00
{
2001-07-02 23:38:02 +04:00
// add the correct extension
2001-08-29 18:46:59 +04:00
std : : string ltname = * lib + " _LIBRARY_TYPE " ;
2001-07-02 23:38:02 +04:00
const char * libType
2001-08-08 19:54:46 +04:00
= m_Makefile - > GetDefinition ( ltname . c_str ( ) ) ;
2002-01-18 21:30:51 +03:00
// if it was a library..
if ( libType )
2001-05-16 23:15:21 +04:00
{
2002-01-18 21:30:51 +03:00
std : : string library = m_LibraryPrefix ;
library + = * lib ;
std : : string libpath = cacheValue ;
if ( libType & & std : : string ( libType ) = = " SHARED " )
{
library + = m_Makefile - > GetDefinition ( " CMAKE_SHLIB_SUFFIX " ) ;
}
else if ( libType & & std : : string ( libType ) = = " MODULE " )
{
library + = m_Makefile - > GetDefinition ( " CMAKE_MODULE_SUFFIX " ) ;
}
else if ( libType & & std : : string ( libType ) = = " STATIC " )
{
library + = m_StaticLibraryExtension ;
}
else
{
cmSystemTools : : Error ( " Unknown library type! " ) ;
return ;
}
if ( m_LibraryOutputPath . size ( ) )
{
libpath = m_LibraryOutputPath ;
}
else
{
libpath + = " / " ;
}
libpath + = library ;
// put out a rule to build the library if it does not exist
this - > OutputBuildLibraryInDir ( fout ,
cacheValue ,
library . c_str ( ) ,
libpath . c_str ( ) ) ;
2001-06-14 01:03:49 +04:00
}
2002-01-18 21:30:51 +03:00
// something other than a library...
2001-06-14 01:03:49 +04:00
else
{
2002-01-18 21:30:51 +03:00
std : : string exepath = cacheValue ;
if ( m_ExecutableOutputPath . size ( ) )
{
exepath = m_ExecutableOutputPath ;
}
else
{
exepath + = " / " ;
}
exepath + = * lib ;
this - > OutputBuildExecutableInDir ( fout ,
cacheValue ,
lib - > c_str ( ) ,
exepath . c_str ( ) ) ;
2001-06-14 01:03:49 +04:00
}
2001-05-16 23:15:21 +04:00
}
}
2001-02-19 23:13:48 +03:00
}
2001-11-28 01:53:05 +03:00
void cmUnixMakefileGenerator : : OutputBuildLibraryInDir ( std : : ostream & fout ,
const char * path ,
2001-12-08 02:15:18 +03:00
const char * library ,
2001-11-28 01:53:05 +03:00
const char * fullpath )
{
2001-12-09 05:10:37 +03:00
const char * makeTarget = library ;
2001-12-10 20:02:10 +03:00
const char * libOutPath = m_Makefile - > GetDefinition ( " LIBRARY_OUTPUT_PATH " ) ;
if ( libOutPath & & strcmp ( libOutPath , " " ) ! = 0 )
2001-12-09 05:10:37 +03:00
{
makeTarget = fullpath ;
}
2002-02-22 21:38:33 +03:00
fout < < this - > ConvertToOutputPath ( fullpath )
< < " : \n \t cd " < < this - > ConvertToOutputPath ( path )
2002-05-29 17:56:33 +04:00
< < " ; $(MAKE) $(MAKESILENT) cmake.depends "
< < " ; $(MAKE) $(MAKESILENT) cmake.check_depends "
< < " ; $(MAKE) $(MAKESILENT) -f cmake.check_depends "
2001-12-29 01:00:05 +03:00
< < " ; $(MAKE) $(MAKESILENT) " < < makeTarget < < " \n \n " ;
2001-11-28 01:53:05 +03:00
}
2001-11-28 15:15:04 +03:00
2002-01-18 21:30:51 +03:00
void cmUnixMakefileGenerator : : OutputBuildExecutableInDir ( std : : ostream & fout ,
const char * path ,
const char * library ,
const char * fullpath )
{
const char * makeTarget = library ;
const char * libOutPath = m_Makefile - > GetDefinition ( " EXECUTABLE_OUTPUT_PATH " ) ;
if ( libOutPath & & strcmp ( libOutPath , " " ) ! = 0 )
{
makeTarget = fullpath ;
}
2002-02-22 21:38:33 +03:00
fout < < this - > ConvertToOutputPath ( fullpath )
< < " : \n \t cd " < < this - > ConvertToOutputPath ( path )
2002-05-29 17:56:33 +04:00
< < " ; $(MAKE) $(MAKESILENT) cmake.depends "
< < " ; $(MAKE) $(MAKESILENT) cmake.check_depends "
< < " ; $(MAKE) $(MAKESILENT) -f cmake.check_depends "
2002-01-18 21:30:51 +03:00
< < " ; $(MAKE) $(MAKESILENT) " < < makeTarget < < " \n \n " ;
}
2001-11-28 15:15:04 +03:00
bool cmUnixMakefileGenerator : : SamePath ( const char * path1 , const char * path2 )
{
return strcmp ( path1 , path2 ) = = 0 ;
}
2001-08-29 18:46:59 +04:00
void cmUnixMakefileGenerator : : OutputLibDepend ( std : : ostream & fout ,
const char * name )
{
const char * cacheValue = m_Makefile - > GetDefinition ( name ) ;
if ( cacheValue )
{
// if there is a cache value, then this is a library that cmake
// knows how to build, so we can depend on it
std : : string libpath ;
2001-11-28 15:15:04 +03:00
if ( ! this - > SamePath ( m_Makefile - > GetCurrentOutputDirectory ( ) , cacheValue ) )
2001-08-29 18:46:59 +04:00
{
// if the library is not in the current directory, then get the full
// path to it
if ( m_LibraryOutputPath . size ( ) )
{
libpath = m_LibraryOutputPath ;
2001-11-15 02:12:22 +03:00
libpath + = m_LibraryPrefix ;
2001-08-29 18:46:59 +04:00
}
else
{
2002-01-17 23:46:04 +03:00
libpath = cacheValue ;
2001-11-15 02:12:22 +03:00
libpath + = " / " ;
libpath + = m_LibraryPrefix ;
2001-08-29 18:46:59 +04:00
}
}
else
{
// library is in current Makefile so use lib as a prefix
libpath = m_LibraryOutputPath ;
2001-11-15 02:12:22 +03:00
libpath + = m_LibraryPrefix ;
2001-08-29 18:46:59 +04:00
}
// add the library name
libpath + = name ;
// add the correct extension
std : : string ltname = name ;
ltname + = " _LIBRARY_TYPE " ;
const char * libType = m_Makefile - > GetDefinition ( ltname . c_str ( ) ) ;
if ( libType & & std : : string ( libType ) = = " SHARED " )
{
libpath + = m_Makefile - > GetDefinition ( " CMAKE_SHLIB_SUFFIX " ) ;
}
else if ( libType & & std : : string ( libType ) = = " MODULE " )
2002-01-17 23:46:04 +03:00
{
libpath + = m_Makefile - > GetDefinition ( " CMAKE_MODULE_SUFFIX " ) ;
}
else if ( libType & & std : : string ( libType ) = = " STATIC " )
2001-08-29 18:46:59 +04:00
{
2001-11-15 02:12:22 +03:00
libpath + = m_StaticLibraryExtension ;
2001-08-29 18:46:59 +04:00
}
2002-02-22 21:38:33 +03:00
fout < < this - > ConvertToOutputPath ( libpath . c_str ( ) ) < < " " ;
2001-08-29 18:46:59 +04:00
}
}
2001-02-19 23:13:48 +03:00
2002-01-17 23:46:04 +03:00
void cmUnixMakefileGenerator : : OutputExeDepend ( std : : ostream & fout ,
const char * name )
{
const char * cacheValue = m_Makefile - > GetDefinition ( name ) ;
if ( cacheValue )
{
// if there is a cache value, then this is a executable/utility that cmake
// knows how to build, so we can depend on it
std : : string exepath ;
if ( ! this - > SamePath ( m_Makefile - > GetCurrentOutputDirectory ( ) , cacheValue ) )
{
// if the exe/utility is not in the current directory, then get the full
// path to it
if ( m_ExecutableOutputPath . size ( ) )
{
exepath = m_ExecutableOutputPath ;
}
else
{
exepath = cacheValue ;
exepath + = " / " ;
}
}
else
{
// library is in current Makefile
exepath = m_ExecutableOutputPath ;
}
// add the library name
exepath + = name ;
// add the correct extension
if ( m_Makefile - > GetDefinition ( " CMAKE_EXECUTABLE_SUFFIX " ) )
{
2002-01-18 21:30:51 +03:00
std : : string replaceVars =
m_Makefile - > GetDefinition ( " CMAKE_EXECUTABLE_SUFFIX " ) ;
if ( ! strcmp ( replaceVars . c_str ( ) , " @CMAKE_EXECUTABLE_SUFFIX@ " ) )
{
replaceVars = " " ;
}
exepath + = replaceVars ;
2002-01-17 23:46:04 +03:00
}
2002-02-22 21:38:33 +03:00
fout < < this - > ConvertToOutputPath ( exepath . c_str ( ) ) < < " " ;
2002-01-17 23:46:04 +03:00
}
}
2001-02-19 23:13:48 +03:00
// fix up names of directories so they can be used
// as targets in makefiles.
inline std : : string FixDirectoryName ( const char * dir )
{
std : : string s = dir ;
// replace ../ with 3 under bars
size_t pos = s . find ( " ../ " ) ;
if ( pos ! = std : : string : : npos )
{
s . replace ( pos , 3 , " ___ " ) ;
}
// replace / directory separators with a single under bar
pos = s . find ( " / " ) ;
while ( pos ! = std : : string : : npos )
{
s . replace ( pos , 1 , " _ " ) ;
pos = s . find ( " / " ) ;
}
return s ;
}
2001-11-14 02:23:45 +03:00
void cmUnixMakefileGenerator : : BuildInSubDirectory ( std : : ostream & fout ,
2001-11-22 01:45:01 +03:00
const char * dir ,
2001-11-14 02:23:45 +03:00
const char * target1 ,
2002-04-22 22:22:46 +04:00
const char * target2 ,
bool silent )
2001-11-14 02:23:45 +03:00
{
2002-02-22 21:38:33 +03:00
std : : string directory = this - > ConvertToOutputPath ( dir ) ;
2001-11-14 02:23:45 +03:00
if ( target1 )
{
fout < < " \t @if test ! -d " < < directory
2002-04-22 22:22:46 +04:00
< < " ; then $(MAKE) rebuild_cache; fi \n " ;
if ( ! silent )
{
2002-04-22 23:16:54 +04:00
fout < < " \t echo " < < directory < < " : building " < < target1 < < " \n " ;
2002-04-22 22:22:46 +04:00
}
fout < < " \t @cd " < < directory
2002-05-29 17:56:33 +04:00
< < " ; $(MAKE) " < < target1 < < " \n " ;
2001-11-14 02:23:45 +03:00
}
if ( target2 )
{
2002-04-22 22:22:46 +04:00
if ( ! silent )
{
2002-04-22 23:16:54 +04:00
fout < < " \t echo " < < directory < < " : building " < < target2 < < " \n " ;
2002-04-22 22:22:46 +04:00
}
2001-11-14 02:23:45 +03:00
fout < < " \t @cd " < < directory
2002-05-29 17:56:33 +04:00
< < " ; $(MAKE) " < < target2 < < " \n " ;
2001-11-14 02:23:45 +03:00
}
2001-12-29 01:00:05 +03:00
fout < < " \n " ;
2001-11-14 02:23:45 +03:00
}
2001-05-16 23:15:21 +04:00
void
cmUnixMakefileGenerator : :
OutputSubDirectoryVars ( std : : ostream & fout ,
const char * var ,
const char * target ,
const char * target1 ,
const char * target2 ,
2002-02-14 18:03:19 +03:00
const char * depend ,
2002-04-22 22:22:46 +04:00
const std : : vector < std : : string > & SubDirectories ,
bool silent )
2001-02-19 23:13:48 +03:00
{
2002-02-14 18:03:19 +03:00
if ( ! depend )
{
depend = " " ;
}
2001-02-19 23:13:48 +03:00
if ( SubDirectories . size ( ) = = 0 )
{
return ;
}
2001-05-16 23:15:21 +04:00
fout < < " # Variable for making " < < target < < " in subdirectories. \n " ;
fout < < var < < " = \\ \n " ;
2001-02-19 23:13:48 +03:00
unsigned int i ;
for ( i = 0 ; i < SubDirectories . size ( ) ; i + + )
{
std : : string subdir = FixDirectoryName ( SubDirectories [ i ] . c_str ( ) ) ;
2001-05-16 23:15:21 +04:00
fout < < target < < " _ " < < subdir . c_str ( ) ;
2001-02-19 23:13:48 +03:00
if ( i = = SubDirectories . size ( ) - 1 )
2000-09-12 13:30:35 +04:00
{
2001-02-19 23:13:48 +03:00
fout < < " \n \n " ;
2000-09-12 13:30:35 +04:00
}
2001-02-19 23:13:48 +03:00
else
2000-09-12 13:30:35 +04:00
{
2001-02-19 23:13:48 +03:00
fout < < " \\ \n " ;
2000-09-12 13:30:35 +04:00
}
2001-02-19 23:13:48 +03:00
}
2001-05-16 23:15:21 +04:00
fout < < " # Targets for making " < < target < < " in subdirectories. \n " ;
2001-12-10 19:03:44 +03:00
std : : string last = " " ;
2001-05-17 01:18:15 +04:00
for ( unsigned int i = 0 ; i < SubDirectories . size ( ) ; i + + )
2001-05-16 23:15:21 +04:00
{
2001-02-19 23:13:48 +03:00
std : : string subdir = FixDirectoryName ( SubDirectories [ i ] . c_str ( ) ) ;
2002-02-14 18:03:19 +03:00
fout < < target < < " _ " < < subdir . c_str ( ) < < " : " < < depend ;
2001-12-10 19:03:44 +03:00
// Make each subdirectory depend on previous one. This forces
// parallel builds (make -j 2) to build in same order as a single
// threaded build to avoid dependency problems.
if ( i > 0 )
2001-08-02 00:14:16 +04:00
{
2001-12-10 19:03:44 +03:00
fout < < " " < < target < < " _ " < < last . c_str ( ) ;
2001-08-02 00:14:16 +04:00
}
2001-12-10 19:03:44 +03:00
2001-08-02 00:14:16 +04:00
fout < < " \n " ;
2001-12-10 19:03:44 +03:00
last = subdir ;
2001-12-20 02:45:22 +03:00
std : : string dir = m_Makefile - > GetCurrentOutputDirectory ( ) ;
dir + = " / " ;
dir + = SubDirectories [ i ] ;
this - > BuildInSubDirectory ( fout , dir . c_str ( ) ,
2002-04-22 22:22:46 +04:00
target1 , target2 , silent ) ;
2000-08-29 23:26:29 +04:00
}
2001-05-16 23:15:21 +04:00
fout < < " \n \n " ;
}
2000-08-29 23:26:29 +04:00
2001-05-16 23:15:21 +04:00
// output rules for decending into sub directories
void cmUnixMakefileGenerator : : OutputSubDirectoryRules ( std : : ostream & fout )
{
// Output Sub directory build rules
const std : : vector < std : : string > & SubDirectories
= m_Makefile - > GetSubDirectories ( ) ;
if ( SubDirectories . size ( ) = = 0 )
{
return ;
2000-08-29 23:26:29 +04:00
}
2001-12-29 01:00:05 +03:00
this - > OutputSubDirectoryVars ( fout ,
" SUBDIR_BUILD " ,
" default_target " ,
" default_target " ,
2002-02-14 18:03:19 +03:00
0 , " $(TARGETS) " ,
2002-04-22 22:22:46 +04:00
SubDirectories ,
2002-04-22 23:16:54 +04:00
false ) ;
2001-05-16 23:15:21 +04:00
this - > OutputSubDirectoryVars ( fout , " SUBDIR_CLEAN " , " clean " ,
" clean " ,
2002-02-14 18:03:19 +03:00
0 , 0 ,
2001-05-16 23:15:21 +04:00
SubDirectories ) ;
this - > OutputSubDirectoryVars ( fout , " SUBDIR_DEPEND " , " depend " ,
" depend " ,
2002-02-14 18:03:19 +03:00
0 , 0 ,
2001-05-16 23:15:21 +04:00
SubDirectories ) ;
2001-05-23 19:53:37 +04:00
this - > OutputSubDirectoryVars ( fout , " SUBDIR_INSTALL " , " install " ,
" install " ,
2002-02-14 18:03:19 +03:00
0 , 0 ,
2001-05-23 19:53:37 +04:00
SubDirectories ) ;
2000-08-29 23:26:29 +04:00
}
2000-09-27 23:01:19 +04:00
2001-01-05 19:41:20 +03:00
2001-02-19 23:13:48 +03:00
// Output the depend information for all the classes
// in the makefile. These would have been generated
// by the class cmMakeDepend GenerateMakefile
2001-12-29 01:00:05 +03:00
bool cmUnixMakefileGenerator : : OutputObjectDepends ( std : : ostream & fout )
2000-09-27 23:01:19 +04:00
{
2001-12-29 01:00:05 +03:00
bool ret = false ;
2001-04-25 17:39:23 +04:00
// Iterate over every target.
2001-08-22 19:58:17 +04:00
std : : map < cmStdString , cmTarget > & targets = m_Makefile - > GetTargets ( ) ;
for ( std : : map < cmStdString , cmTarget > : : const_iterator target = targets . begin ( ) ;
2001-04-25 17:39:23 +04:00
target ! = targets . end ( ) ; + + target )
2000-09-27 23:01:19 +04:00
{
2001-04-25 17:39:23 +04:00
// Iterate over every source for this target.
2002-03-29 18:06:30 +03:00
const std : : vector < cmSourceFile * > & sources = target - > second . GetSourceFiles ( ) ;
for ( std : : vector < cmSourceFile * > : : const_iterator source = sources . begin ( ) ;
2001-04-25 17:39:23 +04:00
source ! = sources . end ( ) ; + + source )
2000-09-27 23:01:19 +04:00
{
2002-03-29 18:06:30 +03:00
if ( ! ( * source ) - > IsAHeaderFileOnly ( ) )
2001-04-11 22:59:02 +04:00
{
2002-03-29 18:06:30 +03:00
if ( ! ( * source ) - > GetDepends ( ) . empty ( ) )
2001-04-11 22:59:02 +04:00
{
2002-03-29 18:06:30 +03:00
fout < < ( * source ) - > GetSourceName ( ) < < m_ObjectFileExtension < < " : " ;
2001-04-25 17:39:23 +04:00
// Iterate through all the dependencies for this source.
for ( std : : vector < std : : string > : : const_iterator dep =
2002-03-29 18:06:30 +03:00
( * source ) - > GetDepends ( ) . begin ( ) ;
dep ! = ( * source ) - > GetDepends ( ) . end ( ) ; + + dep )
2001-04-11 22:59:02 +04:00
{
2001-12-29 01:00:05 +03:00
fout < < " \\ \n "
2002-02-22 21:38:33 +03:00
< < this - > ConvertToOutputPath ( dep - > c_str ( ) ) ;
2001-12-29 01:00:05 +03:00
ret = true ;
2001-04-11 22:59:02 +04:00
}
fout < < " \n \n " ;
}
}
2000-09-27 23:01:19 +04:00
}
}
2001-12-29 01:00:05 +03:00
return ret ;
2000-09-27 23:01:19 +04:00
}
2001-03-03 00:04:26 +03:00
2001-12-29 01:00:05 +03:00
// Output the depend information for all the classes
// in the makefile. These would have been generated
// by the class cmMakeDepend GenerateMakefile
void cmUnixMakefileGenerator : : OutputCheckDepends ( std : : ostream & fout )
{
2002-06-11 22:25:44 +04:00
std : : set < std : : string > emittedLowerPath ;
2001-12-29 01:00:05 +03:00
std : : set < std : : string > emitted ;
// Iterate over every target.
std : : map < cmStdString , cmTarget > & targets = m_Makefile - > GetTargets ( ) ;
2002-01-16 23:53:29 +03:00
fout < < " # Suppresses display of executed commands \n " ;
fout < < " .SILENT: \n " ;
fout < < " # disable some common implicit rules to speed things up \n " ;
fout < < " .SUFFIXES: \n " ;
2002-01-21 19:39:00 +03:00
fout < < " .SUFFIXES:.hpuxmakemusthaverule \n " ;
2001-12-29 01:00:05 +03:00
this - > OutputMakeVariables ( fout ) ;
fout < < " default: \n " ;
2002-05-29 17:56:33 +04:00
fout < < " \t $(MAKE) $(MAKESILENT) -f cmake.check_depends all \n "
< < " \t $(MAKE) $(MAKESILENT) -f cmake.check_depends cmake.depends \n \n " ;
2001-12-29 01:00:05 +03:00
fout < < " all: " ;
for ( std : : map < cmStdString , cmTarget > : : const_iterator target = targets . begin ( ) ;
target ! = targets . end ( ) ; + + target )
{
// Iterate over every source for this target.
2002-03-29 18:06:30 +03:00
const std : : vector < cmSourceFile * > & sources = target - > second . GetSourceFiles ( ) ;
for ( std : : vector < cmSourceFile * > : : const_iterator source = sources . begin ( ) ;
2001-12-29 01:00:05 +03:00
source ! = sources . end ( ) ; + + source )
{
2002-03-29 18:06:30 +03:00
if ( ! ( * source ) - > IsAHeaderFileOnly ( ) )
2001-12-29 01:00:05 +03:00
{
2002-03-29 18:06:30 +03:00
if ( ! ( * source ) - > GetDepends ( ) . empty ( ) )
2001-12-29 01:00:05 +03:00
{
for ( std : : vector < std : : string > : : const_iterator dep =
2002-03-29 18:06:30 +03:00
( * source ) - > GetDepends ( ) . begin ( ) ;
dep ! = ( * source ) - > GetDepends ( ) . end ( ) ; + + dep )
2001-12-29 01:00:05 +03:00
{
std : : string dependfile =
2002-04-19 17:00:35 +04:00
this - > ConvertToOutputPath ( cmSystemTools : : CollapseFullPath ( dep - > c_str ( ) ) . c_str ( ) ) ;
2002-06-11 22:25:44 +04:00
// use the lower path function to create uniqe names
std : : string lowerpath = this - > LowerCasePath ( dependfile . c_str ( ) ) ;
if ( emittedLowerPath . insert ( lowerpath ) . second )
2001-12-29 01:00:05 +03:00
{
2002-06-11 19:01:16 +04:00
emitted . insert ( dependfile ) ;
2001-12-29 01:00:05 +03:00
fout < < " \\ \n " < < dependfile ;
}
}
}
}
}
}
fout < < " \n \n # if any of these files changes run make dependlocal \n " ;
fout < < " cmake.depends: " ;
std : : set < std : : string > : : iterator i ;
for ( i = emitted . begin ( ) ; i ! = emitted . end ( ) ; + + i )
{
fout < < " \\ \n " < < * i ;
}
2002-05-29 17:56:33 +04:00
fout < < " \n \t $(MAKE) $(MAKESILENT) dependlocal \n \n " ;
2001-12-29 01:00:05 +03:00
fout < < " \n \n " ;
fout < < " # if a .h file is removed then run make dependlocal \n \n " ;
for ( std : : set < std : : string > : : iterator i = emitted . begin ( ) ;
i ! = emitted . end ( ) ; + + i )
{
fout < < * i < < " : \n "
2002-05-29 17:56:33 +04:00
< < " \t $(MAKE) $(MAKESILENT) dependlocal \n \n " ;
2001-12-29 01:00:05 +03:00
}
}
2001-03-03 00:04:26 +03:00
// Output each custom rule in the following format:
2001-03-20 21:20:59 +03:00
// output: source depends...
// (tab) command...
2001-03-03 00:04:26 +03:00
void cmUnixMakefileGenerator : : OutputCustomRules ( std : : ostream & fout )
{
2001-04-11 22:59:02 +04:00
// We may be modifying the source groups temporarily, so make a copy.
std : : vector < cmSourceGroup > sourceGroups = m_Makefile - > GetSourceGroups ( ) ;
const cmTargets & tgts = m_Makefile - > GetTargets ( ) ;
for ( cmTargets : : const_iterator tgt = tgts . begin ( ) ;
tgt ! = tgts . end ( ) ; + + tgt )
{
// add any custom rules to the source groups
for ( std : : vector < cmCustomCommand > : : const_iterator cr =
2001-04-19 21:28:46 +04:00
tgt - > second . GetCustomCommands ( ) . begin ( ) ;
cr ! = tgt - > second . GetCustomCommands ( ) . end ( ) ; + + cr )
2001-04-11 22:59:02 +04:00
{
2002-04-11 18:29:51 +04:00
// if the source for the custom command is the same name
// as the target, then to not create a rule in the makefile for
// the custom command, as the command will be fired when the other target
// is built.
if ( cr - > GetSourceName ( ) . compare ( tgt - > first ) ! = 0 )
2002-04-11 00:45:06 +04:00
{
cmSourceGroup & sourceGroup =
m_Makefile - > FindSourceGroup ( cr - > GetSourceName ( ) . c_str ( ) ,
sourceGroups ) ;
cmCustomCommand cc ( * cr ) ;
cc . ExpandVariables ( * m_Makefile ) ;
sourceGroup . AddCustomCommand ( cc ) ;
}
2001-04-11 22:59:02 +04:00
}
}
2001-05-04 19:30:46 +04:00
2001-03-20 21:20:59 +03:00
// Loop through every source group.
for ( std : : vector < cmSourceGroup > : : const_iterator sg =
2001-04-11 22:59:02 +04:00
sourceGroups . begin ( ) ; sg ! = sourceGroups . end ( ) ; + + sg )
2001-03-03 00:04:26 +03:00
{
2001-04-27 22:57:48 +04:00
const cmSourceGroup : : BuildRules & buildRules = sg - > GetBuildRules ( ) ;
if ( buildRules . empty ( ) )
2001-03-20 21:20:59 +03:00
{ continue ; }
std : : string name = sg - > GetName ( ) ;
if ( name ! = " " )
2001-03-03 00:04:26 +03:00
{
2001-03-20 21:20:59 +03:00
fout < < " # Start of source group \" " < < name . c_str ( ) < < " \" \n " ;
2001-03-03 00:04:26 +03:00
}
2001-03-20 21:20:59 +03:00
// Loop through each source in the source group.
2001-04-27 22:57:48 +04:00
for ( cmSourceGroup : : BuildRules : : const_iterator cc =
buildRules . begin ( ) ; cc ! = buildRules . end ( ) ; + + cc )
2001-03-20 21:20:59 +03:00
{
std : : string source = cc - > first ;
2002-03-04 22:14:41 +03:00
const cmSourceGroup : : Commands & commands = cc - > second . m_Commands ;
2001-03-20 21:20:59 +03:00
// Loop through every command generating code from the current source.
for ( cmSourceGroup : : Commands : : const_iterator c = commands . begin ( ) ;
c ! = commands . end ( ) ; + + c )
{
2001-12-04 20:03:58 +03:00
// escape spaces and convert to native slashes path for
// the command
2002-02-22 21:38:33 +03:00
std : : string command =
this - > ConvertToOutputPath ( c - > second . m_Command . c_str ( ) ) ;
2001-12-04 20:03:58 +03:00
command + = " " ;
// now add the arguments
command + = c - > second . m_Arguments ;
2001-03-20 21:20:59 +03:00
const cmSourceGroup : : CommandFiles & commandFiles = c - > second ;
2001-05-02 00:55:32 +04:00
// if the command has no outputs, then it is a utility command
2001-05-05 01:00:22 +04:00
// with no outputs
2001-05-02 00:55:32 +04:00
if ( commandFiles . m_Outputs . size ( ) = = 0 )
{
2001-11-15 02:12:22 +03:00
std : : string depends ;
// collect out all the dependencies for this rule.
for ( std : : set < std : : string > : : const_iterator d =
commandFiles . m_Depends . begin ( ) ;
d ! = commandFiles . m_Depends . end ( ) ; + + d )
{
2002-02-22 21:38:33 +03:00
std : : string dep = this - > ConvertToOutputPath ( d - > c_str ( ) ) ;
2001-11-15 02:12:22 +03:00
depends + = " " ;
depends + = dep ;
}
// output rule
this - > OutputMakeRule ( fout ,
" Custom command " ,
source . c_str ( ) ,
depends . c_str ( ) ,
command . c_str ( ) ) ;
2001-05-02 00:55:32 +04:00
}
2001-03-20 21:20:59 +03:00
// Write a rule for every output generated by this command.
for ( std : : set < std : : string > : : const_iterator output =
commandFiles . m_Outputs . begin ( ) ;
output ! = commandFiles . m_Outputs . end ( ) ; + + output )
{
2002-02-22 21:38:33 +03:00
std : : string src = this - > ConvertToOutputPath ( source . c_str ( ) ) ;
2001-11-15 02:12:22 +03:00
std : : string depends ;
depends + = src ;
// Collect out all the dependencies for this rule.
2001-03-20 21:20:59 +03:00
for ( std : : set < std : : string > : : const_iterator d =
commandFiles . m_Depends . begin ( ) ;
d ! = commandFiles . m_Depends . end ( ) ; + + d )
{
2002-02-22 21:38:33 +03:00
std : : string dep = this - > ConvertToOutputPath ( d - > c_str ( ) ) ;
2001-11-15 02:12:22 +03:00
depends + = " " ;
depends + = dep ;
}
// output rule
this - > OutputMakeRule ( fout ,
" Custom command " ,
output - > c_str ( ) ,
depends . c_str ( ) ,
command . c_str ( ) ) ;
2001-03-20 21:20:59 +03:00
}
}
}
if ( name ! = " " )
{
fout < < " # End of source group \" " < < name . c_str ( ) < < " \" \n \n " ;
}
}
2001-03-03 00:04:26 +03:00
}
2001-05-08 02:11:16 +04:00
void cmUnixMakefileGenerator : : GenerateCacheOnly ( )
{
cmSystemTools : : MakeDirectory ( m_Makefile - > GetStartOutputDirectory ( ) ) ;
std : : string dest = m_Makefile - > GetStartOutputDirectory ( ) ;
dest + = " /Makefile " ;
2001-05-16 23:15:21 +04:00
std : : cout < < " cmake: creating : " < < dest . c_str ( ) < < std : : endl ;
this - > OutputMakefile ( dest . c_str ( ) ) ;
return ;
2001-05-08 02:11:16 +04:00
}
void cmUnixMakefileGenerator : : RecursiveGenerateCacheOnly ( )
{
std : : vector < cmMakefile * > makefiles ;
m_Makefile - > FindSubDirectoryCMakeListsFiles ( makefiles ) ;
for ( std : : vector < cmMakefile * > : : iterator i = makefiles . begin ( ) ;
i ! = makefiles . end ( ) ; + + i )
{
cmMakefile * mf = * i ;
if ( m_Makefile - > GetDefinition ( " RUN_CONFIGURE " ) )
{
mf - > AddDefinition ( " RUN_CONFIGURE " , true ) ;
}
2001-11-14 02:23:45 +03:00
cmUnixMakefileGenerator * gen =
2002-04-03 00:43:23 +04:00
static_cast < cmUnixMakefileGenerator * > ( mf - > GetMakefileGenerator ( ) ) ;
2001-05-08 02:11:16 +04:00
gen - > SetCacheOnlyOn ( ) ;
gen - > SetRecurseOff ( ) ;
mf - > GenerateMakefile ( ) ;
}
// CLEAN up the makefiles created
for ( unsigned int i = 0 ; i < makefiles . size ( ) ; + + i )
{
delete makefiles [ i ] ;
}
}
2001-05-16 23:15:21 +04:00
void cmUnixMakefileGenerator : : OutputMakeVariables ( std : : ostream & fout )
{
const char * variables =
" # the standard shell for make \n "
" SHELL = /bin/sh \n "
" \n "
" CMAKE_RANLIB = @CMAKE_RANLIB@ \n "
2001-05-18 18:15:54 +04:00
" CMAKE_AR = @CMAKE_AR@ \n "
2001-06-29 17:30:01 +04:00
" CMAKE_AR_ARGS = @CMAKE_AR_ARGS@ \n "
2002-04-04 20:01:41 +04:00
" CMAKE_CXX_AR = @CMAKE_CXX_AR@ \n "
" CMAKE_CXX_AR_ARGS = @CMAKE_CXX_AR_ARGS@ \n "
2002-04-09 20:15:32 +04:00
" CMAKE_C_FLAGS = @CMAKE_C_FLAGS@ \n "
2002-04-08 21:36:18 +04:00
" CMAKE_C_COMPILER = @CMAKE_C_COMPILER@ \n "
" CMAKE_C_LINK_SHARED = @CMAKE_C_LINK_SHARED@ \n "
" CMAKE_CXX_LINK_SHARED = @CMAKE_CXX_LINK_SHARED@ \n "
2001-07-02 23:38:02 +04:00
" CMAKE_SHLIB_CFLAGS = @CMAKE_SHLIB_CFLAGS@ \n "
2002-04-08 21:36:18 +04:00
" CMAKE_CXX_SHLIB_CFLAGS = @CMAKE_CXX_SHLIB_CFLAGS@ \n "
" CMAKE_CXX_SHLIB_BUILD_FLAGS = @CMAKE_CXX_SHLIB_BUILD_FLAGS@ \n "
" CMAKE_CXX_SHLIB_LINK_FLAGS = @CMAKE_CXX_SHLIB_LINK_FLAGS@ \n "
" CMAKE_CXX_MODULE_BUILD_FLAGS = @CMAKE_CXX_MODULE_BUILD_FLAGS@ \n "
" CMAKE_CXX_MODULE_LINK_FLAGS = @CMAKE_CXX_MODULE_LINK_FLAGS@ \n "
" CMAKE_CXX_SHLIB_RUNTIME_FLAG = @CMAKE_CXX_SHLIB_RUNTIME_FLAG@ \n "
" CMAKE_CXX_SHLIB_RUNTIME_SEP = @CMAKE_CXX_SHLIB_RUNTIME_SEP@ \n "
2001-05-16 23:15:21 +04:00
" \n "
2001-05-18 18:15:54 +04:00
" CMAKE_CXX_COMPILER = @CMAKE_CXX_COMPILER@ \n "
2001-12-01 00:05:55 +03:00
" CMAKE_CXX_FLAGS = @CMAKE_CXX_FLAGS@ \n "
2001-05-16 23:15:21 +04:00
" \n "
2001-08-29 02:02:59 +04:00
" CMAKE_SHLIB_BUILD_FLAGS = @CMAKE_SHLIB_BUILD_FLAGS@ \n "
" CMAKE_SHLIB_LINK_FLAGS = @CMAKE_SHLIB_LINK_FLAGS@ \n "
2002-04-26 20:21:13 +04:00
" CMAKE_C_SHLIB_LINK_FLAGS = @CMAKE_C_SHLIB_LINK_FLAGS@ \n "
2001-08-29 02:02:59 +04:00
" CMAKE_MODULE_BUILD_FLAGS = @CMAKE_MODULE_BUILD_FLAGS@ \n "
" CMAKE_MODULE_LINK_FLAGS = @CMAKE_MODULE_LINK_FLAGS@ \n "
2002-04-26 20:21:13 +04:00
" CMAKE_C_SHLIB_RUNTIME_FLAG = @CMAKE_C_SHLIB_RUNTIME_FLAG@ \n "
" CMAKE_SHLIB_RUNTIME_FLAG = @CMAKE_SHLIB_RUNTIME_FLAG@ \n "
" CMAKE_SHLIB_RUNTIME_SEP = @CMAKE_SHLIB_RUNTIME_SEP@ \n "
2001-08-29 02:02:59 +04:00
" DL_LIBS = @CMAKE_DL_LIBS@ \n "
" SHLIB_LD_LIBS = @CMAKE_SHLIB_LD_LIBS@ \n "
" SHLIB_SUFFIX = @CMAKE_SHLIB_SUFFIX@ \n "
" MODULE_SUFFIX = @CMAKE_MODULE_SUFFIX@ \n "
" THREAD_LIBS = @CMAKE_THREAD_LIBS@ \n "
2001-12-18 18:21:59 +03:00
" RM = rm -f \n "
2001-05-16 23:15:21 +04:00
" \n " ;
std : : string replaceVars = variables ;
m_Makefile - > ExpandVariablesInString ( replaceVars ) ;
fout < < replaceVars . c_str ( ) ;
2002-04-19 00:13:15 +04:00
fout < < " CMAKE_COMMAND = "
< < this - > ConvertToOutputPath ( m_Makefile - > GetDefinition ( " CMAKE_COMMAND " ) )
< < " \n " ;
2002-05-07 17:02:45 +04:00
if ( m_Makefile - > GetDefinition ( " CMAKE_EDIT_COMMAND " ) )
{
fout < < " CMAKE_EDIT_COMMAND = "
< < this - > ConvertToOutputPath ( m_Makefile - > GetDefinition ( " CMAKE_EDIT_COMMAND " ) )
< < " \n " ;
}
2002-04-19 00:13:15 +04:00
2001-11-22 01:45:01 +03:00
fout < < " CMAKE_CURRENT_SOURCE = " < <
2002-02-22 21:38:33 +03:00
this - > ConvertToOutputPath ( m_Makefile - > GetStartDirectory ( ) ) < < " \n " ;
2001-11-22 01:45:01 +03:00
fout < < " CMAKE_CURRENT_BINARY = " < <
2002-02-22 21:38:33 +03:00
this - > ConvertToOutputPath ( m_Makefile - > GetStartOutputDirectory ( ) ) < < " \n " ;
2001-11-22 01:45:01 +03:00
fout < < " CMAKE_SOURCE_DIR = " < <
2002-02-22 21:38:33 +03:00
this - > ConvertToOutputPath ( m_Makefile - > GetHomeDirectory ( ) ) < < " \n " ;
2001-11-22 01:45:01 +03:00
fout < < " CMAKE_BINARY_DIR = " < <
2002-02-22 21:38:33 +03:00
this - > ConvertToOutputPath ( m_Makefile - > GetHomeOutputDirectory ( ) ) < < " \n " ;
2001-11-07 17:54:46 +03:00
// Output Include paths
fout < < " INCLUDE_FLAGS = " ;
std : : vector < std : : string > & includes = m_Makefile - > GetIncludeDirectories ( ) ;
std : : vector < std : : string > : : iterator i ;
2001-11-22 01:45:01 +03:00
fout < < " -I " < <
2002-02-22 21:38:33 +03:00
this - > ConvertToOutputPath ( m_Makefile - > GetStartDirectory ( ) ) < < " " ;
2001-11-07 17:54:46 +03:00
for ( i = includes . begin ( ) ; i ! = includes . end ( ) ; + + i )
{
std : : string include = * i ;
// Don't output a -I for the standard include path "/usr/include".
// This can cause problems with certain standard library
// implementations because the wrong headers may be found first.
if ( include ! = " /usr/include " )
{
2002-02-22 21:38:33 +03:00
fout < < " -I " < < this - > ConvertToOutputPath ( i - > c_str ( ) ) < < " " ;
2001-11-07 17:54:46 +03:00
}
}
fout < < m_Makefile - > GetDefineFlags ( ) ;
fout < < " \n \n " ;
2001-05-16 23:15:21 +04:00
}
2001-05-23 19:53:37 +04:00
void cmUnixMakefileGenerator : : OutputInstallRules ( std : : ostream & fout )
{
const char * root
2001-08-08 19:54:46 +04:00
= m_Makefile - > GetDefinition ( " CMAKE_ROOT " ) ;
2001-05-23 19:53:37 +04:00
fout < < " INSTALL = " < < root < < " /Templates/install-sh -c \n " ;
2001-11-05 23:39:37 +03:00
fout < < " INSTALL_PROGRAM = $(INSTALL) \n " ;
fout < < " INSTALL_DATA = $(INSTALL) -m 644 \n " ;
2001-05-23 19:53:37 +04:00
const cmTargets & tgts = m_Makefile - > GetTargets ( ) ;
2001-11-05 23:39:37 +03:00
fout < < " install: $(SUBDIR_INSTALL) \n " ;
2001-05-23 19:53:37 +04:00
fout < < " \t @echo \" Installing ... \" \n " ;
const char * prefix
2001-08-08 19:54:46 +04:00
= m_Makefile - > GetDefinition ( " CMAKE_INSTALL_PREFIX " ) ;
2001-05-23 19:53:37 +04:00
if ( ! prefix )
{
prefix = " /usr/local " ;
}
for ( cmTargets : : const_iterator l = tgts . begin ( ) ;
l ! = tgts . end ( ) ; l + + )
{
if ( l - > second . GetInstallPath ( ) ! = " " )
{
// first make the directories for each target
2001-12-21 17:07:17 +03:00
fout < < " \t @if [ ! -d $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( ) < <
2001-05-23 19:53:37 +04:00
" ] ; then \\ \n " ;
2001-12-21 17:07:17 +03:00
fout < < " \t echo \" Making directory $(DESTDIR) " < < prefix
2001-05-23 19:53:37 +04:00
< < l - > second . GetInstallPath ( ) < < " \" ; \\ \n " ;
2001-12-21 17:07:17 +03:00
fout < < " \t mkdir -p $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( )
2001-05-23 19:53:37 +04:00
< < " ; \\ \n " ;
2001-12-21 17:07:17 +03:00
fout < < " \t chmod 755 $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( )
2001-05-23 19:53:37 +04:00
< < " ; \\ \n " ;
fout < < " \t else true; \\ \n " ;
fout < < " \t fi \n " ;
// now install the target
switch ( l - > second . GetType ( ) )
{
2001-07-02 23:38:02 +04:00
case cmTarget : : STATIC_LIBRARY :
2001-06-28 00:14:14 +04:00
fout < < " \t $(INSTALL_DATA) " < < m_LibraryOutputPath < < " lib "
< < l - > first ;
2001-07-02 23:38:02 +04:00
fout < < " .a " ;
2001-12-21 17:07:17 +03:00
fout < < " $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( ) < < " \n " ;
2001-07-02 23:38:02 +04:00
break ;
case cmTarget : : SHARED_LIBRARY :
fout < < " \t $(INSTALL_DATA) " < < m_LibraryOutputPath < < " lib "
< < l - > first ;
fout < < m_Makefile - > GetDefinition ( " CMAKE_SHLIB_SUFFIX " ) ;
2001-12-21 17:07:17 +03:00
fout < < " $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( ) < < " \n " ;
2001-05-23 19:53:37 +04:00
break ;
2001-08-29 02:02:59 +04:00
case cmTarget : : MODULE_LIBRARY :
fout < < " \t $(INSTALL_DATA) " < < m_LibraryOutputPath < < " lib "
< < l - > first ;
fout < < m_Makefile - > GetDefinition ( " CMAKE_MODULE_SUFFIX " ) ;
2001-12-21 17:07:17 +03:00
fout < < " $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( ) < < " \n " ;
2001-08-29 02:02:59 +04:00
break ;
2001-06-12 16:31:33 +04:00
case cmTarget : : WIN32_EXECUTABLE :
2001-05-23 19:53:37 +04:00
case cmTarget : : EXECUTABLE :
2001-06-28 00:14:14 +04:00
fout < < " \t $(INSTALL_PROGRAM) " < < m_ExecutableOutputPath
< < l - > first
2001-06-27 23:42:27 +04:00
< < cmSystemTools : : GetExecutableExtension ( )
2001-12-21 17:07:17 +03:00
< < " $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( ) < < " \n " ;
2001-05-23 19:53:37 +04:00
break ;
2001-07-31 19:29:21 +04:00
case cmTarget : : INSTALL_FILES :
2001-05-23 19:53:37 +04:00
{
const std : : vector < std : : string > & sf = l - > second . GetSourceLists ( ) ;
std : : vector < std : : string > : : const_iterator i ;
for ( i = sf . begin ( ) ; i ! = sf . end ( ) ; + + i )
{
fout < < " \t @ echo \" Installing " < < * i < < " \" \n " ;
2001-07-05 20:03:57 +04:00
fout < < " \t @if [ -f " < < * i < < " ] ; then \\ \n " ;
2001-06-27 23:42:27 +04:00
// avoid using install-sh to install install-sh
// does not work on windows....
if ( * i = = " install-sh " )
{
fout < < " \t cp " ;
}
else
{
2001-07-31 19:29:21 +04:00
fout < < " \t $(INSTALL_DATA) " ;
2001-06-27 23:42:27 +04:00
}
fout < < * i
2001-12-21 17:07:17 +03:00
< < " $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( ) < < " ; \\ \n " ;
2001-11-08 16:42:16 +03:00
fout < < " \t elif [ -f $(CMAKE_CURRENT_SOURCE)/ " < < * i < < " ] ; then \\ \n " ;
2001-06-27 23:42:27 +04:00
// avoid using install-sh to install install-sh
// does not work on windows....
if ( * i = = " install-sh " )
{
fout < < " \t cp " ;
}
else
{
2001-07-31 19:29:21 +04:00
fout < < " \t $(INSTALL_DATA) " ;
}
2001-11-08 16:42:16 +03:00
fout < < " $(CMAKE_CURRENT_SOURCE)/ " < < * i
2001-12-21 17:07:17 +03:00
< < " $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( ) < < " ; \\ \n " ;
2001-07-31 19:29:21 +04:00
fout < < " \t else \\ \n " ;
fout < < " \t echo \" ERROR!!! Unable to find: " < < * i
< < " \" ; \\ \n " ;
fout < < " \t fi \n " ;
}
}
break ;
case cmTarget : : INSTALL_PROGRAMS :
{
const std : : vector < std : : string > & sf = l - > second . GetSourceLists ( ) ;
std : : vector < std : : string > : : const_iterator i ;
for ( i = sf . begin ( ) ; i ! = sf . end ( ) ; + + i )
{
fout < < " \t @ echo \" Installing " < < * i < < " \" \n " ;
fout < < " \t @if [ -f " < < * i < < " ] ; then \\ \n " ;
// avoid using install-sh to install install-sh
// does not work on windows....
if ( * i = = " install-sh " )
{
fout < < " \t cp " ;
}
else
{
fout < < " \t $(INSTALL_PROGRAM) " ;
}
fout < < * i
2001-12-21 17:07:17 +03:00
< < " $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( ) < < " ; \\ \n " ;
2001-11-08 16:42:16 +03:00
fout < < " \t elif [ -f $(CMAKE_CURRENT_SOURCE)/ " < < * i < < " ] ; then \\ \n " ;
2001-07-31 19:29:21 +04:00
// avoid using install-sh to install install-sh
// does not work on windows....
if ( * i = = " install-sh " )
{
fout < < " \t cp " ;
}
else
{
fout < < " \t $(INSTALL_PROGRAM) " ;
2001-06-27 23:42:27 +04:00
}
2001-11-08 16:42:16 +03:00
fout < < " $(CMAKE_CURRENT_SOURCE)/ " < < * i
2001-12-21 17:07:17 +03:00
< < " $(DESTDIR) " < < prefix < < l - > second . GetInstallPath ( ) < < " ; \\ \n " ;
2001-05-23 19:53:37 +04:00
fout < < " \t else \\ \n " ;
fout < < " \t echo \" ERROR!!! Unable to find: " < < * i
< < " \" ; \\ \n " ;
fout < < " \t fi \n " ;
}
}
break ;
2001-06-12 16:31:33 +04:00
case cmTarget : : UTILITY :
default :
break ;
2001-05-23 19:53:37 +04:00
}
}
}
}
2001-05-16 23:15:21 +04:00
void cmUnixMakefileGenerator : : OutputMakeRules ( std : : ostream & fout )
{
2001-05-23 19:53:37 +04:00
this - > OutputMakeRule ( fout ,
2001-05-16 23:15:21 +04:00
" Default build rule " ,
" all " ,
2001-12-29 01:00:05 +03:00
" cmake.depends $(TARGETS) $(SUBDIR_BUILD) " ,
2001-05-16 23:15:21 +04:00
0 ) ;
2002-01-15 00:28:38 +03:00
this - > OutputMakeRule ( fout ,
" remove generated files " ,
" clean " ,
" $(SUBDIR_CLEAN) " ,
" -@ $(RM) $(CLEAN_OBJECT_FILES) $(EXECUTABLES) "
" $(TARGETS) $(GENERATED_QT_FILES) $(GENERATED_FLTK_FILES) " ) ;
2001-12-31 19:54:14 +03:00
// collect up all the sources
2002-01-02 19:54:50 +03:00
std : : string allsources ;
2001-12-31 19:54:14 +03:00
std : : map < cmStdString , cmTarget > & targets = m_Makefile - > GetTargets ( ) ;
for ( std : : map < cmStdString , cmTarget > : : const_iterator target = targets . begin ( ) ;
target ! = targets . end ( ) ; + + target )
{
// Iterate over every source for this target.
2002-03-29 18:06:30 +03:00
const std : : vector < cmSourceFile * > & sources = target - > second . GetSourceFiles ( ) ;
for ( std : : vector < cmSourceFile * > : : const_iterator source = sources . begin ( ) ;
2001-12-31 19:54:14 +03:00
source ! = sources . end ( ) ; + + source )
{
2002-03-29 18:06:30 +03:00
if ( ! ( * source ) - > IsAHeaderFileOnly ( ) )
2001-12-31 19:54:14 +03:00
{
allsources + = " \\ \n " ;
2002-04-17 22:39:32 +04:00
allsources + = this - > ConvertToOutputPath ( ( * source ) - > GetFullPath ( ) . c_str ( ) ) ;
2001-12-31 19:54:14 +03:00
}
}
}
2001-12-29 01:00:05 +03:00
this - > OutputMakeRule ( fout ,
" Rule to build the cmake.depends and Makefile as side effect, if a source cmakelist file is out of date. " ,
" cmake.depends " ,
2002-01-02 19:54:50 +03:00
" $(CMAKE_MAKEFILE_SOURCES) " ,
" $(CMAKE_COMMAND) "
" -S$(CMAKE_CURRENT_SOURCE) -O$(CMAKE_CURRENT_BINARY) "
" -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) "
) ;
this - > OutputMakeRule ( fout ,
" Rule to build the cmake.check_depends and Makefile as side effect, if any source file has changed. " ,
" cmake.check_depends " ,
2001-12-31 19:54:14 +03:00
allsources . c_str ( ) ,
2001-12-29 01:00:05 +03:00
" $(CMAKE_COMMAND) "
" -S$(CMAKE_CURRENT_SOURCE) -O$(CMAKE_CURRENT_BINARY) "
" -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) "
) ;
2002-01-02 19:54:50 +03:00
2001-05-16 23:15:21 +04:00
this - > OutputMakeRule ( fout ,
" Rule to force the build of cmake.depends " ,
" depend " ,
2001-12-29 01:00:05 +03:00
" $(SUBDIR_DEPEND) " ,
" $(CMAKE_COMMAND) "
" -S$(CMAKE_CURRENT_SOURCE) -O$(CMAKE_CURRENT_BINARY) "
" -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) " ) ;
this - > OutputMakeRule ( fout ,
" Rule to force the build of cmake.depends "
" in the current directory only. " ,
" dependlocal " ,
2001-12-21 23:39:43 +03:00
0 ,
2001-11-05 23:39:37 +03:00
" $(CMAKE_COMMAND) "
" -S$(CMAKE_CURRENT_SOURCE) -O$(CMAKE_CURRENT_BINARY) "
2001-12-29 01:00:05 +03:00
" -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) " ) ;
2001-05-16 23:15:21 +04:00
this - > OutputMakeRule ( fout ,
2001-11-05 23:39:37 +03:00
" Rebuild CMakeCache.txt file " ,
2001-05-16 23:15:21 +04:00
" rebuild_cache " ,
2001-11-22 01:45:01 +03:00
" $(CMAKE_BINARY_DIR)/CMakeCache.txt " ,
2001-11-05 23:39:37 +03:00
" $(CMAKE_COMMAND) "
2001-11-22 01:45:01 +03:00
" -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) " ) ;
2002-05-07 17:02:45 +04:00
// if CMAKE_EDIT_COMMAND is defined then add a rule to run it
// called edit_cache
if ( m_Makefile - > GetDefinition ( " CMAKE_EDIT_COMMAND " ) )
{
this - > OutputMakeRule ( fout ,
" Edit the CMakeCache.txt file with ccmake or CMakeSetup " ,
" edit_cache " ,
0 ,
" $(CMAKE_EDIT_COMMAND) "
" -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) " ) ;
}
2001-05-22 00:10:20 +04:00
this - > OutputMakeRule ( fout ,
2001-11-05 23:39:37 +03:00
" Create CMakeCache.txt file " ,
2001-11-22 01:45:01 +03:00
" $(CMAKE_BINARY_DIR)/CMakeCache.txt " ,
2001-11-09 20:03:41 +03:00
0 ,
2001-11-05 23:39:37 +03:00
" $(CMAKE_COMMAND) "
2001-11-22 01:45:01 +03:00
" -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) " ) ;
2001-07-06 22:41:18 +04:00
this - > OutputMakeRule ( fout ,
" Rule to keep make from removing Makefiles "
" if control-C is hit during a run of cmake. " ,
" .PRECIOUS " ,
" Makefile cmake.depends " ,
0 ) ;
this - > OutputSourceObjectBuildRules ( fout ) ;
2001-08-23 19:32:56 +04:00
// find ctest
std : : string ctest = m_Makefile - > GetDefinition ( " CMAKE_COMMAND " ) ;
ctest = cmSystemTools : : GetFilenamePath ( ctest . c_str ( ) ) ;
ctest + = " / " ;
ctest + = " ctest " ;
2001-12-08 03:11:28 +03:00
ctest + = cmSystemTools : : GetExecutableExtension ( ) ;
if ( ! cmSystemTools : : FileExists ( ctest . c_str ( ) ) )
{
ctest = m_Makefile - > GetDefinition ( " CMAKE_COMMAND " ) ;
ctest = cmSystemTools : : GetFilenamePath ( ctest . c_str ( ) ) ;
ctest + = " /Debug/ " ;
ctest + = " ctest " ;
ctest + = cmSystemTools : : GetExecutableExtension ( ) ;
}
if ( ! cmSystemTools : : FileExists ( ctest . c_str ( ) ) )
{
ctest = m_Makefile - > GetDefinition ( " CMAKE_COMMAND " ) ;
ctest = cmSystemTools : : GetFilenamePath ( ctest . c_str ( ) ) ;
ctest + = " /Release/ " ;
ctest + = " ctest " ;
ctest + = cmSystemTools : : GetExecutableExtension ( ) ;
}
2001-08-23 19:32:56 +04:00
if ( cmSystemTools : : FileExists ( ctest . c_str ( ) ) )
{
this - > OutputMakeRule ( fout ,
" run any tests " ,
" test " ,
" " ,
2002-03-06 02:41:24 +03:00
this - > ConvertToOutputPath ( ctest . c_str ( ) ) . c_str ( ) ) ;
2001-08-23 19:32:56 +04:00
}
2001-07-06 22:41:18 +04:00
}
2001-06-28 23:08:50 +04:00
2001-11-13 23:54:41 +03:00
void
cmUnixMakefileGenerator : :
OutputBuildObjectFromSource ( std : : ostream & fout ,
const char * shortName ,
const cmSourceFile & source ,
const char * extraCompileFlags ,
bool shared )
{
2001-12-28 23:58:21 +03:00
// Header files shouldn't have build rules.
if ( source . IsAHeaderFileOnly ( ) )
2002-03-29 18:06:30 +03:00
{
2001-12-28 23:58:21 +03:00
return ;
2002-03-29 18:06:30 +03:00
}
2001-12-28 23:58:21 +03:00
2001-11-13 23:54:41 +03:00
std : : string comment = " Build " ;
2001-11-14 18:21:59 +03:00
std : : string objectFile = std : : string ( shortName ) + m_ObjectFileExtension ;
2002-02-22 23:40:44 +03:00
objectFile = this - > ConvertToOutputPath ( objectFile . c_str ( ) ) ;
2001-11-13 23:54:41 +03:00
comment + = objectFile + " From " ;
comment + = source . GetFullPath ( ) ;
std : : string compileCommand ;
std : : string ext = source . GetSourceExtension ( ) ;
if ( ext = = " c " )
{
2001-11-30 04:59:53 +03:00
compileCommand = " $(CMAKE_C_COMPILER) $(CMAKE_C_FLAGS) " ;
2001-11-13 23:54:41 +03:00
compileCommand + = extraCompileFlags ;
if ( shared )
{
compileCommand + = " $(CMAKE_SHLIB_CFLAGS) " ;
}
compileCommand + = " $(INCLUDE_FLAGS) -c " ;
2001-11-22 01:45:01 +03:00
compileCommand + =
2002-02-22 21:38:33 +03:00
this - > ConvertToOutputPath ( source . GetFullPath ( ) . c_str ( ) ) ;
2001-11-13 23:54:41 +03:00
compileCommand + = " -o " ;
compileCommand + = objectFile ;
}
else
{
2001-12-01 00:05:55 +03:00
compileCommand = " $(CMAKE_CXX_COMPILER) $(CMAKE_CXX_FLAGS) " ;
2001-11-13 23:54:41 +03:00
compileCommand + = extraCompileFlags ;
if ( shared )
{
compileCommand + = " $(CMAKE_SHLIB_CFLAGS) " ;
}
compileCommand + = " $(INCLUDE_FLAGS) -c " ;
2001-11-22 01:45:01 +03:00
compileCommand + =
2002-02-22 21:38:33 +03:00
this - > ConvertToOutputPath ( source . GetFullPath ( ) . c_str ( ) ) ;
2001-11-13 23:54:41 +03:00
compileCommand + = " -o " ;
compileCommand + = objectFile ;
}
this - > OutputMakeRule ( fout ,
comment . c_str ( ) ,
objectFile . c_str ( ) ,
2002-02-22 21:38:33 +03:00
this - > ConvertToOutputPath ( source . GetFullPath ( ) .
c_str ( ) ) . c_str ( ) ,
2001-11-13 23:54:41 +03:00
compileCommand . c_str ( ) ) ;
}
2001-07-06 22:41:18 +04:00
void cmUnixMakefileGenerator : : OutputSourceObjectBuildRules ( std : : ostream & fout )
{
2001-11-14 18:21:59 +03:00
fout < < " # Rules to build " < < m_ObjectFileExtension
< < " files from their sources: \n " ;
2001-06-28 23:08:50 +04:00
2001-07-02 23:38:02 +04:00
std : : set < std : : string > rules ;
2001-06-28 23:08:50 +04:00
// Iterate over every target.
2001-08-22 19:58:17 +04:00
std : : map < cmStdString , cmTarget > & targets = m_Makefile - > GetTargets ( ) ;
for ( std : : map < cmStdString , cmTarget > : : const_iterator target = targets . begin ( ) ;
2001-06-28 23:08:50 +04:00
target ! = targets . end ( ) ; + + target )
{
2001-08-29 02:02:59 +04:00
bool shared = ( ( target - > second . GetType ( ) = = cmTarget : : SHARED_LIBRARY ) | |
( target - > second . GetType ( ) = = cmTarget : : MODULE_LIBRARY ) ) ;
2001-07-10 19:46:20 +04:00
std : : string exportsDef = " " ;
if ( shared )
{
exportsDef = " -D " + target - > first + " _EXPORTS " ;
}
2001-06-28 23:08:50 +04:00
// Iterate over every source for this target.
2002-03-29 18:06:30 +03:00
const std : : vector < cmSourceFile * > & sources = target - > second . GetSourceFiles ( ) ;
for ( std : : vector < cmSourceFile * > : : const_iterator source = sources . begin ( ) ;
2001-06-28 23:08:50 +04:00
source ! = sources . end ( ) ; + + source )
{
2002-03-29 18:06:30 +03:00
if ( ! ( * source ) - > IsAHeaderFileOnly ( ) )
2001-06-28 23:08:50 +04:00
{
2001-07-02 23:38:02 +04:00
std : : string shortName ;
2001-07-03 00:52:56 +04:00
std : : string sourceName ;
2001-07-02 23:38:02 +04:00
// If the full path to the source file includes this
// directory, we want to use the relative path for the
// filename of the object file. Otherwise, we will use just
// the filename portion.
2002-03-29 18:06:30 +03:00
if ( ( cmSystemTools : : GetFilenamePath ( ( * source ) - > GetFullPath ( ) ) . find ( m_Makefile - > GetCurrentDirectory ( ) ) = = 0 )
| | ( cmSystemTools : : GetFilenamePath ( ( * source ) - > GetFullPath ( ) ) . find ( m_Makefile - >
2001-11-06 00:38:35 +03:00
GetCurrentOutputDirectory ( ) ) = = 0 ) )
2001-07-02 23:38:02 +04:00
{
2002-03-29 18:06:30 +03:00
sourceName = ( * source ) - > GetSourceName ( ) + " . " + ( * source ) - > GetSourceExtension ( ) ;
shortName = ( * source ) - > GetSourceName ( ) ;
2001-07-02 23:38:02 +04:00
// The path may be relative. See if a directory needs to be
// created for the output file. This is a ugly, and perhaps
// should be moved elsewhere.
std : : string relPath =
2002-03-29 18:06:30 +03:00
cmSystemTools : : GetFilenamePath ( ( * source ) - > GetSourceName ( ) ) ;
2001-07-02 23:38:02 +04:00
if ( relPath ! = " " )
{
std : : string outPath = m_Makefile - > GetCurrentOutputDirectory ( ) ;
outPath + = " / " + relPath ;
cmSystemTools : : MakeDirectory ( outPath . c_str ( ) ) ;
}
}
else
{
2002-03-29 18:06:30 +03:00
sourceName = ( * source ) - > GetFullPath ( ) ;
shortName = cmSystemTools : : GetFilenameName ( ( * source ) - > GetSourceName ( ) ) ;
2001-07-02 23:38:02 +04:00
}
2001-11-15 16:42:34 +03:00
std : : string shortNameWithExt = shortName +
2002-03-29 18:06:30 +03:00
( * source ) - > GetSourceExtension ( ) ;
2001-07-02 23:38:02 +04:00
// Only output a rule for each .o once.
2001-11-15 16:42:34 +03:00
if ( rules . find ( shortNameWithExt ) = = rules . end ( ) )
2001-07-02 23:38:02 +04:00
{
2002-03-29 18:06:30 +03:00
if ( ( * source ) - > GetCompileFlags ( ) )
2002-03-04 22:14:41 +03:00
{
2002-03-29 18:06:30 +03:00
exportsDef + = ( * source ) - > GetCompileFlags ( ) ;
2002-03-04 22:14:41 +03:00
exportsDef + = " " ;
}
2001-11-13 23:54:41 +03:00
this - > OutputBuildObjectFromSource ( fout ,
shortName . c_str ( ) ,
2002-03-29 18:06:30 +03:00
* ( * source ) ,
2001-11-13 23:54:41 +03:00
exportsDef . c_str ( ) ,
shared ) ;
2001-11-15 17:00:44 +03:00
rules . insert ( shortNameWithExt ) ;
2001-07-02 23:38:02 +04:00
}
2001-06-28 23:08:50 +04:00
}
}
}
2001-05-16 23:15:21 +04:00
}
void cmUnixMakefileGenerator : : OutputMakeRule ( std : : ostream & fout ,
const char * comment ,
const char * target ,
const char * depends ,
2001-11-02 02:37:28 +03:00
const char * command ,
const char * command2 ,
const char * command3 ,
const char * command4 )
2001-05-16 23:15:21 +04:00
{
if ( ! target )
{
cmSystemTools : : Error ( " no target for OutputMakeRule " ) ;
return ;
}
std : : string replace ;
if ( comment )
{
replace = comment ;
m_Makefile - > ExpandVariablesInString ( replace ) ;
2001-11-02 02:37:28 +03:00
fout < < " #--------------------------------------------------------- \n " ;
2002-04-11 17:53:41 +04:00
fout < < " # " < < replace ;
2001-11-02 02:37:28 +03:00
fout < < " \n # \n " ;
2001-05-16 23:15:21 +04:00
}
fout < < " \n " ;
2002-04-11 17:53:41 +04:00
2001-05-16 23:15:21 +04:00
replace = target ;
m_Makefile - > ExpandVariablesInString ( replace ) ;
2002-02-22 23:40:44 +03:00
fout < < this - > ConvertToOutputPath ( replace . c_str ( ) ) < < " : " ;
2002-04-11 17:53:41 +04:00
2001-05-16 23:15:21 +04:00
if ( depends )
{
replace = depends ;
m_Makefile - > ExpandVariablesInString ( replace ) ;
fout < < replace . c_str ( ) ;
}
fout < < " \n " ;
2002-04-11 17:53:41 +04:00
const char * commands [ ] = { command , command2 , command3 , command4 } ;
2002-05-07 17:11:39 +04:00
for ( unsigned int i = 0 ; i < sizeof ( commands ) / sizeof ( commands [ 0 ] ) ; + + i )
2001-11-02 02:37:28 +03:00
{
2002-04-11 17:53:41 +04:00
if ( commands [ i ] )
2001-12-21 23:39:43 +03:00
{
2002-04-11 17:53:41 +04:00
replace = commands [ i ] ;
m_Makefile - > ExpandVariablesInString ( replace ) ;
if ( replace [ 0 ] ! = ' - ' & & replace . find ( " echo " ) ! = 0
& & replace . find ( " $(MAKE) " ) ! = 0 )
{
std : : string echostring = replace ;
2002-04-18 21:44:50 +04:00
// for unix we want to quote the output of echo
// for nmake and borland, the echo should not be quoted
if ( strcmp ( this - > GetName ( ) , " Unix Makefiles " ) = = 0 )
{
2002-04-18 23:58:35 +04:00
cmSystemTools : : ReplaceString ( echostring , " \\ \n " , " " ) ;
cmSystemTools : : ReplaceString ( echostring , " \t " , " " ) ;
cmSystemTools : : ReplaceString ( echostring , " \n \t " , " \" \n \t echo \" " ) ;
2002-04-18 21:44:50 +04:00
fout < < " \t echo \" " < < echostring . c_str ( ) < < " \" \n " ;
}
else
{
2002-04-18 23:58:35 +04:00
cmSystemTools : : ReplaceString ( echostring , " \n \t " , " \n \t echo " ) ;
2002-04-18 21:44:50 +04:00
fout < < " \t echo " < < echostring . c_str ( ) < < " \n " ;
}
2002-04-11 17:53:41 +04:00
}
fout < < " \t " < < replace . c_str ( ) < < " \n " ;
2001-12-21 23:39:43 +03:00
}
2001-05-16 23:15:21 +04:00
}
2001-06-28 23:08:50 +04:00
fout < < " \n " ;
2001-05-16 23:15:21 +04:00
}
2001-05-18 19:12:21 +04:00
void cmUnixMakefileGenerator : : SetLocal ( bool local )
{
if ( local )
{
m_CacheOnly = false ;
m_Recurse = false ;
}
else
{
m_CacheOnly = true ;
m_Recurse = true ;
}
}
2001-05-18 23:20:31 +04:00
2002-04-03 00:43:23 +04:00
void cmUnixMakefileGenerator : : EnableLanguage ( const char * lang )
2001-05-18 23:20:31 +04:00
{
if ( m_CacheOnly )
{
2001-12-04 20:03:58 +03:00
// see man putenv for explaination of this stupid code....
static char envCXX [ 5000 ] ;
static char envCC [ 5000 ] ;
2001-08-27 22:44:15 +04:00
if ( m_Makefile - > GetDefinition ( " CMAKE_CXX_COMPILER " ) )
{
std : : string env = " CXX=${CMAKE_CXX_COMPILER} " ;
m_Makefile - > ExpandVariablesInString ( env ) ;
2001-12-04 20:03:58 +03:00
strncpy ( envCXX , env . c_str ( ) , 4999 ) ;
envCXX [ 4999 ] = 0 ;
putenv ( envCXX ) ;
2001-08-27 22:44:15 +04:00
}
if ( m_Makefile - > GetDefinition ( " CMAKE_C_COMPILER " ) )
{
std : : string env = " CC=${CMAKE_C_COMPILER} " ;
m_Makefile - > ExpandVariablesInString ( env ) ;
2001-12-04 20:03:58 +03:00
strncpy ( envCC , env . c_str ( ) , 4999 ) ;
envCC [ 4999 ] = 0 ;
putenv ( envCC ) ;
2001-08-27 22:44:15 +04:00
}
std : : string output ;
2002-04-03 00:43:23 +04:00
std : : string root
= this - > ConvertToOutputPath ( m_Makefile - > GetDefinition ( " CMAKE_ROOT " ) ) ;
// if no lang specified use CXX
if ( ! lang )
{
lang = " CXX " ;
}
// if CXX or C, then enable C
if ( ( ! this - > GetLanguageEnabled ( lang ) & & lang [ 0 ] = = ' C ' ) )
{
std : : string cmd = root ;
cmd + = " /Templates/cconfigure " ;
cmSystemTools : : RunCommand ( cmd . c_str ( ) , output ,
this - > ConvertToOutputPath ( m_Makefile - > GetHomeOutputDirectory ( ) ) . c_str ( ) ) ;
std : : string fpath = m_Makefile - > GetHomeOutputDirectory ( ) ;
fpath + = " /CCMakeSystemConfig.cmake " ;
m_Makefile - > ReadListFile ( NULL , fpath . c_str ( ) ) ;
this - > SetLanguageEnabled ( " C " ) ;
}
// if CXX
if ( ! this - > GetLanguageEnabled ( lang ) | | strcmp ( lang , " CXX " ) = = 0 )
{
std : : string cmd = root ;
cmd + = " /Templates/cxxconfigure " ;
cmSystemTools : : RunCommand ( cmd . c_str ( ) , output ,
this - > ConvertToOutputPath ( m_Makefile - > GetHomeOutputDirectory ( ) ) . c_str ( ) ) ;
std : : string fpath = m_Makefile - > GetHomeOutputDirectory ( ) ;
fpath + = " /CXXCMakeSystemConfig.cmake " ;
m_Makefile - > ReadListFile ( NULL , fpath . c_str ( ) ) ;
this - > SetLanguageEnabled ( " CXX " ) ;
}
2001-08-27 22:44:15 +04:00
m_Makefile - > AddDefinition ( " RUN_CONFIGURE " , true ) ;
2001-05-18 23:20:31 +04:00
}
}