some fixin's for mingw, thanks zorlan
[boost:zeuners-boost-cmake.git] / tools / build / CMake / BoostCore.cmake
1 ##########################################################################
2 # Core Functionality for Boost                                           #
3 ##########################################################################
4 # Copyright (C) 2007-2009 Douglas Gregor <doug.gregor@gmail.com>         #
5 # Copyright (C) 2007-2009 Troy Straszheim <troy@resophonic.com>          #
6 #                                                                        #
7 # Distributed under the Boost Software License, Version 1.0.             #
8 # See accompanying file LICENSE_1_0.txt or copy at                       #
9 #   http://www.boost.org/LICENSE_1_0.txt                                 #
10 ##########################################################################
11 # Important developer macros in this file:                               #
12 #                                                                        #
13 #   boost_library_project: Defines a Boost library project (e.g.,        #
14 #   Boost.Python).                                                       #
15 #                                                                        #
16 #   boost_add_library: Builds library binaries for Boost libraries       #
17 #   with compiled sources (e.g., boost_filesystem).                      #
18 #                                                                        #
19 #   boost_add_executable: Builds executables.                            #
20 ##########################################################################
21
22 # Defines a Boost library project (e.g., for Boost.Python). Use as:
23 #
24 #   boost_library_project(libname
25 #                         [SRCDIRS srcdir1 srcdir2 ...] 
26 #                         [TESTDIRS testdir1 testdir2 ...]
27 #                         [DEPENDS lib1 lib2 ...]
28 #                         [DESCRIPTION description]
29 #                         [AUTHORS author1 author2 ...]
30 #                         [MAINTAINERS maint1 maint2 ...]
31 #                         [MODULARIZED])
32 #
33 # where libname is the name of the library (e.g., Python, or
34 # Filesystem), srcdir1, srcdir2, etc, are subdirectories containing
35 # library sources (for Boost libraries that build actual library
36 # binaries), and testdir1, testdir2, etc, are subdirectories
37 # containing regression tests. DEPENDS lists the names of the other
38 # Boost libraries that this library depends on. If the dependencies
39 # are not satisfied (e.g., because the library isn't present or its
40 # build is turned off), this library won't be built. 
41 #
42 # DESCRIPTION provides a brief description of the library, which can
43 # be used to summarize the behavior of the library for a user. AUTHORS
44 # lists the authors of the library, while MAINTAINERS lists the active
45 # maintainers. If MAINTAINERS is left empty, it is assumed that the 
46 # authors are still maintaining the library. Both authors and maintainers
47 # should have their name followed by their current e-mail address in
48 # angle brackets, with -at- instead of the at sign, e.g.,
49 #   Douglas Gregor <doug.gregor -at- gmail.com>
50 #
51 # Example: 
52 #   boost_library_project(
53 #     Thread
54 #     SRCDIRS src 
55 #     TESTDIRS test
56 #     )
57 macro(boost_library_project LIBNAME)
58   parse_arguments(THIS_PROJECT
59     "SRCDIRS;TESTDIRS;EXAMPLEDIRS;HEADERS;DOCDIRS;DESCRIPTION;AUTHORS;MAINTAINERS"
60     "MODULARIZED"
61     ${ARGN}
62     )
63
64   # Set THIS_PROJECT_DEPENDS_ALL to the set of all of its
65   # dependencies, its dependencies' dependencies, etc., transitively.
66   string(TOUPPER "BOOST_${LIBNAME}_DEPENDS" THIS_PROJECT_DEPENDS)
67   set(THIS_PROJECT_DEPENDS_ALL ${${THIS_PROJECT_DEPENDS}})
68   set(ADDED_DEPS TRUE)
69   while (ADDED_DEPS)
70     set(ADDED_DEPS FALSE)
71     foreach(DEP ${THIS_PROJECT_DEPENDS_ALL})
72       string(TOUPPER "BOOST_${DEP}_DEPENDS" DEP_DEPENDS)
73       foreach(DEPDEP ${${DEP_DEPENDS}})
74         list(FIND THIS_PROJECT_DEPENDS_ALL ${DEPDEP} DEPDEP_INDEX)
75         if (DEPDEP_INDEX EQUAL -1)
76           list(APPEND THIS_PROJECT_DEPENDS_ALL ${DEPDEP})
77           set(ADDED_DEPS TRUE)
78         endif()
79       endforeach()
80     endforeach()
81   endwhile()
82
83   string(TOLOWER "${LIBNAME}" libname)
84   string(TOLOWER "${LIBNAME}" BOOST_PROJECT_NAME)
85   string(TOUPPER "${LIBNAME}" ULIBNAME)
86   project(${LIBNAME})
87   
88
89   if (THIS_PROJECT_MODULARIZED OR THIS_PROJECT_SRCDIRS)
90     
91     # We only build a component group for modularized libraries or libraries
92     # that have compiled parts.
93     if (COMMAND cpack_add_component_group)
94       # Compute a reasonable description for this library.
95       if (THIS_PROJECT_DESCRIPTION)
96         set(THIS_PROJECT_DESCRIPTION "Boost.${LIBNAME}\n\n${THIS_PROJECT_DESCRIPTION}")
97         
98         if (THIS_PROJECT_AUTHORS)
99           list(LENGTH THIS_PROJECT_AUTHORS THIS_PROJECT_NUM_AUTHORS)
100           if (THIS_PROJECT_NUM_AUTHORS EQUAL 1)
101             set(THIS_PROJECT_DESCRIPTION "${THIS_PROJECT_DESCRIPTION}\n\nAuthor: ")
102           else()
103             set(THIS_PROJECT_DESCRIPTION "${THIS_PROJECT_DESCRIPTION}\n\nAuthors: ")
104           endif()
105           set(THIS_PROJECT_FIRST_AUTHOR TRUE)
106           foreach(AUTHOR ${THIS_PROJECT_AUTHORS})
107             string(REGEX REPLACE " *-at- *" "@" AUTHOR ${AUTHOR})
108             if (THIS_PROJECT_FIRST_AUTHOR)
109               set(THIS_PROJECT_FIRST_AUTHOR FALSE)
110             else()
111               set(THIS_PROJECT_DESCRIPTION "${THIS_PROJECT_DESCRIPTION}\n         ")
112             endif()
113             set(THIS_PROJECT_DESCRIPTION "${THIS_PROJECT_DESCRIPTION}${AUTHOR}")
114           endforeach(AUTHOR)
115         endif (THIS_PROJECT_AUTHORS)
116
117         if (THIS_PROJECT_MAINTAINERS)
118           list(LENGTH THIS_PROJECT_MAINTAINERS THIS_PROJECT_NUM_MAINTAINERS)
119           if (THIS_PROJECT_NUM_MAINTAINERS EQUAL 1)
120             set(THIS_PROJECT_DESCRIPTION "${THIS_PROJECT_DESCRIPTION}\nMaintainer: ")
121           else()
122             set(THIS_PROJECT_DESCRIPTION "${THIS_PROJECT_DESCRIPTION}\nMaintainers: ")
123           endif()
124           set(THIS_PROJECT_FIRST_MAINTAINER TRUE)
125           foreach(MAINTAINER ${THIS_PROJECT_MAINTAINERS})
126             string(REGEX REPLACE " *-at- *" "@" MAINTAINER ${MAINTAINER})
127             if (THIS_PROJECT_FIRST_MAINTAINER)
128               set(THIS_PROJECT_FIRST_MAINTAINER FALSE)
129             else()
130               set(THIS_PROJECT_DESCRIPTION "${THIS_PROJECT_DESCRIPTION}\n             ")
131             endif()
132             set(THIS_PROJECT_DESCRIPTION "${THIS_PROJECT_DESCRIPTION}${MAINTAINER}")
133           endforeach(MAINTAINER)
134         endif (THIS_PROJECT_MAINTAINERS)
135       endif (THIS_PROJECT_DESCRIPTION)
136       
137       # Create a component group for this library
138       fix_cpack_component_name(CPACK_COMPONENT_GROUP_NAME ${libname})
139       cpack_add_component_group(${CPACK_COMPONENT_GROUP_NAME}
140         DISPLAY_NAME "${LIBNAME}"
141         DESCRIPTION ${THIS_PROJECT_DESCRIPTION})
142     endif () # COMMAND cpake_add_component_group
143   endif () # THIS_PROJECT_MODULARIZED OR THIS_PROJECT_SRCDIRS
144   
145   if (THIS_PROJECT_MODULARIZED)
146     #
147     # Don't add this module's include directory
148     # until modularization makes sense
149     #
150     # include_directories("${Boost_SOURCE_DIR}/libs/${libname}/include")
151     
152     #
153     # Horrible hackery.  Make install of headers from modularized directories
154     # OPTIONAL, which only works on cmake >= 2.7
155     # 
156     #
157     # TDS 20091009: disable this modularized stuff, as forcing
158     # people to make modularize (which wastes your source directory)
159     # is a huge hassle and anyway it looks like the 'modularization'
160     # of boost is dead for a while.
161     #
162
163     # if (${CMAKE_MAJOR_VERSION} GREATER 1 AND ${CMAKE_MINOR_VERSION} GREATER 6)
164     #   # Install this module's headers
165     #   install(DIRECTORY include/boost 
166     #     DESTINATION ${BOOST_HEADER_DIR}
167     #     ${_INSTALL_OPTIONAL}
168     #     COMPONENT ${libname}_headers
169     #     PATTERN "CVS" EXCLUDE
170     #     PATTERN ".svn" EXCLUDE)
171     # else()
172     #   if (EXISTS include/boost)
173     #     # Install this module's headers
174     #     install(DIRECTORY include/boost 
175     #       DESTINATION ${BOOST_HEADER_DIR}
176     #       ${_INSTALL_OPTIONAL}
177     #       COMPONENT ${libname}_headers
178     #       PATTERN "CVS" EXCLUDE
179     #       PATTERN ".svn" EXCLUDE)
180     #   endif()
181     # endif()
182
183     
184     if (COMMAND cpack_add_component)        
185       # Determine the header dependencies
186       set(THIS_PROJECT_HEADER_DEPENDS)
187       foreach(DEP ${${THIS_PROJECT_DEPENDS}})
188         string(TOLOWER ${DEP} dep)
189         if (${dep} STREQUAL "serialization")
190           # TODO: Ugly, ugly hack until the serialization library is modularized
191         elseif (${dep} STREQUAL "thread")
192         else()
193           list(APPEND THIS_PROJECT_HEADER_DEPENDS ${dep}_headers)
194         endif()
195       endforeach(DEP)
196
197       # Tell CPack about the headers component
198       fix_cpack_component_name(CPACK_COMPONENT_GROUP_NAME ${libname})
199       cpack_add_component(${libname}_headers
200         DISPLAY_NAME "Header files"
201         GROUP      ${CPACK_COMPONENT_GROUP_NAME}
202         DEPENDS    ${THIS_PROJECT_HEADER_DEPENDS})
203     endif ()
204   endif () # THIS_PROJECT_MODULARIZED
205
206   #-- This is here to debug the modularize code
207   set(modularize_debug FALSE)
208   if (modularize_debug)
209     set(modularize_output ${Boost_BINARY_DIR})
210     set(modularize_libs_dir "modularize")
211   else (modularize_debug)
212     set(modularize_output ${Boost_SOURCE_DIR})
213     set(modularize_libs_dir "libs")
214   endif(modularize_debug)
215
216   #
217   # Modularization code
218   #
219   if(THIS_PROJECT_HEADERS)
220     set(${LIBNAME}-modularize-commands)
221     foreach(item ${THIS_PROJECT_HEADERS})
222       if(EXISTS "${Boost_SOURCE_DIR}/boost/${item}")
223         if(IS_DIRECTORY "${Boost_SOURCE_DIR}/boost/${item}")
224           list(APPEND ${LIBNAME}-modularize-commands
225             COMMAND "${CMAKE_COMMAND}" -E copy_directory
226             "${Boost_SOURCE_DIR}/boost/${item}"
227             "${modularize_output}/${modularize_libs_dir}/${libname}/include/boost/${item}"
228             )
229           if (NOT modularize_debug)
230             list(APPEND ${LIBNAME}-modularize-commands
231               COMMAND "${CMAKE_COMMAND}" -E remove_directory "${Boost_SOURCE_DIR}/boost/${item}" 
232               )
233           endif (NOT modularize_debug)
234         else(IS_DIRECTORY "${Boost_SOURCE_DIR}/boost/${item}")
235           list(APPEND ${LIBNAME}-modularize-commands
236             COMMAND "${CMAKE_COMMAND}" -E copy
237             "${Boost_SOURCE_DIR}/boost/${item}"
238             "${modularize_output}/${modularize_libs_dir}/${libname}/include/boost/${item}"
239             )
240           if (NOT modularize_debug)
241             list(APPEND ${LIBNAME}-modularize-commands
242               COMMAND "${CMAKE_COMMAND}" -E remove "${Boost_SOURCE_DIR}/boost/${item}" 
243               )
244           endif (NOT modularize_debug)
245           
246         endif(IS_DIRECTORY "${Boost_SOURCE_DIR}/boost/${item}")
247       elseif(EXISTS "${Boost_SOURCE_DIR}/${modularize_libs_dir}/${libname}/include/boost/${item}")
248         # Okay; already modularized
249       else()
250         message(SEND_ERROR 
251           "Header or directory boost/${item} does not exist. The HEADERS argument in ${Boost_SOURCE_DIR}/${modularize_libs_dir}/${libname}/CMakeLists.txt should be updated.")
252       endif()
253     endforeach(item)
254
255     if (${LIBNAME}-modularize-commands)
256       set(${LIBNAME}-modularize-commands
257         # COMMAND "${CMAKE_COMMAND}" -E remove_directory "${modularize_output}/libs/${libname}/include"
258         COMMAND "${CMAKE_COMMAND}" -E make_directory
259         "${modularize_output}/${modularize_libs_dir}/${libname}/include/boost"
260         ${${LIBNAME}-modularize-commands}
261         )
262       if (NOT modularize_debug)
263         set(${LIBNAME}-modularize-commands
264           COMMAND "${CMAKE_COMMAND}" -E remove_directory "${modularize_output}/${modularize_libs_dir}/${libname}/include"
265           ${${LIBNAME}-modularize-commands}
266           )
267       endif (NOT modularize_debug)
268       # disable modularization
269       # add_custom_target(${LIBNAME}-modularize
270       # ${${LIBNAME}-modularize-commands}
271       # COMMENT "Modularizing ${LIBNAME} headers to project-local dir from monolithic boost dir"
272       # )
273
274       if(THIS_PROJECT_MODULARIZED)
275         #
276         # Temporarily disable modularization 
277         #
278         # add_dependencies(modularize ${LIBNAME}-modularize)
279         #
280       endif(THIS_PROJECT_MODULARIZED)
281     endif()
282   endif(THIS_PROJECT_HEADERS)
283   
284   # For each of the modular libraries on which this project depends,
285   # add the include path for that library.
286   set(THIS_PROJECT_HAS_HEADER_DEPENDS FALSE)
287   # Temporarily disable modularization stuff.
288   # foreach(DEP ${THIS_PROJECT_DEPENDS_ALL})
289   #   include_directories("${modularize_output}/${modularize_libs_dir}/${DEP}/include")
290   # endforeach(DEP)
291
292   # TODO: is this still necessary?
293   if(NOT EXISTS ${CMAKE_BINARY_DIR}/bin/tests)
294     file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/bin/tests)
295   endif(NOT EXISTS ${CMAKE_BINARY_DIR}/bin/tests)
296   if(NOT EXISTS ${CMAKE_BINARY_DIR}/bin/tests/${BOOST_PROJECT_NAME})
297     file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/bin/tests/${BOOST_PROJECT_NAME})
298   endif(NOT EXISTS ${CMAKE_BINARY_DIR}/bin/tests/${BOOST_PROJECT_NAME})
299
300   # Include each of the source directories
301   if(THIS_PROJECT_SRCDIRS)
302     foreach(SUBDIR ${THIS_PROJECT_SRCDIRS})
303       add_subdirectory(${SUBDIR})
304     endforeach(SUBDIR ${THIS_PROJECT_SRCDIRS})
305   endif()
306
307   set(BOOST_ALL_COMPONENTS ${BOOST_ALL_COMPONENTS} PARENT_SCOPE)
308
309   #set(BOOST_${LIBNAME}_COMPONENTS ${THIS_PROJECT_COMPONENTS} PARENT_SCOPE)
310   #message("BOOST_${LIBNAME}_COMPONENTS ${THIS_PROJECT_COMPONENTS}")
311   #set(BOOST_ALL_COMPONENTS ${LIBNAME} ${BOOST_ALL_COMPONENTS} PARENT_SCOPE)
312
313   list(FIND BUILD_TESTS ${libname} BUILD_TESTS_INDEX)
314   if ((BUILD_TESTS_INDEX GREATER -1) OR (BUILD_TESTS STREQUAL "ALL"))
315     # set the tests directories list for later inclusion
316     # project(${libname}-tests)
317     if (THIS_PROJECT_TESTDIRS)
318       set(BOOST_TEST_PROJECTS ${ULIBNAME} ${BOOST_TEST_PROJECTS} PARENT_SCOPE)
319     endif()
320     foreach(SUBDIR ${THIS_PROJECT_TESTDIRS})
321       # message(STATUS "+-- ${SUBDIR}")
322       # add_subdirectory(${SUBDIR})
323       set(BOOST_${ULIBNAME}_TESTDIRS
324         ${BOOST_${ULIBNAME}_TESTDIRS}
325         ${CMAKE_CURRENT_SOURCE_DIR}/${SUBDIR}
326         PARENT_SCOPE)
327     endforeach()
328   endif()
329
330   list(FIND BUILD_EXAMPLES ${libname} BUILD_EXAMPLES_INDEX)
331   if ((BUILD_EXAMPLES_INDEX GREATER -1) OR (BUILD_EXAMPLES STREQUAL "ALL"))
332     project(${libname}-examples)
333     # Include the example directories.
334     foreach(SUBDIR ${THIS_PROJECT_EXAMPLEDIRS})
335       message(STATUS "+-- ${SUBDIR}")
336       add_subdirectory(${SUBDIR})
337     endforeach()
338   endif()
339
340   if (BUILD_DOCUMENTATION AND THIS_PROJECT_DOCDIRS)
341     foreach(SUBDIR ${THIS_PROJECT_DOCDIRS})
342       add_subdirectory(${SUBDIR})
343     endforeach(SUBDIR)
344   endif ()
345 endmacro(boost_library_project)
346
347 macro(boost_tool_project TOOLNAME)
348   parse_arguments(THIS_PROJECT
349     "DESCRIPTION;AUTHORS;MAINTAINERS"
350     ""
351     ${ARGN}
352     )
353
354   set(THIS_PROJECT_IS_TOOL TRUE)
355
356   string(TOUPPER ${TOOLNAME} UTOOLNAME)
357   project(${TOOLNAME})
358
359   include_directories(${CMAKE_CURRENT_SOURCE_DIR})
360
361   set(THIS_PROJECT_OKAY ON)
362   set(THIS_PROJECT_FAILED_DEPS "")
363
364   #   message(">>> ${BOOST_${UTOOLNAME}_DEPENDS}")
365   #   foreach(DEP ${BOOST_${UTOOLNAME}_DEPENDS})
366   #     get_target_property(dep_location boost_${DEP} TYPE)
367   #     message("${DEP} TYPE=${dep_location}")
368   #     if (NOT ${dep_location})
369   #       set(THIS_PROJECT_OKAY OFF)
370   #       set(THIS_PROJECT_FAILED_DEPS "${THIS_PROJECT_FAILED_DEPS}  ${DEP}\n")
371   #     endif (NOT ${dep_location})
372   #   endforeach(DEP)
373   # 
374   #   if (NOT THIS_PROJECT_OKAY)
375   #     #if (BUILD_${UTOOLNAME})
376   #       # The user explicitly turned on this tool in a prior
377   #       # iteration, but it can no longer be built because one of the
378   #       # dependencies was turned off. Force this option off and
379   #       # complain about it.
380   #       set(BUILD_${UTOOLNAME} OFF CACHE BOOL "Build ${TOOLNAME}" FORCE)
381   #       message(SEND_ERROR "Cannot build ${TOOLNAME} due to missing library dependencies:\n${THIS_PROJECT_FAILED_DEPS}")
382   #     #endif ()
383   #   endif (NOT THIS_PROJECT_OKAY)
384   # 
385   #   if(BUILD_${UTOOLNAME} AND THIS_PROJECT_OKAY)
386   #     string(TOLOWER "${TOOLNAME}" toolname)
387   #     
388   #     # Add this module's include directory
389   # 
390   #     # For each of the modular libraries on which this project depends,
391   #     # add the include path for that library.
392   #     foreach(DEP ${BOOST_${UTOOLNAME}_DEPENDS})
393   #       string(TOUPPER ${DEP} UDEP)
394   #       #
395   #       # Modularization disabled
396   #       #
397   #       # include_directories("${Boost_SOURCE_DIR}/libs/${DEP}/include")
398   #       #
399   #     endforeach(DEP)
400   #   endif()
401 endmacro(boost_tool_project)
402
403 #TODO: Finish this documentation
404 # Defines dependencies of a boost project and testing targets. Use as:
405 #
406 #   boost_module(libname
407 #                DEPENDS srcdir1 srcdir2 ...
408 #                TEST_DEPENDS testdir1 testdir2 ...
409 #
410 # Example: 
411 #   boost_library_project(
412 #     Thread
413 #     SRCDIRS src 
414 #     TESTDIRS test
415 #     )
416 #
417 macro(boost_module LIBNAME)
418   parse_arguments(THIS_MODULE
419     "DEPENDS"
420     ""
421     ${ARGN}
422     )
423
424   # Export BOOST_${LIBNAME}_DEPENDS
425   string(TOUPPER "BOOST_${LIBNAME}_DEPENDS" THIS_MODULE_LIBNAME_DEPENDS)
426   set(${THIS_MODULE_LIBNAME_DEPENDS} ${THIS_MODULE_DEPENDS})
427
428   # message(STATUS "----------------------------------------------------------------")
429   # message(STATUS "LIBNAME: ${LIBNAME}")
430   # message(STATUS "THIS_MODULE_DEPENDS: ${THIS_MODULE_DEPENDS}")
431   # message(STATUS "THIS_MODULE_LIBNAME_DEPENDS: ${THIS_MODULE_LIBNAME_DEPENDS}")
432   # message(STATUS "${THIS_MODULE_LIBNAME_DEPENDS}: ${${THIS_MODULE_LIBNAME_DEPENDS}}")
433   # message(STATUS "THIS_MODULE_TEST_DEPENDS: ${THIS_MODULE_TEST_DEPENDS}")
434   # message(STATUS "THIS_MODULE_LIBNAME_TEST_DEPENDS: ${THIS_MODULE_LIBNAME_TEST_DEPENDS}")
435   # message(STATUS "${THIS_MODULE_LIBNAME_TEST_DEPENDS}: ${${THIS_MODULE_LIBNAME_TEST_DEPENDS}}")
436 endmacro(boost_module)
437
438 # This macro is an internal utility macro that builds the name of a
439 # particular variant of a library
440 #
441 #   boost_library_variant_target_name(feature1 feature2 ...)
442 #
443 # where feature1, feature2, etc. are the names of features to be
444 # included in this variant, e.g., MULTI_THREADED, DEBUG. 
445 #
446 # This macro sets three macros:
447 #   
448 #   VARIANT_TARGET_NAME: The suffix that should be appended to the
449 #   name of the library target to name this variant of the
450 #   library. For example, this might be "-mt-static" for a static,
451 #   multi-threaded variant. It should be used to name the CMake
452 #   library target, e.g., boost_signals-mt-static.
453 #
454 #   VARIANT_VERSIONED_NAME: The suffix that will be added to the name
455 #   of the generated library, containing information about the
456 #   particular version of the library and the toolset used to build
457 #   this library. For example, this might be "-gcc41-mt-1_34" for the
458 #   multi-threaded, release variant of the library in Boost 1.34.0 as
459 #   compiled with GCC 4.1.  If option MANGLE_LIBNAMES is OFF, this 
460 #   variable is set to the empty string.
461 #
462 #   VARIANT_DISPLAY_NAME: The display name that describes this
463 #   variant, e.g., "Debug, static, multi-threaded".
464 #
465 macro(boost_library_variant_target_name)
466   set(VARIANT_TARGET_NAME "")
467
468   # The versioned name starts with the full Boost toolset
469   if(WINMANGLE_LIBNAMES)
470     set(VARIANT_VERSIONED_NAME "-${BOOST_TOOLSET}")
471   else(WINMANGLE_LIBNAMES)
472     set(VARIANT_VERSIONED_NAME "")
473   endif(WINMANGLE_LIBNAMES)
474
475   # Add -mt for multi-threaded libraries
476   list_contains(VARIANT_IS_MT MULTI_THREADED ${ARGN})
477   if (VARIANT_IS_MT)
478     set(VARIANT_TARGET_NAME "${VARIANT_TARGET_NAME}-mt")
479
480     # If we're creating versioned names, tack on "-mt"
481     set(VARIANT_VERSIONED_NAME "${VARIANT_VERSIONED_NAME}-mt")
482   endif (VARIANT_IS_MT)
483
484   # Add -static for static libraries, -shared for shared libraries
485   list_contains(VARIANT_IS_STATIC STATIC ${ARGN})
486   if (VARIANT_IS_STATIC)
487     set(VARIANT_TARGET_NAME "${VARIANT_TARGET_NAME}-static")
488     set(VARIANT_DISPLAY_NAME "Static")
489   else (VARIANT_IS_STATIC)
490     set(VARIANT_TARGET_NAME "${VARIANT_TARGET_NAME}-shared")
491     set(VARIANT_DISPLAY_NAME "Shared")
492   endif (VARIANT_IS_STATIC)
493
494   # Add "multi-threaded" to the display name for multithreaded libraries.
495   if (VARIANT_IS_MT)
496     set(VARIANT_DISPLAY_NAME "${VARIANT_DISPLAY_NAME}, multi-threaded")
497   endif ()
498
499   # Compute the ABI tag, which depends on various kinds of options
500   set(VARIANT_ABI_TAG "")
501
502   # Linking statically to the runtime library
503   list_contains(VARIANT_IS_STATIC_RUNTIME STATIC_RUNTIME ${ARGN})
504   if (VARIANT_IS_STATIC_RUNTIME)  
505     set(VARIANT_TARGET_NAME "${VARIANT_TARGET_NAME}-staticrt")
506     set(VARIANT_ABI_TAG "${VARIANT_ABI_TAG}s")
507     set(VARIANT_DISPLAY_NAME "${VARIANT_DISPLAY_NAME}, static runtime")
508   endif (VARIANT_IS_STATIC_RUNTIME)
509   
510   # Using the debug version of the runtime library.
511   # With Visual C++, this comes automatically with debug
512   if (MSVC)
513     list_contains(VARIANT_IS_DEBUG DEBUG ${ARGN})
514     if (VARIANT_IS_DEBUG)
515       set(VARIANT_ABI_TAG "${VARIANT_ABI_TAG}g")
516     endif (VARIANT_IS_DEBUG)
517   endif (MSVC)
518
519   # Add -pydebug for debug builds of Python
520   list_contains(VARIANT_IS_PYDEBUG PYTHON_DEBUG ${ARGN})
521   if (VARIANT_IS_PYDEBUG)
522     set(VARIANT_TARGET_NAME "${VARIANT_TARGET_NAME}-pydebug")
523     set(VARIANT_ABI_TAG "${VARIANT_ABI_TAG}y")
524     set(VARIANT_DISPLAY_NAME "${VARIANT_DISPLAY_NAME}, Python debugging")
525   endif (VARIANT_IS_PYDEBUG)
526
527   # TODO: STLport rather than default library
528   # TODO: STLport's deprecated iostreams
529
530   # Add -debug for debug libraries
531   list_contains(VARIANT_IS_DEBUG DEBUG ${ARGN})
532   if (VARIANT_IS_DEBUG)
533     # Only add the actual "-debug" if we're also building release libraries
534     if (ENABLE_RELEASE)
535       set(VARIANT_TARGET_NAME "${VARIANT_TARGET_NAME}-debug")
536     endif (ENABLE_RELEASE)
537     set(VARIANT_ABI_TAG "${VARIANT_ABI_TAG}d")
538
539     set(VARIANT_DISPLAY_NAME "${VARIANT_DISPLAY_NAME}, debug")
540   else()
541     set(VARIANT_DISPLAY_NAME "${VARIANT_DISPLAY_NAME}, release")
542   endif()
543
544   # If there is an ABI tag, append it to the versioned name
545   if (VARIANT_ABI_TAG)
546     set(VARIANT_VERSIONED_NAME "${VARIANT_VERSIONED_NAME}-${VARIANT_ABI_TAG}")
547   endif (VARIANT_ABI_TAG)
548
549   if(WINMANGLE_LIBNAMES)
550     # Append the Boost version number to the versioned name
551     if(BOOST_VERSION_SUBMINOR GREATER 0)
552       set(VARIANT_VERSIONED_NAME
553         "${VARIANT_VERSIONED_NAME}-${BOOST_VERSION_MAJOR}_${BOOST_VERSION_MINOR}_${BOOST_VERSION_SUBMINOR}")
554     else(BOOST_VERSION_SUBMINOR GREATER 0)
555       set(VARIANT_VERSIONED_NAME 
556         "${VARIANT_VERSIONED_NAME}-${BOOST_VERSION_MAJOR}_${BOOST_VERSION_MINOR}")
557     endif(BOOST_VERSION_SUBMINOR GREATER 0)
558   endif(WINMANGLE_LIBNAMES)
559 endmacro(boost_library_variant_target_name)
560
561 # This macro is an internal utility macro that updates compilation and
562 # linking flags based on interactions among the features in a variant.
563 #
564 #   boost_feature_interactions(prefix
565 #                              feature1 feature2 ...)
566 #
567 # where "prefix" is the prefix of the compilation and linking flags
568 # that will be updated (e.g., ${prefix}_COMPILE_FLAGS). feature1,
569 # feature2, etc. are the names of the features used in this particular
570 # variant. If the features in this variant conflict, set
571 # ${prefix}_OKAY to FALSE.
572 macro(boost_feature_interactions PREFIX)
573   # Don't build or link against a shared library and a static run-time
574   list_contains(IS_SHARED SHARED ${ARGN})
575   list_contains(IS_STATIC_RUNTIME STATIC_RUNTIME ${ARGN})
576   if (IS_SHARED AND IS_STATIC_RUNTIME)
577     set(${PREFIX}_OKAY FALSE)
578   endif (IS_SHARED AND IS_STATIC_RUNTIME)
579   
580   # With Visual C++, the dynamic runtime is multi-threaded only
581   if (MSVC)
582     list_contains(IS_DYNAMIC_RUNTIME DYNAMIC_RUNTIME ${ARGN})
583     list_contains(IS_SINGLE_THREADED SINGLE_THREADED ${ARGN})
584     if (IS_DYNAMIC_RUNTIME AND IS_SINGLE_THREADED)
585       set(${PREFIX}_OKAY FALSE)
586     endif (IS_DYNAMIC_RUNTIME AND IS_SINGLE_THREADED) 
587   endif (MSVC)
588
589   # Visual C++-specific runtime library flags
590   if(MSVC)
591     list_contains(IS_STATIC_RUNTIME STATIC_RUNTIME ${ARGN})
592     list_contains(IS_DEBUG DEBUG ${ARGN})
593     if(IS_DEBUG)
594       if(IS_STATIC_RUNTIME)
595         set(${PREFIX}_COMPILE_FLAGS "/MTd ${${PREFIX}_COMPILE_FLAGS}")
596       else(IS_STATIC_RUNTIME)
597         set(${PREFIX}_COMPILE_FLAGS "/MDd ${${PREFIX}_COMPILE_FLAGS}")
598       endif(IS_STATIC_RUNTIME)       
599     else(IS_DEBUG)
600       if(IS_STATIC_RUNTIME)
601         set(${PREFIX}_COMPILE_FLAGS "/MT ${${PREFIX}_COMPILE_FLAGS}")
602       else(IS_STATIC_RUNTIME)
603         set(${PREFIX}_COMPILE_FLAGS "/MD ${${PREFIX}_COMPILE_FLAGS}")
604       endif(IS_STATIC_RUNTIME)       
605     endif(IS_DEBUG)
606   endif(MSVC)  
607 endmacro(boost_feature_interactions)
608
609 # This macro is an internal utility macro that builds a particular
610 # variant of a boost library.
611 #
612 #   boost_library_variant(libname 
613 #                         feature1 feature2 ...)
614 #
615 # where libname is the name of the Boost library (e.g.,
616 # "boost_filesystem") and feature1, feature2, ... are the features
617 # that will be used in this variant. 
618 #
619 # This macro will define a new library target based on libname and the
620 # specific variant name (see boost_library_variant_target_name), which
621 # depends on the utility target libname. The compilation and linking
622 # flags for this library are defined by THIS_LIB_COMPILE_FLAGS,
623 # THIS_LIB_LINK_FLAGS, THIS_LIB_LINK_LIBS, and all of the compile and
624 # linking flags implied by the features provided.
625 #
626 # If any of the features listed conflict with this library, no new
627 # targets will be built. For example, if the library provides the
628 # option NO_MULTI_THREADED, and one of the features provided is
629 # MULTI_THREADED, this macro will essentially be a no-op.
630 macro(boost_library_variant LIBNAME)
631   set(THIS_VARIANT_COMPILE_FLAGS "${THIS_LIB_COMPILE_FLAGS}")
632   set(THIS_VARIANT_LINK_FLAGS "${THIS_LIB_LINK_FLAGS}")
633   set(THIS_VARIANT_LINK_LIBS ${THIS_LIB_LINK_LIBS})
634   
635   # Determine if it is okay to build this variant
636   set(THIS_VARIANT_OKAY TRUE)
637   foreach(ARG ${ARGN})
638     # If the library itself stated that we cannot build this variant,
639     # don't. For example, we're trying to build a shared library
640     # variant, but the user specified NO_SHARED in the requirements of
641     # the library.
642     if (THIS_LIB_NO_${ARG})
643       set(THIS_VARIANT_OKAY FALSE)
644       set(SELECT_VARIANT_FAILURE_REASONS "NO_${ARG}")
645     endif (THIS_LIB_NO_${ARG})
646
647     # If the user specified that we should not build any variants of
648     # this kind, don't. For example, if the ENABLE_SHARED option is
649     # off, don't build shared libraries.
650     if(NOT ENABLE_${ARG})
651       set(THIS_VARIANT_OKAY FALSE)
652       set(SELECT_VARIANT_FAILURE_REASONS "ENABLE_${ARG} is OFF")
653     endif(NOT ENABLE_${ARG})
654
655     # Accumulate compile and link flags
656     set(THIS_VARIANT_COMPILE_FLAGS "${THIS_VARIANT_COMPILE_FLAGS} ${THIS_LIB_${ARG}_COMPILE_FLAGS} ${${ARG}_COMPILE_FLAGS}")
657     set(THIS_VARIANT_LINK_FLAGS "${THIS_VARIANT_LINK_FLAGS} ${THIS_LIB_${ARG}_LINK_FLAGS} ${${ARG}_LINK_FLAGS}")
658     set(THIS_VARIANT_LINK_LIBS ${THIS_VARIANT_LINK_LIBS} ${THIS_LIB_${ARG}_LINK_LIBS} ${${ARG}_LINK_LIBS})
659   endforeach(ARG ${ARGN})
660
661   # message("boost_library_variant(${LIBNAME} ${ARGN})")
662
663   # Handle feature interactions
664   boost_feature_interactions("THIS_VARIANT" ${ARGN})
665   boost_library_variant_target_name(${ARGN})
666   # Determine the suffix for this library target
667   set(VARIANT_LIBNAME "${LIBNAME}${VARIANT_TARGET_NAME}")
668
669   set(DEPENDENCY_FAILURES "")
670   foreach(dep ${THIS_LIB_DEPENDS})
671     dependency_check("${dep}${VARIANT_TARGET_NAME}")
672   endforeach()
673
674   #
675   # Announce dependency failures only if this variant
676   # is otherwise OK
677   #
678   if(THIS_VARIANT_OKAY AND DEPENDENCY_FAILURES)
679     set(THIS_VARIANT_OKAY FALSE)
680     # separate_arguments(DEPENDENCY_FAILURES)
681     colormsg(HIRED "    ${LIBNAME}${VARIANT_TARGET_NAME}" RED "(library) disabled due to dependency failures:")
682     foreach (depfail ${DEPENDENCY_FAILURES})
683       colormsg(RED "     " YELLOW "${depfail}")
684     endforeach()
685   endif()
686
687   if (THIS_VARIANT_OKAY)
688
689     # We handle static vs. dynamic libraries differently
690     list_contains(THIS_LIB_IS_STATIC "STATIC" ${ARGN})
691     if (THIS_LIB_IS_STATIC)
692       # On Windows, we need static and shared libraries to have
693       # different names, so we follow the Boost.Build version 2 style
694       # and prepend "lib" to the name.
695       if(WIN32 AND NOT (CYGWIN OR MINGW))
696         set_target_properties(${VARIANT_LIBNAME}
697           PROPERTIES
698           PREFIX "${LIBPREFIX}"
699           )
700       endif()
701       
702       add_library(${VARIANT_LIBNAME} STATIC ${THIS_LIB_SOURCES})
703
704       set_target_properties(${VARIANT_LIBNAME}
705         PROPERTIES
706         OUTPUT_NAME "${LIBNAME}${VARIANT_VERSIONED_NAME}"
707         CLEAN_DIRECT_OUTPUT 1
708         COMPILE_FLAGS "${THIS_VARIANT_COMPILE_FLAGS}"
709         LINK_FLAGS "${THIS_VARIANT_LINK_FLAGS}"
710         LABELS "${BOOST_PROJECT_NAME}"
711         )
712
713     elseif (THIS_LIB_MODULE)
714
715       add_library(${VARIANT_LIBNAME} MODULE ${THIS_LIB_SOURCES})
716
717       #
718       # You don't set SOVERSION here... nothing links "to" these things                 
719       #
720       set_target_properties(${VARIANT_LIBNAME}
721         PROPERTIES
722         OUTPUT_NAME ${LIBNAME}
723         CLEAN_DIRECT_OUTPUT 1
724         COMPILE_FLAGS "${THIS_VARIANT_COMPILE_FLAGS}"
725         LINK_FLAGS "${THIS_VARIANT_LINK_FLAGS}"
726         LABELS "${BOOST_PROJECT_NAME}"
727         PREFIX ""
728         )
729
730     else ()  # shared
731
732       add_library(${VARIANT_LIBNAME} SHARED ${THIS_LIB_SOURCES})
733
734       if(MINGW)
735         set_target_properties(${VARIANT_LIBNAME}
736           PROPERTIES
737           PREFIX ""
738           )
739       endif()
740
741       set_target_properties(${VARIANT_LIBNAME}
742         PROPERTIES
743         OUTPUT_NAME "${LIBNAME}${VARIANT_VERSIONED_NAME}"
744         CLEAN_DIRECT_OUTPUT 1
745         COMPILE_FLAGS "${THIS_VARIANT_COMPILE_FLAGS}"
746         LINK_FLAGS "${THIS_VARIANT_LINK_FLAGS}"
747         LABELS "${BOOST_PROJECT_NAME}"
748         )
749
750       if (BUILD_SOVERSIONED)
751         set_target_properties(${VARIANT_LIBNAME}
752           PROPERTIES
753           SOVERSION "${BOOST_VERSION}"
754           )
755       endif()
756     endif ()
757     
758     # The basic LIBNAME target depends on each of the variants
759     add_dependencies(${LIBNAME} ${VARIANT_LIBNAME})
760
761     # Link against whatever libraries this library depends on
762     target_link_libraries(${VARIANT_LIBNAME} ${THIS_VARIANT_LINK_LIBS})
763
764     foreach(d ${THIS_LIB_DEPENDS})
765       # message(STATUS "linking ${d}")
766       target_link_libraries(${VARIANT_LIBNAME} "${d}${VARIANT_TARGET_NAME}")
767     endforeach()
768
769     export(TARGETS ${VARIANT_LIBNAME} 
770       APPEND
771       FILE ${BOOST_EXPORTS_FILE})
772
773     if(NOT THIS_LIB_NO_INSTALL)
774       # Setup installation properties
775       string(TOLOWER "${BOOST_PROJECT_NAME}${VARIANT_TARGET_NAME}" LIB_COMPONENT)
776       string(REPLACE "-" "_" LIB_COMPONENT ${LIB_COMPONENT})
777       
778       # Installation of this library variant
779       string(TOLOWER ${BOOST_PROJECT_NAME} libname)
780
781       #
782       # tds:  componentization disabled for the moment
783       #
784       install(TARGETS ${VARIANT_LIBNAME} 
785         EXPORT Boost 
786         DESTINATION ${BOOST_LIB_INSTALL_DIR}
787         COMPONENT Boost) #${LIB_COMPONENT})
788
789       # set_property( 
790       #      TARGET ${VARIANT_LIBNAME}
791       #      PROPERTY BOOST_CPACK_COMPONENT
792       #      ${LIB_COMPONENT})
793       
794       # Make the library installation component dependent on the library
795       # installation components of dependent libraries.
796       set(THIS_LIB_COMPONENT_DEPENDS)
797       foreach(DEP ${THIS_LIB_DEPENDS})
798         # We ask the library variant that this library depends on to tell us
799         # what it's associated installation component is. We depend on that 
800         # installation component.
801         get_property(DEP_COMPONENT 
802           TARGET "${DEP}${VARIANT_TARGET_NAME}"
803           PROPERTY BOOST_CPACK_COMPONENT)
804         
805         if (DEP_COMPONENT)
806           if (DEP_COMPONENT STREQUAL LIB_COMPONENT)
807             # Do nothing: we have library dependencies within one 
808             # Boost library
809           else()
810             list(APPEND THIS_LIB_COMPONENT_DEPENDS ${DEP_COMPONENT})
811           endif()
812         endif()
813       endforeach(DEP)
814       
815       if (COMMAND cpack_add_component)
816         fix_cpack_component_name(CPACK_COMPONENT_GROUP_NAME ${libname})
817         cpack_add_component(${LIB_COMPONENT}
818           DISPLAY_NAME "${VARIANT_DISPLAY_NAME}"
819           GROUP ${CPACK_COMPONENT_GROUP_NAME}
820           DEPENDS ${THIS_LIB_COMPONENT_DEPENDS})
821       endif ()
822     endif(NOT THIS_LIB_NO_INSTALL)
823   endif ()
824 endmacro(boost_library_variant)
825
826 # Updates the set of default build variants to account for variations
827 # in the given feature.
828 #
829 #   boost_add_default_variant(feature-val1 feature-val2 ...)
830 #
831 # Each new feature creates a new set of build variants using that
832 # feature. For example, writing:
833
834 #    boost_add_default_variant(SINGLE_THREADED MULTI_THREADED)
835 #
836 # will create single- and multi-threaded variants of every default
837 # library variant already defined, doubling the number of variants
838 # that will be built. See the top-level CMakeLists.txt for the set of
839 # default variants.
840 #
841 # Variables affected:
842 #
843 #   BOOST_DEFAULT_VARIANTS:
844 #     This variable describes all of the variants that will be built
845 #     by default, and will be updated with each invocation of
846 #     boost_add_default_variant. The variable itself is a list, where
847 #     each element in the list contains a colon-separated string
848 #     naming a specific set of features for that variant, e.g.,
849 #     STATIC:DEBUG:SINGLE_THREADED.
850 #
851 #   BOOST_FEATURES:
852 #     This variable describes all of the feature sets that we know about,
853 #     and will be extended each time ither boost_add_default_variant or 
854 #     boost_add_extra_variant is invoked. This macro will contain a list
855 #     of feature sets, each containing the values for a given feature
856 #     separated by colons, e.g., "DEBUG:RELEASE".
857 #
858 #   BOOST_ADD_ARG_NAMES:
859 #     This variable describes all of the feature-specific arguments
860 #     that can be used for the boost_add_library macro, separated by
861 #     semicolons. For example, given the use of
862 #     boost_add_default_variant above, this variable will contain (at
863 #     least)
864 #
865 #        SINGLE_THREADED_COMPILE_FLAGS;SINGLE_THREADED_LINK_FLAGS;
866 #        MULTI_THREADED_COMPILE_FLAGS;MULTI_THREADED_LINK_FLAGS
867 #
868 #     When this variable is used in boost_add_library, it turns these
869 #     names into feature-specific options. For example,
870 #     MULTI_THREADED_COMPILE_FLAGS provides extra compile flags to be
871 #     used only for multi-threaded variants of the library.
872 #
873 #   BOOST_ADDLIB_OPTION_NAMES:
874 #     Like BOOST_ADD_ARG_NAMES, this variable describes
875 #     feature-specific options to boost_add_library that can be used to
876 #     turn off building of the library when the variant would require
877 #     certain features. For example, the NO_SINGLE_THREADED option
878 #     turns off building of single-threaded variants for a library.
879 #
880 #   BOOST_ADDEXE_OPTION_NAMES:
881 #     Like BOOST_ADDLIB_OPTION_NAMES, except that that variable 
882 #     describes options to boost_add_executable that can be used to
883 #     describe which features are needed to build the executable.
884 #     For example, the MULTI_THREADED option requires that the 
885 #     executable be built against multi-threaded libraries and with
886 #     multi-threaded options.
887 macro(boost_add_default_variant)
888   # Update BOOST_DEFAULT_VARIANTS
889   if (BOOST_DEFAULT_VARIANTS)
890     set(BOOST_DEFAULT_VARIANTS_ORIG ${BOOST_DEFAULT_VARIANTS})
891     set(BOOST_DEFAULT_VARIANTS)
892     foreach(VARIANT ${BOOST_DEFAULT_VARIANTS_ORIG})
893       foreach(FEATURE ${ARGN})
894         list(APPEND BOOST_DEFAULT_VARIANTS "${VARIANT}:${FEATURE}")
895       endforeach(FEATURE ${ARGN})
896     endforeach(VARIANT ${BOOST_DEFAULT_VARIANTS_ORIG})
897     set(BOOST_DEFAULT_VARIANTS_ORIG)
898   else (BOOST_DEFAULT_VARIANTS)
899     set(BOOST_DEFAULT_VARIANTS ${ARGN})
900   endif (BOOST_DEFAULT_VARIANTS)
901
902   # Set Feature flag options used by the boost_library macro and the
903   # BOOST_FEATURES variable
904   set(BOOST_DEFVAR_FEATURES)
905   foreach(FEATURE ${ARGN})
906     set(BOOST_ADD_ARG_NAMES 
907       "${BOOST_ADD_ARG_NAMES};${FEATURE}_COMPILE_FLAGS;${FEATURE}_LINK_FLAGS;${FEATURE}_LINK_LIBS")
908     set(BOOST_ADDLIB_OPTION_NAMES "${BOOST_ADDLIB_OPTION_NAMES};NO_${FEATURE}")
909     set(BOOST_ADDEXE_OPTION_NAMES "${BOOST_ADDEXE_OPTION_NAMES};${FEATURE}")
910     if (BOOST_DEFVAR_FEATURES)
911       set(BOOST_DEFVAR_FEATURES "${BOOST_DEFVAR_FEATURES}:${FEATURE}")
912     else (BOOST_DEFVAR_FEATURES)
913       set(BOOST_DEFVAR_FEATURES "${FEATURE}")
914     endif (BOOST_DEFVAR_FEATURES)
915   endforeach(FEATURE ${ARGN})
916   list(APPEND BOOST_FEATURES ${BOOST_DEFVAR_FEATURES})
917 endmacro(boost_add_default_variant)
918
919 # Updates the set of "extra" build variants, which may be used to
920 # generate extra, library-specific variants of libraries.
921 #
922 #   boost_add_extra_variant(feature-val1 feature-val2 ...)
923 #
924 # Each extra viarant makes it possible for libraries to define extra
925 # variants.  For example, writing:
926
927 #    boost_add_extra_variant(PYTHON_NODEBUG PYTHON_DEBUG)
928 #
929 # creates a PYTHON_NODEBUG/PYTHON_DEBUG feature pair as an extra
930 # variant, used by the Boost.Python library, which generates separate
931 # variants of the Boost.Python library: one variant uses the Python
932 # debug libraries, the other does not.
933 #
934 # The difference between boost_add_default_variant and
935 # boost_add_extra_variant is that adding a new default variant
936 # introduces additional variants to *all* Boost libraries, unless
937 # those variants are explicitly excluded by the library. Adding a new
938 # extra variant, on the other hand, allows libraries to specifically
939 # request extra variants using that feature.
940 #
941 # Variables affected:
942 #
943 #   BOOST_FEATURES:
944 #     See boost_add_default_variant.
945 #
946 #   BOOST_ADD_ARG_NAMES: 
947 #     See boost_add_default_variant.
948 #
949 #   BOOST_ADDLIB_OPTION_NAMES:
950 #     See boost_add_default_variant.
951 #
952 #   BOOST_ADDEXE_OPTION_NAMES:
953 #     See boost_add_default_variant.
954 macro(boost_add_extra_variant)
955   set(BOOST_EXTVAR_FEATURES)
956   foreach(FEATURE ${ARGN})
957     set(BOOST_ADD_ARG_NAMES 
958       "${BOOST_ADD_ARG_NAMES};${FEATURE}_COMPILE_FLAGS;${FEATURE}_LINK_FLAGS;${FEATURE}_LINK_LIBS")
959     set(BOOST_ADDLIB_OPTION_NAMES "${BOOST_ADDLIB_OPTION_NAMES};NO_${FEATURE}")
960     set(BOOST_ADDEXE_OPTION_NAMES "${BOOST_ADDEXE_OPTION_NAMES};${FEATURE}")
961     if (BOOST_EXTVAR_FEATURES)
962       set(BOOST_EXTVAR_FEATURES "${BOOST_EXTVAR_FEATURES}:${FEATURE}")
963     else (BOOST_EXTVAR_FEATURES)
964       set(BOOST_EXTVAR_FEATURES "${FEATURE}")
965     endif (BOOST_EXTVAR_FEATURES)
966   endforeach(FEATURE ${ARGN})  
967   list(APPEND BOOST_FEATURES ${BOOST_EXTVAR_FEATURES})
968 endmacro(boost_add_extra_variant)
969
970 # Compute the variant that will be used to build this executable or
971 # module, taking into account both the requested features passed to
972 # boost_add_executable or boost_add_library and what options the user
973 # has set.
974 macro(boost_select_variant NAME PREFIX)
975   set(${PREFIX}_DEBUG_AND_RELEASE FALSE)
976   set(SELECT_VARIANT_OKAY TRUE)
977   set(SELECT_VARIANT_FAILURE_REASONS)
978   set(${PREFIX}_VARIANT)
979
980   foreach(FEATURESET_STR ${BOOST_FEATURES})
981     string(REPLACE ":" ";" FEATURESET ${FEATURESET_STR})
982     separate_arguments(FEATURESET)
983     set(${PREFIX}_REQUESTED_FROM_SET FALSE)
984     foreach (FEATURE ${FEATURESET})
985       if (${PREFIX}_${FEATURE})
986         # Make this feature part of the variant
987         list(APPEND ${PREFIX}_VARIANT ${FEATURE})
988         set(${PREFIX}_REQUESTED_FROM_SET TRUE)
989
990         # The caller has requested this particular feature be used
991         # when building the executable or module. If we can't satisfy
992         # that request (because the user has turned off the build
993         # variants with that feature), then we won't build this
994         # executable or module.
995         if (NOT ENABLE_${FEATURE})
996           set(SELECT_VARIANT_OKAY FALSE)
997           list(APPEND SELECT_VARIANT_FAILURE_REASONS 
998             "ENABLE_${FEATURE} is FALSE")
999         endif (NOT ENABLE_${FEATURE})
1000       endif (${PREFIX}_${FEATURE})
1001     endforeach (FEATURE ${FEATURESET})
1002
1003     if (NOT ${PREFIX}_REQUESTED_FROM_SET)
1004       # The caller did not specify which feature value to use from
1005       # this set, so find the first feature value that actually works.
1006       set(${PREFIX}_FOUND_FEATURE FALSE)
1007
1008       # If this feature set decides between Release and Debug, we
1009       # either query CMAKE_BUILD_TYPE to determine which to use (for
1010       # makefile targets) or handle both variants separately (for IDE
1011       # targets). We only build both variants separately for executable targets.
1012       if (FEATURESET_STR STREQUAL "RELEASE:DEBUG")
1013         if (CMAKE_CONFIGURATION_TYPES)
1014           # IDE target: can we build both debug and release?
1015           if (ENABLE_DEBUG AND ENABLE_RELEASE)
1016             if (${PREFIX} STREQUAL "THIS_EXE")
1017               # Remember that we're capable of building both configurations
1018               set(${PREFIX}_DEBUG_AND_RELEASE TRUE)
1019
1020               # Don't add RELEASE or DEBUG to the variant (yet)
1021               set(${PREFIX}_FOUND_FEATURE TRUE)
1022             endif ()
1023           endif ()
1024         else (CMAKE_CONFIGURATION_TYPES)
1025           # Makefile target: CMAKE_BUILD_TYPE tells us which variant to build
1026           if (CMAKE_BUILD_TYPE STREQUAL "Release")
1027             # Okay, build the release variant
1028             list(APPEND ${PREFIX}_VARIANT RELEASE)
1029             set(${PREFIX}_FOUND_FEATURE TRUE)
1030           elseif (CMAKE_BUILD_TYPE STREQUAL "Debug")
1031             # Okay, build the debug variant
1032             list(APPEND ${PREFIX}_VARIANT DEBUG)
1033             set(${PREFIX}_FOUND_FEATURE TRUE)
1034           endif (CMAKE_BUILD_TYPE STREQUAL "Release")
1035         endif (CMAKE_CONFIGURATION_TYPES)
1036       endif (FEATURESET_STR STREQUAL "RELEASE:DEBUG")
1037
1038       # Search through all of the features in the set to find one that works
1039       foreach (FEATURE ${FEATURESET})
1040         # We only care about the first feature value we find...
1041         if (NOT ${PREFIX}_FOUND_FEATURE)
1042           # Are we allowed to build this feature?
1043           if (ENABLE_${FEATURE})
1044             # Found it: we're done
1045             list(APPEND ${PREFIX}_VARIANT ${FEATURE})
1046             set(${PREFIX}_FOUND_FEATURE TRUE)
1047           endif (ENABLE_${FEATURE})
1048         endif (NOT ${PREFIX}_FOUND_FEATURE)
1049       endforeach (FEATURE ${FEATURESET})
1050
1051       if (NOT ${PREFIX}_FOUND_FEATURE)
1052         # All of the features in this set were turned off. 
1053         # Just don't build anything.
1054         set(SELECT_VARIANT_OKAY FALSE)
1055         message("NOT ${PREFIX}_FOUND_FEATURE")
1056       endif (NOT ${PREFIX}_FOUND_FEATURE)
1057     endif (NOT ${PREFIX}_REQUESTED_FROM_SET)
1058   endforeach(FEATURESET_STR ${BOOST_FEATURES})
1059   
1060   # Propagate flags from each of the features
1061   if (SELECT_VARIANT_OKAY)
1062     foreach (FEATURE ${${PREFIX}_VARIANT})
1063       # Add all of the flags for this feature
1064       set(${PREFIX}_COMPILE_FLAGS 
1065         "${${PREFIX}_COMPILE_FLAGS} ${${PREFIX}_${FEATURE}_COMPILE_FLAGS} ${${FEATURE}_COMPILE_FLAGS}")
1066       set(${PREFIX}_LINK_FLAGS 
1067         "${${PREFIX}_LINK_FLAGS} ${${PREFIX}_${FEATURE}_LINK_FLAGS} ${${FEATURE}_LINK_FLAGS}")
1068       if (${PREFIX} STREQUAL "THIS_EXE")
1069         set(${PREFIX}_LINK_FLAGS 
1070           "${${PREFIX}_LINK_FLAGS} ${${FEATURE}_EXE_LINK_FLAGS}")
1071       endif()
1072       set(${PREFIX}_LINK_LIBS 
1073         ${${PREFIX}_LINK_LIBS} ${${PREFIX}_${FEATURE}_LINK_LIBS} ${${FEATURE}_LINK_LIBS})
1074     endforeach (FEATURE ${${PREFIX}_VARIANT})
1075
1076     # Handle feature interactions
1077     boost_feature_interactions("${PREFIX}" ${${PREFIX}_VARIANT})
1078   else ()
1079     set(${PREFIX}_VARIANT)
1080   endif ()
1081 endmacro(boost_select_variant)
1082
1083 # Creates a new Boost library target that generates a compiled library
1084 # (.a, .lib, .dll, .so, etc) from source files. This routine will
1085 # actually build several different variants of the same library, with
1086 # different compilation options, as determined by the set of "default"
1087 # library variants.
1088 #
1089 #   boost_add_library(libname
1090 #                     source1 source2 ...
1091 #                     [COMPILE_FLAGS compileflags]
1092 #                     [feature_COMPILE_FLAGS compileflags]
1093 #                     [LINK_FLAGS linkflags]
1094 #                     [feature_LINK_FLAGS linkflags]
1095 #                     [LINK_LIBS linklibs]
1096 #                     [feature_LINK_LIBS linklibs]
1097 #                     [DEPENDS libdepend1 libdepend2 ...]
1098 #                     [MODULE]
1099 #                     [NO_feature]
1100 #                     [EXTRA_VARIANTS variant1 variant2 ...]
1101 #                     [FORCE_VARIANTS variant1])
1102 #
1103 # where libname is the name of Boost library binary (e.g.,
1104 # "boost_regex") and source1, source2, etc. are the source files used
1105 # to build the library, e.g., cregex.cpp.
1106 #
1107 # This macro has a variety of options that affect its behavior. In
1108 # several cases, we use the placeholder "feature" in the option name
1109 # to indicate that there are actually several different kinds of
1110 # options, each referring to a different build feature, e.g., shared
1111 # libraries, multi-threaded, debug build, etc. For a complete listing
1112 # of these features, please refer to the CMakeLists.txt file in the
1113 # root of the Boost distribution, which defines the set of features
1114 # that will be used to build Boost libraries by default.
1115 #
1116 # The options that affect this macro's behavior are:
1117 #
1118 #   COMPILE_FLAGS: Provides additional compilation flags that will be
1119 #   used when building all variants of the library. For example, one
1120 #   might want to add "-DBOOST_SIGNALS_NO_LIB=1" through this option
1121 #   (which turns off auto-linking for the Signals library while
1122 #   building it).
1123 #
1124 #   feature_COMPILE_FLAGS: Provides additional compilation flags that
1125 #   will be used only when building variants of the library that
1126 #   include the given feature. For example,
1127 #   MULTI_THREADED_COMPILE_FLAGS are additional flags that will be
1128 #   used when building a multi-threaded variant, while
1129 #   SHARED_COMPILE_FLAGS will be used when building a shared library
1130 #   (as opposed to a static library).
1131 #
1132 #   LINK_FLAGS: Provides additional flags that will be passed to the
1133 #   linker when linking each variant of the library. This option
1134 #   should not be used to link in additional libraries; see LINK_LIBS
1135 #   and DEPENDS.
1136 #
1137 #   feature_LINK_FLAGS: Provides additional flags that will be passed
1138 #   to the linker when building variants of the library that contain a
1139 #   specific feature, e.g., MULTI_THREADED_LINK_FLAGS. This option
1140 #   should not be used to link in additional libraries; see
1141 #   feature_LINK_LIBS.
1142 #
1143 #   LINK_LIBS: Provides additional libraries against which each of the
1144 #   library variants will be linked. For example, one might provide
1145 #   "expat" as options to LINK_LIBS, to state that each of the library
1146 #   variants will link against the expat library binary. Use LINK_LIBS
1147 #   for libraries external to Boost; for Boost libraries, use DEPENDS.
1148 #
1149 #   feature_LINK_LIBS: Provides additional libraries for specific
1150 #   variants of the library to link against. For example,
1151 #   MULTI_THREADED_LINK_LIBS provides extra libraries to link into
1152 #   multi-threaded variants of the library.
1153 #
1154 #   DEPENDS: States that this Boost library depends on and links
1155 #   against another Boost library. The arguments to DEPENDS should be
1156 #   the unversioned name of the Boost library, such as
1157 #   "boost_filesystem". Like LINK_LIBS, this option states that all
1158 #   variants of the library being built will link against the stated
1159 #   libraries. Unlike LINK_LIBS, however, DEPENDS takes particular
1160 #   library variants into account, always linking the variant of one
1161 #   Boost library against the same variant of the other Boost
1162 #   library. For example, if the boost_mpi_python library DEPENDS on
1163 #   boost_python, multi-threaded variants of boost_mpi_python will
1164 #   link against multi-threaded variants of boost_python.
1165 #
1166 #   MODULE: This option states that, when building a shared library,
1167 #   the shared library should be built as a module rather than a
1168 #   normal shared library. Modules have special meaning an behavior on
1169 #   some platforms, such as Mac OS X.
1170 #
1171 #   NO_feature: States that library variants containing a particular
1172 #   feature should not be built. For example, passing
1173 #   NO_SINGLE_THREADED suppresses generation of single-threaded
1174 #   variants of this library.
1175 #
1176 #   EXTRA_VARIANTS: Specifies that extra variants of this library
1177 #   should be built, based on the features listed. Each "variant" is a 
1178 #   colon-separated list of features. For example, passing
1179 #     EXTRA_VARIANTS "PYTHON_NODEBUG:PYTHON_DEBUG"
1180 #   will result in the creation of an extra set of library variants,
1181 #   some with the PYTHON_NODEBUG feature and some with the
1182 #   PYTHON_DEBUG feature. 
1183 #
1184 #   FORCE_VARIANTS: This will force the build system to ALWAYS build this 
1185 #   variant of the library not matter what variants are set.
1186 #
1187 # Example:
1188 #   boost_add_library(
1189 #     boost_thread
1190 #     barrier.cpp condition.cpp exceptions.cpp mutex.cpp once.cpp 
1191 #     recursive_mutex.cpp thread.cpp tss_hooks.cpp tss_dll.cpp tss_pe.cpp 
1192 #     tss.cpp xtime.cpp
1193 #     SHARED_COMPILE_FLAGS "-DBOOST_THREAD_BUILD_DLL=1"
1194 #     STATIC_COMPILE_FLAGS "-DBOOST_THREAD_BUILD_LIB=1"
1195 #     NO_SINGLE_THREADED
1196 #   )
1197 macro(boost_add_library SHORT_LIBNAME)
1198   set(LIBNAME "boost_${SHORT_LIBNAME}")
1199   parse_arguments(THIS_LIB
1200     "DEPENDS;COMPILE_FLAGS;LINK_FLAGS;LINK_LIBS;EXTRA_VARIANTS;FORCE_VARIANTS;${BOOST_ADD_ARG_NAMES}"
1201     "MODULE;NO_INSTALL;${BOOST_ADDLIB_OPTION_NAMES}"
1202     ${ARGN}
1203     )
1204
1205   set(THIS_LIB_SOURCES ${THIS_LIB_DEFAULT_ARGS})
1206
1207   #
1208   # cmake BoostConfig.cmake generation needs to know which
1209   # libraries are available
1210   #
1211   set(BOOST_ALL_COMPONENTS ${SHORT_LIBNAME} ${BOOST_ALL_COMPONENTS} 
1212     PARENT_SCOPE)
1213
1214   # A top-level target that refers to all of the variants of the
1215   # library, collectively.
1216   add_custom_target(${LIBNAME})
1217
1218   if (THIS_LIB_EXTRA_VARIANTS)
1219     # Build the set of variants that we will generate for this library
1220     set(THIS_LIB_VARIANTS)
1221     foreach(VARIANT ${BOOST_DEFAULT_VARIANTS})
1222       foreach(EXTRA_VARIANT ${THIS_LIB_EXTRA_VARIANTS})
1223         string(REPLACE ":" ";" FEATURES "${EXTRA_VARIANT}")
1224         separate_arguments(FEATURES)
1225         foreach(FEATURE ${FEATURES})
1226           list(APPEND THIS_LIB_VARIANTS "${VARIANT}:${FEATURE}")
1227         endforeach(FEATURE ${FEATURES})
1228       endforeach(EXTRA_VARIANT ${THIS_LIB_EXTRA_VARIANTS})
1229     endforeach(VARIANT ${BOOST_DEFAULT_VARIANTS})
1230   else (THIS_LIB_EXTRA_VARIANTS)
1231     set(THIS_LIB_VARIANTS ${BOOST_DEFAULT_VARIANTS})
1232   endif (THIS_LIB_EXTRA_VARIANTS)
1233   
1234   if (THIS_LIB_FORCE_VARIANTS)
1235     #  string(TOUPPER "${LIBNAME}_FORCE_VARIANTS" force_variants)
1236     #  set(${force_variants} ${THIS_LIB_FORCE_VARIANTS} CACHE INTERNAL "")
1237     set(ENABLE_${THIS_LIB_FORCE_VARIANTS}_PREV ${ENABLE_${THIS_LIB_FORCE_VARIANTS}} )
1238     set(ENABLE_${THIS_LIB_FORCE_VARIANTS} TRUE)
1239   endif (THIS_LIB_FORCE_VARIANTS)
1240   
1241   # Build each of the library variants
1242   foreach(VARIANT_STR ${THIS_LIB_VARIANTS})
1243     string(REPLACE ":" ";" VARIANT ${VARIANT_STR})
1244     separate_arguments(VARIANT)
1245     boost_library_variant(${LIBNAME} ${VARIANT})
1246   endforeach(VARIANT_STR ${THIS_LIB_VARIANTS})
1247   
1248   if (THIS_LIB_FORCE_VARIANTS)
1249     set(ENABLE_${THIS_LIB_FORCE_VARIANTS} ${ENABLE_${THIS_LIB_FORCE_VARIANTS}_PREV} )
1250     # message(STATUS "* ^^ ENABLE_${THIS_LIB_FORCE_VARIANTS}  ${ENABLE_${THIS_LIB_FORCE_VARIANTS}}")
1251   endif (THIS_LIB_FORCE_VARIANTS)  
1252 endmacro(boost_add_library)
1253
1254 # Like boost_add_library, but builds a single library variant
1255 # FIXME: I'm not sure if I like this or not. Document it if it survives.
1256 macro(boost_add_single_library LIBNAME)
1257   parse_arguments(THIS_LIB
1258     "DEPENDS;COMPILE_FLAGS;LINK_FLAGS;LINK_LIBS;${BOOST_ADD_ARG_NAMES}"
1259     "NO_INSTALL;MODULE;${BOOST_ADDEXE_OPTION_NAMES}"
1260     ${ARGN}
1261     )
1262   set(THIS_LIB_SOURCES ${THIS_LIB_DEFAULT_ARGS})
1263
1264   boost_select_variant(${LIBNAME} THIS_LIB)
1265   if (THIS_LIB_VARIANT)
1266     add_custom_target(${LIBNAME})
1267     separate_arguments(THIS_LIB_VARIANT)
1268     boost_library_variant(${LIBNAME} ${THIS_LIB_VARIANT})
1269   endif ()
1270 endmacro(boost_add_single_library)
1271
1272 # Creates a new executable from source files.
1273 #
1274 #   boost_add_executable(exename
1275 #                        source1 source2 ...
1276 #                        [COMPILE_FLAGS compileflags]
1277 #                        [feature_COMPILE_FLAGS compileflags]
1278 #                        [LINK_FLAGS linkflags]
1279 #                        [feature_LINK_FLAGS linkflags]
1280 #                        [LINK_LIBS linklibs]
1281 #                        [feature_LINK_LIBS linklibs]
1282 #                        [DEPENDS libdepend1 libdepend2 ...]
1283 #                        [feature]
1284 #                        [NO_INSTALL])
1285 #
1286 # where exename is the name of the executable (e.g., "wave").  source1,
1287 # source2, etc. are the source files used to build the executable, e.g.,
1288 # cpp.cpp. If no source files are provided, "exename.cpp" will be
1289 # used.
1290 #
1291 # This macro has a variety of options that affect its behavior. In
1292 # several cases, we use the placeholder "feature" in the option name
1293 # to indicate that there are actually several different kinds of
1294 # options, each referring to a different build feature, e.g., shared
1295 # libraries, multi-threaded, debug build, etc. For a complete listing
1296 # of these features, please refer to the CMakeLists.txt file in the
1297 # root of the Boost distribution, which defines the set of features
1298 # that will be used to build Boost libraries by default.
1299 #
1300 # The options that affect this macro's behavior are:
1301 #
1302 #   COMPILE_FLAGS: Provides additional compilation flags that will be
1303 #   used when building the executable.
1304 #
1305 #   feature_COMPILE_FLAGS: Provides additional compilation flags that
1306 #   will be used only when building the executable with the given
1307 #   feature (e.g., SHARED_COMPILE_FLAGS when we're linking against
1308 #   shared libraries). Note that the set of features used to build the
1309 #   executable depends both on the arguments given to
1310 #   boost_add_executable (see the "feature" argument description,
1311 #   below) and on the user's choice of variants to build.
1312 #
1313 #   LINK_FLAGS: Provides additional flags that will be passed to the
1314 #   linker when linking the executable. This option should not be used
1315 #   to link in additional libraries; see LINK_LIBS and DEPENDS.
1316 #
1317 #   feature_LINK_FLAGS: Provides additional flags that will be passed
1318 #   to the linker when linking the executable with the given feature
1319 #   (e.g., MULTI_THREADED_LINK_FLAGS when we're linking a
1320 #   multi-threaded executable).
1321 #
1322 #   LINK_LIBS: Provides additional libraries against which the
1323 #   executable will be linked. For example, one might provide "expat"
1324 #   as options to LINK_LIBS, to state that the executable will link
1325 #   against the expat library binary. Use LINK_LIBS for libraries
1326 #   external to Boost; for Boost libraries, use DEPENDS.
1327 #
1328 #   feature_LINK_LIBS: Provides additional libraries to link against
1329 #   when linking an executable built with the given feature. 
1330 #
1331 #   DEPENDS: States that this executable depends on and links against
1332 #   a Boostlibrary. The arguments to DEPENDS should be the unversioned
1333 #   name of the Boost library, such as "boost_filesystem". Like
1334 #   LINK_LIBS, this option states that the executable will link
1335 #   against the stated libraries. Unlike LINK_LIBS, however, DEPENDS
1336 #   takes particular library variants into account, always linking to
1337 #   the appropriate variant of a Boost library. For example, if the
1338 #   MULTI_THREADED feature was requested in the call to
1339 #   boost_add_executable, DEPENDS will ensure that we only link
1340 #   against multi-threaded libraries.
1341 #
1342 #   feature: States that the executable should always be built using a
1343 #   given feature, e.g., SHARED linking (against its libraries) or
1344 #   MULTI_THREADED (for multi-threaded builds). If that feature has
1345 #   been turned off by the user, the executable will not build.
1346 #
1347 #   NO_INSTALL: Don't install this executable with the rest of Boost.
1348 #
1349 #   OUTPUT_NAME: If you want the executable to be generated somewhere
1350 #   other than the binary directory, pass the path (including
1351 #   directory and file name) via the OUTPUT_NAME parameter.
1352 #
1353 # Example:
1354 #   boost_add_executable(wave cpp.cpp 
1355 #     DEPENDS boost_wave boost_program_options boost_filesystem 
1356 #             boost_serialization
1357 #     )
1358 macro(boost_add_executable EXENAME)
1359   # Note: ARGS is here to support the use of boost_add_executable in
1360   # the testing code.
1361   parse_arguments(THIS_EXE
1362     "DEPENDS;COMPILE_FLAGS;LINK_FLAGS;LINK_LIBS;OUTPUT_NAME;ARGS;${BOOST_ADD_ARG_NAMES}"
1363     "NO_INSTALL;${BOOST_ADDEXE_OPTION_NAMES}"
1364     ${ARGN}
1365     )
1366
1367   # Determine the list of sources
1368   if (THIS_EXE_DEFAULT_ARGS)
1369     set(THIS_EXE_SOURCES ${THIS_EXE_DEFAULT_ARGS})
1370   else (THIS_EXE_DEFAULT_ARGS)
1371     set(THIS_EXE_SOURCES ${EXENAME}.cpp)
1372   endif (THIS_EXE_DEFAULT_ARGS)
1373
1374   # Whether we can build both debug and release versions of this
1375   # executable within an IDE (based on the selected configuration
1376   # type).
1377   set(THIS_EXE_DEBUG_AND_RELEASE FALSE)
1378   
1379   # Compute the variant that will be used to build this executable,
1380   # taking into account both the requested features passed to
1381   # boost_add_executable and what options the user has set.
1382   boost_select_variant(${EXENAME} THIS_EXE)
1383
1384   # Possibly hyphenate exe's name
1385   if (THIS_PROJECT_IS_TOOL)
1386     set(THIS_EXE_NAME ${EXENAME})
1387   else()
1388     set(THIS_EXE_NAME ${BOOST_PROJECT_NAME}-${EXENAME})
1389   endif()
1390
1391   # Compute the name of the variant targets that we'll be linking
1392   # against. We'll use this to link against the appropriate
1393   # dependencies. For IDE targets where we can build both debug and
1394   # release configurations, create DEBUG_ and RELEASE_ versions of
1395   # the macros.
1396   if (THIS_EXE_DEBUG_AND_RELEASE)
1397     boost_library_variant_target_name(RELEASE ${THIS_EXE_VARIANT})
1398     set(RELEASE_VARIANT_TARGET_NAME "${VARIANT_TARGET_NAME}")
1399     boost_library_variant_target_name(DEBUG ${THIS_EXE_VARIANT})
1400     set(DEBUG_VARIANT_TARGET_NAME "${VARIANT_TARGET_NAME}")
1401   else (THIS_EXE_DEBUG_AND_RELEASE)
1402     boost_library_variant_target_name(${THIS_EXE_VARIANT})
1403   endif (THIS_EXE_DEBUG_AND_RELEASE)
1404
1405   # Compute the actual set of library dependencies, based on the
1406   # variant name we computed above. The RELEASE and DEBUG versions
1407   # only apply when THIS_EXE_DEBUG_AND_RELEASE.
1408   set(THIS_EXE_ACTUAL_DEPENDS)
1409   set(THIS_EXE_RELEASE_ACTUAL_DEPENDS)
1410   set(THIS_EXE_DEBUG_ACTUAL_DEPENDS)
1411   set(DEPENDENCY_FAILURES "")
1412   foreach(LIB ${THIS_EXE_DEPENDS})
1413     if (LIB MATCHES ".*-.*")
1414       # The user tried to state exactly which variant to use. Just
1415       # propagate the dependency and hope that s/he was
1416       # right. Eventually, this should at least warn, because it is
1417       # not the "proper" way to do things
1418       list(APPEND THIS_EXE_ACTUAL_DEPENDS ${LIB})
1419       list(APPEND THIS_EXE_RELEASE_ACTUAL_DEPENDS ${LIB})
1420       list(APPEND THIS_EXE_DEBUG_ACTUAL_DEPENDS ${LIB})
1421       dependency_check(${LIB})
1422     else ()
1423       # The user has given the name of just the library target,
1424       # e.g., "boost_filesystem". We add on the appropriate variant
1425       # name(s).
1426       list(APPEND THIS_EXE_ACTUAL_DEPENDS "${LIB}${VARIANT_TARGET_NAME}")
1427       list(APPEND THIS_EXE_RELEASE_ACTUAL_DEPENDS "${LIB}${RELEASE_VARIANT_TARGET_NAME}")
1428       list(APPEND THIS_EXE_DEBUG_ACTUAL_DEPENDS "${LIB}${DEBUG_VARIANT_TARGET_NAME}")
1429       if(THIS_EXE_RELEASE_AND_DEBUG)
1430         dependency_check("${LIB}${RELEASE_VARIANT_TARGET_NAME}")
1431         dependency_check("${LIB}${DEBUG_VARIANT_TARGET_NAME}")
1432       else()
1433         dependency_check("${LIB}${VARIANT_TARGET_NAME}")
1434       endif()
1435     endif ()
1436   endforeach()
1437
1438   set(THIS_EXE_OKAY TRUE)
1439
1440   if(DEPENDENCY_FAILURES)
1441     set(THIS_EXE_OKAY FALSE)
1442     # separate_arguments(DEPENDENCY_FAILURES)
1443     colormsg(HIRED "    ${THIS_EXE_NAME}" RED "(executable) disabled due to dependency failures:")
1444     colormsg("      ${DEPENDENCY_FAILURES}")
1445   endif()
1446
1447   trace(THIS_EXE_VARIANT)
1448   trace(THIS_EXE_OUTPUT_NAME)
1449   if (THIS_EXE_VARIANT AND (NOT DEPENDENCY_FAILURES))
1450     # It's okay to build this executable
1451
1452     add_executable(${THIS_EXE_NAME} ${THIS_EXE_SOURCES})
1453     
1454     # Set the various compilation and linking flags
1455     set_target_properties(${THIS_EXE_NAME}
1456       PROPERTIES
1457       COMPILE_FLAGS "${THIS_EXE_COMPILE_FLAGS}"
1458       LINK_FLAGS "${THIS_EXE_LINK_FLAGS}"
1459       LABELS "${BOOST_PROJECT_NAME}"
1460       )
1461
1462     # For IDE generators where we can build both debug and release
1463     # configurations, pass the configurations along separately.
1464     if (THIS_EXE_DEBUG_AND_RELEASE)
1465       set_target_properties(${THIS_EXE_NAME}
1466         PROPERTIES
1467         COMPILE_FLAGS_DEBUG "${DEBUG_COMPILE_FLAGS} ${THIS_EXE_COMPILE_FLAGS}"
1468         COMPILE_FLAGS_RELEASE "${RELEASE_COMPILE_FLAGS} ${THIS_EXE_COMPILE_FLAGS}"
1469         LINK_FLAGS_DEBUG "${DEBUG_LINK_FLAGS} ${DEBUG_EXE_LINK_FLAGS} ${THIS_EXE_LINK_FLAGS}"
1470         LINK_FLAGS_RELEASE "${RELEASE_LINK_FLAGS} ${RELEASE_EXE_LINK_FLAGS} ${THIS_EXE_LINK_FLAGS}"
1471         )
1472     endif (THIS_EXE_DEBUG_AND_RELEASE)
1473
1474     # If the user gave an output name, use it.
1475     if(THIS_EXE_OUTPUT_NAME)
1476       set_target_properties(${THIS_EXE_NAME}
1477         PROPERTIES
1478         OUTPUT_NAME ${THIS_EXE_OUTPUT_NAME}
1479         )
1480     endif()
1481
1482     # Link against the various libraries 
1483     if (THIS_EXE_DEBUG_AND_RELEASE)
1484       # Configuration-agnostic libraries
1485       target_link_libraries(${THIS_EXE_NAME} ${THIS_EXE_LINK_LIBS})
1486       
1487       foreach(LIB ${THIS_EXE_RELEASE_ACTUAL_DEPENDS} ${THIS_EXE_RELEASE_LINK_LIBS})     
1488         target_link_libraries(${THIS_EXE_NAME} optimized ${LIB})
1489       endforeach(LIB ${THIS_EXE_RELEASE_ACTUAL_DEPENDS} ${THIS_EXE_RELEASE_LINK_LIBS})     
1490       
1491       foreach(LIB ${THIS_EXE_DEBUG_ACTUAL_DEPENDS} ${THIS_EXE_DEBUG_LINK_LIBS})     
1492         target_link_libraries(${THIS_EXE_NAME} debug ${LIB})
1493       endforeach(LIB ${THIS_EXE_DEBUG_ACTUAL_DEPENDS} ${THIS_EXE_DEBUG_LINK_LIBS})     
1494
1495     else (THIS_EXE_DEBUG_AND_RELEASE)
1496       target_link_libraries(${THIS_EXE_NAME} 
1497         ${THIS_EXE_ACTUAL_DEPENDS} 
1498         ${THIS_EXE_LINK_LIBS})
1499     endif (THIS_EXE_DEBUG_AND_RELEASE)
1500
1501   endif ()
1502 endmacro(boost_add_executable)
1503
1504
1505 #
1506 #  Macro for building boost.python extensions
1507 #
1508 macro(boost_python_extension MODULE_NAME)
1509   parse_arguments(BPL_EXT 
1510     "" 
1511     "" 
1512     ${ARGN})
1513   
1514   boost_add_single_library(
1515     ${MODULE_NAME}
1516     ${BPL_EXT_DEFAULT_ARGS}
1517     MODULE
1518     LINK_LIBS ${PYTHON_LIBRARIES}
1519     DEPENDS boost_python
1520     SHARED
1521     MULTI_THREADED
1522     )
1523   if (NOT THIS_VARIANT_OKAY)
1524     colormsg(HIRED "    ${MODULE_NAME}" RED "(python extension) disabled because:")
1525     foreach(msg ${SELECT_VARIANT_FAILURE_REASONS})
1526       colormsg(YELLOW "      ${msg}")
1527     endforeach()
1528   endif()
1529
1530 endmacro()