diff options
779 files changed, 23287 insertions, 14783 deletions
diff --git a/Auxiliary/cmake-indent.vim b/Auxiliary/cmake-indent.vim index 6cee9c8..fa088e4 100644 --- a/Auxiliary/cmake-indent.vim +++ b/Auxiliary/cmake-indent.vim @@ -16,7 +16,7 @@ " Version: $Revision$ " " Licence: The CMake license applies to this file. See -" http://www.cmake.org/licensing +" https://cmake.org/licensing " This implies that distribution with Vim is allowed if exists("b:did_indent") diff --git a/Auxiliary/cmake-mode.el b/Auxiliary/cmake-mode.el index 11e33b3..08ac490 100644 --- a/Auxiliary/cmake-mode.el +++ b/Auxiliary/cmake-mode.el @@ -70,11 +70,11 @@ set the path with these commands: (defconst cmake-regex-indented (rx-to-string `(and bol (* (group (or (regexp ,cmake-regex-token) (any space ?\n))))))) (defconst cmake-regex-block-open - (rx-to-string `(and bow (or ,@(append cmake-keywords-block-open - (mapcar 'downcase cmake-keywords-block-open))) eow))) + (rx-to-string `(and symbol-start (or ,@(append cmake-keywords-block-open + (mapcar 'downcase cmake-keywords-block-open))) symbol-end))) (defconst cmake-regex-block-close - (rx-to-string `(and bow (or ,@(append cmake-keywords-block-close - (mapcar 'downcase cmake-keywords-block-close))) eow))) + (rx-to-string `(and symbol-start (or ,@(append cmake-keywords-block-close + (mapcar 'downcase cmake-keywords-block-close))) symbol-end))) (defconst cmake-regex-close (rx-to-string `(and bol (* space) (regexp ,cmake-regex-block-close) (* space) (regexp ,cmake-regex-paren-left)))) @@ -177,7 +177,7 @@ the indentation. Otherwise it retains the same position on the line" (interactive) (save-excursion (goto-char (point-min)) - (while (re-search-forward "^\\([ \t]*\\)\\(\\w+\\)\\([ \t]*(\\)" nil t) + (while (re-search-forward "^\\([ \t]*\\)\\_<\\(\\(?:\\w\\|\\s_\\)+\\)\\_>\\([ \t]*(\\)" nil t) (replace-match (concat (match-string 1) diff --git a/Auxiliary/cmake-syntax.vim b/Auxiliary/cmake-syntax.vim index 3e4a122..624a8c4 100644 --- a/Auxiliary/cmake-syntax.vim +++ b/Auxiliary/cmake-syntax.vim @@ -16,7 +16,7 @@ " Version: $Revision$ " " Licence: The CMake license applies to this file. See -" http://www.cmake.org/licensing +" https://cmake.org/licensing " This implies that distribution with Vim is allowed " For version 5.x: Clear all syntax items diff --git a/CMakeCPackOptions.cmake.in b/CMakeCPackOptions.cmake.in index a1e425a..b6013ef 100644 --- a/CMakeCPackOptions.cmake.in +++ b/CMakeCPackOptions.cmake.in @@ -14,14 +14,14 @@ if(CPACK_GENERATOR MATCHES "NSIS") # tell cpack to create links to the doc files set(CPACK_NSIS_MENU_LINKS "@CMAKE_DOC_DIR@/html/index.html" "CMake Documentation" - "http://www.cmake.org" "CMake Web Site" + "https://cmake.org" "CMake Web Site" ) # Use the icon from cmake-gui for add-remove programs set(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\cmake-gui.exe") set(CPACK_NSIS_PACKAGE_NAME "@CPACK_NSIS_PACKAGE_NAME@") set(CPACK_NSIS_DISPLAY_NAME "@CPACK_NSIS_PACKAGE_NAME@, a cross-platform, open-source build system") - set(CPACK_NSIS_HELP_LINK "http://www.cmake.org") + set(CPACK_NSIS_HELP_LINK "https://cmake.org") set(CPACK_NSIS_URL_INFO_ABOUT "http://www.kitware.com") set(CPACK_NSIS_CONTACT @CPACK_PACKAGE_CONTACT@) set(CPACK_NSIS_MODIFY_PATH ON) @@ -35,7 +35,7 @@ if(CPACK_GENERATOR MATCHES "IFW") # Installer configuration set(CPACK_IFW_PACKAGE_TITLE "CMake Build Tool") - set(CPACK_IFW_PRODUCT_URL "http://www.cmake.org") + set(CPACK_IFW_PRODUCT_URL "https://cmake.org") @_CPACK_IFW_PACKAGE_ICON@ set(CPACK_IFW_PACKAGE_WINDOW_ICON "@CMake_SOURCE_DIR@/Source/QtDialog/CMakeSetup128.png") @@ -204,7 +204,7 @@ if("${CPACK_GENERATOR}" STREQUAL "WIX") set(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION}.${patch}") endif() - set(CPACK_WIX_PROPERTY_ARPURLINFOABOUT "http://www.cmake.org") + set(CPACK_WIX_PROPERTY_ARPURLINFOABOUT "https://cmake.org") set(CPACK_WIX_PROPERTY_ARPCONTACT "@CPACK_PACKAGE_CONTACT@") diff --git a/CMakeLists.txt b/CMakeLists.txt index 5e13a7e..ebee14b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -13,6 +13,9 @@ cmake_minimum_required(VERSION 2.8.4 FATAL_ERROR) if(POLICY CMP0025) cmake_policy(SET CMP0025 NEW) endif() +if(POLICY CMP0053) + cmake_policy(SET CMP0053 NEW) +endif() project(CMake) if(CMAKE_BOOTSTRAP) @@ -38,7 +41,12 @@ endif() # Use most-recent available language dialects with GNU and Clang if(NOT DEFINED CMAKE_C_STANDARD AND NOT CMake_NO_C_STANDARD) - set(CMAKE_C_STANDARD 11) + include(${CMake_SOURCE_DIR}/Source/Checks/cm_c11_thread_local.cmake) + if(NOT CMake_C11_THREAD_LOCAL_BROKEN) + set(CMAKE_C_STANDARD 11) + else() + set(CMAKE_C_STANDARD 99) + endif() endif() if(NOT DEFINED CMAKE_CXX_STANDARD AND NOT CMake_NO_CXX_STANDARD) include(${CMake_SOURCE_DIR}/Source/Checks/cm_cxx14_cstdio.cmake) @@ -364,12 +372,14 @@ macro (CMAKE_BUILD_UTILITIES) set(ENABLE_LZMA ON CACHE INTERNAL "Enable the use of the system found LZMA library if found") set(ENABLE_ZLIB ON CACHE INTERNAL "Enable the use of the system found ZLIB library if found") set(ENABLE_BZip2 ON CACHE INTERNAL "Enable the use of the system found BZip2 library if found") + set(ENABLE_LIBXML2 OFF CACHE INTERNAL "Enable the use of the system found libxml2 library if found") set(ENABLE_EXPAT OFF CACHE INTERNAL "Enable the use of the system found EXPAT library if found") set(ENABLE_PCREPOSIX OFF CACHE INTERNAL "Enable the use of the system found PCREPOSIX library if found") set(ENABLE_LibGCC OFF CACHE INTERNAL "Enable the use of the system found LibGCC library if found") set(ENABLE_XATTR OFF CACHE INTERNAL "Enable extended attribute support") set(ENABLE_ACL OFF CACHE INTERNAL "Enable ACL support") set(ENABLE_ICONV OFF CACHE INTERNAL "Enable iconv support") + set(ENABLE_CNG OFF CACHE INTERNAL "Enable the use of CNG(Crypto Next Generation)") add_subdirectory(Utilities/cmlibarchive) CMAKE_SET_TARGET_FOLDER(cmlibarchive "Utilities/3rdParty") set(CMAKE_TAR_LIBRARIES cmlibarchive ${BZIP2_LIBRARIES}) diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index 5daaf9c..0e5c7e1 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -14,7 +14,7 @@ Please subscribe and post to the `CMake Developers List`_ to offer contributions. Regular and productive contributors may be invited to gain direct push access. -.. _`CMake Developers List`: http://www.cmake.org/mailman/listinfo/cmake-developers +.. _`CMake Developers List`: https://cmake.org/mailman/listinfo/cmake-developers Patches ======= diff --git a/CTestCustom.cmake.in b/CTestCustom.cmake.in index d3cff51..2adf317 100644 --- a/CTestCustom.cmake.in +++ b/CTestCustom.cmake.in @@ -1,9 +1,7 @@ -set(CTEST_CUSTOM_ERROR_MATCH - ${CTEST_CUSTOM_ERROR_MATCH} +list(APPEND CTEST_CUSTOM_ERROR_MATCH "ERROR:") -set(CTEST_CUSTOM_WARNING_EXCEPTION - ${CTEST_CUSTOM_WARNING_EXCEPTION} +list(APPEND CTEST_CUSTOM_WARNING_EXCEPTION "xtree.[0-9]+. : warning C4702: unreachable code" "warning LNK4221" "warning LNK4204" # Occurs by race condition with objects in small libs @@ -84,22 +82,18 @@ set(CTEST_CUSTOM_WARNING_EXCEPTION ) if(NOT "@CMAKE_GENERATOR@" MATCHES "Xcode") - set(CTEST_CUSTOM_COVERAGE_EXCLUDE - ${CTEST_CUSTOM_COVERAGE_EXCLUDE} + list(APPEND CTEST_CUSTOM_COVERAGE_EXCLUDE "XCode" ) endif () if(NOT "@CMAKE_GENERATOR@" MATCHES "KDevelop") - set(CTEST_CUSTOM_COVERAGE_EXCLUDE - ${CTEST_CUSTOM_COVERAGE_EXCLUDE} + list(APPEND CTEST_CUSTOM_COVERAGE_EXCLUDE "Kdevelop" ) endif () -set(CTEST_CUSTOM_COVERAGE_EXCLUDE - ${CTEST_CUSTOM_COVERAGE_EXCLUDE} - +list(APPEND CTEST_CUSTOM_COVERAGE_EXCLUDE # Exclude kwsys files from coverage results. They are reported # (with better coverage results) on kwsys dashboards... "/Source/(cm|kw)sys/" diff --git a/Help/command/add_executable.rst b/Help/command/add_executable.rst index 4ed10e1..8b3fb57 100644 --- a/Help/command/add_executable.rst +++ b/Help/command/add_executable.rst @@ -14,7 +14,7 @@ files listed in the command invocation. The ``<name>`` corresponds to the logical target name and must be globally unique within a project. The actual file name of the executable built is constructed based on conventions of the native platform (such as ``<name>.exe`` or just -``<name>``. +``<name>``). By default the executable file will be created in the build tree directory corresponding to the source tree directory in which the diff --git a/Help/command/add_library.rst b/Help/command/add_library.rst index fe7735c..5033e18 100644 --- a/Help/command/add_library.rst +++ b/Help/command/add_library.rst @@ -36,6 +36,12 @@ property is set to ``ON`` automatically. A ``SHARED`` library may be marked with the :prop_tgt:`FRAMEWORK` target property to create an OS X Framework. +If a library does not export any symbols, it must not be declared as a +``SHARED`` library. For example, a Windows resource DLL or a managed C++/CLI +DLL that exports no unmanaged symbols would need to be a ``MODULE`` library. +This is because CMake expects a ``SHARED`` library to always have an +associated import library on Windows. + By default the library file will be created in the build tree directory corresponding to the source tree directory in which the command was invoked. See documentation of the :prop_tgt:`ARCHIVE_OUTPUT_DIRECTORY`, diff --git a/Help/command/add_test.rst b/Help/command/add_test.rst index 7e7e6bd..d8a96e9 100644 --- a/Help/command/add_test.rst +++ b/Help/command/add_test.rst @@ -28,6 +28,13 @@ quotes, or other characters special in CMake syntax. The options are: directory set to the build directory corresponding to the current source directory. +The given test command is expected to exit with code ``0`` to pass and +non-zero to fail, or vice-versa if the :prop_test:`WILL_FAIL` test +property is set. Any output written to stdout or stderr will be +captured by :manual:`ctest(1)` but does not affect the pass/fail status +unless the :prop_test:`PASS_REGULAR_EXPRESSION` or +:prop_test:`FAIL_REGULAR_EXPRESSION` test property is used. + The ``COMMAND`` and ``WORKING_DIRECTORY`` options may use "generator expressions" with the syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` manual for available expressions. diff --git a/Help/command/ctest_read_custom_files.rst b/Help/command/ctest_read_custom_files.rst index 0bc57cd..cf8e17a 100644 --- a/Help/command/ctest_read_custom_files.rst +++ b/Help/command/ctest_read_custom_files.rst @@ -9,3 +9,6 @@ read CTestCustom files. Read all the CTestCustom.ctest or CTestCustom.cmake files from the given directory. + +By default, invoking :manual:`ctest(1)` without a script will read custom +files from the binary directory. diff --git a/Help/command/ctest_test.rst b/Help/command/ctest_test.rst index 162db69..412e323 100644 --- a/Help/command/ctest_test.rst +++ b/Help/command/ctest_test.rst @@ -85,3 +85,6 @@ The options are: been printed to the console. Output from the underlying test command is not affected. Summary info detailing the percentage of passing tests is also unaffected by the ``QUIET`` option. + +See also the :variable:`CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE` +and :variable:`CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE` variables. diff --git a/Help/command/file.rst b/Help/command/file.rst index bbddd40..96ac6c7 100644 --- a/Help/command/file.rst +++ b/Help/command/file.rst @@ -103,7 +103,8 @@ Generate a list of files that match the ``<globbing-expressions>`` and store it into the ``<variable>``. Globbing expressions are similar to regular expressions, but much simpler. If ``RELATIVE`` flag is specified, the results will be returned as relative paths to the given -path. +path. No specific order of results is defined. If order is important then +sort the list explicitly (e.g. using the :command:`list(SORT)` command). By default ``GLOB`` lists directories - directories are omited in result if ``LIST_DIRECTORIES`` is set to false. diff --git a/Help/command/get_filename_component.rst b/Help/command/get_filename_component.rst index 82f9120..14c8cf2 100644 --- a/Help/command/get_filename_component.rst +++ b/Help/command/get_filename_component.rst @@ -19,7 +19,7 @@ Set ``<VAR>`` to a component of ``<FileName>``, where ``<COMP>`` is one of: NAME_WE = File name without directory or longest extension PATH = Legacy alias for DIRECTORY (use for CMake <= 2.8.11) -Paths are returned with forward slashes and have no trailing slahes. +Paths are returned with forward slashes and have no trailing slashes. The longest file extension is always considered. If the optional ``CACHE`` argument is specified, the result variable is added to the cache. diff --git a/Help/command/install.rst b/Help/command/install.rst index c99ed73..423899e 100644 --- a/Help/command/install.rst +++ b/Help/command/install.rst @@ -192,6 +192,10 @@ The list of ``files...`` given to ``FILES`` or ``PROGRAMS`` may use However, if any item begins in a generator expression it must evaluate to a full path. +The install destination given to the files install ``DESTINATION`` may +use "generator expressions" with the syntax ``$<...>``. See the +:manual:`cmake-generator-expressions(7)` manual for available expressions. + Installing Directories ^^^^^^^^^^^^^^^^^^^^^^ @@ -267,6 +271,10 @@ will install the ``icons`` directory to ``share/myproj/icons`` and the file permissions, the scripts will be given specific permissions, and any ``CVS`` directories will be excluded. +The install destination given to the directory install ``DESTINATION`` may +use "generator expressions" with the syntax ``$<...>``. See the +:manual:`cmake-generator-expressions(7)` manual for available expressions. + Custom Installation Logic ^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/Help/command/string.rst b/Help/command/string.rst index 20f8094..0361c74 100644 --- a/Help/command/string.rst +++ b/Help/command/string.rst @@ -1,102 +1,84 @@ string ------ +.. only:: html + + .. contents:: + String operations. +Search and Replace +^^^^^^^^^^^^^^^^^^ + +FIND +"""" + :: - string(REGEX MATCH <regular_expression> - <output variable> <input> [<input>...]) - string(REGEX MATCHALL <regular_expression> - <output variable> <input> [<input>...]) - string(REGEX REPLACE <regular_expression> - <replace_expression> <output variable> - <input> [<input>...]) - string(REPLACE <match_string> - <replace_string> <output variable> - <input> [<input>...]) - string(APPEND <string variable> [<input>...]) - string(CONCAT <output variable> [<input>...]) - string(<MD5|SHA1|SHA224|SHA256|SHA384|SHA512> - <output variable> <input>) - string(COMPARE EQUAL <string1> <string2> <output variable>) - string(COMPARE NOTEQUAL <string1> <string2> <output variable>) - string(COMPARE LESS <string1> <string2> <output variable>) - string(COMPARE GREATER <string1> <string2> <output variable>) - string(ASCII <number> [<number> ...] <output variable>) - string(CONFIGURE <string1> <output variable> - [@ONLY] [ESCAPE_QUOTES]) - string(TOUPPER <string1> <output variable>) - string(TOLOWER <string1> <output variable>) - string(LENGTH <string> <output variable>) - string(SUBSTRING <string> <begin> <length> <output variable>) - string(STRIP <string> <output variable>) - string(RANDOM [LENGTH <length>] [ALPHABET <alphabet>] - [RANDOM_SEED <seed>] <output variable>) string(FIND <string> <substring> <output variable> [REVERSE]) - string(TIMESTAMP <output variable> [<format string>] [UTC]) - string(MAKE_C_IDENTIFIER <input string> <output variable>) - string(GENEX_STRIP <input string> <output variable>) - string(UUID <output variable> NAMESPACE <namespace> NAME <name> - TYPE <MD5|SHA1> [UPPER]) -``REGEX MATCH`` will match the regular expression once and store the match -in the output variable. +Return the position where the given substring was found in +the supplied string. If the ``REVERSE`` flag was used, the command will +search for the position of the last occurrence of the specified +substring. If the substring is not found, a position of -1 is returned. -``REGEX MATCHALL`` will match the regular expression as many times as -possible and store the matches in the output variable as a list. +REPLACE +""""""" -``REGEX REPLACE`` will match the regular expression as many times as -possible and substitute the replacement expression for the match in -the output. The replace expression may refer to paren-delimited -subexpressions of the match using \1, \2, ..., \9. Note that two -backslashes (\\1) are required in CMake code to get a backslash -through argument parsing. +:: -``REPLACE`` will replace all occurrences of ``match_string`` in the input + string(REPLACE <match_string> + <replace_string> <output variable> + <input> [<input>...]) + +Replace all occurrences of ``match_string`` in the input with ``replace_string`` and store the result in the output. -``APPEND`` will append all the input arguments to the string. +Regular Expressions +^^^^^^^^^^^^^^^^^^^ -``CONCAT`` will concatenate all the input arguments together and store -the result in the named output variable. +REGEX MATCH +""""""""""" -``MD5``, ``SHA1``, ``SHA224``, ``SHA256``, ``SHA384``, and ``SHA512`` will -compute a cryptographic hash of the input string. +:: -``COMPARE EQUAL``/``COMPARE NOTEQUAL``/``COMPARE LESS/GREATER`` will -compare the strings and store true or false in the output variable. + string(REGEX MATCH <regular_expression> + <output variable> <input> [<input>...]) -``ASCII`` will convert all numbers into corresponding ASCII characters. +Match the regular expression once and store the match in the output variable. +All ``<input>`` arguments are concatenated before matching. -``CONFIGURE`` will transform a string like :command:`configure_file` -transforms a file. +REGEX MATCHALL +"""""""""""""" -``TOUPPER``/``TOLOWER`` will convert string to upper/lower characters. +:: -``LENGTH`` will return a given string's length. + string(REGEX MATCHALL <regular_expression> + <output variable> <input> [<input>...]) -``SUBSTRING`` will return a substring of a given string. If length is -1 -the remainder of the string starting at begin will be returned. -If string is shorter than length then end of string is used instead. +Match the regular expression as many times as possible and store the matches +in the output variable as a list. +All ``<input>`` arguments are concatenated before matching. -.. note:: - CMake 3.1 and below reported an error if length pointed past - the end of string. +REGEX REPLACE +""""""""""""" -``STRIP`` will return a substring of a given string with leading and -trailing spaces removed. +:: -``RANDOM`` will return a random string of given length consisting of -characters from the given alphabet. Default length is 5 characters -and default alphabet is all numbers and upper and lower case letters. -If an integer ``RANDOM_SEED`` is given, its value will be used to seed the -random number generator. + string(REGEX REPLACE <regular_expression> + <replace_expression> <output variable> + <input> [<input>...]) -``FIND`` will return the position where the given substring was found in -the supplied string. If the ``REVERSE`` flag was used, the command will -search for the position of the last occurrence of the specified -substring. If the substring is not found, a position of -1 is returned. +Match the regular expression as many times as possible and substitute the +replacement expression for the match in the output. +All ``<input>`` arguments are concatenated before matching. + +The replace expression may refer to paren-delimited subexpressions of the +match using ``\1``, ``\2``, ..., ``\9``. Note that two backslashes (``\\1``) +are required in CMake code to get a backslash through argument parsing. + +Regex Specification +""""""""""""""""""" The following characters have special meaning in regular expressions: @@ -123,10 +105,159 @@ The following characters have special meaning in regular expressions: ``*``, ``+`` and ``?`` have higher precedence than concatenation. ``|`` has lower precedence than concatenation. This means that the regular -expression "^ab+d$" matches "abbd" but not "ababd", and the regular -expression "^(ab|cd)$" matches "ab" but not "abd". +expression ``^ab+d$`` matches ``abbd`` but not ``ababd``, and the regular +expression ``^(ab|cd)$`` matches ``ab`` but not ``abd``. + +Manipulation +^^^^^^^^^^^^ + +APPEND +"""""" + +:: + + string(APPEND <string variable> [<input>...]) + +Append all the input arguments to the string. + +CONCAT +"""""" + +:: + + string(CONCAT <output variable> [<input>...]) + +Concatenate all the input arguments together and store +the result in the named output variable. + +TOLOWER +""""""" + +:: + + string(TOLOWER <string1> <output variable>) + +Convert string to lower characters. + +TOUPPER +""""""" -``TIMESTAMP`` will write a string representation of the current date +:: + + string(TOUPPER <string1> <output variable>) + +Convert string to upper characters. + +LENGTH +"""""" + +:: + + string(LENGTH <string> <output variable>) + +Store in an output variable a given string's length. + +SUBSTRING +""""""""" + +:: + + string(SUBSTRING <string> <begin> <length> <output variable>) + +Store in an output variable a substring of a given string. If length is +``-1`` the remainder of the string starting at begin will be returned. +If string is shorter than length then end of string is used instead. + +.. note:: + CMake 3.1 and below reported an error if length pointed past + the end of string. + +STRIP +""""" + +:: + + string(STRIP <string> <output variable>) + +Store in an output variable a substring of a given string with leading and +trailing spaces removed. + +GENEX_STRIP +""""""""""" + +:: + + string(GENEX_STRIP <input string> <output variable>) + +Strip any :manual:`generator expressions <cmake-generator-expressions(7)>` +from the ``input string`` and store the result in the ``output variable``. + +Comparison +^^^^^^^^^^ + +:: + + string(COMPARE EQUAL <string1> <string2> <output variable>) + string(COMPARE NOTEQUAL <string1> <string2> <output variable>) + string(COMPARE LESS <string1> <string2> <output variable>) + string(COMPARE GREATER <string1> <string2> <output variable>) + +Compare the strings and store true or false in the output variable. + +Hashing +^^^^^^^ + +:: + + string(<MD5|SHA1|SHA224|SHA256|SHA384|SHA512> + <output variable> <input>) + +Compute a cryptographic hash of the input string. + +Generation +^^^^^^^^^^ + +ASCII +""""" + +:: + + string(ASCII <number> [<number> ...] <output variable>) + +Convert all numbers into corresponding ASCII characters. + +CONFIGURE +""""""""" + +:: + + string(CONFIGURE <string1> <output variable> + [@ONLY] [ESCAPE_QUOTES]) + +Transform a string like :command:`configure_file` transforms a file. + +RANDOM +"""""" + +:: + + string(RANDOM [LENGTH <length>] [ALPHABET <alphabet>] + [RANDOM_SEED <seed>] <output variable>) + +Return a random string of given length consisting of +characters from the given alphabet. Default length is 5 characters +and default alphabet is all numbers and upper and lower case letters. +If an integer ``RANDOM_SEED`` is given, its value will be used to seed the +random number generator. + +TIMESTAMP +""""""""" + +:: + + string(TIMESTAMP <output variable> [<format string>] [UTC]) + +Write a string representation of the current date and/or time to the output variable. Should the command be unable to obtain a timestamp the output variable @@ -163,14 +294,22 @@ If no explicit ``<format string>`` is given it will default to: %Y-%m-%dT%H:%M:%S for local time. %Y-%m-%dT%H:%M:%SZ for UTC. -``MAKE_C_IDENTIFIER`` will write a string which can be used as an -identifier in C. -``GENEX_STRIP`` will strip any -:manual:`generator expressions <cmake-generator-expressions(7)>` from the -``input string`` and store the result in the ``output variable``. +:: + + string(MAKE_C_IDENTIFIER <input string> <output variable>) + +Write a string which can be used as an identifier in C. + +UUID +"""" + +:: + + string(UUID <output variable> NAMESPACE <namespace> NAME <name> + TYPE <MD5|SHA1> [UPPER]) -``UUID`` creates a univerally unique identifier (aka GUID) as per RFC4122 +Create a univerally unique identifier (aka GUID) as per RFC4122 based on the hash of the combined values of ``<namespace>`` (which itself has to be a valid UUID) and ``<name>``. The hash algorithm can be either ``MD5`` (Version 3 UUID) or diff --git a/Help/command/try_compile.rst b/Help/command/try_compile.rst index 1ed24df..28dae80 100644 --- a/Help/command/try_compile.rst +++ b/Help/command/try_compile.rst @@ -100,6 +100,7 @@ If set, the following variables are passed in to the generated try_compile CMakeLists.txt to initialize compile target properties with default values: +* :variable:`CMAKE_ENABLE_EXPORTS` * :variable:`CMAKE_LINK_SEARCH_START_STATIC` * :variable:`CMAKE_LINK_SEARCH_END_STATIC` * :variable:`CMAKE_POSITION_INDEPENDENT_CODE` @@ -107,5 +108,7 @@ default values: If :policy:`CMP0056` is set to ``NEW``, then :variable:`CMAKE_EXE_LINKER_FLAGS` is passed in as well. +The current setting of :policy:`CMP0065` is set in the generated project. + Set the :variable:`CMAKE_TRY_COMPILE_CONFIGURATION` variable to choose a build configuration. diff --git a/Help/manual/LINKS.txt b/Help/manual/LINKS.txt index 38fd151..3993ff8 100644 --- a/Help/manual/LINKS.txt +++ b/Help/manual/LINKS.txt @@ -1,25 +1,25 @@ The following resources are available to get help using CMake: Home Page - http://www.cmake.org + https://cmake.org The primary starting point for learning about CMake. Frequently Asked Questions - http://www.cmake.org/Wiki/CMake_FAQ + https://cmake.org/Wiki/CMake_FAQ A Wiki is provided containing answers to frequently asked questions. Online Documentation - http://www.cmake.org/documentation + https://cmake.org/documentation Links to available documentation may be found on this web page. Mailing List - http://www.cmake.org/mailing-lists + https://cmake.org/mailing-lists For help and discussion about using cmake, a mailing list is provided at cmake@cmake.org. The list is member-post-only but one may sign up on the CMake web page. Please first read the full - documentation at http://www.cmake.org before posting questions to + documentation at https://cmake.org before posting questions to the list. diff --git a/Help/manual/OPTIONS_BUILD.txt b/Help/manual/OPTIONS_BUILD.txt index b65b7c7..4207db4 100644 --- a/Help/manual/OPTIONS_BUILD.txt +++ b/Help/manual/OPTIONS_BUILD.txt @@ -77,49 +77,10 @@ Suppress developer warnings. Suppress warnings that are meant for the author of the - CMakeLists.txt files. By default this will also turn off - deprecation warnings. + CMakeLists.txt files. ``-Wdev`` Enable developer warnings. Enable warnings that are meant for the author of the CMakeLists.txt - files. By default this will also turn on deprecation warnings. - -``-Werror=dev`` - Make developer warnings errors. - - Make warnings that are meant for the author of the CMakeLists.txt - files errors. By default this will also turn on treatment of - deprecation warnings as errors. - -``-Wno-error=dev`` - Make developer warnings not errors. - - Make warnings that are meant for the author of the CMakeLists.txt - files not errors. By default this will also turn off treatment of - deprecation warnings as errors. - -``-Wdeprecated`` - Enable deprecated macro and function warnings. - - Enable warnings for usage of deprecated macros and functions, that - are meant for the author of the CMakeLists.txt files. - -``-Wno-deprecated`` - Suppress deprecated macro and function warnings. - - Suppress warnings for usage of deprecated macros and functions, that - are meant for the author of the CMakeLists.txt files. - -``-Werror=deprecated`` - Make deprecated macro and function warnings errors. - - Make warnings for usage of deprecated macros and functions, that - are meant for the author of the CMakeLists.txt files, errors. - -``-Wno-error=deprecated`` - Make deprecated macro and function warnings not errors. - - Make warnings for usage of deprecated macros and functions, that - are meant for the author of the CMakeLists.txt files, not errors. + files. diff --git a/Help/manual/cmake-buildsystem.7.rst b/Help/manual/cmake-buildsystem.7.rst index 357aae9..bc633e6 100644 --- a/Help/manual/cmake-buildsystem.7.rst +++ b/Help/manual/cmake-buildsystem.7.rst @@ -80,6 +80,10 @@ regardless of the library type. The ``MODULE`` library type is dissimilar in that it is generally not linked to -- it is not used in the right-hand-side of the :command:`target_link_libraries` command. It is a type which is loaded as a plugin using runtime techniques. +If the library does not export any unmanaged symbols (e.g. Windows +resource DLL, C++/CLI DLL), it is required that the library not be a +``SHARED`` library because CMake expects ``SHARED`` libraries to export +at least one symbol. .. code-block:: cmake @@ -781,7 +785,8 @@ An *archive* output artifact of a buildsystem target may be: * On DLL platforms: the import library file (e.g. ``.lib``) of a shared library target created by the :command:`add_library` command - with the ``SHARED`` option. + with the ``SHARED`` option. This file is only guaranteed to exist if + the library exports at least one unmanaged symbol. * On DLL platforms: the import library file (e.g. ``.lib``) of an executable target created by the :command:`add_executable` command diff --git a/Help/manual/cmake-developer.7.rst b/Help/manual/cmake-developer.7.rst index 90a081d..a335384 100644 --- a/Help/manual/cmake-developer.7.rst +++ b/Help/manual/cmake-developer.7.rst @@ -52,9 +52,9 @@ When adding the first supported feature to a particular CompilerId, it is necessary to list support for all features known to cmake (See :variable:`CMAKE_C_COMPILE_FEATURES` and :variable:`CMAKE_CXX_COMPILE_FEATURES` as appropriate), where available for -the compiler. Furthermore, set ``CMAKE_<LANG>_STANDARD_DEFAULT`` to the -default language standard level the compiler uses, or to the empty string -if the compiler has no notion of standard levels (such as ``MSVC``). +the compiler. Ensure that the ``CMAKE_<LANG>_STANDARD_DEFAULT`` is set to +the computed internal variable ``CMAKE_<LANG>_STANDARD_COMPUTED_DEFAULT`` +for compiler versions which should be supported. It is sensible to record the features for the most recent version of a particular CompilerId first, and then work backwards. It is sensible to diff --git a/Help/manual/cmake-generator-expressions.7.rst b/Help/manual/cmake-generator-expressions.7.rst index 189c3ef..13ee4bd 100644 --- a/Help/manual/cmake-generator-expressions.7.rst +++ b/Help/manual/cmake-generator-expressions.7.rst @@ -278,3 +278,7 @@ Available output expressions are: object of type ``OBJECT_LIBRARY``. This expression may only be used in the sources of :command:`add_library` and :command:`add_executable` commands. +``$<SHELL_PATH:...>`` + Content of ``...`` converted to shell path style. For example, slashes are + converted to backslashes in Windows shells and drive letters are converted + to posix paths in MSYS shells. The ``...`` must be an absolute path. diff --git a/Help/manual/cmake-policies.7.rst b/Help/manual/cmake-policies.7.rst index 590f10d..ae5354f 100644 --- a/Help/manual/cmake-policies.7.rst +++ b/Help/manual/cmake-policies.7.rst @@ -122,3 +122,4 @@ All Policies /policy/CMP0062 /policy/CMP0063 /policy/CMP0064 + /policy/CMP0065 diff --git a/Help/manual/cmake-properties.7.rst b/Help/manual/cmake-properties.7.rst index ac893c2..931363c 100644 --- a/Help/manual/cmake-properties.7.rst +++ b/Help/manual/cmake-properties.7.rst @@ -254,17 +254,22 @@ Properties on Targets /prop_tgt/TYPE /prop_tgt/VERSION /prop_tgt/VISIBILITY_INLINES_HIDDEN + /prop_tgt/VS_DESKTOP_EXTENSIONS_VERSION /prop_tgt/VS_DOTNET_REFERENCES /prop_tgt/VS_DOTNET_TARGET_FRAMEWORK_VERSION /prop_tgt/VS_GLOBAL_KEYWORD /prop_tgt/VS_GLOBAL_PROJECT_TYPES /prop_tgt/VS_GLOBAL_ROOTNAMESPACE /prop_tgt/VS_GLOBAL_variable + /prop_tgt/VS_IOT_EXTENSIONS_VERSION + /prop_tgt/VS_IOT_STARTUP_TASK /prop_tgt/VS_KEYWORD + /prop_tgt/VS_MOBILE_EXTENSIONS_VERSION /prop_tgt/VS_SCC_AUXPATH /prop_tgt/VS_SCC_LOCALPATH /prop_tgt/VS_SCC_PROJECTNAME /prop_tgt/VS_SCC_PROVIDER + /prop_tgt/VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION /prop_tgt/VS_WINRT_COMPONENT /prop_tgt/VS_WINRT_EXTENSIONS /prop_tgt/VS_WINRT_REFERENCES diff --git a/Help/manual/cmake-toolchains.7.rst b/Help/manual/cmake-toolchains.7.rst index a06dce7..492fcac 100644 --- a/Help/manual/cmake-toolchains.7.rst +++ b/Help/manual/cmake-toolchains.7.rst @@ -220,6 +220,23 @@ Windows CE to use. Currently version 8.0 (Windows Embedded Compact 2013) is supported out of the box. Other versions may require one to set :variable:`CMAKE_GENERATOR_TOOLSET` to the correct value. +Cross Compiling for Windows 10 Universal Applications +----------------------------------------------------- + +A toolchain file to configure a Visual Studio generator for a +Windows 10 Universal Application may look like this: + +.. code-block:: cmake + + set(CMAKE_SYSTEM_NAME WindowsStore) + set(CMAKE_SYSTEM_VERSION 10.0) + +A Windows 10 Universal Application targets both Windows Store and +Windows Phone. Specify the :variable:`CMAKE_SYSTEM_VERSION` variable +to be ``10.0`` to build with the latest available Windows 10 SDK. +Specify a more specific version (e.g. ``10.0.10240.0`` for RTM) +to build with the corresponding SDK. + Cross Compiling for Windows Phone --------------------------------- diff --git a/Help/manual/cmake-variables.7.rst b/Help/manual/cmake-variables.7.rst index e0dbdeb..2116900 100644 --- a/Help/manual/cmake-variables.7.rst +++ b/Help/manual/cmake-variables.7.rst @@ -82,6 +82,7 @@ Variables that Provide Information /variable/CMAKE_VS_NsightTegra_VERSION /variable/CMAKE_VS_PLATFORM_NAME /variable/CMAKE_VS_PLATFORM_TOOLSET + /variable/CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION /variable/CMAKE_XCODE_PLATFORM_TOOLSET /variable/PROJECT_BINARY_DIR /variable/PROJECT-NAME_BINARY_DIR @@ -245,6 +246,7 @@ Variables that Control the Build /variable/CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY_CONFIG /variable/CMAKE_CONFIG_POSTFIX /variable/CMAKE_DEBUG_POSTFIX + /variable/CMAKE_ENABLE_EXPORTS /variable/CMAKE_EXE_LINKER_FLAGS_CONFIG /variable/CMAKE_EXE_LINKER_FLAGS /variable/CMAKE_Fortran_FORMAT @@ -374,6 +376,23 @@ Variables for CTest /variable/CTEST_COVERAGE_COMMAND /variable/CTEST_COVERAGE_EXTRA_FLAGS /variable/CTEST_CURL_OPTIONS + /variable/CTEST_CUSTOM_COVERAGE_EXCLUDE + /variable/CTEST_CUSTOM_ERROR_EXCEPTION + /variable/CTEST_CUSTOM_ERROR_MATCH + /variable/CTEST_CUSTOM_ERROR_POST_CONTEXT + /variable/CTEST_CUSTOM_ERROR_PRE_CONTEXT + /variable/CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE + /variable/CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS + /variable/CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS + /variable/CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE + /variable/CTEST_CUSTOM_MEMCHECK_IGNORE + /variable/CTEST_CUSTOM_POST_MEMCHECK + /variable/CTEST_CUSTOM_POST_TEST + /variable/CTEST_CUSTOM_PRE_MEMCHECK + /variable/CTEST_CUSTOM_PRE_TEST + /variable/CTEST_CUSTOM_TEST_IGNORE + /variable/CTEST_CUSTOM_WARNING_EXCEPTION + /variable/CTEST_CUSTOM_WARNING_MATCH /variable/CTEST_CVS_CHECKOUT /variable/CTEST_CVS_COMMAND /variable/CTEST_CVS_UPDATE_OPTIONS @@ -383,6 +402,7 @@ Variables for CTest /variable/CTEST_DROP_SITE_CDASH /variable/CTEST_DROP_SITE_PASSWORD /variable/CTEST_DROP_SITE_USER + /variable/CTEST_EXTRA_COVERAGE_GLOB /variable/CTEST_GIT_COMMAND /variable/CTEST_GIT_UPDATE_CUSTOM /variable/CTEST_GIT_UPDATE_OPTIONS diff --git a/Help/manual/ctest.1.rst b/Help/manual/ctest.1.rst index 50c856a..2fdf7f3 100644 --- a/Help/manual/ctest.1.rst +++ b/Help/manual/ctest.1.rst @@ -302,6 +302,12 @@ Options ``--test-command`` The test to run with the --build-and-test option. +``--test-output-size-passed <size>`` + Limit the output for passed tests to <size> bytes. + +``--test-output-size-failed <size>`` + Limit the output for failed tests to <size> bytes. + ``--test-timeout`` The time limit in seconds, internal use only. diff --git a/Help/policy/CMP0065.rst b/Help/policy/CMP0065.rst new file mode 100644 index 0000000..2ed775d --- /dev/null +++ b/Help/policy/CMP0065.rst @@ -0,0 +1,27 @@ +CMP0065 +------- + +Do not add flags to export symbols from executables without +the :prop_tgt:`ENABLE_EXPORTS` target property. + +CMake 3.3 and below, for historical reasons, always linked executables +on some platforms with flags like ``-rdynamic`` to export symbols from +the executables for use by any plugins they may load via ``dlopen``. +CMake 3.4 and above prefer to do this only for executables that are +explicitly marked with the :prop_tgt:`ENABLE_EXPORTS` target property. + +The ``OLD`` behavior of this policy is to always use the additional link +flags when linking executables regardless of the value of the +:prop_tgt:`ENABLE_EXPORTS` target property. + +The ``NEW`` behavior of this policy is to only use the additional link +flags when linking executables if the :prop_tgt:`ENABLE_EXPORTS` target +property is set to ``True``. + +This policy was introduced in CMake version 3.4. Unlike most policies, +CMake version |release| does *not* warn by default when this policy +is not set and simply uses OLD behavior. See documentation of the +:variable:`CMAKE_POLICY_WARNING_CMP0065 <CMAKE_POLICY_WARNING_CMP<NNNN>>` +variable to control the warning. + +.. include:: DEPRECATED.txt diff --git a/Help/prop_sf/OBJECT_DEPENDS.rst b/Help/prop_sf/OBJECT_DEPENDS.rst index 18022de..1d24960 100644 --- a/Help/prop_sf/OBJECT_DEPENDS.rst +++ b/Help/prop_sf/OBJECT_DEPENDS.rst @@ -3,9 +3,12 @@ OBJECT_DEPENDS Additional files on which a compiled object file depends. -Specifies a semicolon-separated list of full-paths to files on which -any object files compiled from this source file depend. An object -file will be recompiled if any of the named files is newer than it. +Specifies a :ref:`;-list <CMake Language Lists>` of full-paths to +files on which any object files compiled from this source file depend. +On :ref:`Makefile Generators` and the :generator:`Ninja` generator an +object file will be recompiled if any of the named files is newer than it. +:ref:`Visual Studio Generators` and the :generator:`Xcode` generator +cannot implement such compilation dependencies. This property need not be used to specify the dependency of a source file on a generated header file that it includes. Although the @@ -14,5 +17,5 @@ necessary. If the generated header file is created by a custom command in the same target as the source file, the automatic dependency scanning process will recognize the dependency. If the generated header file is created by another target, an inter-target -dependency should be created with the add_dependencies command (if one -does not already exist due to linking relationships). +dependency should be created with the :command:`add_dependencies` +command (if one does not already exist due to linking relationships). diff --git a/Help/prop_tgt/ENABLE_EXPORTS.rst b/Help/prop_tgt/ENABLE_EXPORTS.rst index 283f5a8..dfd4af7 100644 --- a/Help/prop_tgt/ENABLE_EXPORTS.rst +++ b/Help/prop_tgt/ENABLE_EXPORTS.rst @@ -7,7 +7,7 @@ Normally an executable does not export any symbols because it is the final program. It is possible for an executable to export symbols to be used by loadable modules. When this property is set to true CMake will allow other targets to "link" to the executable with the -TARGET_LINK_LIBRARIES command. On all platforms a target-level +:command:`TARGET_LINK_LIBRARIES` command. On all platforms a target-level dependency on the executable is created for targets that link to it. For DLL platforms an import library will be created for the exported symbols and then used for linking. All Windows-based systems @@ -17,3 +17,6 @@ module will "link" to the executable using a flag like "-bundle_loader". For other non-DLL platforms the link rule is simply ignored since the dynamic loader will automatically bind symbols when the module is loaded. + +This property is initialized by the value of the variable +:variable:`CMAKE_ENABLE_EXPORTS` if it is set when a target is created. diff --git a/Help/prop_tgt/VS_DESKTOP_EXTENSIONS_VERSION.rst b/Help/prop_tgt/VS_DESKTOP_EXTENSIONS_VERSION.rst new file mode 100644 index 0000000..19d1620 --- /dev/null +++ b/Help/prop_tgt/VS_DESKTOP_EXTENSIONS_VERSION.rst @@ -0,0 +1,10 @@ +VS_DESKTOP_EXTENSIONS_VERSION +----------------------------- + +Visual Studio Windows 10 Desktop Extensions Version + +Specifies the version of the Desktop Extensions that should be included in the +target. For example ``10.0.10240.0``. If the value is not specified, the Desktop +Extensions will not be included. To use the same version of the extensions as +the Windows 10 SDK that is being used, you can use the +:variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` variable. diff --git a/Help/prop_tgt/VS_IOT_EXTENSIONS_VERSION.rst b/Help/prop_tgt/VS_IOT_EXTENSIONS_VERSION.rst new file mode 100644 index 0000000..27c8a3d --- /dev/null +++ b/Help/prop_tgt/VS_IOT_EXTENSIONS_VERSION.rst @@ -0,0 +1,10 @@ +VS_IOT_EXTENSIONS_VERSION +------------------------- + +Visual Studio Windows 10 IoT Extensions Version + +Specifies the version of the IoT Extensions that should be included in the +target. For example ``10.0.10240.0``. If the value is not specified, the IoT +Extensions will not be included. To use the same version of the extensions as +the Windows 10 SDK that is being used, you can use the +:variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` variable. diff --git a/Help/prop_tgt/VS_IOT_STARTUP_TASK.rst b/Help/prop_tgt/VS_IOT_STARTUP_TASK.rst new file mode 100644 index 0000000..add50cb --- /dev/null +++ b/Help/prop_tgt/VS_IOT_STARTUP_TASK.rst @@ -0,0 +1,6 @@ +VS_IOT_STARTUP_TASK +------------------- + +Visual Studio Windows 10 IoT Continuous Background Task + +Specifies that the target should be compiled as a Continuous Background Task library. diff --git a/Help/prop_tgt/VS_MOBILE_EXTENSIONS_VERSION.rst b/Help/prop_tgt/VS_MOBILE_EXTENSIONS_VERSION.rst new file mode 100644 index 0000000..be3c9a0 --- /dev/null +++ b/Help/prop_tgt/VS_MOBILE_EXTENSIONS_VERSION.rst @@ -0,0 +1,10 @@ +VS_MOBILE_EXTENSIONS_VERSION +---------------------------- + +Visual Studio Windows 10 Mobile Extensions Version + +Specifies the version of the Mobile Extensions that should be included in the +target. For example ``10.0.10240.0``. If the value is not specified, the Mobile +Extensions will not be included. To use the same version of the extensions as +the Windows 10 SDK that is being used, you can use the +:variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` variable. diff --git a/Help/prop_tgt/VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION.rst b/Help/prop_tgt/VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION.rst new file mode 100644 index 0000000..1ad7a71 --- /dev/null +++ b/Help/prop_tgt/VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION.rst @@ -0,0 +1,10 @@ +VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION +-------------------------------------- + +Visual Studio Windows Target Platform Minimum Version + +For Windows 10. Specifies the minimum version of the OS that is being +targeted. For example ``10.0.10240.0``. If the value is not specified, the +value of :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` will be used on +WindowsStore projects otherwise the target platform minimum version will not +be specified for the project. diff --git a/Help/release/3.4.rst b/Help/release/3.4.rst new file mode 100644 index 0000000..89c5561 --- /dev/null +++ b/Help/release/3.4.rst @@ -0,0 +1,273 @@ +CMake 3.4 Release Notes +*********************** + +.. only:: html + + .. contents:: + +Changes made since CMake 3.3 include the following. + +New Features +============ + +Generators +---------- + +* The :generator:`Visual Studio 14 2015` generator learned to select + a Windows 10 SDK based on the value of the :variable:`CMAKE_SYSTEM_VERSION` + variable and the SDKs available on the host. + +* CMake learned rudimentary support for the Apple Swift language. When using + the :generator:`Xcode` generator with Xcode 6.1 or higher, one may enable + the ``Swift`` language with the :command:`enable_language` command or the + :command:`project` command (this is an error with other generators or when + Xcode is too old). Then one may list ``.swift`` source files in targets + for compilation. + +Commands +-------- + +* The :command:`find_program` command learned a ``NAMES_PER_DIR`` + option to consider all given ``NAMES`` in each directory before + moving on to the next directory. + +* The :command:`get_filename_component` command learned a new ``BASE_DIR`` + subcommand. This is used to specify a base directory when calculating an + absolute path from a relative path. + +* The :command:`if` command learned a new ``TEST`` operator that evaluates + to true if a given test name has been defined by the :command:`add_test` + command. See policy :policy:`CMP0064`. + +* The :command:`install(DIRECTORY)` command ``DESTINATION`` option learned to + support :manual:`generator expressions <cmake-generator-expressions(7)>`. + +* The :command:`install(FILES)` command ``DESTINATION`` option learned to + support :manual:`generator expressions <cmake-generator-expressions(7)>`. + +* The :command:`string` command learned a new ``APPEND`` subcommand. + +Variables +--------- + +* The :ref:`Makefile Generators` and the :generator:`Ninja` generator + learned to add compiler launcher tools like distcc and ccache along + with the compiler for ``C`` and ``CXX`` languages. See the + :variable:`CMAKE_<LANG>_COMPILER_LAUNCHER` variable and + :prop_tgt:`<LANG>_COMPILER_LAUNCHER` target property for details. + +* New :variable:`CMAKE_LINK_SEARCH_START_STATIC` and + :variable:`CMAKE_LINK_SEARCH_END_STATIC` variables were + introduced to initialize the + :prop_tgt:`LINK_SEARCH_START_STATIC` and + :prop_tgt:`LINK_SEARCH_END_STATIC` target properties, + respectively. + +Properties +---------- + +* :ref:`Visual Studio Generators` learned to support additonal + target properties to customize projects for NVIDIA Nsight + Tegra Visual Studio Edition: + + * :prop_tgt:`ANDROID_ANT_ADDITIONAL_OPTIONS` + * :prop_tgt:`ANDROID_ARCH` + * :prop_tgt:`ANDROID_ASSETS_DIRECTORIES` + * :prop_tgt:`ANDROID_JAR_DEPENDENCIES` + * :prop_tgt:`ANDROID_JAR_DIRECTORIES` + * :prop_tgt:`ANDROID_JAVA_SOURCE_DIR` + * :prop_tgt:`ANDROID_NATIVE_LIB_DEPENDENCIES` + * :prop_tgt:`ANDROID_NATIVE_LIB_DIRECTORIES` + * :prop_tgt:`ANDROID_PROCESS_MAX` + * :prop_tgt:`ANDROID_PROGUARD` + * :prop_tgt:`ANDROID_PROGUARD_CONFIG_PATH` + * :prop_tgt:`ANDROID_SECURE_PROPS_PATH` + * :prop_tgt:`ANDROID_SKIP_ANT_STEP` + * :prop_tgt:`ANDROID_STL_TYPE` + +* The :prop_tgt:`ARCHIVE_OUTPUT_DIRECTORY`, + :prop_tgt:`LIBRARY_OUTPUT_DIRECTORY`, and + :prop_tgt:`RUNTIME_OUTPUT_DIRECTORY` target properties learned to + support :manual:`generator expressions <cmake-generator-expressions(7)>`. + +* The :prop_tgt:`SOURCE_DIR` and :prop_tgt:`BINARY_DIR` target properties + were introduced to allow project code to query where a target is defined. + +* The :prop_tgt:`OUTPUT_NAME` target property and its variants learned to + support :manual:`generator expressions <cmake-generator-expressions(7)>`. + +* A :prop_gbl:`TARGET_MESSAGES` global property was added to tell the + :ref:`Makefile Generators` whether to generate commands to print output + after each target is completed. + +* On Windows with MS-compatible tools, CMake learned to optionally + generate a module definition (``.def``) file for ``SHARED`` libraries. + See the :prop_tgt:`WINDOWS_EXPORT_ALL_SYMBOLS` target property. + +Modules +------- + +* The :module:`ExternalProject` module :command:`ExternalProject_Add` + function ``GIT_SUBMODULES`` option now also limits the set of + submodules that are initialized in addition to the prior behavior + of limiting the set of submodules that are updated. + +* The :module:`ExternalProject` module learned new ``USES_TERMINAL`` + arguments for giving steps exclusive terminal access. This is + useful with the :generator:`Ninja` generator to monitor CMake + superbuild progress and prevent CPU oversubscription. + +* The :module:`FindBISON` module ``BISON_TARGET`` macro learned a + new ``DEFINES_FILE`` option to specify a custom output header + to be generated. + +* The :module:`FindHDF5` module learend a new ``HDF5_PREFER_PARALLEL`` + option allowing users to specify that a parallel HDF5 tool is + preferred if both are available. + +* The :module:`FindIce` module now provides imported targets. + +* The :module:`FindJava` module learned to optionally find + the ``idlj`` and ``jarsigner`` tools. + +* The :module:`FindOpenSSL` module now provides imported targets. + +* The :module:`FindOpenSSL` module learned a new ``OPENSSL_USE_STATIC_LIBS`` + option to search only for static libraries. + +* The :module:`FindPkgConfig` learned a new :command:`pkg_get_variable` + command which may be used to query for arbitrary variables from a package + (such as for related tools or data and plugin install paths). + +* The :module:`FindProtobuf` module gained a new + :command:`protobuf_generate_python` function to generate python + sources from ``.proto`` files. + +* The :module:`FindTIFF` module learned to search separately for + debug and release variants. + +* The :module:`FindwxWidgets` module learned to support version requests. + +* The :module:`FindXercesC` module learned to search separately for + debug and release variants. + +* The :module:`FindZLIB` module learned to search separately for + debug and release variants. + +* The :module:`GNUInstallDirs` module learned special default values + for certain installation prefixes according to the `GNU Coding + Standards`_ and the `Filesystem Hierarchy Standard`_. + +* The :module:`UseJava` module ``add_jar`` function learned + to support response files (e.g. ``@srcs.txt``) for source + specification. + +* The :module:`UseJava` module ``install_jar`` function learned + new ``DESTINATION`` and ``COMPONENT`` options to specify + the corresponding :command:`install` command options. + +* The :module:`UseJava` module gained a new ``create_javah`` + function to create C headers from Java classes. + +.. _`GNU Coding Standards`: https://www.gnu.org/prep/standards/html_node/Directory-Variables.html +.. _`Filesystem Hierarchy Standard`: https://refspecs.linuxfoundation.org/FHS_3.0/fhs/index.html + +Generator Expressions +--------------------- + +* A new ``$<SHELL_PATH:...>`` + :manual:`generator expression <cmake-generator-expressions(7)>` + has been added. + +CTest +----- + +* CTest learned to optionally measure the CPU load during parallel + testing and avoid starting tests that may cause the load to exceed + a given threshold. See the :manual:`ctest(1)` command ``--test-load`` + option, the ``TestLoad`` setting of the :ref:`CTest Test Step`, + the :variable:`CTEST_TEST_LOAD` variable, and the ``TEST_LOAD`` + option of the :command:`ctest_test` command. + +* :manual:`ctest(1)` learned options + ``--test-output-size-passed`` and ``--test-output-size-failed`` + to customize the limit on test output size submitted when + running as a :ref:`Dashboard Client`. + +CPack +----- + +* The :module:`CPackDeb` module learned to set package dependencies + per component. See variables: + + * :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_BREAKS` + * :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_CONFLICTS` + * :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_ENHANCES` + * :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_PREDEPENDS` + * :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_PROVIDES` + * :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_RECOMMENDS` + * :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_REPLACES` + * :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_SUGGESTS` + +* The :module:`CPack` module learned to package empty directories. + +* The :module:`CPack` module gained a new setting, ``CPACK_VERBATIM_VARIABLES``, + which can be used to ensure the cpack program receives the settings' values + exactly as they were set, even if they contain CMake-special characters. + For compatibility, it's off by default. + +Other +----- + +* The :manual:`Compile Features <cmake-compile-features(7)>` functionality + is now aware of features supported by GNU C compilers on Windows. + +* CMake learned to honor ``*.manifest`` source files with MSVC tools. + Manifest files named as sources of ``.exe`` and ``.dll`` targets + will be merged with linker-generated manifests and embedded in the + binary. + +* The `Concurrent Fortran 77 <https://ccur.com>`__ compiler is now supported. + Its :variable:`compiler id <CMAKE_<LANG>_COMPILER_ID>` is ``CCur``. + +* :manual:`cmake(1)` gained a new ``--trace-expand`` command line option + that is like ``--trace`` but expands variable references in the output. + +Deprecated and Removed Features +=============================== + +* The :module:`CMakeExpandImportedTargets` module is now documented + as deprecated. See module documentation for an explanation. + +* The :variable:`CMAKE_USE_RELATIVE_PATHS` variable no longer has any + effect. Previously it was partially implemented and unreliable. + +Other Changes +============= + +* The :module:`CheckFunctionExists`, :module:`CheckLibraryExists`, + :module:`CheckSymbolExists`, and :module:`FindThreads` modules learned to + work in environments where only CXX is enabled. + +* The :module:`CPackDeb` module now correctly excludes symlinks during package + checksum calculation. + +* The :module:`CPackDeb` no longer uses fakeroot and system tar program for + packaging. + +* The :module:`CPack` module no longer mangles settings with CMake-special + characters when they're used as defaults for other settings. The macro + ``cpack_set_if_not_set``, which was responsible for this, is now deprecated. + +* CMake no longer links executables with flags to export symbols + unless the :prop_tgt:`ENABLE_EXPORTS` target property is set. + See policy :policy:`CMP0065`. + +* The ``SONAME`` field is no longer set for ``MODULE`` libraries + created with the :command:`add_library` command. ``MODULE`` + libraries are meant for explicit dynamic loading at runtime. + They cannot be linked so ``SONAME`` is not useful. + +* The internal :variable:`CMAKE_<LANG>_COMPILE_OBJECT` rule variable now + substitutes compiler include flags in a separate ``<INCLUDES>`` placeholder + instead of the main ``<FLAGS>`` placeholder. diff --git a/Help/release/dev/ConcurrentFortran-compiler-id.rst b/Help/release/dev/ConcurrentFortran-compiler-id.rst deleted file mode 100644 index 71e79aa..0000000 --- a/Help/release/dev/ConcurrentFortran-compiler-id.rst +++ /dev/null @@ -1,5 +0,0 @@ -ConcurrentFortran-compiler-id ------------------------------ - -* The `Concurrent Fortran 77 <https://ccur.com>`__ compiler is now supported. - Its :variable:`compiler id <CMAKE_<LANG>_COMPILER_ID>` is ``CCur``. diff --git a/Help/release/dev/ExternalProject-USES_TERMINAL.rst b/Help/release/dev/ExternalProject-USES_TERMINAL.rst deleted file mode 100644 index 415540d..0000000 --- a/Help/release/dev/ExternalProject-USES_TERMINAL.rst +++ /dev/null @@ -1,7 +0,0 @@ -ExternalProject-USES_TERMINAL ------------------------------ - -* The :module:`ExternalProject` module learned new ``USES_TERMINAL`` - arguments for giving steps exclusive terminal access. Especially - useful with the :generator:`Ninja` generator to monitor CMake - superbuild progress and prevent CPU oversubscription. diff --git a/Help/release/dev/ExternalProject_init_selected_submodules.rst b/Help/release/dev/ExternalProject_init_selected_submodules.rst deleted file mode 100644 index e642c19..0000000 --- a/Help/release/dev/ExternalProject_init_selected_submodules.rst +++ /dev/null @@ -1,7 +0,0 @@ -ExternalProject_init_selected_submodules ----------------------------------------- - -* The :module:`ExternalProject` module :command:`ExternalProject_Add` - function ``GIT_SUBMODULES`` option now also limits the set of - submodules that are initialized in addition to the prior behavior - of limiting the set of submodules that are updated. diff --git a/Help/release/dev/FindBISON-DEFINES_FILE.rst b/Help/release/dev/FindBISON-DEFINES_FILE.rst deleted file mode 100644 index 815d560..0000000 --- a/Help/release/dev/FindBISON-DEFINES_FILE.rst +++ /dev/null @@ -1,6 +0,0 @@ -FindBISON-DEFINES_FILE ----------------------- - -* The :module:`FindBISON` module ``BISON_TARGET`` macro learned a - new ``DEFINES_FILE`` option to specify a custom output header - to be generated. diff --git a/Help/release/dev/FindFLEX-DEFINES_FILE.rst b/Help/release/dev/FindFLEX-DEFINES_FILE.rst new file mode 100644 index 0000000..95133aa --- /dev/null +++ b/Help/release/dev/FindFLEX-DEFINES_FILE.rst @@ -0,0 +1,6 @@ +FindFLEX-DEFINES_FILE +--------------------- + +* The :module:`FindFLEX` module ``FLEX_TARGET`` macro learned a + new ``DEFINES_FILE`` option to specify a custom output header + to be generated. diff --git a/Help/release/dev/FindGTK2_sigc++_c++11.rst b/Help/release/dev/FindGTK2_sigc++_c++11.rst new file mode 100644 index 0000000..2ba1459 --- /dev/null +++ b/Help/release/dev/FindGTK2_sigc++_c++11.rst @@ -0,0 +1,7 @@ +FindGTK2_sigc++_c++11 +--------------------- + +* Starting with sigc++ 2.5.1, c++11 must be enabled in order to use + sigc++. The GTK2::sigc++ imported target will automatically enable the + required build flags in order to build with the version found on the + system. diff --git a/Help/release/dev/FindIce-imported-targets.rst b/Help/release/dev/FindIce-imported-targets.rst deleted file mode 100644 index 7e1b2f4..0000000 --- a/Help/release/dev/FindIce-imported-targets.rst +++ /dev/null @@ -1,4 +0,0 @@ -FindIce-imported-targets ------------------------- - -* The :module:`FindIce` module now provides imported targets. diff --git a/Help/release/dev/FindOpenSSL-msvc-static-rt.rst b/Help/release/dev/FindOpenSSL-msvc-static-rt.rst new file mode 100644 index 0000000..6e0ee27 --- /dev/null +++ b/Help/release/dev/FindOpenSSL-msvc-static-rt.rst @@ -0,0 +1,6 @@ +FindOpenSSL-msvc-static-rt +-------------------------- + +* The :module:`FindOpenSSL` module gained a new + ``OPENSSL_MSVC_STATIC_RT`` option to search for libraries using + the MSVC static runtime. diff --git a/Help/release/dev/FindTIFF-updates.rst b/Help/release/dev/FindTIFF-updates.rst deleted file mode 100644 index 083e40f..0000000 --- a/Help/release/dev/FindTIFF-updates.rst +++ /dev/null @@ -1,5 +0,0 @@ -FindTIFF-updates ----------------- - -* The :module:`FindTIFF` module learned to search separately for - debug and release variants. diff --git a/Help/release/dev/FindXercesC-updates.rst b/Help/release/dev/FindXercesC-updates.rst deleted file mode 100644 index 47a8ada..0000000 --- a/Help/release/dev/FindXercesC-updates.rst +++ /dev/null @@ -1,5 +0,0 @@ -FindXercesC-updates -------------------- - -* The :module:`FindXercesC` module learned to search separately for - debug and release variants. diff --git a/Help/release/dev/GNUInstallDirs-special-prefixes.rst b/Help/release/dev/GNUInstallDirs-special-prefixes.rst deleted file mode 100644 index 83c1352..0000000 --- a/Help/release/dev/GNUInstallDirs-special-prefixes.rst +++ /dev/null @@ -1,9 +0,0 @@ -GNUInstallDirs-special-prefixes -------------------------------- - -* The :module:`GNUInstallDirs` module learned special default values - for certain installation prefixes according to the `GNU Coding - Standards`_ and the `Filesystem Hierarchy Standard`_. - -.. _`GNU Coding Standards`: https://www.gnu.org/prep/standards/html_node/Directory-Variables.html -.. _`Filesystem Hierarchy Standard`: https://refspecs.linuxfoundation.org/FHS_3.0/fhs/index.html diff --git a/Help/release/dev/OUTPUT_DIRECTORY-genex.rst b/Help/release/dev/OUTPUT_DIRECTORY-genex.rst deleted file mode 100644 index 8b839c0..0000000 --- a/Help/release/dev/OUTPUT_DIRECTORY-genex.rst +++ /dev/null @@ -1,7 +0,0 @@ -OUTPUT_DIRECTORY-genex ----------------------- - -* The :prop_tgt:`ARCHIVE_OUTPUT_DIRECTORY`, - :prop_tgt:`LIBRARY_OUTPUT_DIRECTORY`, and - :prop_tgt:`RUNTIME_OUTPUT_DIRECTORY` target properties learned to - support :manual:`generator expressions <cmake-generator-expressions(7)>`. diff --git a/Help/release/dev/OUTPUT_NAME-genex.rst b/Help/release/dev/OUTPUT_NAME-genex.rst deleted file mode 100644 index 0a39820..0000000 --- a/Help/release/dev/OUTPUT_NAME-genex.rst +++ /dev/null @@ -1,5 +0,0 @@ -OUTPUT_NAME-genex ------------------ - -* The :prop_tgt:`OUTPUT_NAME` target property and its variants learned to - support :manual:`generator expressions <cmake-generator-expressions(7)>`. diff --git a/Help/release/dev/add-apple-swift-language.rst b/Help/release/dev/add-apple-swift-language.rst deleted file mode 100644 index 60ce5d8..0000000 --- a/Help/release/dev/add-apple-swift-language.rst +++ /dev/null @@ -1,9 +0,0 @@ -add-apple-swift-language ------------------------- - -* CMake learned rudimentary support for the Apple Swift language. When using - the :generator:`Xcode` generator with Xcode 6.1 or higher, one may enable - the ``Swift`` language with the :command:`enable_language` command or the - :command:`project` command (this is an error with other generators or when - Xcode is too old). Then one may list ``.swift`` source files in targets - for compilation. diff --git a/Help/release/dev/add-link-search-static-properties-defaults.rst b/Help/release/dev/add-link-search-static-properties-defaults.rst deleted file mode 100644 index 98dda30..0000000 --- a/Help/release/dev/add-link-search-static-properties-defaults.rst +++ /dev/null @@ -1,9 +0,0 @@ -add-link-search-static-properties-defaults ------------------------------------------- - -* New :variable:`CMAKE_LINK_SEARCH_START_STATIC` and - :variable:`CMAKE_LINK_SEARCH_END_STATIC` variables were - introduced to initialize the - :prop_tgt:`LINK_SEARCH_START_STATIC` and - :prop_tgt:`LINK_SEARCH_END_STATIC` target properties, - respectively. diff --git a/Help/release/dev/auto_export_dll_symbols.rst b/Help/release/dev/auto_export_dll_symbols.rst deleted file mode 100644 index 9db2b5e..0000000 --- a/Help/release/dev/auto_export_dll_symbols.rst +++ /dev/null @@ -1,6 +0,0 @@ -auto_export_dll_symbols ------------------------ - -* On Windows with MS-compatible tools, CMake learned to optionally - generate a module definition (``.def``) file for ``SHARED`` libraries. - See the :prop_tgt:`WINDOWS_EXPORT_ALL_SYMBOLS` target property. diff --git a/Help/release/dev/cmake-W-options.rst b/Help/release/dev/cmake-W-options.rst deleted file mode 100644 index c0b51d0..0000000 --- a/Help/release/dev/cmake-W-options.rst +++ /dev/null @@ -1,13 +0,0 @@ -cmake-W-options ---------------- - -* The :variable:`CMAKE_ERROR_DEPRECATED` variable can now be set using the - ``-Werror=deprecated`` and ``-Wno-error=deprecated`` :manual:`cmake(1)` - options. - -* The :variable:`CMAKE_WARN_DEPRECATED` variable can now be set using the - ``-Wdeprecated`` and ``-Wno-deprecated`` :manual:`cmake(1)` options. - -* :manual:`cmake(1)` gained options ``-Werror=dev`` and ``-Wno-error=dev`` - to control whether developer warnings intended for project authors - are treated as errors. diff --git a/Help/release/dev/compiler-launcher.rst b/Help/release/dev/compiler-launcher.rst deleted file mode 100644 index 3ba692d..0000000 --- a/Help/release/dev/compiler-launcher.rst +++ /dev/null @@ -1,8 +0,0 @@ -compiler-launcher ------------------ - -* The :ref:`Makefile Generators` and the :generator:`Ninja` generator - learned to add compiler launcher tools like distcc and ccache along with the - compiler for ``C`` and ``CXX`` languages. See the - :variable:`CMAKE_<LANG>_COMPILER_LAUNCHER` variable and - :prop_tgt:`<LANG>_COMPILER_LAUNCHER` target property for details. diff --git a/Help/release/dev/cpack-nsis-bitmap.rst b/Help/release/dev/cpack-nsis-bitmap.rst new file mode 100644 index 0000000..c5ccfb5 --- /dev/null +++ b/Help/release/dev/cpack-nsis-bitmap.rst @@ -0,0 +1,6 @@ +cpack-nsis-bitmap +----------------- + +* The :module:`CPackNSIS` module learned new variables to add bitmaps to the + installer. See the :variable:`CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP` + and :variable:`CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP` variables. diff --git a/Help/release/dev/ctest-test-load-option.rst b/Help/release/dev/ctest-test-load-option.rst deleted file mode 100644 index 069f49a..0000000 --- a/Help/release/dev/ctest-test-load-option.rst +++ /dev/null @@ -1,9 +0,0 @@ -ctest-test-load-option ----------------------- - -* CTest learned to optionally measure the CPU load during parallel - testing and avoid starting tests that may cause the load to exceed - a given threshold. See the :manual:`ctest(1)` command ``--test-load`` - option, the ``TestLoad`` setting of the :ref:`CTest Test Step`, - the :variable:`CTEST_TEST_LOAD` variable, and the ``TEST_LOAD`` - option of the :command:`ctest_test` command. diff --git a/Help/release/dev/deprecate-CMakeForceCompiler.rst b/Help/release/dev/deprecate-CMakeForceCompiler.rst new file mode 100644 index 0000000..dc6e817 --- /dev/null +++ b/Help/release/dev/deprecate-CMakeForceCompiler.rst @@ -0,0 +1,5 @@ +deprecate-CMakeForceCompiler +---------------------------- + +* The :module:`CMakeForceCompiler` module and its macros are now deprecated. + See module documentation for an explanation. diff --git a/Help/release/dev/doc-CMakeExpandImportedTargets-deprecated.rst b/Help/release/dev/doc-CMakeExpandImportedTargets-deprecated.rst deleted file mode 100644 index 3bdaebe..0000000 --- a/Help/release/dev/doc-CMakeExpandImportedTargets-deprecated.rst +++ /dev/null @@ -1,5 +0,0 @@ -doc-CMakeExpandImportedTargets-deprecated ------------------------------------------ - -* The :module:`CMakeExpandImportedTargets` module is now documented - as deprecated. See module documentation for an explanation. diff --git a/Help/release/dev/find_program-NAMES_PER_DIR.rst b/Help/release/dev/find_program-NAMES_PER_DIR.rst deleted file mode 100644 index 04cd170..0000000 --- a/Help/release/dev/find_program-NAMES_PER_DIR.rst +++ /dev/null @@ -1,6 +0,0 @@ -find_program-NAMES_PER_DIR --------------------------- - -* The :command:`find_program` command learned a ``NAMES_PER_DIR`` - option to consdier all given ``NAMES`` in each directory before - moving on to the next directory. diff --git a/Help/release/dev/get-filename-component-base-dir.rst b/Help/release/dev/get-filename-component-base-dir.rst deleted file mode 100644 index c0df759..0000000 --- a/Help/release/dev/get-filename-component-base-dir.rst +++ /dev/null @@ -1,6 +0,0 @@ -get-filename-component-base-dir -------------------------------- - -* The :command:`get_filename_component` command learned a new ``BASE_DIR`` - subcommand. This is used to specify a base directory when calculating an - absolute path from a relative path. diff --git a/Help/release/dev/if-TEST.rst b/Help/release/dev/if-TEST.rst deleted file mode 100644 index 05bf71c..0000000 --- a/Help/release/dev/if-TEST.rst +++ /dev/null @@ -1,5 +0,0 @@ -if-TEST -------- - -* Add a new TEST operator to if() that evaluates to true - if a given test name has been defined. diff --git a/Help/release/dev/java-updates.rst b/Help/release/dev/java-updates.rst deleted file mode 100644 index 8fd4ed6..0000000 --- a/Help/release/dev/java-updates.rst +++ /dev/null @@ -1,16 +0,0 @@ -java-updates ------------- - -* The :module:`FindJava` module learned to optionally find - the ``idlj`` and ``jarsigner`` tools. - -* The :module:`UseJava` module ``add_jar`` function learned - to support response files (e.g. ``@srcs.txt``) for source - specification. - -* The :module:`UseJava` module ``install_jar`` function learned - new ``DESTINATION`` and ``COMPONENT`` options to specify - the corresponding :command:`install` command options. - -* The :module:`UseJava` module gained a new ``create_javah`` - function to create C headers from Java classes. diff --git a/Help/release/dev/makefile-target-messages.rst b/Help/release/dev/makefile-target-messages.rst deleted file mode 100644 index 3d2cd9b..0000000 --- a/Help/release/dev/makefile-target-messages.rst +++ /dev/null @@ -1,6 +0,0 @@ -makefile-target-messages ------------------------- - -* A :prop_gbl:`TARGET_MESSAGES` global property was added to tell the - :ref:`Makefile Generators` whether to generate commands to print output - after each target is completed. diff --git a/Help/release/dev/modules-no-soname.rst b/Help/release/dev/modules-no-soname.rst deleted file mode 100644 index 8fe74f8..0000000 --- a/Help/release/dev/modules-no-soname.rst +++ /dev/null @@ -1,7 +0,0 @@ -modules-no-soname ------------------ - -* The ``SONAME`` field is no longer set for ``MODULE`` libraries - created with the :command:`add_library` command. ``MODULE`` - libraries are meant for explicit dynamic loading at runtime. - They cannot be linked so ``SONAME`` is not useful. diff --git a/Help/release/dev/remove-CMAKE_USE_RELATIVE_PATHS.rst b/Help/release/dev/remove-CMAKE_USE_RELATIVE_PATHS.rst deleted file mode 100644 index dd52ace..0000000 --- a/Help/release/dev/remove-CMAKE_USE_RELATIVE_PATHS.rst +++ /dev/null @@ -1,5 +0,0 @@ -remove-CMAKE_USE_RELATIVE_PATHS -------------------------------- - -* The :variable:`CMAKE_USE_RELATIVE_PATHS` variable no longer has any - effect. Previously it was partially implemented and unreliable. diff --git a/Help/release/dev/string-append.rst b/Help/release/dev/string-append.rst deleted file mode 100644 index 190b51e..0000000 --- a/Help/release/dev/string-append.rst +++ /dev/null @@ -1,4 +0,0 @@ -string-append -------------- - -* The :command:`string` command learned a new ``APPEND`` subcommand. diff --git a/Help/release/dev/target-directory-properties.rst b/Help/release/dev/target-directory-properties.rst deleted file mode 100644 index 5ab2938..0000000 --- a/Help/release/dev/target-directory-properties.rst +++ /dev/null @@ -1,5 +0,0 @@ -target-directory-properties ---------------------------- - -* The :prop_tgt:`SOURCE_DIR` and :prop_tgt:`BINARY_DIR` target properties - were introduced to allow project code to query where a target is defined. diff --git a/Help/release/dev/trace-expand.rst b/Help/release/dev/trace-expand.rst deleted file mode 100644 index 383326e..0000000 --- a/Help/release/dev/trace-expand.rst +++ /dev/null @@ -1,5 +0,0 @@ -trace-expand ------------- - -* Add ``--trace-expand`` argument to CMake. Acts like ``--trace``, but expands - variable references in the output. diff --git a/Help/release/dev/vs-nsight-tegra-attributes.rst b/Help/release/dev/vs-nsight-tegra-attributes.rst deleted file mode 100644 index 7ebea33..0000000 --- a/Help/release/dev/vs-nsight-tegra-attributes.rst +++ /dev/null @@ -1,21 +0,0 @@ -vs-nsight-tegra-attributes --------------------------- - -* :ref:`Visual Studio Generators` learned to support additonal - target properties to customize projects for NVIDIA Nsight - Tegra Visual Studio Edition: - - * :prop_tgt:`ANDROID_ANT_ADDITIONAL_OPTIONS` - * :prop_tgt:`ANDROID_ARCH` - * :prop_tgt:`ANDROID_ASSETS_DIRECTORIES` - * :prop_tgt:`ANDROID_JAR_DEPENDENCIES` - * :prop_tgt:`ANDROID_JAR_DIRECTORIES` - * :prop_tgt:`ANDROID_JAVA_SOURCE_DIR` - * :prop_tgt:`ANDROID_NATIVE_LIB_DEPENDENCIES` - * :prop_tgt:`ANDROID_NATIVE_LIB_DIRECTORIES` - * :prop_tgt:`ANDROID_PROCESS_MAX` - * :prop_tgt:`ANDROID_PROGUARD` - * :prop_tgt:`ANDROID_PROGUARD_CONFIG_PATH` - * :prop_tgt:`ANDROID_SECURE_PROPS_PATH` - * :prop_tgt:`ANDROID_SKIP_ANT_STEP` - * :prop_tgt:`ANDROID_STL_TYPE` diff --git a/Help/release/index.rst b/Help/release/index.rst index b558e9d..752acbd 100644 --- a/Help/release/index.rst +++ b/Help/release/index.rst @@ -13,6 +13,7 @@ Releases .. toctree:: :maxdepth: 1 + 3.4 <3.4> 3.3 <3.3> 3.2 <3.2> 3.1 <3.1> diff --git a/Help/variable/CMAKE_BINARY_DIR.rst b/Help/variable/CMAKE_BINARY_DIR.rst index f8dd8ab..3b323b7 100644 --- a/Help/variable/CMAKE_BINARY_DIR.rst +++ b/Help/variable/CMAKE_BINARY_DIR.rst @@ -6,3 +6,8 @@ The path to the top level of the build tree. This is the full path to the top level of the current CMake build tree. For an in-source build, this would be the same as :variable:`CMAKE_SOURCE_DIR`. + +When run in -P script mode, CMake sets the variables +:variable:`CMAKE_BINARY_DIR`, :variable:`CMAKE_SOURCE_DIR`, +:variable:`CMAKE_CURRENT_BINARY_DIR` and +:variable:`CMAKE_CURRENT_SOURCE_DIR` to the current working directory. diff --git a/Help/variable/CMAKE_CURRENT_BINARY_DIR.rst b/Help/variable/CMAKE_CURRENT_BINARY_DIR.rst index cc3b639..40496b5 100644 --- a/Help/variable/CMAKE_CURRENT_BINARY_DIR.rst +++ b/Help/variable/CMAKE_CURRENT_BINARY_DIR.rst @@ -8,3 +8,8 @@ processed by cmake. Each directory added by :command:`add_subdirectory` will create a binary directory in the build tree, and as it is being processed this variable will be set. For in-source builds this is the current source directory being processed. + +When run in -P script mode, CMake sets the variables +:variable:`CMAKE_BINARY_DIR`, :variable:`CMAKE_SOURCE_DIR`, +:variable:`CMAKE_CURRENT_BINARY_DIR` and +:variable:`CMAKE_CURRENT_SOURCE_DIR` to the current working directory. diff --git a/Help/variable/CMAKE_CURRENT_SOURCE_DIR.rst b/Help/variable/CMAKE_CURRENT_SOURCE_DIR.rst index db063a4..c1b755a 100644 --- a/Help/variable/CMAKE_CURRENT_SOURCE_DIR.rst +++ b/Help/variable/CMAKE_CURRENT_SOURCE_DIR.rst @@ -5,3 +5,8 @@ The path to the source directory currently being processed. This the full path to the source directory that is currently being processed by cmake. + +When run in -P script mode, CMake sets the variables +:variable:`CMAKE_BINARY_DIR`, :variable:`CMAKE_SOURCE_DIR`, +:variable:`CMAKE_CURRENT_BINARY_DIR` and +:variable:`CMAKE_CURRENT_SOURCE_DIR` to the current working directory. diff --git a/Help/variable/CMAKE_ENABLE_EXPORTS.rst b/Help/variable/CMAKE_ENABLE_EXPORTS.rst new file mode 100644 index 0000000..1f9ba6f --- /dev/null +++ b/Help/variable/CMAKE_ENABLE_EXPORTS.rst @@ -0,0 +1,22 @@ +CMAKE_ENABLE_EXPORTS +-------------------- + +Specify whether an executable exports symbols for loadable modules. + +Normally an executable does not export any symbols because it is the +final program. It is possible for an executable to export symbols to +be used by loadable modules. When this property is set to true CMake +will allow other targets to "link" to the executable with the +:command:`TARGET_LINK_LIBRARIES` command. On all platforms a target-level +dependency on the executable is created for targets that link to it. +For DLL platforms an import library will be created for the exported +symbols and then used for linking. All Windows-based systems +including Cygwin are DLL platforms. For non-DLL platforms that +require all symbols to be resolved at link time, such as Mac OS X, the +module will "link" to the executable using a flag like +"-bundle_loader". For other non-DLL platforms the link rule is simply +ignored since the dynamic loader will automatically bind symbols when +the module is loaded. + +This variable is used to initialize the target property +:prop_tgt:`ENABLE_EXPORTS` for executable targets. diff --git a/Help/variable/CMAKE_ERROR_DEPRECATED.rst b/Help/variable/CMAKE_ERROR_DEPRECATED.rst index 39dc4a8..277a4cc 100644 --- a/Help/variable/CMAKE_ERROR_DEPRECATED.rst +++ b/Help/variable/CMAKE_ERROR_DEPRECATED.rst @@ -6,7 +6,3 @@ Whether to issue deprecation errors for macros and functions. If ``TRUE``, this can be used by macros and functions to issue fatal errors when deprecated macros or functions are used. This variable is ``FALSE`` by default. - -These errors can be enabled with the ``-Werror=deprecated`` option, or -disabled with the ``-Wno-error=deprecated`` option, when running -:manual:`cmake(1)`. diff --git a/Help/variable/CMAKE_POLICY_WARNING_CMPNNNN.rst b/Help/variable/CMAKE_POLICY_WARNING_CMPNNNN.rst index 8de0d56..582f9e4 100644 --- a/Help/variable/CMAKE_POLICY_WARNING_CMPNNNN.rst +++ b/Help/variable/CMAKE_POLICY_WARNING_CMPNNNN.rst @@ -13,6 +13,8 @@ warn by default: policy :policy:`CMP0056`. * ``CMAKE_POLICY_WARNING_CMP0060`` controls the warning for policy :policy:`CMP0060`. +* ``CMAKE_POLICY_WARNING_CMP0065`` controls the warning for + policy :policy:`CMP0065`. This variable should not be set by a project in CMake code. Project developers running CMake may set this variable in their cache to diff --git a/Help/variable/CMAKE_SOURCE_DIR.rst b/Help/variable/CMAKE_SOURCE_DIR.rst index 3df0226..416fbe1 100644 --- a/Help/variable/CMAKE_SOURCE_DIR.rst +++ b/Help/variable/CMAKE_SOURCE_DIR.rst @@ -6,3 +6,8 @@ The path to the top level of the source tree. This is the full path to the top level of the current CMake source tree. For an in-source build, this would be the same as :variable:`CMAKE_BINARY_DIR`. + +When run in -P script mode, CMake sets the variables +:variable:`CMAKE_BINARY_DIR`, :variable:`CMAKE_SOURCE_DIR`, +:variable:`CMAKE_CURRENT_BINARY_DIR` and +:variable:`CMAKE_CURRENT_SOURCE_DIR` to the current working directory. diff --git a/Help/variable/CMAKE_SYSTEM_NAME.rst b/Help/variable/CMAKE_SYSTEM_NAME.rst index 0466da4..c3a42e5 100644 --- a/Help/variable/CMAKE_SYSTEM_NAME.rst +++ b/Help/variable/CMAKE_SYSTEM_NAME.rst @@ -1,8 +1,20 @@ CMAKE_SYSTEM_NAME ----------------- -Name of the operating system CMake is building for. +The name of the operating system for which CMake is to build. +See the :variable:`CMAKE_SYSTEM_VERSION` variable for the OS version. -This is the name of the operating system on which CMake is targeting. This -variable is the same as :variable:`CMAKE_HOST_SYSTEM_NAME` if you build for the -host system instead of the target system when cross compiling. +System Name for Host Builds +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``CMAKE_SYSTEM_NAME`` is by default set to the same value as the +:variable:`CMAKE_HOST_SYSTEM_NAME` variable so that the build +targets the host system. + +System Name for Cross Compiling +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``CMAKE_SYSTEM_NAME`` may be set explicitly when first configuring a new build +tree in order to enable :ref:`cross compiling <Cross Compiling Toolchain>`. +In this case the :variable:`CMAKE_SYSTEM_VERSION` variable must also be +set explicitly. diff --git a/Help/variable/CMAKE_SYSTEM_VERSION.rst b/Help/variable/CMAKE_SYSTEM_VERSION.rst index 3b3cdc5..aba8ca3 100644 --- a/Help/variable/CMAKE_SYSTEM_VERSION.rst +++ b/Help/variable/CMAKE_SYSTEM_VERSION.rst @@ -1,8 +1,28 @@ CMAKE_SYSTEM_VERSION -------------------- -The operating system version CMake is building for. +The version of the operating system for which CMake is to build. +See the :variable:`CMAKE_SYSTEM_NAME` variable for the OS name. -This variable is the same as :variable:`CMAKE_HOST_SYSTEM_VERSION` if -you build for the host system instead of the target system when -cross compiling. +System Version for Host Builds +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +When the :variable:`CMAKE_SYSTEM_NAME` variable takes its default value +then ``CMAKE_SYSTEM_VERSION`` is by default set to the same value as the +:variable:`CMAKE_HOST_SYSTEM_VERSION` variable so that the build targets +the host system version. + +In the case of a host build then ``CMAKE_SYSTEM_VERSION`` may be set +explicitly when first configuring a new build tree in order to enable +targeting the build for a different version of the host operating system +than is actually running on the host. This is allowed and not considered +cross compiling so long as the binaries built for the specified OS version +can still run on the host. + +System Version for Cross Compiling +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +When the :variable:`CMAKE_SYSTEM_NAME` variable is set explicitly to +enable :ref:`cross compiling <Cross Compiling Toolchain>` then the +value of ``CMAKE_SYSTEM_VERSION`` must also be set explicitly to specify +the target system version. diff --git a/Help/variable/CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION.rst b/Help/variable/CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION.rst new file mode 100644 index 0000000..6392849 --- /dev/null +++ b/Help/variable/CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION.rst @@ -0,0 +1,11 @@ +CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION +---------------------------------------- + +Visual Studio Windows Target Platform Version. + +When targeting Windows 10 and above Visual Studio 2015 and above support +specification of a target Windows version to select a corresponding SDK. +The :variable:`CMAKE_SYSTEM_VERSION` variable may be set to specify a +version. Otherwise CMake computes a default version based on the Windows +SDK versions available. The chosen Windows target version number is provided +in ``CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION``. diff --git a/Help/variable/CMAKE_WARN_DEPRECATED.rst b/Help/variable/CMAKE_WARN_DEPRECATED.rst index 7b8533c..662cbd8 100644 --- a/Help/variable/CMAKE_WARN_DEPRECATED.rst +++ b/Help/variable/CMAKE_WARN_DEPRECATED.rst @@ -5,7 +5,3 @@ Whether to issue deprecation warnings for macros and functions. If ``TRUE``, this can be used by macros and functions to issue deprecation warnings. This variable is ``FALSE`` by default. - -These warnings can be enabled with the ``-Wdeprecated`` option, or -disabled with the ``-Wno-deprecated`` option, when running -:manual:`cmake(1)`. diff --git a/Help/variable/CTEST_CUSTOM_COVERAGE_EXCLUDE.rst b/Help/variable/CTEST_CUSTOM_COVERAGE_EXCLUDE.rst new file mode 100644 index 0000000..d5893c9 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_COVERAGE_EXCLUDE.rst @@ -0,0 +1,7 @@ +CTEST_CUSTOM_COVERAGE_EXCLUDE +----------------------------- + +A list of regular expressions which will be used to exclude files by their +path from coverage output by the :command:`ctest_coverage` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_ERROR_EXCEPTION.rst b/Help/variable/CTEST_CUSTOM_ERROR_EXCEPTION.rst new file mode 100644 index 0000000..cd65ae3 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_ERROR_EXCEPTION.rst @@ -0,0 +1,7 @@ +CTEST_CUSTOM_ERROR_EXCEPTION +---------------------------- + +A list of regular expressions which will be used to exclude when detecting +error messages in build outputs by the :command:`ctest_test` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_ERROR_MATCH.rst b/Help/variable/CTEST_CUSTOM_ERROR_MATCH.rst new file mode 100644 index 0000000..558f5e5 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_ERROR_MATCH.rst @@ -0,0 +1,7 @@ +CTEST_CUSTOM_ERROR_MATCH +------------------------ + +A list of regular expressions which will be used to detect error messages in +build outputs by the :command:`ctest_test` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_ERROR_POST_CONTEXT.rst b/Help/variable/CTEST_CUSTOM_ERROR_POST_CONTEXT.rst new file mode 100644 index 0000000..614859b --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_ERROR_POST_CONTEXT.rst @@ -0,0 +1,7 @@ +CTEST_CUSTOM_ERROR_POST_CONTEXT +------------------------------- + +The number of lines to include as context which follow an error message by the +:command:`ctest_test` command. The default is 10. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_ERROR_PRE_CONTEXT.rst b/Help/variable/CTEST_CUSTOM_ERROR_PRE_CONTEXT.rst new file mode 100644 index 0000000..74dc47a --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_ERROR_PRE_CONTEXT.rst @@ -0,0 +1,7 @@ +CTEST_CUSTOM_ERROR_PRE_CONTEXT +------------------------------ + +The number of lines to include as context which precede an error message by +the :command:`ctest_test` command. The default is 10. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE.rst b/Help/variable/CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE.rst new file mode 100644 index 0000000..5aeae88 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE.rst @@ -0,0 +1,8 @@ +CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE +-------------------------------------------- + +When saving a failing test's output, this is the maximum size, in bytes, that +will be collected by the :command:`ctest_test` command. Defaults to 307200 +(300 KiB). + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS.rst b/Help/variable/CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS.rst new file mode 100644 index 0000000..920cb04 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS.rst @@ -0,0 +1,8 @@ +CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS +------------------------------------- + +The maximum number of errors in a single build step which will be detected. +After this, the :command:`ctest_test` command will truncate the output. +Defaults to 50. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS.rst b/Help/variable/CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS.rst new file mode 100644 index 0000000..a1f1cc1 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS.rst @@ -0,0 +1,8 @@ +CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS +--------------------------------------- + +The maximum number of warnings in a single build step which will be detected. +After this, the :command:`ctest_test` command will truncate the output. +Defaults to 50. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE.rst b/Help/variable/CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE.rst new file mode 100644 index 0000000..1fbb8c5 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE.rst @@ -0,0 +1,8 @@ +CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE +-------------------------------------------- + +When saving a passing test's output, this is the maximum size, in bytes, that +will be collected by the :command:`ctest_test` command. Defaults to 1024 +(1 KiB). + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_MEMCHECK_IGNORE.rst b/Help/variable/CTEST_CUSTOM_MEMCHECK_IGNORE.rst new file mode 100644 index 0000000..578576c --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_MEMCHECK_IGNORE.rst @@ -0,0 +1,7 @@ +CTEST_CUSTOM_MEMCHECK_IGNORE +---------------------------- + +A list of regular expressions to use to exclude tests during the +:command:`ctest_memcheck` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_POST_MEMCHECK.rst b/Help/variable/CTEST_CUSTOM_POST_MEMCHECK.rst new file mode 100644 index 0000000..40291fe --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_POST_MEMCHECK.rst @@ -0,0 +1,6 @@ +CTEST_CUSTOM_POST_MEMCHECK +-------------------------- + +A list of commands to run at the end of the :command:`ctest_memcheck` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_POST_TEST.rst b/Help/variable/CTEST_CUSTOM_POST_TEST.rst new file mode 100644 index 0000000..791292c --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_POST_TEST.rst @@ -0,0 +1,6 @@ +CTEST_CUSTOM_POST_TEST +---------------------- + +A list of commands to run at the end of the :command:`ctest_test` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_PRE_MEMCHECK.rst b/Help/variable/CTEST_CUSTOM_PRE_MEMCHECK.rst new file mode 100644 index 0000000..00de8aa --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_PRE_MEMCHECK.rst @@ -0,0 +1,7 @@ +CTEST_CUSTOM_PRE_MEMCHECK +------------------------- + +A list of commands to run at the start of the :command:`ctest_memcheck` +command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_PRE_TEST.rst b/Help/variable/CTEST_CUSTOM_PRE_TEST.rst new file mode 100644 index 0000000..6af7152 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_PRE_TEST.rst @@ -0,0 +1,6 @@ +CTEST_CUSTOM_PRE_TEST +---------------------- + +A list of commands to run at the start of the :command:`ctest_test` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_TEST_IGNORE.rst b/Help/variable/CTEST_CUSTOM_TEST_IGNORE.rst new file mode 100644 index 0000000..6114e60 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_TEST_IGNORE.rst @@ -0,0 +1,7 @@ +CTEST_CUSTOM_TEST_IGNORE +------------------------ + +A list of regular expressions to use to exclude tests during the +:command:`ctest_test` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_WARNING_EXCEPTION.rst b/Help/variable/CTEST_CUSTOM_WARNING_EXCEPTION.rst new file mode 100644 index 0000000..36fa37d --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_WARNING_EXCEPTION.rst @@ -0,0 +1,7 @@ +CTEST_CUSTOM_WARNING_EXCEPTION +------------------------------ + +A list of regular expressions which will be used to exclude when detecting +warning messages in build outputs by the :command:`ctest_test` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_WARNING_MATCH.rst b/Help/variable/CTEST_CUSTOM_WARNING_MATCH.rst new file mode 100644 index 0000000..a35be96 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_WARNING_MATCH.rst @@ -0,0 +1,7 @@ +CTEST_CUSTOM_WARNING_MATCH +-------------------------- + +A list of regular expressions which will be used to detect warning messages in +build outputs by the :command:`ctest_test` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Help/variable/CTEST_CUSTOM_XXX.txt b/Help/variable/CTEST_CUSTOM_XXX.txt new file mode 100644 index 0000000..02d1547 --- /dev/null +++ b/Help/variable/CTEST_CUSTOM_XXX.txt @@ -0,0 +1,2 @@ +It is initialized by :manual:`ctest(1)`, but may be edited in a ``CTestCustom`` +file. See :command:`ctest_read_custom_files` documentation. diff --git a/Help/variable/CTEST_EXTRA_COVERAGE_GLOB.rst b/Help/variable/CTEST_EXTRA_COVERAGE_GLOB.rst new file mode 100644 index 0000000..286f7df --- /dev/null +++ b/Help/variable/CTEST_EXTRA_COVERAGE_GLOB.rst @@ -0,0 +1,7 @@ +CTEST_EXTRA_COVERAGE_GLOB +------------------------- + +A list of regular expressions which will be used to find files which should be +covered by the :command:`ctest_coverage` command. + +.. include:: CTEST_CUSTOM_XXX.txt diff --git a/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in b/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in index b1c4fdf..bc78016 100644 --- a/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in +++ b/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in @@ -9,22 +9,22 @@ set(PACKAGE_VERSION "@CVF_VERSION@") -if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}" ) +if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) set(PACKAGE_VERSION_COMPATIBLE FALSE) else() set(PACKAGE_VERSION_COMPATIBLE TRUE) - if( "${PACKAGE_FIND_VERSION}" STREQUAL "${PACKAGE_VERSION}") + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) set(PACKAGE_VERSION_EXACT TRUE) endif() endif() # if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: -if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "@CMAKE_SIZEOF_VOID_P@" STREQUAL "") +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "@CMAKE_SIZEOF_VOID_P@" STREQUAL "") return() endif() # check that the installed version has the same 32/64bit-ness as the one which is currently searching: -if(NOT "${CMAKE_SIZEOF_VOID_P}" STREQUAL "@CMAKE_SIZEOF_VOID_P@") +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "@CMAKE_SIZEOF_VOID_P@") math(EXPR installedBits "@CMAKE_SIZEOF_VOID_P@ * 8") set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") set(PACKAGE_VERSION_UNSUITABLE TRUE) diff --git a/Modules/BasicConfigVersion-ExactVersion.cmake.in b/Modules/BasicConfigVersion-ExactVersion.cmake.in index 9fd0136..de4a23a 100644 --- a/Modules/BasicConfigVersion-ExactVersion.cmake.in +++ b/Modules/BasicConfigVersion-ExactVersion.cmake.in @@ -17,30 +17,30 @@ else() set(CVF_VERSION_NO_TWEAK "@CVF_VERSION@") endif() -if("${PACKAGE_FIND_VERSION}" MATCHES "^([0-9]+\\.[0-9]+\\.[0-9]+)\\.") # strip the tweak version +if(PACKAGE_FIND_VERSION MATCHES "^([0-9]+\\.[0-9]+\\.[0-9]+)\\.") # strip the tweak version set(REQUESTED_VERSION_NO_TWEAK "${CMAKE_MATCH_1}") else() set(REQUESTED_VERSION_NO_TWEAK "${PACKAGE_FIND_VERSION}") endif() -if("${REQUESTED_VERSION_NO_TWEAK}" STREQUAL "${CVF_VERSION_NO_TWEAK}") +if(REQUESTED_VERSION_NO_TWEAK STREQUAL CVF_VERSION_NO_TWEAK) set(PACKAGE_VERSION_COMPATIBLE TRUE) else() set(PACKAGE_VERSION_COMPATIBLE FALSE) endif() -if( "${PACKAGE_FIND_VERSION}" STREQUAL "${PACKAGE_VERSION}") +if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) set(PACKAGE_VERSION_EXACT TRUE) endif() # if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: -if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "@CMAKE_SIZEOF_VOID_P@" STREQUAL "") +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "@CMAKE_SIZEOF_VOID_P@" STREQUAL "") return() endif() # check that the installed version has the same 32/64bit-ness as the one which is currently searching: -if(NOT "${CMAKE_SIZEOF_VOID_P}" STREQUAL "@CMAKE_SIZEOF_VOID_P@") +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "@CMAKE_SIZEOF_VOID_P@") math(EXPR installedBits "@CMAKE_SIZEOF_VOID_P@ * 8") set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") set(PACKAGE_VERSION_UNSUITABLE TRUE) diff --git a/Modules/BasicConfigVersion-SameMajorVersion.cmake.in b/Modules/BasicConfigVersion-SameMajorVersion.cmake.in index 4acd9bb..a32245d 100644 --- a/Modules/BasicConfigVersion-SameMajorVersion.cmake.in +++ b/Modules/BasicConfigVersion-SameMajorVersion.cmake.in @@ -11,7 +11,7 @@ set(PACKAGE_VERSION "@CVF_VERSION@") -if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}" ) +if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) set(PACKAGE_VERSION_COMPATIBLE FALSE) else() @@ -21,25 +21,25 @@ else() set(CVF_VERSION_MAJOR "@CVF_VERSION@") endif() - if("${PACKAGE_FIND_VERSION_MAJOR}" STREQUAL "${CVF_VERSION_MAJOR}") + if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) set(PACKAGE_VERSION_COMPATIBLE TRUE) else() set(PACKAGE_VERSION_COMPATIBLE FALSE) endif() - if( "${PACKAGE_FIND_VERSION}" STREQUAL "${PACKAGE_VERSION}") + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) set(PACKAGE_VERSION_EXACT TRUE) endif() endif() # if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: -if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "@CMAKE_SIZEOF_VOID_P@" STREQUAL "") +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "@CMAKE_SIZEOF_VOID_P@" STREQUAL "") return() endif() # check that the installed version has the same 32/64bit-ness as the one which is currently searching: -if(NOT "${CMAKE_SIZEOF_VOID_P}" STREQUAL "@CMAKE_SIZEOF_VOID_P@") +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "@CMAKE_SIZEOF_VOID_P@") math(EXPR installedBits "@CMAKE_SIZEOF_VOID_P@ * 8") set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") set(PACKAGE_VERSION_UNSUITABLE TRUE) diff --git a/Modules/CMakeCCompiler.cmake.in b/Modules/CMakeCCompiler.cmake.in index 86cd894..a1bfc70 100644 --- a/Modules/CMakeCCompiler.cmake.in +++ b/Modules/CMakeCCompiler.cmake.in @@ -2,6 +2,8 @@ set(CMAKE_C_COMPILER "@CMAKE_C_COMPILER@") set(CMAKE_C_COMPILER_ARG1 "@CMAKE_C_COMPILER_ARG1@") set(CMAKE_C_COMPILER_ID "@CMAKE_C_COMPILER_ID@") set(CMAKE_C_COMPILER_VERSION "@CMAKE_C_COMPILER_VERSION@") +set(CMAKE_C_COMPILER_LINKS_STATICALLY "@CMAKE_C_COMPILER_LINKS_STATICALLY@") +set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "@CMAKE_C_STANDARD_COMPUTED_DEFAULT@") set(CMAKE_C_COMPILE_FEATURES "@CMAKE_C_COMPILE_FEATURES@") set(CMAKE_C90_COMPILE_FEATURES "@CMAKE_C90_COMPILE_FEATURES@") set(CMAKE_C99_COMPILE_FEATURES "@CMAKE_C99_COMPILE_FEATURES@") @@ -52,12 +54,14 @@ if(CMAKE_C_LIBRARY_ARCHITECTURE) set(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_C_LIBRARY_ARCHITECTURE@") endif() +set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "@CMAKE_C_CL_SHOWINCLUDES_PREFIX@") +if(CMAKE_C_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}") +endif() + @CMAKE_C_SYSROOT_FLAG_CODE@ @CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG_CODE@ set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "@CMAKE_C_IMPLICIT_LINK_LIBRARIES@") set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "@CMAKE_C_IMPLICIT_LINK_DIRECTORIES@") set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "@CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES@") - -@SET_CMAKE_CMCLDEPS_EXECUTABLE@ -@SET_CMAKE_CL_SHOWINCLUDES_PREFIX@ diff --git a/Modules/CMakeCCompilerId.c.in b/Modules/CMakeCCompilerId.c.in index 09ae509..b224007 100644 --- a/Modules/CMakeCCompilerId.c.in +++ b/Modules/CMakeCCompilerId.c.in @@ -24,6 +24,17 @@ char const* qnxnto = "INFO" ":" "qnxnto[]"; @CMAKE_C_COMPILER_ID_PLATFORM_CONTENT@ @CMAKE_C_COMPILER_ID_ERROR_FOR_TEST@ +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if !defined(__STDC_VERSION__) + "90" +#elif __STDC_VERSION__ >= 201000L + "11" +#elif __STDC_VERSION__ >= 199901L + "99" +#else +#endif +"]"; + /*--------------------------------------------------------------------------*/ #ifdef ID_VOID_MAIN diff --git a/Modules/CMakeCInformation.cmake b/Modules/CMakeCInformation.cmake index 7bcbb19..0d102a1 100644 --- a/Modules/CMakeCInformation.cmake +++ b/Modules/CMakeCInformation.cmake @@ -75,6 +75,10 @@ if(CMAKE_C_SIZEOF_DATA_PTR) unset(CMAKE_C_ABI_FILES) endif() +if(CMAKE_C_COMPILER_LINKS_STATICALLY) + set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS FALSE) +endif() + # This should be included before the _INIT variables are # used to initialize the cache. Since the rule variables # have if blocks on them, users can still define them here. @@ -175,7 +179,7 @@ endif() # Create a static archive incrementally for large object file counts. # If CMAKE_C_CREATE_STATIC_LIBRARY is set it will override these. if(NOT DEFINED CMAKE_C_ARCHIVE_CREATE) - set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> cq <TARGET> <LINK_FLAGS> <OBJECTS>") + set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> qc <TARGET> <LINK_FLAGS> <OBJECTS>") endif() if(NOT DEFINED CMAKE_C_ARCHIVE_APPEND) set(CMAKE_C_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>") diff --git a/Modules/CMakeCXXCompiler.cmake.in b/Modules/CMakeCXXCompiler.cmake.in index af79a31..4218a6d 100644 --- a/Modules/CMakeCXXCompiler.cmake.in +++ b/Modules/CMakeCXXCompiler.cmake.in @@ -2,6 +2,8 @@ set(CMAKE_CXX_COMPILER "@CMAKE_CXX_COMPILER@") set(CMAKE_CXX_COMPILER_ARG1 "@CMAKE_CXX_COMPILER_ARG1@") set(CMAKE_CXX_COMPILER_ID "@CMAKE_CXX_COMPILER_ID@") set(CMAKE_CXX_COMPILER_VERSION "@CMAKE_CXX_COMPILER_VERSION@") +set(CMAKE_CXX_COMPILER_LINKS_STATICALLY "@CMAKE_CXX_COMPILER_LINKS_STATICALLY@") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "@CMAKE_CXX_STANDARD_COMPUTED_DEFAULT@") set(CMAKE_CXX_COMPILE_FEATURES "@CMAKE_CXX_COMPILE_FEATURES@") set(CMAKE_CXX98_COMPILE_FEATURES "@CMAKE_CXX98_COMPILE_FEATURES@") set(CMAKE_CXX11_COMPILE_FEATURES "@CMAKE_CXX11_COMPILE_FEATURES@") @@ -53,12 +55,14 @@ if(CMAKE_CXX_LIBRARY_ARCHITECTURE) set(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_CXX_LIBRARY_ARCHITECTURE@") endif() +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "@CMAKE_CXX_CL_SHOWINCLUDES_PREFIX@") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + @CMAKE_CXX_SYSROOT_FLAG_CODE@ @CMAKE_CXX_OSX_DEPLOYMENT_TARGET_FLAG_CODE@ set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "@CMAKE_CXX_IMPLICIT_LINK_LIBRARIES@") set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "@CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES@") set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "@CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES@") - -@SET_CMAKE_CMCLDEPS_EXECUTABLE@ -@SET_CMAKE_CL_SHOWINCLUDES_PREFIX@ diff --git a/Modules/CMakeCXXCompilerId.cpp.in b/Modules/CMakeCXXCompilerId.cpp.in index cc3ab49..d467507 100644 --- a/Modules/CMakeCXXCompilerId.cpp.in +++ b/Modules/CMakeCXXCompilerId.cpp.in @@ -23,6 +23,16 @@ char const* qnxnto = "INFO" ":" "qnxnto[]"; @CMAKE_CXX_COMPILER_ID_PLATFORM_CONTENT@ @CMAKE_CXX_COMPILER_ID_ERROR_FOR_TEST@ +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if __cplusplus >= 201402L + "14" +#elif __cplusplus >= 201103L + "11" +#else + "98" +#endif +"]"; + /*--------------------------------------------------------------------------*/ int main(int argc, char* argv[]) diff --git a/Modules/CMakeCXXInformation.cmake b/Modules/CMakeCXXInformation.cmake index 1aac9d3..dad7969 100644 --- a/Modules/CMakeCXXInformation.cmake +++ b/Modules/CMakeCXXInformation.cmake @@ -74,6 +74,10 @@ if(CMAKE_CXX_SIZEOF_DATA_PTR) unset(CMAKE_CXX_ABI_FILES) endif() +if(CMAKE_CXX_COMPILER_LINKS_STATICALLY) + set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS FALSE) +endif() + # This should be included before the _INIT variables are # used to initialize the cache. Since the rule variables # have if blocks on them, users can still define them here. @@ -266,7 +270,7 @@ endif() # Create a static archive incrementally for large object file counts. # If CMAKE_CXX_CREATE_STATIC_LIBRARY is set it will override these. if(NOT DEFINED CMAKE_CXX_ARCHIVE_CREATE) - set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> cq <TARGET> <LINK_FLAGS> <OBJECTS>") + set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> qc <TARGET> <LINK_FLAGS> <OBJECTS>") endif() if(NOT DEFINED CMAKE_CXX_ARCHIVE_APPEND) set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>") diff --git a/Modules/CMakeClDeps.cmake b/Modules/CMakeClDeps.cmake deleted file mode 100644 index b46e7c2..0000000 --- a/Modules/CMakeClDeps.cmake +++ /dev/null @@ -1,34 +0,0 @@ - -#============================================================================= -# Copyright 2012 Kitware, Inc. -# -# Distributed under the OSI-approved BSD License (the "License"); -# see accompanying file Copyright.txt for details. -# -# This software is distributed WITHOUT ANY WARRANTY; without even the -# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the License for more information. -#============================================================================= -# (To distribute this file outside of CMake, substitute the full -# License text for the above reference.) - -# -# When using Ninja cl.exe is wrapped by cmcldeps to extract the included -# headers for dependency tracking. -# -# cmcldeps path is set, and cmcldeps needs to know the localized string -# in front of each include path, so it can remove it. -# - -if(CMAKE_GENERATOR MATCHES "Ninja" AND CMAKE_C_COMPILER AND CMAKE_COMMAND) - string(REPLACE "cmake.exe" "cmcldeps.exe" CMAKE_CMCLDEPS_EXECUTABLE ${CMAKE_COMMAND}) - set(showdir ${CMAKE_BINARY_DIR}/CMakeFiles/ShowIncludes) - file(WRITE ${showdir}/foo.h "\n") - file(WRITE ${showdir}/main.c "#include \"foo.h\" \nint main(){}\n") - execute_process(COMMAND ${CMAKE_C_COMPILER} /nologo /showIncludes ${showdir}/main.c - WORKING_DIRECTORY ${showdir} OUTPUT_VARIABLE outLine) - string(REGEX MATCH "\n([^:]*:[^:]*:[ \t]*)" tmp "${outLine}") - set(localizedPrefix "${CMAKE_MATCH_1}") - set(SET_CMAKE_CMCLDEPS_EXECUTABLE "set(CMAKE_CMCLDEPS_EXECUTABLE \"${CMAKE_CMCLDEPS_EXECUTABLE}\")") - set(SET_CMAKE_CL_SHOWINCLUDES_PREFIX "set(CMAKE_CL_SHOWINCLUDES_PREFIX \"${localizedPrefix}\")") -endif() diff --git a/Modules/CMakeDetermineCCompiler.cmake b/Modules/CMakeDetermineCCompiler.cmake index 9bd1d67..e0b5468 100644 --- a/Modules/CMakeDetermineCCompiler.cmake +++ b/Modules/CMakeDetermineCCompiler.cmake @@ -101,7 +101,7 @@ if(NOT CMAKE_C_COMPILER_ID_RUN) CMAKE_C_COMPILER_ID_PLATFORM_CONTENT) # The IAR compiler produces weird output. - # See http://www.cmake.org/Bug/view.php?id=10176#c19598 + # See https://cmake.org/Bug/view.php?id=10176#c19598 list(APPEND CMAKE_C_COMPILER_ID_VENDORS IAR) set(CMAKE_C_COMPILER_ID_VENDOR_FLAGS_IAR ) set(CMAKE_C_COMPILER_ID_VENDOR_REGEX_IAR "IAR .+ Compiler") @@ -173,7 +173,6 @@ endif () include(CMakeFindBinUtils) if(MSVC_C_ARCHITECTURE_ID) - include(${CMAKE_ROOT}/Modules/CMakeClDeps.cmake) set(SET_MSVC_C_ARCHITECTURE_ID "set(MSVC_C_ARCHITECTURE_ID ${MSVC_C_ARCHITECTURE_ID})") endif() diff --git a/Modules/CMakeDetermineCXXCompiler.cmake b/Modules/CMakeDetermineCXXCompiler.cmake index f25a2db..3c9bbc2 100644 --- a/Modules/CMakeDetermineCXXCompiler.cmake +++ b/Modules/CMakeDetermineCXXCompiler.cmake @@ -96,7 +96,7 @@ if(NOT CMAKE_CXX_COMPILER_ID_RUN) CMAKE_CXX_COMPILER_ID_PLATFORM_CONTENT) # The IAR compiler produces weird output. - # See http://www.cmake.org/Bug/view.php?id=10176#c19598 + # See https://cmake.org/Bug/view.php?id=10176#c19598 list(APPEND CMAKE_CXX_COMPILER_ID_VENDORS IAR) set(CMAKE_CXX_COMPILER_ID_VENDOR_FLAGS_IAR ) set(CMAKE_CXX_COMPILER_ID_VENDOR_REGEX_IAR "IAR .+ Compiler") @@ -171,7 +171,6 @@ endif () include(CMakeFindBinUtils) if(MSVC_CXX_ARCHITECTURE_ID) - include(${CMAKE_ROOT}/Modules/CMakeClDeps.cmake) set(SET_MSVC_CXX_ARCHITECTURE_ID "set(MSVC_CXX_ARCHITECTURE_ID ${MSVC_CXX_ARCHITECTURE_ID})") endif() diff --git a/Modules/CMakeDetermineCompilerId.cmake b/Modules/CMakeDetermineCompilerId.cmake index c699315..2e74100 100644 --- a/Modules/CMakeDetermineCompilerId.cmake +++ b/Modules/CMakeDetermineCompilerId.cmake @@ -75,6 +75,12 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src) set(CMAKE_EXECUTABLE_FORMAT "Unknown" CACHE INTERNAL "Executable file format") endif() + if(CMAKE_GENERATOR STREQUAL "Ninja" AND MSVC_${lang}_ARCHITECTURE_ID) + CMAKE_DETERMINE_MSVC_SHOWINCLUDES_PREFIX(${lang}) + else() + set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "") + endif() + # Display the final identification result. if(CMAKE_${lang}_COMPILER_ID) if(CMAKE_${lang}_COMPILER_VERSION) @@ -99,9 +105,12 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src) set(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE) set(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}" PARENT_SCOPE) + set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "${CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX}" PARENT_SCOPE) + set(CMAKE_${lang}_COMPILER_LINKS_STATICALLY "${CMAKE_${lang}_COMPILER_LINKS_STATICALLY}" PARENT_SCOPE) set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_${lang}_COMPILER_VERSION}" PARENT_SCOPE) set(CMAKE_${lang}_SIMULATE_ID "${CMAKE_${lang}_SIMULATE_ID}" PARENT_SCOPE) set(CMAKE_${lang}_SIMULATE_VERSION "${CMAKE_${lang}_SIMULATE_VERSION}" PARENT_SCOPE) + set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT}" PARENT_SCOPE) endfunction() include(CMakeCompilerIdDetection) @@ -201,6 +210,9 @@ Id flags: ${testflags} else() set(id_system_version "") endif() + if(CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION) + set(id_WindowsTargetPlatformVersion "<WindowsTargetPlatformVersion>${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}</WindowsTargetPlatformVersion>") + endif() if(id_platform STREQUAL ARM) set(id_WindowsSDKDesktopARMSupport "<WindowsSDKDesktopARMSupport>true</WindowsSDKDesktopARMSupport>") else() @@ -313,29 +325,17 @@ Id flags: ${testflags} endif() endif() else() - if(COMMAND EXECUTE_PROCESS) - execute_process( - COMMAND "${CMAKE_${lang}_COMPILER}" - ${CMAKE_${lang}_COMPILER_ID_ARG1} - ${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST} - ${testflags} - "${src}" - WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR} - OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT - ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT - RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT - ) - else() - exec_program( - "${CMAKE_${lang}_COMPILER}" ${CMAKE_${lang}_COMPILER_ID_DIR} - ARGS ${CMAKE_${lang}_COMPILER_ID_ARG1} - ${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST} - ${testflags} - \"${src}\" - OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT - RETURN_VALUE CMAKE_${lang}_COMPILER_ID_RESULT - ) - endif() + execute_process( + COMMAND "${CMAKE_${lang}_COMPILER}" + ${CMAKE_${lang}_COMPILER_ID_ARG1} + ${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST} + ${testflags} + "${src}" + WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR} + OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT + ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT + RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT + ) endif() # Check the result of compilation. @@ -487,6 +487,9 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file) if("${info}" MATCHES "INFO:qnxnto\\[\\]") set(COMPILER_QNXNTO 1) endif() + if("${info}" MATCHES "INFO:dialect_default\\[([^]\"]*)\\]") + set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_MATCH_1}") + endif() endforeach() # Construct compiler version from components if needed. @@ -530,6 +533,13 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file) endif() endif() + if(UNIX) + execute_process(COMMAND file "${file}" OUTPUT_VARIABLE out ERROR_VARIABLE out) + if(out MATCHES "statically linked") + set(CMAKE_${lang}_COMPILER_LINKS_STATICALLY 1 PARENT_SCOPE) + endif() + endif() + # Check if a valid compiler and platform were found. if(COMPILER_ID AND NOT COMPILER_ID_TWICE) set(CMAKE_${lang}_COMPILER_ID "${COMPILER_ID}") @@ -590,6 +600,7 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file) set(CMAKE_${lang}_SIMULATE_VERSION "${CMAKE_${lang}_SIMULATE_VERSION}" PARENT_SCOPE) set(CMAKE_EXECUTABLE_FORMAT "${CMAKE_EXECUTABLE_FORMAT}" PARENT_SCOPE) set(COMPILER_QNXNTO "${COMPILER_QNXNTO}" PARENT_SCOPE) + set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT}" PARENT_SCOPE) endfunction() #----------------------------------------------------------------------------- @@ -645,3 +656,27 @@ function(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang) endif() endforeach() endfunction() + +function(CMAKE_DETERMINE_MSVC_SHOWINCLUDES_PREFIX lang) + # Run this MSVC-compatible compiler to detect what the /showIncludes + # option displays. We can use a C source even with the C++ compiler + # because MSVC-compatible compilers handle both and show the same output. + set(showdir ${CMAKE_BINARY_DIR}/CMakeFiles/ShowIncludes) + file(WRITE ${showdir}/foo.h "\n") + file(WRITE ${showdir}/main.c "#include \"foo.h\" \nint main(){}\n") + execute_process( + COMMAND "${CMAKE_${lang}_COMPILER}" + ${CMAKE_${lang}_COMPILER_ID_ARG1} + ${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST} + /nologo /showIncludes /c main.c + WORKING_DIRECTORY ${showdir} + OUTPUT_VARIABLE out + ERROR_VARIABLE err + RESULT_VARIABLE res + ) + if(res EQUAL 0 AND "${out}" MATCHES "\n([^:]*:[^:]*:[ \t]*)") + set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "${CMAKE_MATCH_1}" PARENT_SCOPE) + else() + set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "" PARENT_SCOPE) + endif() +endfunction() diff --git a/Modules/CMakeDetermineSystem.cmake b/Modules/CMakeDetermineSystem.cmake index fa14641..d9f7579 100644 --- a/Modules/CMakeDetermineSystem.cmake +++ b/Modules/CMakeDetermineSystem.cmake @@ -123,7 +123,9 @@ elseif(CMAKE_VS_WINCE_VERSION) set(PRESET_CMAKE_SYSTEM_NAME TRUE) else() set(CMAKE_SYSTEM_NAME "${CMAKE_HOST_SYSTEM_NAME}") - set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}") + if(NOT DEFINED CMAKE_SYSTEM_VERSION) + set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}") + endif() set(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}") set(CMAKE_CROSSCOMPILING FALSE) set(PRESET_CMAKE_SYSTEM_NAME FALSE) diff --git a/Modules/CMakeForceCompiler.cmake b/Modules/CMakeForceCompiler.cmake index 1d8b110..343ab3f 100644 --- a/Modules/CMakeForceCompiler.cmake +++ b/Modules/CMakeForceCompiler.cmake @@ -2,11 +2,17 @@ # CMakeForceCompiler # ------------------ # +# Deprecated. Do not use. # +# The macros provided by this module were once intended for use by +# cross-compiling toolchain files when CMake was not able to automatically +# detect the compiler identification. Since the introduction of this module, +# CMake's compiler identification capabilities have improved and can now be +# taught to recognize any compiler. Furthermore, the suite of information +# CMake detects from a compiler is now too extensive to be provided by +# toolchain files using these macros. # -# This module defines macros intended for use by cross-compiling -# toolchain files when CMake is not able to automatically detect the -# compiler identification. +# ------------------------------------------------------------------------- # # Macro CMAKE_FORCE_C_COMPILER has the following signature: # @@ -64,6 +70,8 @@ # License text for the above reference.) macro(CMAKE_FORCE_C_COMPILER compiler id) + message(DEPRECATION "The CMAKE_FORCE_C_COMPILER macro is deprecated. " + "Instead just set CMAKE_C_COMPILER and allow CMake to identify the compiler.") set(CMAKE_C_COMPILER "${compiler}") set(CMAKE_C_COMPILER_ID_RUN TRUE) set(CMAKE_C_COMPILER_ID ${id}) @@ -76,6 +84,8 @@ macro(CMAKE_FORCE_C_COMPILER compiler id) endmacro() macro(CMAKE_FORCE_CXX_COMPILER compiler id) + message(DEPRECATION "The CMAKE_FORCE_CXX_COMPILER macro is deprecated. " + "Instead just set CMAKE_CXX_COMPILER and allow CMake to identify the compiler.") set(CMAKE_CXX_COMPILER "${compiler}") set(CMAKE_CXX_COMPILER_ID_RUN TRUE) set(CMAKE_CXX_COMPILER_ID ${id}) @@ -88,6 +98,8 @@ macro(CMAKE_FORCE_CXX_COMPILER compiler id) endmacro() macro(CMAKE_FORCE_Fortran_COMPILER compiler id) + message(DEPRECATION "The CMAKE_FORCE_Fortran_COMPILER macro is deprecated. " + "Instead just set CMAKE_Fortran_COMPILER and allow CMake to identify the compiler.") set(CMAKE_Fortran_COMPILER "${compiler}") set(CMAKE_Fortran_COMPILER_ID_RUN TRUE) set(CMAKE_Fortran_COMPILER_ID ${id}) diff --git a/Modules/CMakeFortranCompiler.cmake.in b/Modules/CMakeFortranCompiler.cmake.in index 14fdd60..6b984e5 100644 --- a/Modules/CMakeFortranCompiler.cmake.in +++ b/Modules/CMakeFortranCompiler.cmake.in @@ -2,6 +2,7 @@ set(CMAKE_Fortran_COMPILER "@CMAKE_Fortran_COMPILER@") set(CMAKE_Fortran_COMPILER_ARG1 "@CMAKE_Fortran_COMPILER_ARG1@") set(CMAKE_Fortran_COMPILER_ID "@CMAKE_Fortran_COMPILER_ID@") set(CMAKE_Fortran_COMPILER_VERSION "@CMAKE_Fortran_COMPILER_VERSION@") +set(CMAKE_Fortran_COMPILER_LINKS_STATICALLY "@CMAKE_Fortran_COMPILER_LINKS_STATICALLY@") set(CMAKE_Fortran_PLATFORM_ID "@CMAKE_Fortran_PLATFORM_ID@") set(CMAKE_Fortran_SIMULATE_ID "@CMAKE_Fortran_SIMULATE_ID@") set(CMAKE_Fortran_SIMULATE_VERSION "@CMAKE_Fortran_SIMULATE_VERSION@") diff --git a/Modules/CMakeFortranCompilerId.F.in b/Modules/CMakeFortranCompilerId.F.in index 2533d3f..017af91 100644 --- a/Modules/CMakeFortranCompilerId.F.in +++ b/Modules/CMakeFortranCompilerId.F.in @@ -17,7 +17,9 @@ # if defined(_MSC_VER) PRINT *, 'INFO:simulate[MSVC]' -# if _MSC_VER >= 1800 +# if _MSC_VER >= 1900 + PRINT *, 'INFO:simulate_version[019.00]' +# elif _MSC_VER >= 1800 PRINT *, 'INFO:simulate_version[018.00]' # elif _MSC_VER >= 1700 PRINT *, 'INFO:simulate_version[017.00]' diff --git a/Modules/CMakeFortranInformation.cmake b/Modules/CMakeFortranInformation.cmake index 835ffcf..aa48df7 100644 --- a/Modules/CMakeFortranInformation.cmake +++ b/Modules/CMakeFortranInformation.cmake @@ -51,6 +51,10 @@ if(CMAKE_Fortran_SIZEOF_DATA_PTR) unset(CMAKE_Fortran_ABI_FILES) endif() +if(CMAKE_Fortran_COMPILER_LINKS_STATICALLY) + set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS FALSE) +endif() + # This should be included before the _INIT variables are # used to initialize the cache. Since the rule variables # have if blocks on them, users can still define them here. @@ -194,7 +198,7 @@ endif() # Create a static archive incrementally for large object file counts. # If CMAKE_Fortran_CREATE_STATIC_LIBRARY is set it will override these. if(NOT DEFINED CMAKE_Fortran_ARCHIVE_CREATE) - set(CMAKE_Fortran_ARCHIVE_CREATE "<CMAKE_AR> cq <TARGET> <LINK_FLAGS> <OBJECTS>") + set(CMAKE_Fortran_ARCHIVE_CREATE "<CMAKE_AR> qc <TARGET> <LINK_FLAGS> <OBJECTS>") endif() if(NOT DEFINED CMAKE_Fortran_ARCHIVE_APPEND) set(CMAKE_Fortran_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>") diff --git a/Modules/CMakeParseImplicitLinkInfo.cmake b/Modules/CMakeParseImplicitLinkInfo.cmake index 8abc465..59092bd 100644 --- a/Modules/CMakeParseImplicitLinkInfo.cmake +++ b/Modules/CMakeParseImplicitLinkInfo.cmake @@ -31,7 +31,7 @@ function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var fwk_var log_var obj # Construct a regex to match linker lines. It must match both the # whole line and just the command (argv[0]). set(linker_regex "^( *|.*[/\\])(${linker}|([^/\\]+-)?ld|collect2)[^/\\]*( |$)") - set(linker_exclude_regex "collect2 version ") + set(linker_exclude_regex "collect2 version |^[A-Za-z0-9_]+=") set(log "${log} link line regex: [${linker_regex}]\n") string(REGEX REPLACE "\r?\n" ";" output_lines "${text}") foreach(line IN LISTS output_lines) diff --git a/Modules/CMakeTestSwiftCompiler.cmake b/Modules/CMakeTestSwiftCompiler.cmake index 9186426..89849fb 100644 --- a/Modules/CMakeTestSwiftCompiler.cmake +++ b/Modules/CMakeTestSwiftCompiler.cmake @@ -12,4 +12,54 @@ # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) -set(CMAKE_Swift_COMPILER_WORKS 1) +if(CMAKE_Swift_COMPILER_FORCED) + # The compiler configuration was forced by the user. + # Assume the user has configured all compiler information. + set(CMAKE_Swift_COMPILER_WORKS TRUE) + return() +endif() + +include(CMakeTestCompilerCommon) + +# Remove any cached result from an older CMake version. +# We now store this in CMakeSwiftCompiler.cmake. +unset(CMAKE_Swift_COMPILER_WORKS CACHE) + +# This file is used by EnableLanguage in cmGlobalGenerator to +# determine that that selected C++ compiler can actually compile +# and link the most basic of programs. If not, a fatal error +# is set and cmake stops processing commands and will not generate +# any makefiles or projects. +if(NOT CMAKE_Swift_COMPILER_WORKS) + PrintTestCompilerStatus("Swift" "") + file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/main.swift + "import Foundation\n" + "print(\"CMake\")\n") + try_compile(CMAKE_Swift_COMPILER_WORKS ${CMAKE_BINARY_DIR} + ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/main.swift + OUTPUT_VARIABLE __CMAKE_Swift_COMPILER_OUTPUT) + # Move result from cache to normal variable. + set(CMAKE_Swift_COMPILER_WORKS ${CMAKE_Swift_COMPILER_WORKS}) + unset(CMAKE_Swift_COMPILER_WORKS CACHE) + set(Swift_TEST_WAS_RUN 1) +endif() + +if(NOT CMAKE_Swift_COMPILER_WORKS) + PrintTestCompilerStatus("Swift" " -- broken") + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log + "Determining if the Swift compiler works failed with " + "the following output:\n${__CMAKE_Swift_COMPILER_OUTPUT}\n\n") + message(FATAL_ERROR "The Swift compiler \"${CMAKE_Swift_COMPILER}\" " + "is not able to compile a simple test program.\nIt fails " + "with the following output:\n ${__CMAKE_Swift_COMPILER_OUTPUT}\n\n" + "CMake will not be able to correctly generate this project.") +else() + if(Swift_TEST_WAS_RUN) + PrintTestCompilerStatus("Swift" " -- works") + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log + "Determining if the Swift compiler works passed with " + "the following output:\n${__CMAKE_Swift_COMPILER_OUTPUT}\n\n") + endif() +endif() + +unset(__CMAKE_Swift_COMPILER_OUTPUT) diff --git a/Modules/CPack.cmake b/Modules/CPack.cmake index e223286..77f854d 100644 --- a/Modules/CPack.cmake +++ b/Modules/CPack.cmake @@ -182,6 +182,17 @@ # will be a boolean variable which enables stripping of all files (a list # of files evaluates to TRUE in CMake, so this change is compatible). # +# .. variable:: CPACK_VERBATIM_VARIABLES +# +# If set to TRUE, values of variables prefixed with CPACK_ will be escaped +# before being written to the configuration files, so that the cpack program +# receives them exactly as they were specified. If not, characters like quotes +# and backslashes can cause parsing errors or alter the value received by the +# cpack program. Defaults to FALSE for backwards compatibility. +# +# * Mandatory : NO +# * Default : FALSE +# # The following CPack variables are specific to source packages, and # will not affect binary packages: # @@ -299,49 +310,68 @@ endif() include(CPackComponent) # Macro for setting values if a user did not overwrite them +# Mangles CMake-special characters. Only kept for backwards compatibility. macro(cpack_set_if_not_set name value) - if(NOT DEFINED "${name}") - set(${name} "${value}") - endif() + message(DEPRECATION "cpack_set_if_not_set is obsolete; do not use.") + _cpack_set_default("${name}" "${value}") endmacro() -# cpack_encode_variables - Macro to encode variables for the configuration file +# cpack_encode_variables - Function to encode variables for the configuration file # find any variable that starts with CPACK and create a variable # _CPACK_OTHER_VARIABLES_ that contains SET commands for # each cpack variable. _CPACK_OTHER_VARIABLES_ is then # used as an @ replacment in configure_file for the CPackConfig. -macro(cpack_encode_variables) - set(_CPACK_OTHER_VARIABLES_) +function(cpack_encode_variables) + set(commands "") get_cmake_property(res VARIABLES) foreach(var ${res}) if(var MATCHES "^CPACK") - set(_CPACK_OTHER_VARIABLES_ - "${_CPACK_OTHER_VARIABLES_}\nSET(${var} \"${${var}}\")") + if(CPACK_VERBATIM_VARIABLES) + _cpack_escape_for_cmake(value "${${var}}") + else() + set(value "${${var}}") endif() + + set(commands "${commands}\nSET(${var} \"${value}\")") + endif() endforeach() -endmacro() + + set(_CPACK_OTHER_VARIABLES_ "${commands}" PARENT_SCOPE) +endfunction() + +# Internal use functions +function(_cpack_set_default name value) + if(NOT DEFINED "${name}") + set("${name}" "${value}" PARENT_SCOPE) + endif() +endfunction() + +function(_cpack_escape_for_cmake var value) + string(REGEX REPLACE "([\\\$\"])" "\\\\\\1" escaped "${value}") + set("${var}" "${escaped}" PARENT_SCOPE) +endfunction() # Set the package name -cpack_set_if_not_set(CPACK_PACKAGE_NAME "${CMAKE_PROJECT_NAME}") -cpack_set_if_not_set(CPACK_PACKAGE_VERSION_MAJOR "0") -cpack_set_if_not_set(CPACK_PACKAGE_VERSION_MINOR "1") -cpack_set_if_not_set(CPACK_PACKAGE_VERSION_PATCH "1") -cpack_set_if_not_set(CPACK_PACKAGE_VERSION +_cpack_set_default(CPACK_PACKAGE_NAME "${CMAKE_PROJECT_NAME}") +_cpack_set_default(CPACK_PACKAGE_VERSION_MAJOR "0") +_cpack_set_default(CPACK_PACKAGE_VERSION_MINOR "1") +_cpack_set_default(CPACK_PACKAGE_VERSION_PATCH "1") +_cpack_set_default(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}") -cpack_set_if_not_set(CPACK_PACKAGE_VENDOR "Humanity") -cpack_set_if_not_set(CPACK_PACKAGE_DESCRIPTION_SUMMARY +_cpack_set_default(CPACK_PACKAGE_VENDOR "Humanity") +_cpack_set_default(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${CMAKE_PROJECT_NAME} built using CMake") -cpack_set_if_not_set(CPACK_PACKAGE_DESCRIPTION_FILE +_cpack_set_default(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_ROOT}/Templates/CPack.GenericDescription.txt") -cpack_set_if_not_set(CPACK_RESOURCE_FILE_LICENSE +_cpack_set_default(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_ROOT}/Templates/CPack.GenericLicense.txt") -cpack_set_if_not_set(CPACK_RESOURCE_FILE_README +_cpack_set_default(CPACK_RESOURCE_FILE_README "${CMAKE_ROOT}/Templates/CPack.GenericDescription.txt") -cpack_set_if_not_set(CPACK_RESOURCE_FILE_WELCOME +_cpack_set_default(CPACK_RESOURCE_FILE_WELCOME "${CMAKE_ROOT}/Templates/CPack.GenericWelcome.txt") -cpack_set_if_not_set(CPACK_MODULE_PATH "${CMAKE_MODULE_PATH}") +_cpack_set_default(CPACK_MODULE_PATH "${CMAKE_MODULE_PATH}") if(CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL) set(CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL ON) @@ -359,7 +389,7 @@ if(__cpack_system_name MATCHES "Windows") set(__cpack_system_name win32) endif() endif() -cpack_set_if_not_set(CPACK_SYSTEM_NAME "${__cpack_system_name}") +_cpack_set_default(CPACK_SYSTEM_NAME "${__cpack_system_name}") # Root dir: default value should be the string literal "$PROGRAMFILES" # for backwards compatibility. Projects may set this value to anything. @@ -369,17 +399,17 @@ if("x${__cpack_system_name}" STREQUAL "xwin64") else() set(__cpack_root_default "$PROGRAMFILES") endif() -cpack_set_if_not_set(CPACK_NSIS_INSTALL_ROOT "${__cpack_root_default}") +_cpack_set_default(CPACK_NSIS_INSTALL_ROOT "${__cpack_root_default}") # <project>-<major>.<minor>.<patch>-<release>-<platform>.<pkgtype> -cpack_set_if_not_set(CPACK_PACKAGE_FILE_NAME +_cpack_set_default(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_SYSTEM_NAME}") -cpack_set_if_not_set(CPACK_PACKAGE_INSTALL_DIRECTORY +_cpack_set_default(CPACK_PACKAGE_INSTALL_DIRECTORY "${CPACK_PACKAGE_NAME} ${CPACK_PACKAGE_VERSION}") -cpack_set_if_not_set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY +_cpack_set_default(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "${CPACK_PACKAGE_INSTALL_DIRECTORY}") -cpack_set_if_not_set(CPACK_PACKAGE_DEFAULT_LOCATION "/") -cpack_set_if_not_set(CPACK_PACKAGE_RELOCATABLE "true") +_cpack_set_default(CPACK_PACKAGE_DEFAULT_LOCATION "/") +_cpack_set_default(CPACK_PACKAGE_RELOCATABLE "true") # always force to exactly "true" or "false" for CPack.Info.plist.in: if(CPACK_PACKAGE_RELOCATABLE) @@ -519,10 +549,10 @@ mark_as_advanced( ) # Set some other variables -cpack_set_if_not_set(CPACK_INSTALL_CMAKE_PROJECTS +_cpack_set_default(CPACK_INSTALL_CMAKE_PROJECTS "${CMAKE_BINARY_DIR};${CMAKE_PROJECT_NAME};ALL;/") -cpack_set_if_not_set(CPACK_CMAKE_GENERATOR "${CMAKE_GENERATOR}") -cpack_set_if_not_set(CPACK_TOPLEVEL_TAG "${CPACK_SYSTEM_NAME}") +_cpack_set_default(CPACK_CMAKE_GENERATOR "${CMAKE_GENERATOR}") +_cpack_set_default(CPACK_TOPLEVEL_TAG "${CPACK_SYSTEM_NAME}") # if the user has set CPACK_NSIS_DISPLAY_NAME remember it if(DEFINED CPACK_NSIS_DISPLAY_NAME) set(CPACK_NSIS_DISPLAY_NAME_SET TRUE) @@ -531,34 +561,32 @@ endif() # explicitly, then use that as the default # value of CPACK_NSIS_PACKAGE_NAME instead # of CPACK_PACKAGE_INSTALL_DIRECTORY -cpack_set_if_not_set(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY}") +_cpack_set_default(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY}") if(CPACK_NSIS_DISPLAY_NAME_SET) - string(REPLACE "\\" "\\\\" - _NSIS_DISPLAY_NAME_TMP "${CPACK_NSIS_DISPLAY_NAME}") - cpack_set_if_not_set(CPACK_NSIS_PACKAGE_NAME "${_NSIS_DISPLAY_NAME_TMP}") + _cpack_set_default(CPACK_NSIS_PACKAGE_NAME "${CPACK_NSIS_DISPLAY_NAME}") else() - cpack_set_if_not_set(CPACK_NSIS_PACKAGE_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY}") + _cpack_set_default(CPACK_NSIS_PACKAGE_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY}") endif() -cpack_set_if_not_set(CPACK_OUTPUT_CONFIG_FILE +_cpack_set_default(CPACK_OUTPUT_CONFIG_FILE "${CMAKE_BINARY_DIR}/CPackConfig.cmake") -cpack_set_if_not_set(CPACK_SOURCE_OUTPUT_CONFIG_FILE +_cpack_set_default(CPACK_SOURCE_OUTPUT_CONFIG_FILE "${CMAKE_BINARY_DIR}/CPackSourceConfig.cmake") -cpack_set_if_not_set(CPACK_SET_DESTDIR OFF) -cpack_set_if_not_set(CPACK_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") +_cpack_set_default(CPACK_SET_DESTDIR OFF) +_cpack_set_default(CPACK_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") -cpack_set_if_not_set(CPACK_NSIS_INSTALLER_ICON_CODE "") -cpack_set_if_not_set(CPACK_NSIS_INSTALLER_MUI_ICON_CODE "") +_cpack_set_default(CPACK_NSIS_INSTALLER_ICON_CODE "") +_cpack_set_default(CPACK_NSIS_INSTALLER_MUI_ICON_CODE "") # WiX specific variables -cpack_set_if_not_set(CPACK_WIX_SIZEOF_VOID_P "${CMAKE_SIZEOF_VOID_P}") +_cpack_set_default(CPACK_WIX_SIZEOF_VOID_P "${CMAKE_SIZEOF_VOID_P}") # set sysroot so SDK tools can be used if(CMAKE_OSX_SYSROOT) - cpack_set_if_not_set(CPACK_OSX_SYSROOT "${CMAKE_OSX_SYSROOT}") + _cpack_set_default(CPACK_OSX_SYSROOT "${_CMAKE_OSX_SYSROOT_PATH}") endif() if(DEFINED CPACK_COMPONENTS_ALL) @@ -598,13 +626,20 @@ cpack_encode_variables() configure_file("${cpack_input_file}" "${CPACK_OUTPUT_CONFIG_FILE}" @ONLY) # Generate source file -cpack_set_if_not_set(CPACK_SOURCE_INSTALLED_DIRECTORIES +_cpack_set_default(CPACK_SOURCE_INSTALLED_DIRECTORIES "${CMAKE_SOURCE_DIR};/") -cpack_set_if_not_set(CPACK_SOURCE_TOPLEVEL_TAG "${CPACK_SYSTEM_NAME}-Source") -cpack_set_if_not_set(CPACK_SOURCE_PACKAGE_FILE_NAME +_cpack_set_default(CPACK_SOURCE_TOPLEVEL_TAG "${CPACK_SYSTEM_NAME}-Source") +_cpack_set_default(CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-Source") -cpack_set_if_not_set(CPACK_SOURCE_IGNORE_FILES - "/CVS/;/\\\\\\\\.svn/;/\\\\\\\\.bzr/;/\\\\\\\\.hg/;/\\\\\\\\.git/;\\\\\\\\.swp$;\\\\\\\\.#;/#") + +set(__cpack_source_ignore_files_default + "/CVS/;/\\.svn/;/\\.bzr/;/\\.hg/;/\\.git/;\\.swp$;\\.#;/#") +if(NOT CPACK_VERBATIM_VARIABLES) + _cpack_escape_for_cmake(__cpack_source_ignore_files_default + "${__cpack_source_ignore_files_default}") +endif() +_cpack_set_default(CPACK_SOURCE_IGNORE_FILES "${__cpack_source_ignore_files_default}") + set(CPACK_INSTALL_CMAKE_PROJECTS "${CPACK_SOURCE_INSTALL_CMAKE_PROJECTS}") set(CPACK_INSTALLED_DIRECTORIES "${CPACK_SOURCE_INSTALLED_DIRECTORIES}") set(CPACK_GENERATOR "${CPACK_SOURCE_GENERATOR}") diff --git a/Modules/CPackComponent.cmake b/Modules/CPackComponent.cmake index 573e5aa..96d5609 100644 --- a/Modules/CPackComponent.cmake +++ b/Modules/CPackComponent.cmake @@ -263,7 +263,7 @@ # # The site argument is a URL where the archives for downloadable # components will reside, e.g., -# http://www.cmake.org/files/2.6.1/installer/ All of the archives +# https://cmake.org/files/2.6.1/installer/ All of the archives # produced by CPack should be uploaded to that location. # # UPLOAD_DIRECTORY is the local directory where CPack will create the @@ -301,7 +301,7 @@ if(NOT CPackComponent_CMake_INCLUDED) set(CPackComponent_CMake_INCLUDED 1) -# Argument-parsing macro from http://www.cmake.org/Wiki/CMakeMacroParseArguments +# Argument-parsing macro from https://cmake.org/Wiki/CMakeMacroParseArguments macro(cpack_parse_arguments prefix arg_names option_names) set(${prefix}_DEFAULT_ARGS) foreach(arg_name ${arg_names}) diff --git a/Modules/CPackDeb.cmake b/Modules/CPackDeb.cmake index 75e9966..60e0d1f 100644 --- a/Modules/CPackDeb.cmake +++ b/Modules/CPackDeb.cmake @@ -9,7 +9,7 @@ # # CPackDeb may be used to create Deb package using CPack. # CPackDeb is a CPack generator thus it uses the CPACK_XXX variables -# used by CPack : http://www.cmake.org/Wiki/CMake:CPackConfiguration. +# used by CPack : https://cmake.org/Wiki/CMake:CPackConfiguration. # CPackDeb generator should work on any linux host but it will produce # better deb package when Debian specific tools 'dpkg-xxx' are usable on # the build system. @@ -23,7 +23,7 @@ # a component GROUP name. # # You'll find a detailed usage on the wiki: -# http://www.cmake.org/Wiki/CMake:CPackPackageGenerators#DEB_.28UNIX_only.29 . +# https://cmake.org/Wiki/CMake:CPackPackageGenerators#DEB_.28UNIX_only.29 . # However as a handy reminder here comes the list of specific variables: # # .. variable:: CPACK_DEBIAN_PACKAGE_NAME @@ -78,6 +78,7 @@ # # set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.3.1-6), libc6 (< 2.4)") # +# # .. variable:: CPACK_DEBIAN_PACKAGE_MAINTAINER # # The Debian package maintainer @@ -152,7 +153,7 @@ # You may need set :variable:`CMAKE_INSTALL_RPATH` to an appropriate value # if you use this feature, because if you don't :code:`dpkg-shlibdeps` # may fail to find your own shared libs. -# See http://www.cmake.org/Wiki/CMake_RPATH_handling. +# See https://cmake.org/Wiki/CMake_RPATH_handling. # # # .. variable:: CPACK_DEBIAN_PACKAGE_DEBUG @@ -164,6 +165,7 @@ # * Default : - # # .. variable:: CPACK_DEBIAN_PACKAGE_PREDEPENDS +# CPACK_DEBIAN_<COMPONENT>_PACKAGE_PREDEPENDS # # Sets the `Pre-Depends` field of the Debian package. # Like :variable:`Depends <CPACK_DEBIAN_PACKAGE_DEPENDS>`, except that it @@ -172,11 +174,16 @@ # pre-dependency. # # * Mandatory : NO -# * Default : - +# * Default : +# +# - An empty string for non-component based installations +# - :variable:`CPACK_DEBIAN_PACKAGE_PREDEPENDS` for component-based +# installations. # # See http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps # # .. variable:: CPACK_DEBIAN_PACKAGE_ENHANCES +# CPACK_DEBIAN_<COMPONENT>_PACKAGE_ENHANCES # # Sets the `Enhances` field of the Debian package. # Similar to :variable:`Suggests <CPACK_DEBIAN_PACKAGE_SUGGESTS>` but works @@ -184,11 +191,16 @@ # functionality of another package. # # * Mandatory : NO -# * Default : - +# * Default : +# +# - An empty string for non-component based installations +# - :variable:`CPACK_DEBIAN_PACKAGE_ENHANCES` for component-based +# installations. # # See http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps # # .. variable:: CPACK_DEBIAN_PACKAGE_BREAKS +# CPACK_DEBIAN_<COMPONENT>_PACKAGE_BREAKS # # Sets the `Breaks` field of the Debian package. # When a binary package (P) declares that it breaks other packages (B), @@ -199,12 +211,17 @@ # packages (B) cannot be reconfigured again. # # * Mandatory : NO -# * Default : - +# * Default : +# +# - An empty string for non-component based installations +# - :variable:`CPACK_DEBIAN_PACKAGE_BREAKS` for component-based +# installations. # # See https://www.debian.org/doc/debian-policy/ch-relationships.html#s-breaks # # # .. variable:: CPACK_DEBIAN_PACKAGE_CONFLICTS +# CPACK_DEBIAN_<COMPONENT>_PACKAGE_CONFLICTS # # Sets the `Conflicts` field of the Debian package. # When one binary package declares a conflict with another using a `Conflicts` @@ -212,7 +229,11 @@ # the same time. # # * Mandatory : NO -# * Default : - +# * Default : +# +# - An empty string for non-component based installations +# - :variable:`CPACK_DEBIAN_PACKAGE_CONFLICTS` for component-based +# installations. # # See https://www.debian.org/doc/debian-policy/ch-relationships.html#s-conflicts # @@ -225,48 +246,68 @@ # time. # # .. variable:: CPACK_DEBIAN_PACKAGE_PROVIDES +# CPACK_DEBIAN_<COMPONENT>_PACKAGE_PROVIDES # # Sets the `Provides` field of the Debian package. # A virtual package is one which appears in the `Provides` control field of # another package. # # * Mandatory : NO -# * Default : - +# * Default : +# +# - An empty string for non-component based installations +# - :variable:`CPACK_DEBIAN_PACKAGE_PROVIDES` for component-based +# installations. # # See https://www.debian.org/doc/debian-policy/ch-relationships.html#s-virtual # # # .. variable:: CPACK_DEBIAN_PACKAGE_REPLACES +# CPACK_DEBIAN_<COMPONENT>_PACKAGE_REPLACES # # Sets the `Replaces` field of the Debian package. # Packages can declare in their control file that they should overwrite # files in certain other packages, or completely replace other packages. # # * Mandatory : NO -# * Default : - +# * Default : +# +# - An empty string for non-component based installations +# - :variable:`CPACK_DEBIAN_PACKAGE_REPLACES` for component-based +# installations. # # See http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps # # # .. variable:: CPACK_DEBIAN_PACKAGE_RECOMMENDS +# CPACK_DEBIAN_<COMPONENT>_PACKAGE_RECOMMENDS # # Sets the `Recommends` field of the Debian package. # Allows packages to declare a strong, but not absolute, dependency on other # packages. # # * Mandatory : NO -# * Default : - +# * Default : +# +# - An empty string for non-component based installations +# - :variable:`CPACK_DEBIAN_PACKAGE_RECOMMENDS` for component-based +# installations. # # See http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps # # # .. variable:: CPACK_DEBIAN_PACKAGE_SUGGESTS +# CPACK_DEBIAN_<COMPONENT>_PACKAGE_SUGGESTS # # Sets the `Suggests` field of the Debian package. # Allows packages to declare a suggested package install grouping. # # * Mandatory : NO -# * Default : - +# * Default : +# +# - An empty string for non-component based installations +# - :variable:`CPACK_DEBIAN_PACKAGE_SUGGESTS` for component-based +# installations. # # See http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps # @@ -285,6 +326,34 @@ # # set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA # "${CMAKE_CURRENT_SOURCE_DIR/prerm;${CMAKE_CURRENT_SOURCE_DIR}/postrm") +# +# .. note:: +# +# The original permissions of the files will be used in the final +# package unless the variable +# :variable:`CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION` is set. +# In particular, the scripts should have the proper executable +# flag prior to the generation of the package. +# +# .. variable:: CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION +# CPACK_DEBIAN_<COMPONENT>_PACKAGE_CONTROL_STRICT_PERMISSION +# +# This variable indicates if the Debian policy on control files should be +# strictly followed. +# +# * Mandatory : NO +# * Default : FALSE +# +# Usage:: +# +# set(CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION TRUE) +# +# .. note:: +# +# This overrides the permissions on the original files, following the rules +# set by Debian policy +# https://www.debian.org/doc/debian-policy/ch-files.html#s-permissions-owners +# #============================================================================= @@ -321,11 +390,6 @@ function(cpack_deb_prepare_package_vars) set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS OFF) endif() - find_program(FAKEROOT_EXECUTABLE fakeroot) - if(FAKEROOT_EXECUTABLE) - set(CPACK_DEBIAN_FAKEROOT_EXECUTABLE ${FAKEROOT_EXECUTABLE}) - endif() - set(WDIR "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}${CPACK_DEB_PACKAGE_COMPONENT_PART_PATH}") # per component automatic discover: some of the component might not have @@ -496,18 +560,21 @@ function(cpack_deb_prepare_package_vars) # You should set: DEBIAN_PACKAGE_DEPENDS # TODO: automate 'objdump -p | grep NEEDED' - # if per-component dependency, overrides the global CPACK_DEBIAN_PACKAGE_DEPENDS + # if per-component dependency, overrides the global CPACK_DEBIAN_PACKAGE_${dependency_type_} # automatic dependency discovery will be performed afterwards. if(CPACK_DEB_PACKAGE_COMPONENT) - set(_component_depends_var "CPACK_DEBIAN_${_local_component_name}_PACKAGE_DEPENDS") + foreach(dependency_type_ DEPENDS RECOMMENDS SUGGESTS PREDEPENDS ENHANCES BREAKS CONFLICTS PROVIDES REPLACES) + set(_component_var "CPACK_DEBIAN_${_local_component_name}_PACKAGE_${dependency_type_}") - # if set, overrides the global dependency - if(DEFINED ${_component_depends_var}) - set(CPACK_DEBIAN_PACKAGE_DEPENDS "${${_component_depends_var}}") - if(CPACK_DEBIAN_PACKAGE_DEBUG) - message("CPackDeb Debug: component '${_local_component_name}' dependencies set to '${CPACK_DEBIAN_PACKAGE_DEPENDS}'") + # if set, overrides the global dependency + if(DEFINED ${_component_var}) + set(CPACK_DEBIAN_PACKAGE_${dependency_type_} "${${_component_var}}") + if(CPACK_DEBIAN_PACKAGE_DEBUG) + message("CPackDeb Debug: component '${_local_component_name}' ${dependency_type_}" + "dependencies set to '${CPACK_DEBIAN_PACKAGE_${dependency_}}'") + endif() endif() - endif() + endforeach() endif() # at this point, the CPACK_DEBIAN_PACKAGE_DEPENDS is properly set @@ -591,7 +658,7 @@ function(cpack_deb_prepare_package_vars) # Are we packaging components ? if(CPACK_DEB_PACKAGE_COMPONENT) # override values with per component version if set - foreach(VAR_NAME_ "PACKAGE_CONTROL_EXTRA") + foreach(VAR_NAME_ "PACKAGE_CONTROL_EXTRA" "PACKAGE_CONTROL_STRICT_PERMISSION") if(CPACK_DEBIAN_${_local_component_name}_${VAR_NAME_}) set(CPACK_DEBIAN_${VAR_NAME_} "${CPACK_DEBIAN_${_local_component_name}_${VAR_NAME_}}") endif() @@ -613,6 +680,7 @@ function(cpack_deb_prepare_package_vars) message("CPackDeb:Debug: CPACK_PACKAGE_FILE_NAME = ${CPACK_PACKAGE_FILE_NAME}") message("CPackDeb:Debug: CPACK_PACKAGE_INSTALL_DIRECTORY = ${CPACK_PACKAGE_INSTALL_DIRECTORY}") message("CPackDeb:Debug: CPACK_TEMPORARY_PACKAGE_FILE_NAME = ${CPACK_TEMPORARY_PACKAGE_FILE_NAME}") + message("CPackDeb:Debug: CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION = ${CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION}") endif() # For debian source packages: @@ -638,7 +706,6 @@ function(cpack_deb_prepare_package_vars) set(GEN_CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_DEBIAN_PACKAGE_MAINTAINER}" PARENT_SCOPE) set(GEN_CPACK_DEBIAN_PACKAGE_DESCRIPTION "${CPACK_DEBIAN_PACKAGE_DESCRIPTION}" PARENT_SCOPE) set(GEN_CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}" PARENT_SCOPE) - set(GEN_CPACK_DEBIAN_FAKEROOT_EXECUTABLE "${CPACK_DEBIAN_FAKEROOT_EXECUTABLE}" PARENT_SCOPE) set(GEN_CPACK_DEBIAN_COMPRESSION_TYPE "${CPACK_DEBIAN_COMPRESSION_TYPE}" PARENT_SCOPE) set(GEN_CPACK_DEBIAN_PACKAGE_RECOMMENDS "${CPACK_DEBIAN_PACKAGE_RECOMMENDS}" PARENT_SCOPE) set(GEN_CPACK_DEBIAN_PACKAGE_SUGGESTS "${CPACK_DEBIAN_PACKAGE_SUGGESTS}" PARENT_SCOPE) @@ -650,6 +717,8 @@ function(cpack_deb_prepare_package_vars) set(GEN_CPACK_DEBIAN_PACKAGE_PROVIDES "${CPACK_DEBIAN_PACKAGE_PROVIDES}" PARENT_SCOPE) set(GEN_CPACK_DEBIAN_PACKAGE_REPLACES "${CPACK_DEBIAN_PACKAGE_REPLACES}" PARENT_SCOPE) set(GEN_CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA}" PARENT_SCOPE) + set(GEN_CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION + "${CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION}" PARENT_SCOPE) set(GEN_WDIR "${WDIR}" PARENT_SCOPE) endfunction() diff --git a/Modules/CPackNSIS.cmake b/Modules/CPackNSIS.cmake index 4b2e0eb..db5984a 100644 --- a/Modules/CPackNSIS.cmake +++ b/Modules/CPackNSIS.cmake @@ -30,6 +30,14 @@ # # undocumented. # +# .. variable:: CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP +# +# The filename of a bitmap to use as the NSIS MUI_WELCOMEFINISHPAGE_BITMAP. +# +# .. variable:: CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP +# +# The filename of a bitmap to use as the NSIS MUI_UNWELCOMEFINISHPAGE_BITMAP. +# # .. variable:: CPACK_NSIS_EXTRA_PREINSTALL_COMMANDS # # Extra NSIS commands that will be added to the beginning of the install @@ -115,7 +123,7 @@ # # set(CPACK_NSIS_MENU_LINKS # "doc/cmake-@CMake_VERSION_MAJOR@.@CMake_VERSION_MINOR@/cmake.html" -# "CMake Help" "http://www.cmake.org" "CMake Web Site") +# "CMake Help" "https://cmake.org" "CMake Web Site") # #============================================================================= diff --git a/Modules/CPackRPM.cmake b/Modules/CPackRPM.cmake index 7c1db14..1e7b055 100644 --- a/Modules/CPackRPM.cmake +++ b/Modules/CPackRPM.cmake @@ -9,7 +9,7 @@ # # CPackRPM may be used to create RPM package using CPack. CPackRPM is a # CPack generator thus it uses the CPACK_XXX variables used by CPack : -# http://www.cmake.org/Wiki/CMake:CPackConfiguration +# https://cmake.org/Wiki/CMake:CPackConfiguration # # However CPackRPM has specific features which are controlled by the # specifics CPACK_RPM_XXX variables. CPackRPM is a component aware @@ -24,7 +24,7 @@ # # :: # -# http://www.cmake.org/Wiki/CMake:CPackPackageGenerators#RPM_.28Unix_Only.29 +# https://cmake.org/Wiki/CMake:CPackPackageGenerators#RPM_.28Unix_Only.29 # # However as a handy reminder here comes the list of specific variables: # diff --git a/Modules/CPackWIX.cmake b/Modules/CPackWIX.cmake index 5fe51a6..bef8e16 100644 --- a/Modules/CPackWIX.cmake +++ b/Modules/CPackWIX.cmake @@ -16,7 +16,7 @@ # # Will be automatically generated unless explicitly provided. # -# It should be explicitly set to a constant generated gloabally unique +# It should be explicitly set to a constant generated globally unique # identifier (GUID) to allow your installers to replace existing # installations that use the same GUID. # @@ -226,7 +226,7 @@ # This variable can be used to provide a value for # the Windows Installer property ``<PROPERTY>`` # -# The follwing list contains some example properties that can be used to +# The following list contains some example properties that can be used to # customize information under # "Programs and Features" (also known as "Add or Remove Programs") # diff --git a/Modules/CTestCoverageCollectGCOV.cmake b/Modules/CTestCoverageCollectGCOV.cmake index 6c74cf3..ef3aa76 100644 --- a/Modules/CTestCoverageCollectGCOV.cmake +++ b/Modules/CTestCoverageCollectGCOV.cmake @@ -161,7 +161,7 @@ function(ctest_coverage_collect_gcov) message(STATUS "Could not determine source file corresponding to: ${gcov_file}") endif() - foreach(exclude_entry ${CTEST_CUSTOM_COVERAGE_EXCLUDE}) + foreach(exclude_entry IN LISTS CTEST_CUSTOM_COVERAGE_EXCLUDE) if(source_file MATCHES "${exclude_entry}") set(is_excluded true) diff --git a/Modules/CheckCSourceCompiles.cmake b/Modules/CheckCSourceCompiles.cmake index 6e80fb5..c2b1723 100644 --- a/Modules/CheckCSourceCompiles.cmake +++ b/Modules/CheckCSourceCompiles.cmake @@ -93,7 +93,7 @@ macro(CHECK_C_SOURCE_COMPILES SOURCE VAR) message(STATUS "Performing Test ${VAR} - Success") endif() file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log - "Performing C SOURCE FILE Test ${VAR} succeded with the following output:\n" + "Performing C SOURCE FILE Test ${VAR} succeeded with the following output:\n" "${OUTPUT}\n" "Source file was:\n${SOURCE}\n") else() diff --git a/Modules/CheckCSourceRuns.cmake b/Modules/CheckCSourceRuns.cmake index 0ce423c..5afeab6 100644 --- a/Modules/CheckCSourceRuns.cmake +++ b/Modules/CheckCSourceRuns.cmake @@ -81,7 +81,7 @@ macro(CHECK_C_SOURCE_RUNS SOURCE VAR) message(STATUS "Performing Test ${VAR} - Success") endif() file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log - "Performing C SOURCE FILE Test ${VAR} succeded with the following output:\n" + "Performing C SOURCE FILE Test ${VAR} succeeded with the following output:\n" "${OUTPUT}\n" "Return value: ${${VAR}}\n" "Source file was:\n${SOURCE}\n") diff --git a/Modules/CheckCXXSourceCompiles.cmake b/Modules/CheckCXXSourceCompiles.cmake index 6d52ec6..f8736e2 100644 --- a/Modules/CheckCXXSourceCompiles.cmake +++ b/Modules/CheckCXXSourceCompiles.cmake @@ -94,7 +94,7 @@ macro(CHECK_CXX_SOURCE_COMPILES SOURCE VAR) message(STATUS "Performing Test ${VAR} - Success") endif() file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log - "Performing C++ SOURCE FILE Test ${VAR} succeded with the following output:\n" + "Performing C++ SOURCE FILE Test ${VAR} succeeded with the following output:\n" "${OUTPUT}\n" "Source file was:\n${SOURCE}\n") else() diff --git a/Modules/CheckCXXSourceRuns.cmake b/Modules/CheckCXXSourceRuns.cmake index 3c06d75..84b661d 100644 --- a/Modules/CheckCXXSourceRuns.cmake +++ b/Modules/CheckCXXSourceRuns.cmake @@ -82,7 +82,7 @@ macro(CHECK_CXX_SOURCE_RUNS SOURCE VAR) message(STATUS "Performing Test ${VAR} - Success") endif() file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log - "Performing C++ SOURCE FILE Test ${VAR} succeded with the following output:\n" + "Performing C++ SOURCE FILE Test ${VAR} succeeded with the following output:\n" "${OUTPUT}\n" "Return value: ${${VAR}}\n" "Source file was:\n${SOURCE}\n") diff --git a/Modules/CheckForPthreads.c b/Modules/CheckForPthreads.c index 7250fbf..344c81b 100644 --- a/Modules/CheckForPthreads.c +++ b/Modules/CheckForPthreads.c @@ -16,8 +16,8 @@ int main(int ac, char*av[]){ pthread_create(&tid[0], 0, runner, (void*)1); pthread_create(&tid[1], 0, runner, (void*)2); -#if defined(__BEOS__) && !defined(__ZETA__) // (no usleep on BeOS 5.) - usleep(1); // for strange behavior on single-processor sun +#if defined(__BEOS__) && !defined(__ZETA__) /* (no usleep on BeOS 5.) */ + usleep(1); /* for strange behavior on single-processor sun */ #endif pthread_join(tid[0], 0); @@ -31,7 +31,7 @@ void* runner(void* args) int cc; for ( cc = 0; cc < 10; cc ++ ) { - printf("%d CC: %d\n", (int)args, cc); + printf("%p CC: %d\n", args, cc); } res ++; return 0; diff --git a/Modules/CheckFortranSourceCompiles.cmake b/Modules/CheckFortranSourceCompiles.cmake index f90d05b..0bdcffa 100644 --- a/Modules/CheckFortranSourceCompiles.cmake +++ b/Modules/CheckFortranSourceCompiles.cmake @@ -94,7 +94,7 @@ macro(CHECK_Fortran_SOURCE_COMPILES SOURCE VAR) message(STATUS "Performing Test ${VAR} - Success") endif() file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log - "Performing Fortran SOURCE FILE Test ${VAR} succeded with the following output:\n" + "Performing Fortran SOURCE FILE Test ${VAR} succeeded with the following output:\n" "${OUTPUT}\n" "Source file was:\n${SOURCE}\n") else() diff --git a/Modules/CheckFunctionExists.c b/Modules/CheckFunctionExists.c index 607b3e8..fd29618 100644 --- a/Modules/CheckFunctionExists.c +++ b/Modules/CheckFunctionExists.c @@ -1,5 +1,8 @@ #ifdef CHECK_FUNCTION_EXISTS +#ifdef __cplusplus +extern "C" +#endif char CHECK_FUNCTION_EXISTS(); #ifdef __CLASSIC_C__ int main(){ diff --git a/Modules/CheckFunctionExists.cmake b/Modules/CheckFunctionExists.cmake index d277c32..5dd3751 100644 --- a/Modules/CheckFunctionExists.cmake +++ b/Modules/CheckFunctionExists.cmake @@ -57,14 +57,26 @@ macro(CHECK_FUNCTION_EXISTS FUNCTION VARIABLE) else() set(CHECK_FUNCTION_EXISTS_ADD_INCLUDES) endif() + + if(CMAKE_C_COMPILER_LOADED) + set(_cfe_source ${CMAKE_ROOT}/Modules/CheckFunctionExists.c) + elseif(CMAKE_CXX_COMPILER_LOADED) + set(_cfe_source ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckFunctionExists/CheckFunctionExists.cxx) + configure_file(${CMAKE_ROOT}/Modules/CheckFunctionExists.c "${_cfe_source}" COPYONLY) + else() + message(FATAL_ERROR "CHECK_FUNCTION_EXISTS needs either C or CXX language enabled") + endif() + try_compile(${VARIABLE} ${CMAKE_BINARY_DIR} - ${CMAKE_ROOT}/Modules/CheckFunctionExists.c + ${_cfe_source} COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} ${CHECK_FUNCTION_EXISTS_ADD_LIBRARIES} CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS} "${CHECK_FUNCTION_EXISTS_ADD_INCLUDES}" OUTPUT_VARIABLE OUTPUT) + unset(_cfe_source) + if(${VARIABLE}) set(${VARIABLE} 1 CACHE INTERNAL "Have function ${FUNCTION}") if(NOT CMAKE_REQUIRED_QUIET) diff --git a/Modules/CheckLibraryExists.cmake b/Modules/CheckLibraryExists.cmake index 95c595a..6b53823 100644 --- a/Modules/CheckLibraryExists.cmake +++ b/Modules/CheckLibraryExists.cmake @@ -53,15 +53,26 @@ macro(CHECK_LIBRARY_EXISTS LIBRARY FUNCTION LOCATION VARIABLE) set(CHECK_LIBRARY_EXISTS_LIBRARIES ${CHECK_LIBRARY_EXISTS_LIBRARIES} ${CMAKE_REQUIRED_LIBRARIES}) endif() + + if(CMAKE_C_COMPILER_LOADED) + set(_cle_source ${CMAKE_ROOT}/Modules/CheckFunctionExists.c) + elseif(CMAKE_CXX_COMPILER_LOADED) + set(_cle_source ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckLibraryExists/CheckFunctionExists.cxx) + configure_file(${CMAKE_ROOT}/Modules/CheckFunctionExists.c "${_cle_source}" COPYONLY) + else() + message(FATAL_ERROR "CHECK_FUNCTION_EXISTS needs either C or CXX language enabled") + endif() + try_compile(${VARIABLE} ${CMAKE_BINARY_DIR} - ${CMAKE_ROOT}/Modules/CheckFunctionExists.c + ${_cle_source} COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} LINK_LIBRARIES ${CHECK_LIBRARY_EXISTS_LIBRARIES} CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_LIBRARY_EXISTS_DEFINITION} -DLINK_DIRECTORIES:STRING=${LOCATION} OUTPUT_VARIABLE OUTPUT) + unset(_cle_source) if(${VARIABLE}) if(NOT CMAKE_REQUIRED_QUIET) diff --git a/Modules/CheckSymbolExists.cmake b/Modules/CheckSymbolExists.cmake index 79c5ba7..c4dff3f 100644 --- a/Modules/CheckSymbolExists.cmake +++ b/Modules/CheckSymbolExists.cmake @@ -44,10 +44,14 @@ # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) - - macro(CHECK_SYMBOL_EXISTS SYMBOL FILES VARIABLE) - _CHECK_SYMBOL_EXISTS("${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.c" "${SYMBOL}" "${FILES}" "${VARIABLE}" ) + if(CMAKE_C_COMPILER_LOADED) + _CHECK_SYMBOL_EXISTS("${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.c" "${SYMBOL}" "${FILES}" "${VARIABLE}" ) + elseif(CMAKE_CXX_COMPILER_LOADED) + _CHECK_SYMBOL_EXISTS("${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.cxx" "${SYMBOL}" "${FILES}" "${VARIABLE}" ) + else() + message(FATAL_ERROR "CHECK_SYMBOL_EXISTS needs either C or CXX language enabled") + endif() endmacro() macro(_CHECK_SYMBOL_EXISTS SOURCEFILE SYMBOL FILES VARIABLE) diff --git a/Modules/Compiler/AppleClang-C.cmake b/Modules/Compiler/AppleClang-C.cmake index 10454f6..5908c26 100644 --- a/Modules/Compiler/AppleClang-C.cmake +++ b/Modules/Compiler/AppleClang-C.cmake @@ -13,7 +13,12 @@ if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.0) endif() if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.0) - set(CMAKE_C_STANDARD_DEFAULT 99) + if (NOT CMAKE_C_COMPILER_FORCED) + if (NOT CMAKE_C_STANDARD_COMPUTED_DEFAULT) + message(FATAL_ERROR "CMAKE_C_STANDARD_COMPUTED_DEFAULT should be set for ${CMAKE_C_COMPILER_ID} (${CMAKE_C_COMPILER}) version ${CMAKE_C_COMPILER_VERSION}") + endif() + set(CMAKE_C_STANDARD_DEFAULT ${CMAKE_C_STANDARD_COMPUTED_DEFAULT}) + endif() endif() macro(cmake_record_c_compile_features) diff --git a/Modules/Compiler/AppleClang-CXX.cmake b/Modules/Compiler/AppleClang-CXX.cmake index 1ba8a77..c4e342b 100644 --- a/Modules/Compiler/AppleClang-CXX.cmake +++ b/Modules/Compiler/AppleClang-CXX.cmake @@ -23,9 +23,15 @@ elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1) endif() if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.0) - set(CMAKE_CXX_STANDARD_DEFAULT 98) + if (NOT CMAKE_CXX_COMPILER_FORCED) + if (NOT CMAKE_CXX_STANDARD_COMPUTED_DEFAULT) + message(FATAL_ERROR "CMAKE_CXX_STANDARD_COMPUTED_DEFAULT should be set for ${CMAKE_CXX_COMPILER_ID} (${CMAKE_CXX_COMPILER}) version ${CMAKE_CXX_COMPILER_VERSION}") + endif() + set(CMAKE_CXX_STANDARD_DEFAULT ${CMAKE_CXX_STANDARD_COMPUTED_DEFAULT}) + endif() endif() + macro(cmake_record_cxx_compile_features) macro(_get_appleclang_features std_version list) record_compiler_features(CXX "${std_version}" ${list}) diff --git a/Modules/Compiler/Clang-C.cmake b/Modules/Compiler/Clang-C.cmake index 548d0a5..a2e81c1 100644 --- a/Modules/Compiler/Clang-C.cmake +++ b/Modules/Compiler/Clang-C.cmake @@ -17,10 +17,13 @@ if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.4) set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11") endif() -if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.6) - set(CMAKE_C_STANDARD_DEFAULT 11) -elseif(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.4) - set(CMAKE_C_STANDARD_DEFAULT 99) +if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.4) + if (NOT CMAKE_C_COMPILER_FORCED) + if (NOT CMAKE_C_STANDARD_COMPUTED_DEFAULT) + message(FATAL_ERROR "CMAKE_C_STANDARD_COMPUTED_DEFAULT should be set for ${CMAKE_C_COMPILER_ID} (${CMAKE_C_COMPILER}) version ${CMAKE_C_COMPILER_VERSION}") + endif() + set(CMAKE_C_STANDARD_DEFAULT ${CMAKE_C_STANDARD_COMPUTED_DEFAULT}) + endif() endif() macro(cmake_record_c_compile_features) diff --git a/Modules/Compiler/Clang-CXX.cmake b/Modules/Compiler/Clang-CXX.cmake index 84b2c74..055a8ee 100644 --- a/Modules/Compiler/Clang-CXX.cmake +++ b/Modules/Compiler/Clang-CXX.cmake @@ -31,8 +31,13 @@ elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4) set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y") endif() -if(UNIX AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4) - set(CMAKE_CXX_STANDARD_DEFAULT 98) +if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4) + if (NOT CMAKE_CXX_COMPILER_FORCED) + if (NOT CMAKE_CXX_STANDARD_COMPUTED_DEFAULT) + message(FATAL_ERROR "CMAKE_CXX_STANDARD_COMPUTED_DEFAULT should be set for ${CMAKE_CXX_COMPILER_ID} (${CMAKE_CXX_COMPILER}) version ${CMAKE_CXX_COMPILER_VERSION}") + endif() + set(CMAKE_CXX_STANDARD_DEFAULT ${CMAKE_CXX_STANDARD_COMPUTED_DEFAULT}) + endif() endif() macro(cmake_record_cxx_compile_features) diff --git a/Modules/Compiler/GNU-C.cmake b/Modules/Compiler/GNU-C.cmake index 89704e6..d979fb7 100644 --- a/Modules/Compiler/GNU-C.cmake +++ b/Modules/Compiler/GNU-C.cmake @@ -22,22 +22,26 @@ elseif (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.6) set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu1x") endif() -if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 5.0) - set(CMAKE_C_STANDARD_DEFAULT 11) -elseif(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.4) - set(CMAKE_C_STANDARD_DEFAULT 90) +if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.4) + if (NOT CMAKE_C_COMPILER_FORCED) + if (NOT CMAKE_C_STANDARD_COMPUTED_DEFAULT) + message(FATAL_ERROR "CMAKE_C_STANDARD_COMPUTED_DEFAULT should be set for ${CMAKE_C_COMPILER_ID} (${CMAKE_C_COMPILER}) version ${CMAKE_C_COMPILER_VERSION}") + endif() + set(CMAKE_C_STANDARD_DEFAULT ${CMAKE_C_STANDARD_COMPUTED_DEFAULT}) + endif() endif() + macro(cmake_record_c_compile_features) macro(_get_gcc_features std_version list) record_compiler_features(C "${std_version}" ${list}) endmacro() set(_result 0) - if (UNIX AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.6) + if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.6) _get_gcc_features(${CMAKE_C11_STANDARD_COMPILE_OPTION} CMAKE_C11_COMPILE_FEATURES) endif() - if (UNIX AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.4) + if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.4) if (_result EQUAL 0) _get_gcc_features(${CMAKE_C99_STANDARD_COMPILE_OPTION} CMAKE_C99_COMPILE_FEATURES) endif() diff --git a/Modules/Compiler/GNU-CXX.cmake b/Modules/Compiler/GNU-CXX.cmake index 2dc02f0..a7e71c3 100644 --- a/Modules/Compiler/GNU-CXX.cmake +++ b/Modules/Compiler/GNU-CXX.cmake @@ -35,7 +35,12 @@ elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8) endif() if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.4) - set(CMAKE_CXX_STANDARD_DEFAULT 98) + if (NOT CMAKE_CXX_COMPILER_FORCED) + if (NOT CMAKE_CXX_STANDARD_COMPUTED_DEFAULT) + message(FATAL_ERROR "CMAKE_CXX_STANDARD_COMPUTED_DEFAULT should be set for ${CMAKE_CXX_COMPILER_ID} (${CMAKE_CXX_COMPILER}) version ${CMAKE_CXX_COMPILER_VERSION}") + endif() + set(CMAKE_CXX_STANDARD_DEFAULT ${CMAKE_CXX_STANDARD_COMPUTED_DEFAULT}) + endif() endif() macro(cmake_record_cxx_compile_features) diff --git a/Modules/Compiler/IAR.cmake b/Modules/Compiler/IAR.cmake index 00e4713..8c6c3f6 100644 --- a/Modules/Compiler/IAR.cmake +++ b/Modules/Compiler/IAR.cmake @@ -1,6 +1,6 @@ # This file is processed when the IAR compiler is used for a C or C++ file # Documentation can be downloaded here: http://www.iar.com/website1/1.0.1.0/675/1/ -# The initial feature request is here: http://www.cmake.org/Bug/view.php?id=10176 +# The initial feature request is here: https://cmake.org/Bug/view.php?id=10176 # It also contains additional links and information. if(_IAR_CMAKE_LOADED) @@ -39,7 +39,7 @@ endif() if(NOT IAR_TARGET_ARCHITECTURE) message(FATAL_ERROR "The IAR compiler for this architecture is not yet supported " - " by CMake. Please go to http://www.cmake.org/Bug and enter a feature request there.") + " by CMake. Please go to https://cmake.org/Bug and enter a feature request there.") endif() set(CMAKE_LINKER "${CMAKE_IAR_LINKER}" CACHE FILEPATH "The IAR linker" FORCE) diff --git a/Modules/Compiler/SunPro-CXX.cmake b/Modules/Compiler/SunPro-CXX.cmake index e0c02d9..50d68ee 100644 --- a/Modules/Compiler/SunPro-CXX.cmake +++ b/Modules/Compiler/SunPro-CXX.cmake @@ -36,8 +36,13 @@ if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.13) set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=c++11") endif() -if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.13) - set(CMAKE_CXX_STANDARD_DEFAULT 98) +if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.13) + if (NOT CMAKE_CXX_COMPILER_FORCED) + if (NOT CMAKE_CXX_STANDARD_COMPUTED_DEFAULT) + message(FATAL_ERROR "CMAKE_CXX_STANDARD_COMPUTED_DEFAULT should be set for ${CMAKE_CXX_COMPILER_ID} (${CMAKE_CXX_COMPILER}) version ${CMAKE_CXX_COMPILER_VERSION}") + endif() + set(CMAKE_CXX_STANDARD_DEFAULT ${CMAKE_CXX_STANDARD_COMPUTED_DEFAULT}) + endif() endif() macro(cmake_record_cxx_compile_features) diff --git a/Modules/CompilerId/VS-10.vcxproj.in b/Modules/CompilerId/VS-10.vcxproj.in index a17d03d..2870a11 100644 --- a/Modules/CompilerId/VS-10.vcxproj.in +++ b/Modules/CompilerId/VS-10.vcxproj.in @@ -12,6 +12,7 @@ <Keyword>Win32Proj</Keyword> @id_system@ @id_system_version@ + @id_WindowsTargetPlatformVersion@ @id_WindowsSDKDesktopARMSupport@ </PropertyGroup> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> diff --git a/Modules/CompilerId/main.swift.in b/Modules/CompilerId/main.swift.in index 962e857..13f0ba0 100644 --- a/Modules/CompilerId/main.swift.in +++ b/Modules/CompilerId/main.swift.in @@ -1 +1 @@ -println("CMakeSwiftCompilerId") +print("CMakeSwiftCompilerId") diff --git a/Modules/ExternalProject.cmake b/Modules/ExternalProject.cmake index 0fbf7c3..c822bdb 100644 --- a/Modules/ExternalProject.cmake +++ b/Modules/ExternalProject.cmake @@ -646,6 +646,11 @@ endfunction() function(_ep_write_gitupdate_script script_filename git_EXECUTABLE git_tag git_submodules git_repository work_dir) + if(NOT GIT_VERSION_STRING VERSION_LESS 1.7.6) + set(git_stash_save_options --all --quiet) + else() + set(git_stash_save_options --quiet) + endif() file(WRITE ${script_filename} "if(\"${git_tag}\" STREQUAL \"\") message(FATAL_ERROR \"Tag for git checkout should not be empty.\") @@ -724,7 +729,7 @@ if(error_code OR is_remote_ref OR NOT (\"\${tag_sha}\" STREQUAL \"\${head_sha}\" # perform git pull --rebase if(need_stash) execute_process( - COMMAND \"${git_EXECUTABLE}\" stash save --all --quiet + COMMAND \"${git_EXECUTABLE}\" stash save ${git_stash_save_options} WORKING_DIRECTORY \"${work_dir}\" RESULT_VARIABLE error_code ) @@ -1631,20 +1636,6 @@ function(_ep_add_mkdir_command name) endfunction() -function(_ep_get_git_version git_EXECUTABLE git_version_var) - if(git_EXECUTABLE) - execute_process( - COMMAND "${git_EXECUTABLE}" --version - OUTPUT_VARIABLE ov - ERROR_VARIABLE ev - OUTPUT_STRIP_TRAILING_WHITESPACE - ) - string(REGEX REPLACE "^git version (.+)$" "\\1" version "${ov}") - set(${git_version_var} "${version}" PARENT_SCOPE) - endif() -endfunction() - - function(_ep_is_dir_empty dir empty_var) file(GLOB gr "${dir}/*") if("${gr}" STREQUAL "") @@ -1740,6 +1731,7 @@ function(_ep_add_download_command name) --non-interactive ${svn_trust_cert_args} ${svn_user_pw_args} ${src_name}) list(APPEND depends ${stamp_dir}/${name}-svninfo.txt) elseif(git_repository) + unset(CMAKE_MODULE_PATH) # Use CMake builtin find module find_package(Git QUIET) if(NOT GIT_EXECUTABLE) message(FATAL_ERROR "error: could not find git for clone of ${name}") @@ -1747,9 +1739,8 @@ function(_ep_add_download_command name) # The git submodule update '--recursive' flag requires git >= v1.6.5 # - _ep_get_git_version("${GIT_EXECUTABLE}" git_version) - if(git_version VERSION_LESS 1.6.5) - message(FATAL_ERROR "error: git version 1.6.5 or later required for 'git submodule update --recursive': git_version='${git_version}'") + if(GIT_VERSION_STRING VERSION_LESS 1.6.5) + message(FATAL_ERROR "error: git version 1.6.5 or later required for 'git submodule update --recursive': GIT_VERSION_STRING='${GIT_VERSION_STRING}'") endif() get_property(git_tag TARGET ${name} PROPERTY _EP_GIT_TAG) diff --git a/Modules/FindFLEX.cmake b/Modules/FindFLEX.cmake index c837c52..ca66493 100644 --- a/Modules/FindFLEX.cmake +++ b/Modules/FindFLEX.cmake @@ -27,13 +27,17 @@ # # :: # -# FLEX_TARGET(Name FlexInput FlexOutput [COMPILE_FLAGS <string>]) +# FLEX_TARGET(Name FlexInput FlexOutput +# [COMPILE_FLAGS <string>] +# [DEFINES_FILE <string>] +# ) # # which creates a custom command to generate the <FlexOutput> file from # the <FlexInput> file. If COMPILE_FLAGS option is specified, the next -# parameter is added to the flex command line. Name is an alias used to -# get details of this custom command. Indeed the macro defines the -# following variables: +# parameter is added to the flex command line. If flex is configured to +# output a header file, the DEFINES_FILE option may be used to specify its +# name. Name is an alias used to get details of this custom command. +# Indeed the macro defines the following variables: # # :: # @@ -41,6 +45,7 @@ # FLEX_${Name}_OUTPUTS - the source file generated by the custom rule, an # alias for FlexOutput # FLEX_${Name}_INPUT - the flex source file, an alias for ${FlexInput} +# FLEX_${Name}_OUTPUT_HEADER - the header flex output, if any. # # # @@ -113,6 +118,8 @@ find_path(FLEX_INCLUDE_DIR FlexLexer.h mark_as_advanced(FL_LIBRARY FLEX_INCLUDE_DIR) +include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseArguments.cmake) + set(FLEX_INCLUDE_DIRS ${FLEX_INCLUDE_DIR}) set(FLEX_LIBRARIES ${FL_LIBRARY}) @@ -145,31 +152,55 @@ if(FLEX_EXECUTABLE) #============================================================ # macro(FLEX_TARGET Name Input Output) - set(FLEX_TARGET_usage "FLEX_TARGET(<Name> <Input> <Output> [COMPILE_FLAGS <string>]") - if(${ARGC} GREATER 3) - if(${ARGC} EQUAL 5) - if("${ARGV3}" STREQUAL "COMPILE_FLAGS") - set(FLEX_EXECUTABLE_opts "${ARGV4}") - separate_arguments(FLEX_EXECUTABLE_opts) - else() - message(SEND_ERROR ${FLEX_TARGET_usage}) - endif() + set(FLEX_TARGET_outputs "${Output}") + set(FLEX_EXECUTABLE_opts "") + + set(FLEX_TARGET_PARAM_OPTIONS) + set(FLEX_TARGET_PARAM_ONE_VALUE_KEYWORDS + COMPILE_FLAGS + DEFINES_FILE + ) + set(FLEX_TARGET_PARAM_MULTI_VALUE_KEYWORDS) + + cmake_parse_arguments( + FLEX_TARGET_ARG + "${FLEX_TARGET_PARAM_OPTIONS}" + "${FLEX_TARGET_PARAM_ONE_VALUE_KEYWORDS}" + "${FLEX_TARGET_MULTI_VALUE_KEYWORDS}" + ${ARGN} + ) + + set(FLEX_TARGET_usage "FLEX_TARGET(<Name> <Input> <Output> [COMPILE_FLAGS <string>] [DEFINES_FILE <string>]") + + if(NOT "${FLEX_TARGET_ARG_UNPARSED_ARGUMENTS}" STREQUAL "") + message(SEND_ERROR ${FLEX_TARGET_usage}) + else() + if(NOT "${FLEX_TARGET_ARG_COMPILE_FLAGS}" STREQUAL "") + set(FLEX_EXECUTABLE_opts "${FLEX_TARGET_ARG_COMPILE_FLAGS}") + separate_arguments(FLEX_EXECUTABLE_opts) + endif() + if(NOT "${FLEX_TARGET_ARG_DEFINES_FILE}" STREQUAL "") + list(APPEND FLEX_TARGET_outputs "${FLEX_TARGET_ARG_DEFINES_FILE}") + list(APPEND FLEX_EXECUTABLE_opts --header-file=${FLEX_TARGET_ARG_DEFINES_FILE}) + endif() + + add_custom_command(OUTPUT ${FLEX_TARGET_outputs} + COMMAND ${FLEX_EXECUTABLE} + ARGS ${FLEX_EXECUTABLE_opts} -o${Output} ${Input} + DEPENDS ${Input} + COMMENT "[FLEX][${Name}] Building scanner with flex ${FLEX_VERSION}" + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) + + set(FLEX_${Name}_DEFINED TRUE) + set(FLEX_${Name}_OUTPUTS ${Output}) + set(FLEX_${Name}_INPUT ${Input}) + set(FLEX_${Name}_COMPILE_FLAGS ${FLEX_EXECUTABLE_opts}) + if("${FLEX_TARGET_ARG_DEFINES_FILE}" STREQUAL "") + set(FLEX_${Name}_OUTPUT_HEADER "") else() - message(SEND_ERROR ${FLEX_TARGET_usage}) + set(FLEX_${Name}_OUTPUT_HEADER ${FLEX_TARGET_ARG_DEFINES_FILE}) endif() endif() - - add_custom_command(OUTPUT ${Output} - COMMAND ${FLEX_EXECUTABLE} - ARGS ${FLEX_EXECUTABLE_opts} -o${Output} ${Input} - DEPENDS ${Input} - COMMENT "[FLEX][${Name}] Building scanner with flex ${FLEX_VERSION}" - WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) - - set(FLEX_${Name}_DEFINED TRUE) - set(FLEX_${Name}_OUTPUTS ${Output}) - set(FLEX_${Name}_INPUT ${Input}) - set(FLEX_${Name}_COMPILE_FLAGS ${FLEX_EXECUTABLE_opts}) endmacro() #============================================================ @@ -181,11 +212,11 @@ if(FLEX_EXECUTABLE) macro(ADD_FLEX_BISON_DEPENDENCY FlexTarget BisonTarget) if(NOT FLEX_${FlexTarget}_OUTPUTS) - message(SEND_ERROR "Flex target `${FlexTarget}' does not exists.") + message(SEND_ERROR "Flex target `${FlexTarget}' does not exist.") endif() if(NOT BISON_${BisonTarget}_OUTPUT_HEADER) - message(SEND_ERROR "Bison target `${BisonTarget}' does not exists.") + message(SEND_ERROR "Bison target `${BisonTarget}' does not exist.") endif() set_source_files_properties(${FLEX_${FlexTarget}_OUTPUTS} diff --git a/Modules/FindGTK2.cmake b/Modules/FindGTK2.cmake index 72bb8eb..ab4ef3e 100644 --- a/Modules/FindGTK2.cmake +++ b/Modules/FindGTK2.cmake @@ -202,6 +202,43 @@ function(_GTK2_GET_VERSION _OUT_major _OUT_minor _OUT_micro _gtkversion_hdr) endif() endfunction() + +#============================================================= +# _GTK2_SIGCXX_GET_VERSION +# Internal function to parse the version number in +# sigc++config.h +# _OUT_major = Major version number +# _OUT_minor = Minor version number +# _OUT_micro = Micro version number +# _sigcxxversion_hdr = Header file to parse +#============================================================= + +function(_GTK2_SIGCXX_GET_VERSION _OUT_major _OUT_minor _OUT_micro _sigcxxversion_hdr) + file(STRINGS ${_sigcxxversion_hdr} _contents REGEX "#define SIGCXX_M[A-Z]+_VERSION[ \t]+") + if(_contents) + string(REGEX REPLACE ".*#define SIGCXX_MAJOR_VERSION[ \t]+([0-9]+).*" "\\1" ${_OUT_major} "${_contents}") + string(REGEX REPLACE ".*#define SIGCXX_MINOR_VERSION[ \t]+([0-9]+).*" "\\1" ${_OUT_minor} "${_contents}") + string(REGEX REPLACE ".*#define SIGCXX_MICRO_VERSION[ \t]+([0-9]+).*" "\\1" ${_OUT_micro} "${_contents}") + + if(NOT ${_OUT_major} MATCHES "[0-9]+") + message(FATAL_ERROR "Version parsing failed for SIGCXX_MAJOR_VERSION!") + endif() + if(NOT ${_OUT_minor} MATCHES "[0-9]+") + message(FATAL_ERROR "Version parsing failed for SIGCXX_MINOR_VERSION!") + endif() + if(NOT ${_OUT_micro} MATCHES "[0-9]+") + message(FATAL_ERROR "Version parsing failed for SIGCXX_MICRO_VERSION!") + endif() + + set(${_OUT_major} ${${_OUT_major}} PARENT_SCOPE) + set(${_OUT_minor} ${${_OUT_minor}} PARENT_SCOPE) + set(${_OUT_micro} ${${_OUT_micro}} PARENT_SCOPE) + else() + message(FATAL_ERROR "Include file ${_gtkversion_hdr} does not exist") + endif() +endfunction() + + #============================================================= # _GTK2_FIND_INCLUDE_DIR # Internal function to find the GTK include directories @@ -734,6 +771,27 @@ foreach(_GTK2_component ${GTK2_FIND_COMPONENTS}) _GTK2_FIND_INCLUDE_DIR(SIGC++CONFIG sigc++config.h) _GTK2_FIND_LIBRARY (SIGC++ sigc true true) _GTK2_ADD_TARGET (SIGC++) + # Since sigc++ 2.5.1 c++11 support is required + if(GTK2_SIGC++CONFIG_INCLUDE_DIR) + _GTK2_SIGCXX_GET_VERSION(GTK2_SIGC++_VERSION_MAJOR + GTK2_SIGC++_VERSION_MINOR + GTK2_SIGC++_VERSION_MICRO + ${GTK2_SIGC++CONFIG_INCLUDE_DIR}/sigc++config.h) + if(NOT ${GTK2_SIGC++_VERSION_MAJOR}.${GTK2_SIGC++_VERSION_MINOR}.${GTK2_SIGC++_VERSION_MICRO} VERSION_LESS 2.5.1) + # These are the features needed by clients in order to include the + # project headers: + set_property(TARGET GTK2::sigc++ + PROPERTY INTERFACE_COMPILE_FEATURES cxx_alias_templates + cxx_auto_type + cxx_decltype + cxx_deleted_functions + cxx_noexcept + cxx_nullptr + cxx_right_angle_brackets + cxx_rvalue_references + cxx_variadic_templates) + endif() + endif() _GTK2_FIND_INCLUDE_DIR(GLIBMM glibmm.h) _GTK2_FIND_INCLUDE_DIR(GLIBMMCONFIG glibmmconfig.h) diff --git a/Modules/FindGit.cmake b/Modules/FindGit.cmake index b4f7b4b..2c3e5fd 100644 --- a/Modules/FindGit.cmake +++ b/Modules/FindGit.cmake @@ -48,17 +48,21 @@ if(WIN32) # GitHub search path for Windows set(github_path "$ENV{LOCALAPPDATA}/Github/PortableGit*/bin") file(GLOB github_path "${github_path}") + # SourceTree search path for Windows + set(_git_sourcetree_path "$ENV{LOCALAPPDATA}/Atlassian/SourceTree/git_local/bin") endif() endif() find_program(GIT_EXECUTABLE NAMES ${git_names} - PATHS ${github_path} + PATHS ${github_path} ${_git_sourcetree_path} PATH_SUFFIXES Git/cmd Git/bin DOC "git command line client" ) mark_as_advanced(GIT_EXECUTABLE) +unset(_git_sourcetree_path) + if(GIT_EXECUTABLE) execute_process(COMMAND ${GIT_EXECUTABLE} --version OUTPUT_VARIABLE git_version diff --git a/Modules/FindHDF5.cmake b/Modules/FindHDF5.cmake index a449132..9f6e666 100644 --- a/Modules/FindHDF5.cmake +++ b/Modules/FindHDF5.cmake @@ -31,6 +31,12 @@ # Find module will then look in this path when searching for HDF5 # executables, paths, and libraries. # +# Both the serial and parallel HDF5 wrappers are considered and the first +# directory to contain either one will be used. In the event that both appear +# in the same directory the serial version is preferentially selected. This +# behavior can be reversed by setting the variable HDF5_PREFER_PARALLEL to +# true. +# # In addition to finding the includes and libraries required to compile # an HDF5 client application, this module also makes an effort to find # tools that come with the HDF5 distribution that may be useful for @@ -103,28 +109,43 @@ else() endforeach() endif() +# Determine whether to search for serial or parallel executable first +if(HDF5_PREFER_PARALLEL) + set(HDF5_C_COMPILER_NAMES h5pcc h5cc) + set(HDF5_CXX_COMPILER_NAMES h5pc++ h5c++) + set(HDF5_Fortran_COMPILER_NAMES h5pfc h5fc) +else() + set(HDF5_C_COMPILER_NAMES h5cc h5pcc) + set(HDF5_CXX_COMPILER_NAMES h5c++ h5pc++) + set(HDF5_Fortran_COMPILER_NAMES h5fc h5pfc) +endif() + # try to find the HDF5 wrapper compilers find_program( HDF5_C_COMPILER_EXECUTABLE - NAMES h5cc h5pcc + NAMES ${HDF5_C_COMPILER_NAMES} NAMES_PER_DIR HINTS ENV HDF5_ROOT PATH_SUFFIXES bin Bin DOC "HDF5 Wrapper compiler. Used only to detect HDF5 compile flags." ) mark_as_advanced( HDF5_C_COMPILER_EXECUTABLE ) find_program( HDF5_CXX_COMPILER_EXECUTABLE - NAMES h5c++ h5pc++ + NAMES ${HDF5_CXX_COMPILER_NAMES} NAMES_PER_DIR HINTS ENV HDF5_ROOT PATH_SUFFIXES bin Bin DOC "HDF5 C++ Wrapper compiler. Used only to detect HDF5 compile flags." ) mark_as_advanced( HDF5_CXX_COMPILER_EXECUTABLE ) find_program( HDF5_Fortran_COMPILER_EXECUTABLE - NAMES h5fc h5pfc + NAMES ${HDF5_Fortran_COMPILER_NAMES} NAMES_PER_DIR HINTS ENV HDF5_ROOT PATH_SUFFIXES bin Bin DOC "HDF5 Fortran Wrapper compiler. Used only to detect HDF5 compile flags." ) mark_as_advanced( HDF5_Fortran_COMPILER_EXECUTABLE ) +unset(HDF5_C_COMPILER_NAMES) +unset(HDF5_CXX_COMPILER_NAMES) +unset(HDF5_Fortran_COMPILER_NAMES) + find_program( HDF5_DIFF_EXECUTABLE NAMES h5diff HINTS ENV HDF5_ROOT @@ -286,7 +307,7 @@ if( NOT HDF5_FOUND ) if( UNIX AND HDF5_USE_STATIC_LIBRARIES ) # According to bug 1643 on the CMake bug tracker, this is the # preferred method for searching for a static library. - # See http://www.cmake.org/Bug/view.php?id=1643. We search + # See https://cmake.org/Bug/view.php?id=1643. We search # first for the full static library name, but fall back to a # generic search on the name if the static search fails. set( THIS_LIBRARY_SEARCH_DEBUG lib${LIB}d.a ${LIB}d ) @@ -378,4 +399,3 @@ find_package_handle_standard_args( HDF5 REQUIRED_VARS HDF5_LIBRARIES HDF5_INCLUDE_DIRS VERSION_VAR HDF5_VERSION ) - diff --git a/Modules/FindMatlab.cmake b/Modules/FindMatlab.cmake index a47a69c..7a36719 100644 --- a/Modules/FindMatlab.cmake +++ b/Modules/FindMatlab.cmake @@ -229,6 +229,7 @@ if(NOT MATLAB_ADDITIONAL_VERSIONS) endif() set(MATLAB_VERSIONS_MAPPING + "R2015b=8.6" "R2015a=8.5" "R2014b=8.4" "R2014a=8.3" diff --git a/Modules/FindOpenSSL.cmake b/Modules/FindOpenSSL.cmake index 434ef58..8b4b988 100644 --- a/Modules/FindOpenSSL.cmake +++ b/Modules/FindOpenSSL.cmake @@ -36,6 +36,8 @@ # ^^^^^ # # Set ``OPENSSL_ROOT_DIR`` to the root directory of an OpenSSL installation. +# Set ``OPENSSL_USE_STATIC_LIBS`` to ``TRUE`` to look for static libraries. +# Set ``OPENSSL_MSVC_STATIC_RT`` set ``TRUE`` to choose the MT version of the lib. #============================================================================= # Copyright 2006-2009 Kitware, Inc. @@ -57,6 +59,16 @@ if (UNIX) pkg_check_modules(_OPENSSL QUIET openssl) endif () +# Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES +if(OPENSSL_USE_STATIC_LIBS) + set(_openssl_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) + if(WIN32) + set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) + else() + set(CMAKE_FIND_LIBRARY_SUFFIXES .a ) + endif() +endif() + if (WIN32) # http://www.slproweb.com/products/Win32OpenSSL.html set(_OPENSSL_ROOT_HINTS @@ -102,7 +114,7 @@ if(WIN32 AND NOT CYGWIN) # /MD and /MDd are the standard values - if someone wants to use # others, the libnames have to change here too # use also ssl and ssleay32 in debug as fallback for openssl < 0.9.8b - # TODO: handle /MT and static lib + # enable OPENSSL_MSVC_STATIC_RT to get the libs build /MT (Multithreaded no-DLL) # In Visual C++ naming convention each of these four kinds of Windows libraries has it's standard suffix: # * MD for dynamic-release # * MDd for dynamic-debug @@ -113,16 +125,31 @@ if(WIN32 AND NOT CYGWIN) # We are using the libraries located in the VC subdir instead of the parent directory eventhough : # libeay32MD.lib is identical to ../libeay32.lib, and # ssleay32MD.lib is identical to ../ssleay32.lib + # enable OPENSSL_USE_STATIC_LIBS to use the static libs located in lib/VC/static - set(_OPENSSL_PATH_SUFFIXES - "lib" - "VC" - "lib/VC" - ) + if (OPENSSL_MSVC_STATIC_RT) + set(_OPENSSL_MSVC_RT_MODE "MT") + else () + set(_OPENSSL_MSVC_RT_MODE "MD") + endif () + + if(OPENSSL_USE_STATIC_LIBS) + set(_OPENSSL_PATH_SUFFIXES + "lib" + "VC/static" + "lib/VC/static" + ) + else() + set(_OPENSSL_PATH_SUFFIXES + "lib" + "VC" + "lib/VC" + ) + endif () find_library(LIB_EAY_DEBUG NAMES - libeay32MDd + libeay32${_OPENSSL_MSVC_RT_MODE}d libeay32d ${_OPENSSL_ROOT_HINTS_AND_PATHS} PATH_SUFFIXES @@ -131,7 +158,7 @@ if(WIN32 AND NOT CYGWIN) find_library(LIB_EAY_RELEASE NAMES - libeay32MD + libeay32${_OPENSSL_MSVC_RT_MODE} libeay32 ${_OPENSSL_ROOT_HINTS_AND_PATHS} PATH_SUFFIXES @@ -140,7 +167,7 @@ if(WIN32 AND NOT CYGWIN) find_library(SSL_EAY_DEBUG NAMES - ssleay32MDd + ssleay32${_OPENSSL_MSVC_RT_MODE}d ssleay32d ${_OPENSSL_ROOT_HINTS_AND_PATHS} PATH_SUFFIXES @@ -149,7 +176,7 @@ if(WIN32 AND NOT CYGWIN) find_library(SSL_EAY_RELEASE NAMES - ssleay32MD + ssleay32${_OPENSSL_MSVC_RT_MODE} ssleay32 ssl ${_OPENSSL_ROOT_HINTS_AND_PATHS} @@ -173,12 +200,8 @@ if(WIN32 AND NOT CYGWIN) set(OPENSSL_LIBRARIES ${SSL_EAY_LIBRARY} ${LIB_EAY_LIBRARY} ) elseif(MINGW) # same player, for MinGW - set(LIB_EAY_NAMES libeay32) - set(SSL_EAY_NAMES ssleay32) - if(CMAKE_CROSSCOMPILING) - list(APPEND LIB_EAY_NAMES crypto) - list(APPEND SSL_EAY_NAMES ssl) - endif() + set(LIB_EAY_NAMES crypto libeay32) + set(SSL_EAY_NAMES ssl ssleay32) find_library(LIB_EAY NAMES ${LIB_EAY_NAMES} @@ -298,7 +321,7 @@ endfunction() if (OPENSSL_INCLUDE_DIR) if(OPENSSL_INCLUDE_DIR AND EXISTS "${OPENSSL_INCLUDE_DIR}/openssl/opensslv.h") file(STRINGS "${OPENSSL_INCLUDE_DIR}/openssl/opensslv.h" openssl_version_str - REGEX "^# *define[\t ]+OPENSSL_VERSION_NUMBER[\t ]+0x([0-9a-fA-F])+.*") + REGEX "^#[\t ]*define[\t ]+OPENSSL_VERSION_NUMBER[\t ]+0x([0-9a-fA-F])+.*") # The version number is encoded as 0xMNNFFPPS: major minor fix patch status # The status gives if this is a developer or prerelease and is ignored here. @@ -414,3 +437,8 @@ if(OPENSSL_FOUND) endif() endif() endif() + +# Restore the original find library ordering +if(OPENSSL_USE_STATIC_LIBS) + set(CMAKE_FIND_LIBRARY_SUFFIXES ${_openssl_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES}) +endif() diff --git a/Modules/FindPkgConfig.cmake b/Modules/FindPkgConfig.cmake index ae6903e..d519c1d 100644 --- a/Modules/FindPkgConfig.cmake +++ b/Modules/FindPkgConfig.cmake @@ -70,14 +70,14 @@ macro(_pkgconfig_invoke _pkglist _prefix _varname _regexp) execute_process( COMMAND ${PKG_CONFIG_EXECUTABLE} ${ARGN} ${_pkglist} OUTPUT_VARIABLE _pkgconfig_invoke_result - RESULT_VARIABLE _pkgconfig_failed) + RESULT_VARIABLE _pkgconfig_failed + OUTPUT_STRIP_TRAILING_WHITESPACE) if (_pkgconfig_failed) set(_pkgconfig_${_varname} "") _pkgconfig_unset(${_prefix}_${_varname}) else() string(REGEX REPLACE "[\r\n]" " " _pkgconfig_invoke_result "${_pkgconfig_invoke_result}") - string(REGEX REPLACE " +$" "" _pkgconfig_invoke_result "${_pkgconfig_invoke_result}") if (NOT ${_regexp} STREQUAL "") string(REGEX REPLACE "${_regexp}" " " _pkgconfig_invoke_result "${_pkgconfig_invoke_result}") @@ -91,6 +91,26 @@ macro(_pkgconfig_invoke _pkglist _prefix _varname _regexp) endif() endmacro() +#[========================================[.rst: +.. command:: pkg_get_variable + + Retrieves the value of a variable from a package:: + + pkg_get_variable(<RESULT> <MODULE> <VARIABLE>) + + For example: + + .. code-block:: cmake + + pkg_get_variable(GI_GIRDIR gobject-introspection-1.0 girdir) +#]========================================] +function (pkg_get_variable result pkg variable) + _pkgconfig_invoke("${pkg}" "prefix" "result" "" "--variable=${variable}") + set("${result}" + "${prefix_result}" + PARENT_SCOPE) +endfunction () + # Invokes pkgconfig two times; once without '--static' and once with # '--static' macro(_pkgconfig_invoke_dyn _pkglist _prefix _varname cleanup_regexp) @@ -308,7 +328,7 @@ macro(_pkg_check_modules_internal _is_required _is_silent _no_cmake_path _no_cma if (_pkg_check_modules_pkg_op) list(APPEND _pkg_check_modules_exist_query "${_pkg_check_modules_pkg_ver}") else() - list(APPEND _pkg_check_modules_exist_query --exists) + list(APPEND _pkg_check_modules_exist_query --exists --print-errors --short-errors) endif() _pkgconfig_unset(${_prefix}_${_pkg_check_modules_pkg_name}_VERSION) @@ -322,12 +342,14 @@ macro(_pkg_check_modules_internal _is_required _is_silent _no_cmake_path _no_cma # execute the query execute_process( COMMAND ${PKG_CONFIG_EXECUTABLE} ${_pkg_check_modules_exist_query} - RESULT_VARIABLE _pkgconfig_retval) + RESULT_VARIABLE _pkgconfig_retval + ERROR_VARIABLE _pkgconfig_error + ERROR_STRIP_TRAILING_WHITESPACE) # evaluate result and tell failures if (_pkgconfig_retval) if(NOT ${_is_silent}) - message(STATUS " Package '${_pkg_check_modules_pkg}' not found") + message(STATUS " ${_pkgconfig_error}") endif() set(_pkg_check_modules_failed 1) @@ -356,9 +378,9 @@ macro(_pkg_check_modules_internal _is_required _is_silent _no_cmake_path _no_cma endif() _pkgconfig_invoke(${_pkg_check_modules_pkg} "${_pkg_check_prefix}" VERSION "" --modversion ) - _pkgconfig_invoke(${_pkg_check_modules_pkg} "${_pkg_check_prefix}" PREFIX "" --variable=prefix ) - _pkgconfig_invoke(${_pkg_check_modules_pkg} "${_pkg_check_prefix}" INCLUDEDIR "" --variable=includedir ) - _pkgconfig_invoke(${_pkg_check_modules_pkg} "${_pkg_check_prefix}" LIBDIR "" --variable=libdir ) + pkg_get_variable("${_pkg_check_prefix}_PREFIX" ${_pkg_check_modules_pkg} "prefix") + pkg_get_variable("${_pkg_check_prefix}_INCLUDEDIR" ${_pkg_check_modules_pkg} "includedir") + pkg_get_variable("${_pkg_check_prefix}_LIBDIR" ${_pkg_check_modules_pkg} "libdir") if (NOT ${_is_silent}) message(STATUS " Found ${_pkg_check_modules_pkg}, version ${_pkgconfig_VERSION}") diff --git a/Modules/FindPostgreSQL.cmake b/Modules/FindPostgreSQL.cmake index 3ce2c73..d05d3da 100644 --- a/Modules/FindPostgreSQL.cmake +++ b/Modules/FindPostgreSQL.cmake @@ -81,7 +81,7 @@ set(PostgreSQL_ROOT_DIR_MESSAGE "Set the PostgreSQL_ROOT system variable to wher set(PostgreSQL_KNOWN_VERSIONS ${PostgreSQL_ADDITIONAL_VERSIONS} - "9.4" "9.3" "9.2" "9.1" "9.0" "8.4" "8.3" "8.2" "8.1" "8.0") + "9.5" "9.4" "9.3" "9.2" "9.1" "9.0" "8.4" "8.3" "8.2" "8.1" "8.0") # Define additional search paths for root directories. set( PostgreSQL_ROOT_DIRECTORIES diff --git a/Modules/FindProtobuf.cmake b/Modules/FindProtobuf.cmake index 335c408..4a68cd1 100644 --- a/Modules/FindProtobuf.cmake +++ b/Modules/FindProtobuf.cmake @@ -57,17 +57,18 @@ # include_directories(${PROTOBUF_INCLUDE_DIRS}) # include_directories(${CMAKE_CURRENT_BINARY_DIR}) # protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS foo.proto) +# protobuf_generate_python(PROTO_PY foo.proto) # add_executable(bar bar.cc ${PROTO_SRCS} ${PROTO_HDRS}) # target_link_libraries(bar ${PROTOBUF_LIBRARIES}) # # .. note:: -# The PROTOBUF_GENERATE_CPP macro and add_executable() or -# add_library() calls only work properly within the same -# directory. +# The ``protobuf_generate_cpp`` and ``protobuf_generate_python`` +# functions and :command:`add_executable` or :command:`add_library` +# calls only work properly within the same directory. # # .. command:: protobuf_generate_cpp # -# Add custom commands to process ``.proto`` files:: +# Add custom commands to process ``.proto`` files to C++:: # # protobuf_generate_cpp (<SRCS> <HDRS> [<ARGN>...]) # @@ -77,6 +78,17 @@ # Variable to define with autogenerated header files # ``ARGN`` # ``.proto`` files +# +# .. command:: protobuf_generate_python +# +# Add custom commands to process ``.proto`` files to Python:: +# +# protobuf_generate_python (<PY> [<ARGN>...]) +# +# ``PY`` +# Variable to define with autogenerated Python files +# ``ARGN`` +# ``.proto`` filess #============================================================================= # Copyright 2009 Kitware, Inc. @@ -147,6 +159,53 @@ function(PROTOBUF_GENERATE_CPP SRCS HDRS) set(${HDRS} ${${HDRS}} PARENT_SCOPE) endfunction() +function(PROTOBUF_GENERATE_PYTHON SRCS) + if(NOT ARGN) + message(SEND_ERROR "Error: PROTOBUF_GENERATE_PYTHON() called without any proto files") + return() + endif() + + if(PROTOBUF_GENERATE_CPP_APPEND_PATH) + # Create an include path for each file specified + foreach(FIL ${ARGN}) + get_filename_component(ABS_FIL ${FIL} ABSOLUTE) + get_filename_component(ABS_PATH ${ABS_FIL} PATH) + list(FIND _protobuf_include_path ${ABS_PATH} _contains_already) + if(${_contains_already} EQUAL -1) + list(APPEND _protobuf_include_path -I ${ABS_PATH}) + endif() + endforeach() + else() + set(_protobuf_include_path -I ${CMAKE_CURRENT_SOURCE_DIR}) + endif() + + if(DEFINED PROTOBUF_IMPORT_DIRS) + foreach(DIR ${PROTOBUF_IMPORT_DIRS}) + get_filename_component(ABS_PATH ${DIR} ABSOLUTE) + list(FIND _protobuf_include_path ${ABS_PATH} _contains_already) + if(${_contains_already} EQUAL -1) + list(APPEND _protobuf_include_path -I ${ABS_PATH}) + endif() + endforeach() + endif() + + set(${SRCS}) + foreach(FIL ${ARGN}) + get_filename_component(ABS_FIL ${FIL} ABSOLUTE) + get_filename_component(FIL_WE ${FIL} NAME_WE) + + list(APPEND ${SRCS} "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}_pb2.py") + add_custom_command( + OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}_pb2.py" + COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} --python_out ${CMAKE_CURRENT_BINARY_DIR} ${_protobuf_include_path} ${ABS_FIL} + DEPENDS ${ABS_FIL} ${PROTOBUF_PROTOC_EXECUTABLE} + COMMENT "Running Python protocol buffer compiler on ${FIL}" + VERBATIM ) + endforeach() + + set(${SRCS} ${${SRCS}} PARENT_SCOPE) +endfunction() + if(CMAKE_SIZEOF_VOID_P EQUAL 8) set(_PROTOBUF_ARCH_DIR x64/) endif() diff --git a/Modules/FindPythonInterp.cmake b/Modules/FindPythonInterp.cmake index 8784e18..879192e 100644 --- a/Modules/FindPythonInterp.cmake +++ b/Modules/FindPythonInterp.cmake @@ -51,7 +51,7 @@ unset(_Python_NAMES) set(_PYTHON1_VERSIONS 1.6 1.5) set(_PYTHON2_VERSIONS 2.7 2.6 2.5 2.4 2.3 2.2 2.1 2.0) -set(_PYTHON3_VERSIONS 3.4 3.3 3.2 3.1 3.0) +set(_PYTHON3_VERSIONS 3.6 3.5 3.4 3.3 3.2 3.1 3.0) if(PythonInterp_FIND_VERSION) if(PythonInterp_FIND_VERSION_COUNT GREATER 1) diff --git a/Modules/FindPythonLibs.cmake b/Modules/FindPythonLibs.cmake index b80d3ce..68e1228 100644 --- a/Modules/FindPythonLibs.cmake +++ b/Modules/FindPythonLibs.cmake @@ -49,6 +49,25 @@ # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) +# Use the executable's path as a hint +set(_Python_LIBRARY_PATH_HINT) +if(PYTHON_EXECUTABLE) + if(WIN32) + get_filename_component(_Python_PREFIX ${PYTHON_EXECUTABLE} PATH) + if(_Python_PREFIX) + set(_Python_LIBRARY_PATH_HINT ${_Python_PREFIX}/libs) + endif() + unset(_Python_PREFIX) + else() + get_filename_component(_Python_PREFIX ${PYTHON_EXECUTABLE} PATH) + get_filename_component(_Python_PREFIX ${_Python_PREFIX} PATH) + if(_Python_PREFIX) + set(_Python_LIBRARY_PATH_HINT ${_Python_PREFIX}/lib) + endif() + unset(_Python_PREFIX) + endif() +endif() + include(${CMAKE_CURRENT_LIST_DIR}/CMakeFindFrameworks.cmake) # Search for the python framework on Apple. CMAKE_FIND_FRAMEWORKS(Python) @@ -64,7 +83,7 @@ set(CMAKE_FIND_FRAMEWORK LAST) set(_PYTHON1_VERSIONS 1.6 1.5) set(_PYTHON2_VERSIONS 2.7 2.6 2.5 2.4 2.3 2.2 2.1 2.0) -set(_PYTHON3_VERSIONS 3.4 3.3 3.2 3.1 3.0) +set(_PYTHON3_VERSIONS 3.6 3.5 3.4 3.3 3.2 3.1 3.0) if(PythonLibs_FIND_VERSION) if(PythonLibs_FIND_VERSION_COUNT GREATER 1) @@ -112,6 +131,7 @@ foreach(_CURRENT_VERSION ${_Python_VERSIONS}) if(WIN32) find_library(PYTHON_DEBUG_LIBRARY NAMES python${_CURRENT_VERSION_NO_DOTS}_d python + HINTS ${_Python_LIBRARY_PATH_HINT} PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/libs/Debug [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/libs/Debug @@ -134,6 +154,8 @@ foreach(_CURRENT_VERSION ${_Python_VERSIONS}) python${_CURRENT_VERSION}m python${_CURRENT_VERSION}u python${_CURRENT_VERSION} + HINTS + ${_Python_LIBRARY_PATH_HINT} PATHS ${PYTHON_FRAMEWORK_LIBRARIES} [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/libs @@ -150,33 +172,42 @@ foreach(_CURRENT_VERSION ${_Python_VERSIONS}) PATH_SUFFIXES python${_CURRENT_VERSION}/config ) - # For backward compatibility, honour value of PYTHON_INCLUDE_PATH, if - # PYTHON_INCLUDE_DIR is not set. - if(DEFINED PYTHON_INCLUDE_PATH AND NOT DEFINED PYTHON_INCLUDE_DIR) - set(PYTHON_INCLUDE_DIR "${PYTHON_INCLUDE_PATH}" CACHE PATH - "Path to where Python.h is found" FORCE) - endif() + # Don't search for include dir until library location is known + if(PYTHON_LIBRARY) - set(PYTHON_FRAMEWORK_INCLUDES) - if(Python_FRAMEWORKS AND NOT PYTHON_INCLUDE_DIR) - foreach(dir ${Python_FRAMEWORKS}) - list(APPEND PYTHON_FRAMEWORK_INCLUDES - ${dir}/Versions/${_CURRENT_VERSION}/include/python${_CURRENT_VERSION}) - endforeach() - endif() + # Use the library's install prefix as a hint + set(_Python_INCLUDE_PATH_HINT) + get_filename_component(_Python_PREFIX ${PYTHON_LIBRARY} PATH) + get_filename_component(_Python_PREFIX ${_Python_PREFIX} PATH) + if(_Python_PREFIX) + set(_Python_INCLUDE_PATH_HINT ${_Python_PREFIX}/include) + endif() + unset(_Python_PREFIX) + + # Add framework directories to the search paths + set(PYTHON_FRAMEWORK_INCLUDES) + if(Python_FRAMEWORKS AND NOT PYTHON_INCLUDE_DIR) + foreach(dir ${Python_FRAMEWORKS}) + list(APPEND PYTHON_FRAMEWORK_INCLUDES + ${dir}/Versions/${_CURRENT_VERSION}/include) + endforeach() + endif() - find_path(PYTHON_INCLUDE_DIR - NAMES Python.h - PATHS - ${PYTHON_FRAMEWORK_INCLUDES} - [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/include - [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/include - PATH_SUFFIXES - python${_CURRENT_VERSION}mu - python${_CURRENT_VERSION}m - python${_CURRENT_VERSION}u - python${_CURRENT_VERSION} - ) + find_path(PYTHON_INCLUDE_DIR + NAMES Python.h + HINTS + ${_Python_INCLUDE_PATH_HINT} + PATHS + ${PYTHON_FRAMEWORK_INCLUDES} + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/include + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/include + PATH_SUFFIXES + python${_CURRENT_VERSION}mu + python${_CURRENT_VERSION}m + python${_CURRENT_VERSION}u + python${_CURRENT_VERSION} + ) + endif() # For backward compatibility, set PYTHON_INCLUDE_PATH. set(PYTHON_INCLUDE_PATH "${PYTHON_INCLUDE_DIR}") @@ -194,6 +225,9 @@ foreach(_CURRENT_VERSION ${_Python_VERSIONS}) endif() endforeach() +unset(_Python_INCLUDE_PATH_HINT) +unset(_Python_LIBRARY_PATH_HINT) + mark_as_advanced( PYTHON_DEBUG_LIBRARY PYTHON_LIBRARY diff --git a/Modules/FindThreads.cmake b/Modules/FindThreads.cmake index a0bc4d1..c607923 100644 --- a/Modules/FindThreads.cmake +++ b/Modules/FindThreads.cmake @@ -39,7 +39,7 @@ #============================================================================= # Copyright 2002-2009 Kitware, Inc. -# Copyright 2011-2014 Rolf Eike Beer <eike@sf-mail.de> +# Copyright 2011-2015 Rolf Eike Beer <eike@sf-mail.de> # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. @@ -51,15 +51,23 @@ # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) -include (CheckIncludeFiles) include (CheckLibraryExists) include (CheckSymbolExists) set(Threads_FOUND FALSE) set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET}) set(CMAKE_REQUIRED_QUIET ${Threads_FIND_QUIETLY}) +if(CMAKE_C_COMPILER_LOADED) + include (CheckIncludeFile) +elseif(CMAKE_CXX_COMPILER_LOADED) + include (CheckIncludeFileCXX) +else() + message(FATAL_ERROR "FindThreads only works if either C or CXX language is enabled") +endif() + # Do we have sproc? if(CMAKE_SYSTEM_NAME MATCHES IRIX AND NOT CMAKE_THREAD_PREFER_PTHREAD) + include (CheckIncludeFiles) CHECK_INCLUDE_FILES("sys/types.h;sys/prctl.h" CMAKE_HAVE_SPROC_H) endif() @@ -83,11 +91,18 @@ macro(_check_pthreads_flag) # If we did not found -lpthread, -lpthread, or -lthread, look for -pthread if(NOT DEFINED THREADS_HAVE_PTHREAD_ARG) message(STATUS "Check if compiler accepts -pthread") + if(CMAKE_C_COMPILER_LOADED) + set(_threads_src ${CMAKE_CURRENT_LIST_DIR}/CheckForPthreads.c) + elseif(CMAKE_CXX_COMPILER_LOADED) + set(_threads_src ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/FindThreads/CheckForPthreads.cxx) + configure_file(${CMAKE_CURRENT_LIST_DIR}/CheckForPthreads.c "${_threads_src}" COPYONLY) + endif() try_run(THREADS_PTHREAD_ARG THREADS_HAVE_PTHREAD_ARG ${CMAKE_BINARY_DIR} - ${CMAKE_CURRENT_LIST_DIR}/CheckForPthreads.c + ${_threads_src} CMAKE_FLAGS -DLINK_LIBRARIES:STRING=-pthread COMPILE_OUTPUT_VARIABLE OUTPUT) + unset(_threads_src) if(THREADS_HAVE_PTHREAD_ARG) if(THREADS_PTHREAD_ARG STREQUAL "2") @@ -120,7 +135,11 @@ if(CMAKE_HAVE_SPROC_H AND NOT CMAKE_THREAD_PREFER_PTHREAD) set(CMAKE_USE_SPROC_INIT 1) else() # Do we have pthreads? - CHECK_INCLUDE_FILES("pthread.h" CMAKE_HAVE_PTHREAD_H) + if(CMAKE_C_COMPILER_LOADED) + CHECK_INCLUDE_FILE("pthread.h" CMAKE_HAVE_PTHREAD_H) + else() + CHECK_INCLUDE_FILE_CXX("pthread.h" CMAKE_HAVE_PTHREAD_H) + endif() if(CMAKE_HAVE_PTHREAD_H) # diff --git a/Modules/FindZLIB.cmake b/Modules/FindZLIB.cmake index d4a27d5..a57f450 100644 --- a/Modules/FindZLIB.cmake +++ b/Modules/FindZLIB.cmake @@ -74,14 +74,28 @@ set(_ZLIB_SEARCH_NORMAL ) list(APPEND _ZLIB_SEARCHES _ZLIB_SEARCH_NORMAL) -set(ZLIB_NAMES z zlib zdll zlib1 zlibd zlibd1) +set(ZLIB_NAMES z zlib zdll zlib1) +set(ZLIB_NAMES_DEBUG zlibd zlibd1) # Try each search configuration. foreach(search ${_ZLIB_SEARCHES}) - find_path(ZLIB_INCLUDE_DIR NAMES zlib.h ${${search}} PATH_SUFFIXES include) - find_library(ZLIB_LIBRARY NAMES ${ZLIB_NAMES} ${${search}} PATH_SUFFIXES lib) + find_path(ZLIB_INCLUDE_DIR NAMES zlib.h ${${search}} PATH_SUFFIXES include) endforeach() +# Allow ZLIB_LIBRARY to be set manually, as the location of the zlib library +if(NOT ZLIB_LIBRARY) + foreach(search ${_ZLIB_SEARCHES}) + find_library(ZLIB_LIBRARY_RELEASE NAMES ${ZLIB_NAMES} ${${search}} PATH_SUFFIXES lib) + find_library(ZLIB_LIBRARY_DEBUG NAMES ${ZLIB_NAMES_DEBUG} ${${search}} PATH_SUFFIXES lib) + endforeach() + + include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake) + select_library_configurations(ZLIB) +endif() + +unset(ZLIB_NAMES) +unset(ZLIB_NAMES_DEBUG) + mark_as_advanced(ZLIB_LIBRARY ZLIB_INCLUDE_DIR) if(ZLIB_INCLUDE_DIR AND EXISTS "${ZLIB_INCLUDE_DIR}/zlib.h") @@ -112,12 +126,33 @@ FIND_PACKAGE_HANDLE_STANDARD_ARGS(ZLIB REQUIRED_VARS ZLIB_LIBRARY ZLIB_INCLUDE_D if(ZLIB_FOUND) set(ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR}) - set(ZLIB_LIBRARIES ${ZLIB_LIBRARY}) + + if(NOT ZLIB_LIBRARIES) + set(ZLIB_LIBRARIES ${ZLIB_LIBRARY}) + endif() if(NOT TARGET ZLIB::ZLIB) add_library(ZLIB::ZLIB UNKNOWN IMPORTED) set_target_properties(ZLIB::ZLIB PROPERTIES - IMPORTED_LOCATION "${ZLIB_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${ZLIB_INCLUDE_DIRS}") + + if(ZLIB_LIBRARY_RELEASE) + set_property(TARGET ZLIB::ZLIB APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE) + set_target_properties(ZLIB::ZLIB PROPERTIES + IMPORTED_LOCATION_RELEASE "${ZLIB_LIBRARY_RELEASE}") + endif() + + if(ZLIB_LIBRARY_DEBUG) + set_property(TARGET ZLIB::ZLIB APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + set_target_properties(ZLIB::ZLIB PROPERTIES + IMPORTED_LOCATION_DEBUG "${ZLIB_LIBRARY_DEBUG}") + endif() + + if(NOT ZLIB_LIBRARY_RELEASE AND NOT ZLIB_LIBRARY_DEBUG) + set_property(TARGET ZLIB::ZLIB APPEND PROPERTY + IMPORTED_LOCATION "${ZLIB_LIBRARY}") + endif() endif() endif() diff --git a/Modules/FindwxWidgets.cmake b/Modules/FindwxWidgets.cmake index 9a70678..9037594 100644 --- a/Modules/FindwxWidgets.cmake +++ b/Modules/FindwxWidgets.cmake @@ -193,8 +193,8 @@ set(wxWidgets_CXX_FLAGS "") # to prevent UsewxWidgets.cmake from using SYSTEM. # # See cmake mailing list discussions for more info: -# http://www.cmake.org/pipermail/cmake/2008-April/021115.html -# http://www.cmake.org/pipermail/cmake/2008-April/021146.html +# https://cmake.org/pipermail/cmake/2008-April/021115.html +# https://cmake.org/pipermail/cmake/2008-April/021146.html # if(APPLE OR CMAKE_CXX_PLATFORM_ID MATCHES "OpenBSD") set(wxWidgets_INCLUDE_DIRS_NO_SYSTEM 1) @@ -302,6 +302,7 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") # Find wxWidgets multilib base libraries. find_library(WX_base${_DBG} NAMES + wxbase31${_UCD}${_DBG} wxbase30${_UCD}${_DBG} wxbase29${_UCD}${_DBG} wxbase28${_UCD}${_DBG} @@ -315,6 +316,7 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") foreach(LIB net odbc xml) find_library(WX_${LIB}${_DBG} NAMES + wxbase31${_UCD}${_DBG}_${LIB} wxbase30${_UCD}${_DBG}_${LIB} wxbase29${_UCD}${_DBG}_${LIB} wxbase28${_UCD}${_DBG}_${LIB} @@ -330,6 +332,7 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") # Find wxWidgets monolithic library. find_library(WX_mono${_DBG} NAMES + wxmsw${_UNV}31${_UCD}${_DBG} wxmsw${_UNV}30${_UCD}${_DBG} wxmsw${_UNV}29${_UCD}${_DBG} wxmsw${_UNV}28${_UCD}${_DBG} @@ -346,6 +349,7 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") stc ribbon propgrid webview) find_library(WX_${LIB}${_DBG} NAMES + wxmsw${_UNV}31${_UCD}${_DBG}_${LIB} wxmsw${_UNV}30${_UCD}${_DBG}_${LIB} wxmsw${_UNV}29${_UCD}${_DBG}_${LIB} wxmsw${_UNV}28${_UCD}${_DBG}_${LIB} @@ -386,7 +390,7 @@ if(wxWidgets_FIND_STYLE STREQUAL "win32") # Clear wxWidgets multilib libraries. foreach(LIB core adv aui html media xrc dbgrid gl qa richtext - stc ribbon propgrid) + webview stc ribbon propgrid) WX_CLEAR_LIB(WX_${LIB}${_DBG}) endforeach() endmacro() @@ -741,7 +745,7 @@ else() #----------------------------------------------------------------- # Support cross-compiling, only search in the target platform. find_program(wxWidgets_CONFIG_EXECUTABLE - NAMES wx-config wx-config-3.0 wx-config-2.9 wx-config-2.8 + NAMES wx-config wx-config-3.1 wx-config-3.0 wx-config-2.9 wx-config-2.8 DOC "Location of wxWidgets library configuration provider binary (wx-config)." ONLY_CMAKE_FIND_ROOT_PATH ) @@ -857,6 +861,28 @@ else() endif() endif() +# Check if a specfic version was requested by find_package(). +if(wxWidgets_FOUND) + find_file(_filename wx/version.h PATHS ${wxWidgets_INCLUDE_DIRS} NO_DEFAULT_PATH) + dbg_msg("_filename: ${_filename}") + + if(NOT _filename) + message(FATAL_ERROR "wxWidgets wx/version.h file not found in ${wxWidgets_INCLUDE_DIRS}.") + endif() + + file(READ ${_filename} _wx_version_h) + + string(REGEX REPLACE "^(.*\n)?#define +wxMAJOR_VERSION +([0-9]+).*" + "\\2" wxWidgets_VERSION_MAJOR "${_wx_version_h}" ) + string(REGEX REPLACE "^(.*\n)?#define +wxMINOR_VERSION +([0-9]+).*" + "\\2" wxWidgets_VERSION_MINOR "${_wx_version_h}" ) + string(REGEX REPLACE "^(.*\n)?#define +wxRELEASE_NUMBER +([0-9]+).*" + "\\2" wxWidgets_VERSION_PATCH "${_wx_version_h}" ) + set(wxWidgets_VERSION_STRING + "${wxWidgets_VERSION_MAJOR}.${wxWidgets_VERSION_MINOR}.${wxWidgets_VERSION_PATCH}" ) + dbg_msg("wxWidgets_VERSION_STRING: ${wxWidgets_VERSION_STRING}") +endif() + # Debug output: DBG_MSG("wxWidgets_FOUND : ${wxWidgets_FOUND}") DBG_MSG("wxWidgets_INCLUDE_DIRS : ${wxWidgets_INCLUDE_DIRS}") @@ -867,10 +893,13 @@ DBG_MSG("wxWidgets_USE_FILE : ${wxWidgets_USE_FILE}") #===================================================================== #===================================================================== + include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) -FIND_PACKAGE_HANDLE_STANDARD_ARGS(wxWidgets DEFAULT_MSG wxWidgets_FOUND) -# Maintain consistency with all other variables. -set(wxWidgets_FOUND ${WXWIDGETS_FOUND}) + +find_package_handle_standard_args(wxWidgets + REQUIRED_VARS wxWidgets_LIBRARIES wxWidgets_INCLUDE_DIRS + VERSION_VAR wxWidgets_VERSION_STRING + ) #===================================================================== # Macros for use in wxWidgets apps. diff --git a/Modules/Internal/FeatureTesting.cmake b/Modules/Internal/FeatureTesting.cmake index abd9a26..86b89b2 100644 --- a/Modules/Internal/FeatureTesting.cmake +++ b/Modules/Internal/FeatureTesting.cmake @@ -5,7 +5,7 @@ macro(record_compiler_features lang compile_flags feature_list) string(TOLOWER ${lang} lang_lc) file(REMOVE "${CMAKE_BINARY_DIR}/CMakeFiles/feature_tests.bin") file(WRITE "${CMAKE_BINARY_DIR}/CMakeFiles/feature_tests.${lang_lc}" " - const char features[] = {\"\"\n") + const char features[] = {\"\\n\"\n") get_property(known_features GLOBAL PROPERTY CMAKE_${lang}_KNOWN_FEATURES) diff --git a/Modules/NSIS.template.in b/Modules/NSIS.template.in index 76310af..1ef3d28 100644 --- a/Modules/NSIS.template.in +++ b/Modules/NSIS.template.in @@ -542,6 +542,8 @@ FunctionEnd ; Define some macro setting for the gui @CPACK_NSIS_INSTALLER_MUI_ICON_CODE@ @CPACK_NSIS_INSTALLER_ICON_CODE@ +@CPACK_NSIS_INSTALLER_MUI_WELCOMEFINISH_CODE@ +@CPACK_NSIS_INSTALLER_MUI_UNWELCOMEFINISH_CODE@ @CPACK_NSIS_INSTALLER_MUI_COMPONENTS_DESC@ @CPACK_NSIS_INSTALLER_MUI_FINISHPAGE_RUN_CODE@ diff --git a/Modules/Platform/Darwin-Initialize.cmake b/Modules/Platform/Darwin-Initialize.cmake index 62fb985..a08411b 100644 --- a/Modules/Platform/Darwin-Initialize.cmake +++ b/Modules/Platform/Darwin-Initialize.cmake @@ -100,6 +100,10 @@ elseif("${CMAKE_GENERATOR}" MATCHES Xcode "Instead using SDK:\n \"${_CMAKE_OSX_SYSROOT_DEFAULT}\"." ) endif() + if(NOT CMAKE_OSX_DEPLOYMENT_TARGET AND _CURRENT_OSX_VERSION VERSION_LESS _CMAKE_OSX_DEPLOYMENT_TARGET) + set(CMAKE_OSX_DEPLOYMENT_TARGET ${_CURRENT_OSX_VERSION} CACHE STRING + "Minimum OS X version to target for deployment (at runtime); newer APIs weak linked. Set to empty string for default value." FORCE) + endif() else() # Assume developer files are in root (such as Xcode 4.5 command-line tools). set(_CMAKE_OSX_SYSROOT_DEFAULT "") diff --git a/Modules/Platform/GHS-MULTI-Initialize.cmake b/Modules/Platform/GHS-MULTI-Initialize.cmake index 342ad21..9eb7a8a 100644 --- a/Modules/Platform/GHS-MULTI-Initialize.cmake +++ b/Modules/Platform/GHS-MULTI-Initialize.cmake @@ -13,13 +13,35 @@ # License text for the above reference.) #Setup Greenhills MULTI specific compilation information -find_path(GHS_INT_DIRECTORY INTEGRITY.ld PATHS - "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\GreenHillsSoftware6433c345;InstallLocation]" #int1122 - "C:/ghs/int1122" - "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\GreenHillsSoftware289b6625;InstallLocation]" #int1104 - "C:/ghs/int1104" - DOC "Path to integrity directory" - ) + +if (NOT GHS_INT_DIRECTORY) + #Assume the C:/ghs/int#### directory that is latest is prefered + set(GHS_EXPECTED_ROOT "C:/ghs") + if (EXISTS ${GHS_EXPECTED_ROOT}) + FILE(GLOB GHS_CANDIDATE_INT_DIRS RELATIVE + ${GHS_EXPECTED_ROOT} ${GHS_EXPECTED_ROOT}/*) + string(REGEX MATCHALL "int[0-9][0-9][0-9][0-9]" GHS_CANDIDATE_INT_DIRS + ${GHS_CANDIDATE_INT_DIRS}) + if (GHS_CANDIDATE_INT_DIRS) + list(SORT GHS_CANDIDATE_INT_DIRS) + list(GET GHS_CANDIDATE_INT_DIRS -1 GHS_INT_DIRECTORY) + string(CONCAT GHS_INT_DIRECTORY ${GHS_EXPECTED_ROOT} "/" + ${GHS_INT_DIRECTORY}) + endif () + endif () + + #Try to look for known registry values + if (NOT GHS_INT_DIRECTORY) + find_path(GHS_INT_DIRECTORY INTEGRITY.ld PATHS + "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\GreenHillsSoftware6433c345;InstallLocation]" #int1122 + "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\GreenHillsSoftware289b6625;InstallLocation]" #int1104 + ) + endif () + + set(GHS_INT_DIRECTORY ${GHS_INT_DIRECTORY} CACHE PATH + "Path to integrity directory") +endif () + set(GHS_OS_DIR ${GHS_INT_DIRECTORY} CACHE PATH "OS directory") set(GHS_PRIMARY_TARGET "arm_integrity.tgt" CACHE STRING "target for compilation") set(GHS_BSP_NAME "simarm" CACHE STRING "BSP name") diff --git a/Modules/Platform/Windows-GNU.cmake b/Modules/Platform/Windows-GNU.cmake index b97409c..d8a423e 100644 --- a/Modules/Platform/Windows-GNU.cmake +++ b/Modules/Platform/Windows-GNU.cmake @@ -65,7 +65,7 @@ macro(__windows_compiler_gnu lang) if(MSYS OR MINGW) # Create archiving rules to support large object file lists for static libraries. - set(CMAKE_${lang}_ARCHIVE_CREATE "<CMAKE_AR> cq <TARGET> <LINK_FLAGS> <OBJECTS>") + set(CMAKE_${lang}_ARCHIVE_CREATE "<CMAKE_AR> qc <TARGET> <LINK_FLAGS> <OBJECTS>") set(CMAKE_${lang}_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>") set(CMAKE_${lang}_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>") diff --git a/Modules/Platform/Windows-MSVC.cmake b/Modules/Platform/Windows-MSVC.cmake index 94470c3..a61413a 100644 --- a/Modules/Platform/Windows-MSVC.cmake +++ b/Modules/Platform/Windows-MSVC.cmake @@ -179,7 +179,9 @@ elseif(WINDOWS_PHONE OR WINDOWS_STORE) set(_PLATFORM_DEFINES "/DWIN32") set(_FLAGS_C " /DUNICODE /D_UNICODE") set(_FLAGS_CXX " /DUNICODE /D_UNICODE /GR /EHsc") - if(WINDOWS_PHONE) + if(WINDOWS_STORE AND MSVC_VERSION GREATER 1899) + set(CMAKE_C_STANDARD_LIBRARIES_INIT "WindowsApp.lib") + elseif(WINDOWS_PHONE) set(CMAKE_C_STANDARD_LIBRARIES_INIT "WindowsPhoneCore.lib RuntimeObject.lib PhoneAppModelHost.lib") elseif(_MSVC_C_ARCHITECTURE_FAMILY STREQUAL "ARM" OR _MSVC_CXX_ARCHITECTURE_FAMILY STREQUAL "ARM") set(CMAKE_C_STANDARD_LIBRARIES_INIT "kernel32.lib user32.lib") @@ -274,8 +276,8 @@ set (CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL_INIT ${CMAKE_EXE_LINKER_FLAGS_MINSIZER macro(__windows_compiler_msvc lang) if(NOT MSVC_VERSION LESS 1400) # for 2005 make sure the manifest is put in the dll with mt - set(_CMAKE_VS_LINK_DLL "<CMAKE_COMMAND> -E vs_link_dll ") - set(_CMAKE_VS_LINK_EXE "<CMAKE_COMMAND> -E vs_link_exe ") + set(_CMAKE_VS_LINK_DLL "<CMAKE_COMMAND> -E vs_link_dll --intdir=<OBJECT_DIR> --manifests <MANIFESTS> -- ") + set(_CMAKE_VS_LINK_EXE "<CMAKE_COMMAND> -E vs_link_exe --intdir=<OBJECT_DIR> --manifests <MANIFESTS> -- ") endif() set(CMAKE_${lang}_CREATE_SHARED_LIBRARY "${_CMAKE_VS_LINK_DLL}<CMAKE_LINKER> ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE} /out:<TARGET> /implib:<TARGET_IMPLIB> /pdb:<TARGET_PDB> /dll /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR>${_PLATFORM_LINK_FLAGS} <LINK_FLAGS> <LINK_LIBRARIES> ${CMAKE_END_TEMP_FILE}") @@ -300,6 +302,7 @@ macro(__windows_compiler_msvc lang) set(CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT "/MD /Zi /O2 /Ob1 /D NDEBUG") set(CMAKE_${lang}_FLAGS_MINSIZEREL_INIT "/MD /O1 /Ob1 /D NDEBUG") set(CMAKE_${lang}_LINKER_SUPPORTS_PDB ON) + set(CMAKE_NINJA_DEPTYPE_${lang} msvc) if(NOT CMAKE_RC_COMPILER_INIT) set(CMAKE_RC_COMPILER_INIT rc) @@ -309,4 +312,5 @@ macro(__windows_compiler_msvc lang) endif() enable_language(RC) + set(CMAKE_NINJA_CMCLDEPS_RC 1) endmacro() diff --git a/Modules/ProcessorCount.cmake b/Modules/ProcessorCount.cmake index 8f21adf..2c5d5ae 100644 --- a/Modules/ProcessorCount.cmake +++ b/Modules/ProcessorCount.cmake @@ -171,17 +171,30 @@ function(ProcessorCount var) endif() if(NOT count) - # Sun (systems where uname -X emits "NumCPU" in its output): - find_program(ProcessorCount_cmd_uname uname) - mark_as_advanced(ProcessorCount_cmd_uname) - if(ProcessorCount_cmd_uname) - execute_process(COMMAND ${ProcessorCount_cmd_uname} -X + # Sun (systems where psrinfo tool is available) + find_program(ProcessorCount_cmd_psrinfo psrinfo PATHS /usr/sbin /sbin) + mark_as_advanced(ProcessorCount_cmd_psrinfo) + if (ProcessorCount_cmd_psrinfo) + execute_process(COMMAND ${ProcessorCount_cmd_psrinfo} -p -v ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE - OUTPUT_VARIABLE uname_X_output) - string(REGEX MATCHALL "NumCPU = ([0-9]+)" procs "${uname_X_output}") + OUTPUT_VARIABLE psrinfo_output) + string(REGEX MATCH "([0-9]+) virtual processor" procs "${psrinfo_output}") set(count "${CMAKE_MATCH_1}") - #message("ProcessorCount: trying uname -X '${ProcessorCount_cmd_uname}'") + #message("ProcessorCount: trying psrinfo -p -v '${ProcessorCount_cmd_prvinfo}'") + else() + # Sun (systems where uname -X emits "NumCPU" in its output): + find_program(ProcessorCount_cmd_uname uname) + mark_as_advanced(ProcessorCount_cmd_uname) + if(ProcessorCount_cmd_uname) + execute_process(COMMAND ${ProcessorCount_cmd_uname} -X + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE + OUTPUT_VARIABLE uname_X_output) + string(REGEX MATCHALL "NumCPU = ([0-9]+)" procs "${uname_X_output}") + set(count "${CMAKE_MATCH_1}") + #message("ProcessorCount: trying uname -X '${ProcessorCount_cmd_uname}'") + endif() endif() endif() diff --git a/Modules/UseSWIG.cmake b/Modules/UseSWIG.cmake index 96b0b35..d757f65 100644 --- a/Modules/UseSWIG.cmake +++ b/Modules/UseSWIG.cmake @@ -153,10 +153,12 @@ macro(SWIG_ADD_SOURCE_TO_MODULE name outfiles infile) else() set(swig_outdir ${CMAKE_CURRENT_BINARY_DIR}) endif() - SWIG_GET_EXTRA_OUTPUT_FILES(${SWIG_MODULE_${name}_LANGUAGE} - swig_extra_generated_files - "${swig_outdir}" - "${swig_source_file_fullname}") + if (NOT SWIG_MODULE_${name}_NOPROXY) + SWIG_GET_EXTRA_OUTPUT_FILES(${SWIG_MODULE_${name}_LANGUAGE} + swig_extra_generated_files + "${swig_outdir}" + "${swig_source_file_fullname}") + endif() set(swig_generated_file_fullname "${swig_outdir}/${swig_source_file_name_we}") # add the language into the name of the file (i.e. TCL_wrap) diff --git a/Modules/UseVTK40.cmake b/Modules/UseVTK40.cmake deleted file mode 100644 index d6bdaaa..0000000 --- a/Modules/UseVTK40.cmake +++ /dev/null @@ -1,29 +0,0 @@ -# - -#============================================================================= -# Copyright 2002-2009 Kitware, Inc. -# -# Distributed under the OSI-approved BSD License (the "License"); -# see accompanying file Copyright.txt for details. -# -# This software is distributed WITHOUT ANY WARRANTY; without even the -# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the License for more information. -#============================================================================= -# (To distribute this file outside of CMake, substitute the full -# License text for the above reference.) - -# This is an implementation detail for using VTK 4.0 with the -# FindVTK.cmake module. Do not include directly by name. This should -# be included only when FindVTK.cmake sets the VTK_USE_FILE variable -# to point here. - -# Add compiler flags needed to use VTK. -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${VTK_REQUIRED_C_FLAGS}") -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${VTK_REQUIRED_CXX_FLAGS}") - -# Add include directories needed to use VTK. -include_directories(${VTK_INCLUDE_DIRS}) - -# Add link directories needed to use VTK. -link_directories(${VTK_LIBRARY_DIRS}) diff --git a/Modules/UseVTKBuildSettings40.cmake b/Modules/UseVTKBuildSettings40.cmake deleted file mode 100644 index 474f67c..0000000 --- a/Modules/UseVTKBuildSettings40.cmake +++ /dev/null @@ -1,38 +0,0 @@ -# - -#============================================================================= -# Copyright 2002-2009 Kitware, Inc. -# -# Distributed under the OSI-approved BSD License (the "License"); -# see accompanying file Copyright.txt for details. -# -# This software is distributed WITHOUT ANY WARRANTY; without even the -# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the License for more information. -#============================================================================= -# (To distribute this file outside of CMake, substitute the full -# License text for the above reference.) - -# Implementation detail for FindVTK.cmake to let it provide a -# VTK_BUILD_SETTINGS_FILE for VTK 4.0. - -set(CMAKE_BUILD_SETTING_CMAKE_MAJOR_VERSION "${VTK40_CMAKE_MAJOR_VERSION}") -set(CMAKE_BUILD_SETTING_CMAKE_MINOR_VERSION "${VTK40_CMAKE_MINOR_VERSION}") -set(CMAKE_BUILD_SETTING_PROJECT_NAME "VTK") - -set(CMAKE_BUILD_SETTING_C_COMPILER "${VTK40_CMAKE_C_COMPILER}") -set(CMAKE_BUILD_SETTING_C_FLAGS "${VTK40_CMAKE_C_FLAGS}") -set(CMAKE_BUILD_SETTING_C_FLAGS_DEBUG "${VTK40_CMAKE_C_FLAGS_DEBUG}") -set(CMAKE_BUILD_SETTING_C_FLAGS_RELEASE "${VTK40_CMAKE_C_FLAGS_RELEASE}") -set(CMAKE_BUILD_SETTING_C_FLAGS_MINSIZEREL "${VTK40_CMAKE_C_FLAGS_MINSIZEREL}") -set(CMAKE_BUILD_SETTING_C_FLAGS_RELWITHDEBINFO "${VTK40_CMAKE_C_FLAGS_RELWITHDEBINFO}") - -set(CMAKE_BUILD_SETTING_CXX_COMPILER "${VTK40_CMAKE_CXX_COMPILER}") -set(CMAKE_BUILD_SETTING_CXX_FLAGS "${VTK40_CMAKE_CXX_FLAGS}") -set(CMAKE_BUILD_SETTING_CXX_FLAGS_DEBUG "${VTK40_CMAKE_CXX_FLAGS_DEBUG}") -set(CMAKE_BUILD_SETTING_CXX_FLAGS_RELEASE "${VTK40_CMAKE_CXX_FLAGS_RELEASE}") -set(CMAKE_BUILD_SETTING_CXX_FLAGS_MINSIZEREL "${VTK40_CMAKE_CXX_FLAGS_MINSIZEREL}") -set(CMAKE_BUILD_SETTING_CXX_FLAGS_RELWITHDEBINFO "${VTK40_CMAKE_CXX_FLAGS_RELWITHDEBINFO}") - -set(CMAKE_BUILD_SETTING_BUILD_TYPE "${VTK40_CMAKE_BUILD_TYPE}") -set(CMAKE_BUILD_SETTING_BUILD_TOOL "${VTK40_CMAKE_BUILD_TOOL}") diff --git a/Modules/UseVTKConfig40.cmake b/Modules/UseVTKConfig40.cmake deleted file mode 100644 index c5022e4..0000000 --- a/Modules/UseVTKConfig40.cmake +++ /dev/null @@ -1,409 +0,0 @@ -# - -#============================================================================= -# Copyright 2002-2009 Kitware, Inc. -# -# Distributed under the OSI-approved BSD License (the "License"); -# see accompanying file Copyright.txt for details. -# -# This software is distributed WITHOUT ANY WARRANTY; without even the -# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the License for more information. -#============================================================================= -# (To distribute this file outside of CMake, substitute the full -# License text for the above reference.) - -# This is an implementation detail for using VTK 4.0 with the -# FindVTK.cmake module. Do not include directly. - -# Hard-code the version number since it isn't provided by VTK 4.0. -set(VTK_MAJOR_VERSION 4) -set(VTK_MINOR_VERSION 0) -set(VTK_BUILD_VERSION 2) - -# Provide a new UseVTK file that doesn't do a full LOAD_CACHE. -set(VTK_USE_FILE ${CMAKE_ROOT}/Modules/UseVTK40.cmake) - -# Provide a build settings file. -set(VTK_BUILD_SETTINGS_FILE ${CMAKE_ROOT}/Modules/UseVTKBuildSettings40.cmake) - -# There are no CMake extensions for VTK 4.0. -set(VTK_CMAKE_EXTENSIONS_DIR "") - -# grep "VTK40_" UseVTKConfig40.cmake |sed 's/.*VTK40_\([A-Za-z0-9_]*\).*/ \1/' -load_cache(${VTK_DIR} READ_WITH_PREFIX VTK40_ - BUILD_SHARED_LIBS - CMAKE_BUILD_TOOL - CMAKE_BUILD_TYPE - CMAKE_CACHE_MAJOR_VERSION - CMAKE_CACHE_MINOR_VERSION - CMAKE_CXX_COMPILER - CMAKE_CXX_FLAGS - CMAKE_CXX_FLAGS_DEBUG - CMAKE_CXX_FLAGS_MINSIZEREL - CMAKE_CXX_FLAGS_RELEASE - CMAKE_CXX_FLAGS_RELWITHDEBINFO - CMAKE_C_COMPILER - CMAKE_C_FLAGS - CMAKE_C_FLAGS_DEBUG - CMAKE_C_FLAGS_MINSIZEREL - CMAKE_C_FLAGS_RELEASE - CMAKE_C_FLAGS_RELWITHDEBINFO - CMAKE_INSTALL_PREFIX - CMAKE_Xutil_INCLUDE_PATH - EXECUTABLE_OUTPUT_PATH - JAVA_INCLUDE_PATH2 - LIBRARY_OUTPUT_PATH - MPIRUN - MPI_INCLUDE_PATH - MPI_POSTFLAGS - MPI_PREFLAGS - OPENGL_INCLUDE_DIR - OSMESA_INCLUDE_PATH - PYTHON_INCLUDE_PATH - TCL_INCLUDE_PATH - VLI_INCLUDE_PATH_FOR_VG500 - VLI_INCLUDE_PATH_FOR_VP1000 - VTK_BINARY_DIR - VTK_DEBUG_LEAKS - VTK_HAVE_VG500 - VTK_HAVE_VP1000 - VTK_MANGLE_MESA - VTK_OPENGL_HAS_OSMESA - VTK_PARSE_JAVA_EXE - VTK_SOURCE_DIR - VTK_USE_64BIT_IDS - VTK_USE_ANSI_STDLIB - VTK_USE_HYBRID - VTK_USE_MATROX_IMAGING - VTK_USE_MPI - VTK_USE_PARALLEL - VTK_USE_PATENTED - VTK_USE_RENDERING - VTK_USE_VIDEO_FOR_WINDOWS - VTK_USE_VOLUMEPRO - VTK_USE_X - VTK_WRAP_JAVA - VTK_WRAP_JAVA_EXE - VTK_WRAP_PYTHON - VTK_WRAP_PYTHON_EXE - VTK_WRAP_TCL - VTK_WRAP_TCL_EXE - vtkCommonJava_LIB_DEPENDS - vtkCommonPython_LIB_DEPENDS - vtkCommonTCL_LIB_DEPENDS - vtkCommon_LIB_DEPENDS - vtkFilteringJava_LIB_DEPENDS - vtkFilteringPython_LIB_DEPENDS - vtkFilteringTCL_LIB_DEPENDS - vtkFiltering_LIB_DEPENDS - vtkGraphicsJava_LIB_DEPENDS - vtkGraphicsPython_LIB_DEPENDS - vtkGraphicsTCL_LIB_DEPENDS - vtkGraphics_LIB_DEPENDS - vtkHybridJava_LIB_DEPENDS - vtkHybridPython_LIB_DEPENDS - vtkHybridTCL_LIB_DEPENDS - vtkHybrid_LIB_DEPENDS - vtkIOJava_LIB_DEPENDS - vtkIOPython_LIB_DEPENDS - vtkIOTCL_LIB_DEPENDS - vtkIO_LIB_DEPENDS - vtkImagingJava_LIB_DEPENDS - vtkImagingPython_LIB_DEPENDS - vtkImagingTCL_LIB_DEPENDS - vtkImaging_LIB_DEPENDS - vtkParallelJava_LIB_DEPENDS - vtkParallelPython_LIB_DEPENDS - vtkParallelTCL_LIB_DEPENDS - vtkParallel_LIB_DEPENDS - vtkPatentedJava_LIB_DEPENDS - vtkPatentedPython_LIB_DEPENDS - vtkPatentedTCL_LIB_DEPENDS - vtkPatented_LIB_DEPENDS - vtkRenderingJava_LIB_DEPENDS - vtkRenderingPythonTkWidgets_LIB_DEPENDS - vtkRenderingPython_LIB_DEPENDS - vtkRenderingTCL_LIB_DEPENDS - vtkRendering_LIB_DEPENDS - vtkjpeg_LIB_DEPENDS - vtkpng_LIB_DEPENDS - vtkzlib_LIB_DEPENDS -) - -# Copy needed settings from the VTK 4.0 cache. -set(VTK_BUILD_SHARED ${VTK40_BUILD_SHARED_LIBS}) -set(VTK_DEBUG_LEAKS ${VTK40_VTK_DEBUG_LEAKS}) -set(VTK_HAVE_VG500 ${VTK40_VTK_HAVE_VG500}) -set(VTK_HAVE_VP1000 ${VTK40_VTK_HAVE_VP1000}) -set(VTK_USE_MANGLED_MESA ${VTK40_VTK_MANGLE_MESA}) -set(VTK_MPIRUN_EXE ${VTK40_MPIRUN}) -set(VTK_MPI_POSTFLAGS ${VTK40_MPI_POSTFLAGS}) -set(VTK_MPI_PREFLAGS ${VTK40_MPI_PREFLAGS}) -set(VTK_OPENGL_HAS_OSMESA ${VTK40_VTK_OPENGL_HAS_OSMESA}) -set(VTK_USE_64BIT_IDS ${VTK40_VTK_USE_64BIT_IDS}) -set(VTK_USE_ANSI_STDLIB ${VTK40_VTK_USE_ANSI_STDLIB}) -set(VTK_USE_HYBRID ${VTK40_VTK_USE_HYBRID}) -set(VTK_USE_MATROX_IMAGING ${VTK40_VTK_USE_MATROX_IMAGING}) -set(VTK_USE_MPI ${VTK40_VTK_USE_MPI}) -set(VTK_USE_PARALLEL ${VTK40_VTK_USE_PARALLEL}) -set(VTK_USE_PATENTED ${VTK40_VTK_USE_PATENTED}) -set(VTK_USE_RENDERING ${VTK40_VTK_USE_RENDERING}) -set(VTK_USE_VIDEO_FOR_WINDOWS ${VTK40_VTK_USE_VIDEO_FOR_WINDOWS}) -set(VTK_USE_VOLUMEPRO ${VTK40_VTK_USE_VOLUMEPRO}) -set(VTK_USE_X ${VTK40_VTK_USE_X}) -set(VTK_WRAP_JAVA ${VTK40_VTK_WRAP_JAVA}) -set(VTK_WRAP_PYTHON ${VTK40_VTK_WRAP_PYTHON}) -set(VTK_WRAP_TCL ${VTK40_VTK_WRAP_TCL}) - -# Create the list of available kits. -set(VTK_KITS COMMON FILTERING GRAPHICS IMAGING IO) -if(VTK_USE_RENDERING) - set(VTK_KITS ${VTK_KITS} RENDERING) -endif() -if(VTK_USE_HYBRID) - set(VTK_KITS ${VTK_KITS} HYBRID) -endif() -if(VTK_USE_PARALLEL) - set(VTK_KITS ${VTK_KITS} PARALLEL) -endif() -if(VTK_USE_PATENTED) - set(VTK_KITS ${VTK_KITS} PATENTED) -endif() - -# Create the list of available languages. -set(VTK_LANGUAGES "") -if(VTK_WRAP_TCL) - set(VTK_LANGUAGES ${VTK_LANGUAGES} TCL) -endif() -if(VTK_WRAP_PYTHON) - set(VTK_LANGUAGES ${VTK_LANGUAGES} PYTHON) -endif() -if(VTK_WRAP_JAVA) - set(VTK_LANGUAGES ${VTK_LANGUAGES} JAVA) -endif() - -# Include directories for other projects installed on the system and -# used by VTK. -set(VTK_INCLUDE_DIRS_SYS "") -if(VTK_USE_RENDERING) - set(VTK_INCLUDE_DIRS_SYS ${VTK_INCLUDE_DIRS_SYS} - ${VTK40_OPENGL_INCLUDE_PATH} ${VTK40_OPENGL_INCLUDE_DIR}) - if(VTK_USE_X) - set(VTK_INCLUDE_DIRS_SYS ${VTK_INCLUDE_DIRS_SYS} - ${VTK40_CMAKE_Xlib_INCLUDE_PATH} ${VTK40_CMAKE_Xutil_INCLUDE_PATH}) - endif() -endif() - -if(VTK_OPENGL_HAS_OSMESA) - set(VTK_INCLUDE_DIRS_SYS ${VTK_INCLUDE_DIRS_SYS} - ${VTK40_OSMESA_INCLUDE_PATH}) -endif() - -if(VTK_USE_MPI) - set(VTK_INCLUDE_DIRS_SYS ${VTK_INCLUDE_DIRS_SYS} ${VTK40_MPI_INCLUDE_PATH}) -endif() - -if(VTK_WRAP_TCL) - set(VTK_INCLUDE_DIRS_SYS ${VTK_INCLUDE_DIRS_SYS} ${VTK40_TCL_INCLUDE_PATH}) -endif() - -if(VTK_WRAP_PYTHON) - set(VTK_INCLUDE_DIRS_SYS ${VTK_INCLUDE_DIRS_SYS} ${VTK40_PYTHON_INCLUDE_PATH}) -endif() - -if(VTK_WRAP_JAVA) - set(VTK_INCLUDE_DIRS_SYS ${VTK_INCLUDE_DIRS_SYS} - ${VTK40_JAVA_INCLUDE_PATH} ${VTK40_JAVA_INCLUDE_PATH2}) -endif() - -if(VTK_HAVE_VG500) - set(VTK_INCLUDE_DIRS_SYS ${VTK_INCLUDE_DIRS_SYS} - ${VTK40_VLI_INCLUDE_PATH_FOR_VG500}) -endif() - -if(VTK_HAVE_VP1000) - set(VTK_INCLUDE_DIRS_SYS ${VTK_INCLUDE_DIRS_SYS} - ${VTK40_VLI_INCLUDE_PATH_FOR_VP1000}) -endif() - -# See if this is a build tree or install tree. -if(EXISTS ${VTK_DIR}/Common) - # This is a VTK 4.0 build tree. - - set(VTK_LIBRARY_DIRS ${VTK40_LIBRARY_OUTPUT_PATH}) - - # Determine the include directories needed. - set(VTK_INCLUDE_DIRS ${VTK40_VTK_BINARY_DIR}) - if(VTK_USE_PARALLEL) - set(VTK_INCLUDE_DIRS ${VTK_INCLUDE_DIRS} ${VTK40_VTK_SOURCE_DIR}/Parallel) - endif() - if(VTK_USE_HYBRID) - set(VTK_INCLUDE_DIRS ${VTK_INCLUDE_DIRS} ${VTK40_VTK_SOURCE_DIR}/Hybrid) - endif() - if(VTK_USE_PATENTED) - set(VTK_INCLUDE_DIRS ${VTK_INCLUDE_DIRS} ${VTK40_VTK_SOURCE_DIR}/Patented) - endif() - if(VTK_USE_RENDERING) - set(VTK_INCLUDE_DIRS ${VTK_INCLUDE_DIRS} ${VTK40_VTK_SOURCE_DIR}/Rendering) - endif() - - # These directories are always needed. - set(VTK_INCLUDE_DIRS ${VTK_INCLUDE_DIRS} - ${VTK40_VTK_SOURCE_DIR}/IO - ${VTK40_VTK_SOURCE_DIR}/Imaging - ${VTK40_VTK_SOURCE_DIR}/Graphics - ${VTK40_VTK_SOURCE_DIR}/Filtering - ${VTK40_VTK_SOURCE_DIR}/Common) - - # Give access to a few utilities. - set(VTK_INCLUDE_DIRS ${VTK_INCLUDE_DIRS} - ${VTK40_VTK_BINARY_DIR}/Utilities/png - ${VTK40_VTK_SOURCE_DIR}/Utilities/png - ${VTK40_VTK_BINARY_DIR}/Utilities/zlib - ${VTK40_VTK_SOURCE_DIR}/Utilities/zlib) - - # Executable locations. - if(VTK_WRAP_TCL) - set(VTK_TCL_EXE ${VTK40_EXECUTABLE_OUTPUT_PATH}/vtk) - set(VTK_WRAP_TCL_EXE ${VTK40_VTK_WRAP_TCL_EXE}) - set(VTK_TCL_HOME ${VTK40_VTK_SOURCE_DIR}/Wrapping/Tcl) - endif() - if(VTK_WRAP_PYTHON) - set(VTK_WRAP_PYTHON_EXE ${VTK40_VTK_WRAP_PYTHON_EXE}) - endif() - if(VTK_WRAP_JAVA) - set(VTK_PARSE_JAVA_EXE ${VTK40_VTK_PARSE_JAVA_EXE}) - set(VTK_WRAP_JAVA_EXE ${VTK40_VTK_WRAP_JAVA_EXE}) - endif() - -else() - # This is a VTK 4.0 install tree. - - set(VTK_INCLUDE_DIRS ${VTK_DIR}) - set(VTK_LIBRARY_DIRS ${VTK40_CMAKE_INSTALL_PREFIX}/lib/vtk) - - # Executable locations. - if(VTK_WRAP_TCL) - set(VTK_TCL_EXE ${VTK40_CMAKE_INSTALL_PREFIX}/bin/vtk) - set(VTK_WRAP_TCL_EXE ${VTK40_CMAKE_INSTALL_PREFIX}/bin/vtkWrapTcl) - set(VTK_TCL_HOME ${VTK40_CMAKE_INSTALL_PREFIX}/lib/vtk/tcl) - endif() - if(VTK_WRAP_PYTHON) - set(VTK_WRAP_PYTHON_EXE ${VTK40_CMAKE_INSTALL_PREFIX}/bin/vtkWrapPython) - endif() - if(VTK_WRAP_JAVA) - set(VTK_PARSE_JAVA_EXE ${VTK40_CMAKE_INSTALL_PREFIX}/bin/vtkParseJava) - set(VTK_WRAP_JAVA_EXE ${VTK40_CMAKE_INSTALL_PREFIX}/bin/vtkWrapJava) - endif() -endif() - -# Add the system include directories last. -set(VTK_INCLUDE_DIRS ${VTK_INCLUDE_DIRS} ${VTK_INCLUDE_DIRS_SYS}) - -# Find the required C and C++ compiler flags. -if(CMAKE_COMPILER_IS_GNUCXX) - if(WIN32) - # The platform is gcc on cygwin. - set(VTK_REQUIRED_CXX_FLAGS "${VTK_REQUIRED_CXX_FLAGS} -mwin32") - set(VTK_REQUIRED_C_FLAGS "${VTK_REQUIRED_C_FLAGS} -mwin32") - endif() -else() - if(CMAKE_ANSI_CFLAGS) - set(VTK_REQUIRED_C_FLAGS "${VTK_REQUIRED_C_FLAGS} ${CMAKE_ANSI_CFLAGS}") - endif() - if(CMAKE_SYSTEM MATCHES "OSF1-V") - set(VTK_REQUIRED_CXX_FLAGS - "${VTK_REQUIRED_CXX_FLAGS} -timplicit_local -no_implicit_include") - endif() -endif() - -if(VTK_USE_X) - if(CMAKE_X_CFLAGS) - set(VTK_REQUIRED_C_FLAGS "${VTK_REQUIRED_C_FLAGS} ${CMAKE_X_CFLAGS}") - set(VTK_REQUIRED_CXX_FLAGS "${VTK_REQUIRED_CXX_FLAGS} ${CMAKE_X_CFLAGS}") - endif() -endif() - -# Copy library dependencies. -set(vtkCommonJava_LIB_DEPENDS "${VTK40_vtkCommonJava_LIB_DEPENDS}") -set(vtkCommonPython_LIB_DEPENDS "${VTK40_vtkCommonPython_LIB_DEPENDS}") -set(vtkCommonTCL_LIB_DEPENDS "${VTK40_vtkCommonTCL_LIB_DEPENDS}") -set(vtkCommon_LIB_DEPENDS "${VTK40_vtkCommon_LIB_DEPENDS}") -set(vtkFilteringJava_LIB_DEPENDS "${VTK40_vtkFilteringJava_LIB_DEPENDS}") -set(vtkFilteringPython_LIB_DEPENDS "${VTK40_vtkFilteringPython_LIB_DEPENDS}") -set(vtkFilteringTCL_LIB_DEPENDS "${VTK40_vtkFilteringTCL_LIB_DEPENDS}") -set(vtkFiltering_LIB_DEPENDS "${VTK40_vtkFiltering_LIB_DEPENDS}") -set(vtkGraphicsJava_LIB_DEPENDS "${VTK40_vtkGraphicsJava_LIB_DEPENDS}") -set(vtkGraphicsPython_LIB_DEPENDS "${VTK40_vtkGraphicsPython_LIB_DEPENDS}") -set(vtkGraphicsTCL_LIB_DEPENDS "${VTK40_vtkGraphicsTCL_LIB_DEPENDS}") -set(vtkGraphics_LIB_DEPENDS "${VTK40_vtkGraphics_LIB_DEPENDS}") -set(vtkHybridJava_LIB_DEPENDS "${VTK40_vtkHybridJava_LIB_DEPENDS}") -set(vtkHybridPython_LIB_DEPENDS "${VTK40_vtkHybridPython_LIB_DEPENDS}") -set(vtkHybridTCL_LIB_DEPENDS "${VTK40_vtkHybridTCL_LIB_DEPENDS}") -set(vtkHybrid_LIB_DEPENDS "${VTK40_vtkHybrid_LIB_DEPENDS}") -set(vtkIOJava_LIB_DEPENDS "${VTK40_vtkIOJava_LIB_DEPENDS}") -set(vtkIOPython_LIB_DEPENDS "${VTK40_vtkIOPython_LIB_DEPENDS}") -set(vtkIOTCL_LIB_DEPENDS "${VTK40_vtkIOTCL_LIB_DEPENDS}") -set(vtkIO_LIB_DEPENDS "${VTK40_vtkIO_LIB_DEPENDS}") -set(vtkImagingJava_LIB_DEPENDS "${VTK40_vtkImagingJava_LIB_DEPENDS}") -set(vtkImagingPython_LIB_DEPENDS "${VTK40_vtkImagingPython_LIB_DEPENDS}") -set(vtkImagingTCL_LIB_DEPENDS "${VTK40_vtkImagingTCL_LIB_DEPENDS}") -set(vtkImaging_LIB_DEPENDS "${VTK40_vtkImaging_LIB_DEPENDS}") -set(vtkParallelJava_LIB_DEPENDS "${VTK40_vtkParallelJava_LIB_DEPENDS}") -set(vtkParallelPython_LIB_DEPENDS "${VTK40_vtkParallelPython_LIB_DEPENDS}") -set(vtkParallelTCL_LIB_DEPENDS "${VTK40_vtkParallelTCL_LIB_DEPENDS}") -set(vtkParallel_LIB_DEPENDS "${VTK40_vtkParallel_LIB_DEPENDS}") -set(vtkPatentedJava_LIB_DEPENDS "${VTK40_vtkPatentedJava_LIB_DEPENDS}") -set(vtkPatentedPython_LIB_DEPENDS "${VTK40_vtkPatentedPython_LIB_DEPENDS}") -set(vtkPatentedTCL_LIB_DEPENDS "${VTK40_vtkPatentedTCL_LIB_DEPENDS}") -set(vtkPatented_LIB_DEPENDS "${VTK40_vtkPatented_LIB_DEPENDS}") -set(vtkRenderingJava_LIB_DEPENDS "${VTK40_vtkRenderingJava_LIB_DEPENDS}") -set(vtkRenderingPythonTkWidgets_LIB_DEPENDS "${VTK40_vtkRenderingPythonTkWidgets_LIB_DEPENDS}") -set(vtkRenderingPython_LIB_DEPENDS "${VTK40_vtkRenderingPython_LIB_DEPENDS}") -set(vtkRenderingTCL_LIB_DEPENDS "${VTK40_vtkRenderingTCL_LIB_DEPENDS}") -set(vtkRendering_LIB_DEPENDS "${VTK40_vtkRendering_LIB_DEPENDS}") -set(vtkjpeg_LIB_DEPENDS "${VTK40_vtkjpeg_LIB_DEPENDS}") -set(vtkpng_LIB_DEPENDS "${VTK40_vtkpng_LIB_DEPENDS}") -set(vtkzlib_LIB_DEPENDS "${VTK40_vtkzlib_LIB_DEPENDS}") - -# List of VTK configuration variables set above. -# grep "^[ ]*set(VTK" UseVTKConfig40.cmake |sed 's/[ ]*set(\([^ ]*\) .*/ \1/' -set(VTK_SETTINGS - VTK_BUILD_SHARED - VTK_BUILD_VERSION - VTK_DEBUG_LEAKS - VTK_HAVE_VG500 - VTK_HAVE_VP1000 - VTK_INCLUDE_DIRS - VTK_KITS - VTK_LANGUAGES - VTK_LIBRARY_DIRS - VTK_MAJOR_VERSION - VTK_MANGLE_MESA - VTK_MINOR_VERSION - VTK_MPIRUN_EXE - VTK_MPI_POSTFLAGS - VTK_MPI_PREFLAGS - VTK_OPENGL_HAS_OSMESA - VTK_PARSE_JAVA_EXE - VTK_TCL_EXE - VTK_TCL_HOME - VTK_USE_64BIT_IDS - VTK_USE_ANSI_STDLIB - VTK_USE_HYBRID - VTK_USE_MATROX_IMAGING - VTK_USE_MPI - VTK_USE_PARALLEL - VTK_USE_PATENTED - VTK_USE_RENDERING - VTK_USE_VIDEO_FOR_WINDOWS - VTK_USE_VOLUMEPRO - VTK_USE_X - VTK_WRAP_JAVA - VTK_WRAP_JAVA_EXE - VTK_WRAP_PYTHON - VTK_WRAP_PYTHON_EXE - VTK_WRAP_TCL - VTK_WRAP_TCL_EXE -) diff --git a/Modules/readme.txt b/Modules/readme.txt index b40f3d0..1e0c13b 100644 --- a/Modules/readme.txt +++ b/Modules/readme.txt @@ -1,4 +1,4 @@ See the "Find Modules" section of the cmake-developer(7) manual page. For more information about how to contribute modules to CMake, see this page: -http://www.cmake.org/Wiki/CMake:Module_Maintainers +https://cmake.org/Wiki/CMake:Module_Maintainers @@ -8,8 +8,8 @@ CMake is a cross-platform, open-source build system generator. For full documentation visit the `CMake Home Page`_ and the `CMake Documentation Page`_. -.. _`CMake Home Page`: http://www.cmake.org -.. _`CMake Documentation Page`: http://www.cmake.org/cmake/help/documentation.html +.. _`CMake Home Page`: https://cmake.org +.. _`CMake Documentation Page`: https://cmake.org/cmake/help/documentation.html CMake is maintained and supported by `Kitware`_ and developed in collaboration with a productive community of contributors. @@ -37,7 +37,7 @@ it should not be a major problem to port CMake to this platform. Subscribe and post to the `CMake Users List`_ to ask if others have had experience with the platform. -.. _`CMake Users List`: http://www.cmake.org/mailman/listinfo/cmake +.. _`CMake Users List`: https://cmake.org/mailman/listinfo/cmake Building CMake from Scratch --------------------------- @@ -46,7 +46,7 @@ UNIX/Mac OSX/MinGW/MSYS/Cygwin ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ You need to have a compiler and a make installed. -Run the ``bootstrap`` script you find the in the source directory of CMake. +Run the ``bootstrap`` script you find in the source directory of CMake. You can use the ``--help`` option to see the supported options. You may use the ``--prefix=<install_prefix>`` option to specify a custom installation directory for CMake. You can run the ``bootstrap`` script from @@ -63,7 +63,7 @@ You need to download and install a binary release of CMake in order to build CMake. You can get these releases from the `CMake Download Page`_ . Then proceed with the instructions below. -.. _`CMake Download Page`: http://www.cmake.org/cmake/resources/software.html +.. _`CMake Download Page`: https://cmake.org/cmake/resources/software.html Building CMake with CMake ------------------------- @@ -73,7 +73,7 @@ run the installed CMake on the sources of this CMake with your preferred options and generators. Then build it and install it. For instructions how to do this, see documentation on `Running CMake`_. -.. _`Running CMake`: http://www.cmake.org/cmake/help/runningcmake.html +.. _`Running CMake`: https://cmake.org/cmake/help/runningcmake.html Reporting Bugs ============== @@ -89,7 +89,7 @@ If you have found a bug: 3. Finally, if the issue is not resolved by the above steps, open an entry in the `CMake Issue Tracker`_. -.. _`CMake Issue Tracker`: http://www.cmake.org/Bug +.. _`CMake Issue Tracker`: https://cmake.org/Bug Contributing ============ diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index 16b9ea1..fd71b0e 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -299,8 +299,6 @@ set(SRCS cmLocalUnixMakefileGenerator3.cxx cmLocale.h ${MACH_SRCS} - cmMakeDepend.cxx - cmMakeDepend.h cmMakefile.cxx cmMakefile.h cmMakefileTargetGenerator.cxx @@ -327,6 +325,8 @@ set(SRCS cmPropertyDefinitionMap.h cmPropertyMap.cxx cmPropertyMap.h + cmQtAutoGeneratorInitializer.cxx + cmQtAutoGeneratorInitializer.h cmQtAutoGenerators.cxx cmQtAutoGenerators.h cmRST.cxx @@ -502,6 +502,10 @@ if (WIN32) cmGhsMultiGpj.cxx cmGhsMultiGpj.h ) + + # Add a manifest file to executables on Windows to allow for + # GetVersion to work properly on Windows 8 and above. + set(MANIFEST_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake.version.manifest) endif() endif () @@ -531,7 +535,7 @@ set(SRCS ${SRCS} if(WIN32 AND NOT CYGWIN) set_source_files_properties(cmcldeps.cxx PROPERTIES COMPILE_DEFINITIONS _WIN32_WINNT=0x0501) - add_executable(cmcldeps cmcldeps.cxx) + add_executable(cmcldeps cmcldeps.cxx ${MANIFEST_FILE}) target_link_libraries(cmcldeps CMakeLib) install(TARGETS cmcldeps DESTINATION bin) endif() @@ -542,6 +546,19 @@ foreach(v CURL_CA_BUNDLE CURL_CA_PATH) endif() endforeach() +foreach(check + STAT_HAS_ST_MTIM + STAT_HAS_ST_MTIMESPEC + ) + if(KWSYS_CXX_${check}_COMPILED) # abuse KWSys check cache entry + set(CMake_${check} 1) + else() + set(CMake_${check} 0) + endif() + set_property(SOURCE cmFileTimeComparison.cxx APPEND PROPERTY + COMPILE_DEFINITIONS CMake_${check}=${CMake_${check}}) +endforeach() + # create a library used by the command line and the GUI add_library(CMakeLib ${SRCS}) target_link_libraries(CMakeLib cmsys @@ -720,15 +737,15 @@ if(APPLE) endif() # Build CMake executable -add_executable(cmake cmakemain.cxx cmcmd.cxx cmcmd.h) +add_executable(cmake cmakemain.cxx cmcmd.cxx cmcmd.h ${MANIFEST_FILE}) target_link_libraries(cmake CMakeLib) # Build CTest executable -add_executable(ctest ctest.cxx) +add_executable(ctest ctest.cxx ${MANIFEST_FILE}) target_link_libraries(ctest CTestLib) # Build CPack executable -add_executable(cpack CPack/cpack.cxx) +add_executable(cpack CPack/cpack.cxx ${MANIFEST_FILE}) target_link_libraries(cpack CPackLib) # Curses GUI diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake index ed72665..9f6bfbf 100644 --- a/Source/CMakeVersion.cmake +++ b/Source/CMakeVersion.cmake @@ -1,5 +1,5 @@ # CMake version number components. set(CMake_VERSION_MAJOR 3) -set(CMake_VERSION_MINOR 3) -set(CMake_VERSION_PATCH 20150902) +set(CMake_VERSION_MINOR 4) +set(CMake_VERSION_PATCH 20151102) #set(CMake_VERSION_RC 1) diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.cxx b/Source/CPack/IFW/cmCPackIFWGenerator.cxx index 43d34ee..4eb23c1 100644 --- a/Source/CPack/IFW/cmCPackIFWGenerator.cxx +++ b/Source/CPack/IFW/cmCPackIFWGenerator.cxx @@ -24,7 +24,6 @@ #include <cmsys/RegularExpression.hxx> #include <cmGlobalGenerator.h> -#include <cmLocalGenerator.h> #include <cmSystemTools.h> #include <cmMakefile.h> #include <cmGeneratedFileStream.h> diff --git a/Source/CPack/WiX/cmWIXPatch.cxx b/Source/CPack/WiX/cmWIXPatch.cxx index 5a8dc63..471c3a4 100644 --- a/Source/CPack/WiX/cmWIXPatch.cxx +++ b/Source/CPack/WiX/cmWIXPatch.cxx @@ -33,13 +33,30 @@ void cmWIXPatch::ApplyFragment( if(i == Fragments.end()) return; const cmWIXPatchElement& fragment = i->second; + + this->ApplyElementChildren(fragment, writer); + + Fragments.erase(i); +} + +void cmWIXPatch::ApplyElementChildren( + const cmWIXPatchElement& element, cmWIXSourceWriter& writer) +{ for(cmWIXPatchElement::child_list_t::const_iterator - j = fragment.children.begin(); j != fragment.children.end(); ++j) + j = element.children.begin(); j != element.children.end(); ++j) + { + cmWIXPatchNode *node = *j; + + switch(node->type()) { - ApplyElement(**j, writer); + case cmWIXPatchNode::ELEMENT: + ApplyElement(dynamic_cast<const cmWIXPatchElement&>(*node), writer); + break; + case cmWIXPatchNode::TEXT: + writer.AddTextNode(dynamic_cast<const cmWIXPatchText&>(*node).text); + break; } - - Fragments.erase(i); + } } void cmWIXPatch::ApplyElement( @@ -53,16 +70,11 @@ void cmWIXPatch::ApplyElement( writer.AddAttribute(i->first, i->second); } - for(cmWIXPatchElement::child_list_t::const_iterator - i = element.children.begin(); i != element.children.end(); ++i) - { - ApplyElement(**i, writer); - } + this->ApplyElementChildren(element, writer); writer.EndElement(element.name); } - bool cmWIXPatch::CheckForUnappliedFragments() { std::string fragmentList; diff --git a/Source/CPack/WiX/cmWIXPatch.h b/Source/CPack/WiX/cmWIXPatch.h index 7b7b2f1..d53fcb4 100644 --- a/Source/CPack/WiX/cmWIXPatch.h +++ b/Source/CPack/WiX/cmWIXPatch.h @@ -33,6 +33,9 @@ public: bool CheckForUnappliedFragments(); private: + void ApplyElementChildren(const cmWIXPatchElement& element, + cmWIXSourceWriter& writer); + void ApplyElement(const cmWIXPatchElement& element, cmWIXSourceWriter& writer); diff --git a/Source/CPack/WiX/cmWIXPatchParser.cxx b/Source/CPack/WiX/cmWIXPatchParser.cxx index e066c28..14c5413 100644 --- a/Source/CPack/WiX/cmWIXPatchParser.cxx +++ b/Source/CPack/WiX/cmWIXPatchParser.cxx @@ -16,6 +16,21 @@ #include <cm_expat.h> +cmWIXPatchNode::Type cmWIXPatchText::type() +{ + return cmWIXPatchNode::TEXT; +} + +cmWIXPatchNode::Type cmWIXPatchElement::type() +{ + return cmWIXPatchNode::ELEMENT; +} + +cmWIXPatchNode::~cmWIXPatchNode() +{ + +} + cmWIXPatchElement::~cmWIXPatchElement() { for(child_list_t::iterator i = children.begin(); i != children.end(); ++i) @@ -63,20 +78,20 @@ void cmWIXPatchParser::StartElement(const std::string& name, const char **atts) { cmWIXPatchElement &parent = *ElementStack.back(); - parent.children.resize(parent.children.size() + 1); - cmWIXPatchElement*& currentElement = parent.children.back(); - currentElement = new cmWIXPatchElement; - currentElement->name = name; + cmWIXPatchElement *element = new cmWIXPatchElement; + parent.children.push_back(element); + + element->name = name; for(size_t i = 0; atts[i]; i += 2) { std::string key = atts[i]; std::string value = atts[i+1]; - currentElement->attributes[key] = value; + element->attributes[key] = value; } - ElementStack.push_back(currentElement); + ElementStack.push_back(element); } } @@ -117,11 +132,34 @@ void cmWIXPatchParser::EndElement(const std::string& name) } else { - ElementStack.pop_back(); + ElementStack.pop_back(); } } } +void cmWIXPatchParser::CharacterDataHandler(const char* data, int length) +{ + const char* whitespace = "\x20\x09\x0d\x0a"; + + if(State == INSIDE_FRAGMENT) + { + cmWIXPatchElement &parent = *ElementStack.back(); + + std::string text(data, length); + + std::string::size_type first = text.find_first_not_of(whitespace); + std::string::size_type last = text.find_last_not_of(whitespace); + + if(first != std::string::npos && last != std::string::npos) + { + cmWIXPatchText *text_node = new cmWIXPatchText; + text_node->text = text.substr(first, last - first + 1); + + parent.children.push_back(text_node); + } + } +} + void cmWIXPatchParser::ReportError(int line, int column, const char* msg) { cmCPackLogger(cmCPackLog::LOG_ERROR, diff --git a/Source/CPack/WiX/cmWIXPatchParser.h b/Source/CPack/WiX/cmWIXPatchParser.h index acfb4c0..acaeae3 100644 --- a/Source/CPack/WiX/cmWIXPatchParser.h +++ b/Source/CPack/WiX/cmWIXPatchParser.h @@ -20,11 +20,33 @@ #include <map> #include <list> -struct cmWIXPatchElement +struct cmWIXPatchNode { + enum Type + { + TEXT, + ELEMENT + }; + + virtual ~cmWIXPatchNode(); + + virtual Type type() = 0; +}; + +struct cmWIXPatchText : public cmWIXPatchNode +{ + virtual Type type(); + + std::string text; +}; + +struct cmWIXPatchElement : cmWIXPatchNode +{ + virtual Type type(); + ~cmWIXPatchElement(); - typedef std::list<cmWIXPatchElement*> child_list_t; + typedef std::list<cmWIXPatchNode*> child_list_t; typedef std::map<std::string, std::string> attributes_t; std::string name; @@ -48,6 +70,9 @@ private: void StartFragment(const char **attributes); virtual void EndElement(const std::string& name); + + virtual void CharacterDataHandler(const char* data, int length); + virtual void ReportError(int line, int column, const char* msg); void ReportValidationError(std::string const& message); diff --git a/Source/CPack/WiX/cmWIXSourceWriter.cxx b/Source/CPack/WiX/cmWIXSourceWriter.cxx index 8d38e9b..63acb27 100644 --- a/Source/CPack/WiX/cmWIXSourceWriter.cxx +++ b/Source/CPack/WiX/cmWIXSourceWriter.cxx @@ -102,6 +102,25 @@ void cmWIXSourceWriter::EndElement(std::string const& name) State = DEFAULT; } +void cmWIXSourceWriter::AddTextNode(std::string const& text) +{ + if(State == BEGIN) + { + File << ">"; + } + + if(Elements.empty()) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "can not add text without open WiX element in '" << + SourceFilename << "'" << std::endl); + return; + } + + File << this->EscapeAttributeValue(text); + State = DEFAULT; +} + void cmWIXSourceWriter::AddProcessingInstruction( std::string const& target, std::string const& content) { diff --git a/Source/CPack/WiX/cmWIXSourceWriter.h b/Source/CPack/WiX/cmWIXSourceWriter.h index 3b9999c..9e303f0 100644 --- a/Source/CPack/WiX/cmWIXSourceWriter.h +++ b/Source/CPack/WiX/cmWIXSourceWriter.h @@ -34,6 +34,8 @@ public: void EndElement(std::string const& name); + void AddTextNode(std::string const& text); + void AddProcessingInstruction( std::string const& target, std::string const& content); diff --git a/Source/CPack/cmCPackArchiveGenerator.cxx b/Source/CPack/cmCPackArchiveGenerator.cxx index 58bd947..db985db 100644 --- a/Source/CPack/cmCPackArchiveGenerator.cxx +++ b/Source/CPack/cmCPackArchiveGenerator.cxx @@ -14,7 +14,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" @@ -78,7 +77,7 @@ int cmCPackArchiveGenerator::addOneComponentToArchive(cmArchiveWrite& archive, std::string rp = filePrefix + *fileIt; cmCPackLogger(cmCPackLog::LOG_DEBUG,"Adding file: " << rp << std::endl); - archive.Add(rp); + archive.Add(rp, 0, 0, false); if (!archive) { cmCPackLogger(cmCPackLog::LOG_ERROR, "ERROR while packaging files: " @@ -284,7 +283,7 @@ int cmCPackArchiveGenerator::PackageFiles() // Get the relative path to the file std::string rp = cmSystemTools::RelativePath(toplevel.c_str(), fileIt->c_str()); - archive.Add(rp); + archive.Add(rp, 0, 0, false); if(!archive) { cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem while adding file< " diff --git a/Source/CPack/cmCPackCygwinBinaryGenerator.cxx b/Source/CPack/cmCPackCygwinBinaryGenerator.cxx index 6605f16..1f905c0 100644 --- a/Source/CPack/cmCPackCygwinBinaryGenerator.cxx +++ b/Source/CPack/cmCPackCygwinBinaryGenerator.cxx @@ -14,7 +14,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CPack/cmCPackCygwinSourceGenerator.cxx b/Source/CPack/cmCPackCygwinSourceGenerator.cxx index f1e8539..f5cb53c 100644 --- a/Source/CPack/cmCPackCygwinSourceGenerator.cxx +++ b/Source/CPack/cmCPackCygwinSourceGenerator.cxx @@ -14,7 +14,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CPack/cmCPackDebGenerator.cxx b/Source/CPack/cmCPackDebGenerator.cxx index 5049a3f..04efb71 100644 --- a/Source/CPack/cmCPackDebGenerator.cxx +++ b/Source/CPack/cmCPackDebGenerator.cxx @@ -15,6 +15,7 @@ #include "cmMakefile.h" #include "cmGeneratedFileStream.h" #include "cmCPackLog.h" +#include "cmArchiveWrite.h" #include <cmsys/SystemTools.hxx> #include <cmsys/Glob.hxx> @@ -94,6 +95,7 @@ int cmCPackDebGenerator::PackageOnePack(std::string initialTopLevel, std::string findExpr(this->GetOption("GEN_WDIR")); findExpr += "/*"; gl.RecurseOn(); + gl.SetRecurseListDirs(true); if ( !gl.FindFiles(findExpr) ) { cmCPackLogger(cmCPackLog::LOG_ERROR, @@ -221,6 +223,7 @@ int cmCPackDebGenerator::PackageComponentsAllInOne() std::string findExpr(this->GetOption("GEN_WDIR")); findExpr += "/*"; gl.RecurseOn(); + gl.SetRecurseListDirs(true); if ( !gl.FindFiles(findExpr) ) { cmCPackLogger(cmCPackLog::LOG_ERROR, @@ -388,9 +391,9 @@ int cmCPackDebGenerator::createDeb() { std::string dirName = this->GetOption("CPACK_TEMPORARY_DIRECTORY"); dirName += '/'; - for (std::vector<std::string>::const_iterator fileIt = - packageFiles.begin(); - fileIt != packageFiles.end(); ++ fileIt ) + for (std::vector<std::string>::const_iterator fileIt = + packageFiles.begin(); + fileIt != packageFiles.end(); ++ fileIt ) { totalSize += cmSystemTools::FileLength(*fileIt); } @@ -401,8 +404,9 @@ int cmCPackDebGenerator::createDeb() out << std::endl; } - std::string cmd(this->GetOption("GEN_CPACK_DEBIAN_FAKEROOT_EXECUTABLE")); + const std::string strGenWDIR(this->GetOption("GEN_WDIR")); + cmArchiveWrite::Compress tar_compression_type = cmArchiveWrite::CompressGZip; const char* debian_compression_type = this->GetOption("GEN_CPACK_DEBIAN_COMPRESSION_TYPE"); if(!debian_compression_type) @@ -410,108 +414,136 @@ int cmCPackDebGenerator::createDeb() debian_compression_type = "gzip"; } - std::string cmake_tar = " ", compression_modifier = "a", compression_suffix; + std::string compression_suffix; if(!strcmp(debian_compression_type, "lzma")) { compression_suffix = ".lzma"; + tar_compression_type = cmArchiveWrite::CompressLZMA; } else if(!strcmp(debian_compression_type, "xz")) { compression_suffix = ".xz"; + tar_compression_type = cmArchiveWrite::CompressXZ; } else if(!strcmp(debian_compression_type, "bzip2")) { compression_suffix = ".bz2"; - compression_modifier = "j"; - cmake_tar += "\"" + cmSystemTools::GetCMakeCommand() + "\" -E "; + tar_compression_type = cmArchiveWrite::CompressBZip2; } else if(!strcmp(debian_compression_type, "gzip")) { compression_suffix = ".gz"; - compression_modifier = "z"; - cmake_tar += "\"" + cmSystemTools::GetCMakeCommand() + "\" -E "; + tar_compression_type = cmArchiveWrite::CompressGZip; } else if(!strcmp(debian_compression_type, "none")) { compression_suffix = ""; - compression_modifier = ""; - cmake_tar += "\"" + cmSystemTools::GetCMakeCommand() + "\" -E "; + tar_compression_type = cmArchiveWrite::CompressNone; } else { cmCPackLogger(cmCPackLog::LOG_ERROR, "Error unrecognized compression type: " << debian_compression_type << std::endl); } - cmd += cmake_tar + "tar c" + compression_modifier + "f data.tar" - + compression_suffix; - // now add all directories which have to be compressed - // collect all top level install dirs for that - // e.g. /opt/bin/foo, /usr/bin/bar and /usr/bin/baz would give /usr and /opt - size_t topLevelLength = std::string(this->GetOption("GEN_WDIR")).length(); - cmCPackLogger(cmCPackLog::LOG_DEBUG, "WDIR: \"" - << this->GetOption("GEN_WDIR") - << "\", length = " << topLevelLength + std::string filename_data_tar = strGenWDIR + + "/data.tar" + compression_suffix; + + // atomic file generation for data.tar + { + cmGeneratedFileStream fileStream_data_tar; + fileStream_data_tar.Open(filename_data_tar.c_str(), false, true); + if(!fileStream_data_tar) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Error opening the file \"" << filename_data_tar << "\" for writing" << std::endl); - std::set<std::string> installDirs; + return 0; + } + cmArchiveWrite data_tar(fileStream_data_tar, tar_compression_type, "paxr"); + + // uid/gid should be the one of the root user, and this root user has + // always uid/gid equal to 0. + data_tar.SetUIDAndGID(0u, 0u); + data_tar.SetUNAMEAndGNAME("root", "root"); + + // now add all directories which have to be compressed + // collect all top level install dirs for that + // e.g. /opt/bin/foo, /usr/bin/bar and /usr/bin/baz would + // give /usr and /opt + size_t topLevelLength = strGenWDIR.length(); + cmCPackLogger(cmCPackLog::LOG_DEBUG, "WDIR: \"" + << strGenWDIR + << "\", length = " << topLevelLength + << std::endl); + std::set<std::string> orderedFiles; + + // we have to reconstruct the parent folders as well + for (std::vector<std::string>::const_iterator fileIt = - packageFiles.begin(); - fileIt != packageFiles.end(); ++ fileIt ) - { - cmCPackLogger(cmCPackLog::LOG_DEBUG, "FILEIT: \"" << *fileIt << "\"" - << std::endl); - std::string::size_type slashPos = fileIt->find('/', topLevelLength+1); - std::string relativeDir = fileIt->substr(topLevelLength, - slashPos - topLevelLength); - cmCPackLogger(cmCPackLog::LOG_DEBUG, "RELATIVEDIR: \"" << relativeDir - << "\"" << std::endl); - if (installDirs.find(relativeDir) == installDirs.end()) + packageFiles.begin(); + fileIt != packageFiles.end(); ++ fileIt ) { - installDirs.insert(relativeDir); - cmd += " ."; - cmd += relativeDir; + std::string currentPath = *fileIt; + while(currentPath != strGenWDIR) + { + // the last one IS strGenWDIR, but we do not want this one: + // XXX/application/usr/bin/myprogram with GEN_WDIR=XXX/application + // should not add XXX/application + orderedFiles.insert(currentPath); + currentPath = cmSystemTools::CollapseCombinedPath(currentPath, ".."); + } } - } - std::string output; - int retval = -1; - int res = cmSystemTools::RunSingleCommand(cmd.c_str(), &output, &output, - &retval, this->GetOption("GEN_WDIR"), this->GeneratorVerbose, 0); - if ( !res || retval ) - { - std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY"); - tmpFile += "/Deb.log"; - cmGeneratedFileStream ofs(tmpFile.c_str()); - ofs << "# Run command: " << cmd << std::endl - << "# Working directory: " << toplevel << std::endl - << "# Output:" << std::endl - << output << std::endl; - cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running tar command: " - << cmd << std::endl - << "Please check " << tmpFile << " for errors" << std::endl); - return 0; - } + for (std::set<std::string>::const_iterator fileIt = + orderedFiles.begin(); + fileIt != orderedFiles.end(); ++ fileIt ) + { + cmCPackLogger(cmCPackLog::LOG_DEBUG, "FILEIT: \"" << *fileIt << "\"" + << std::endl); + std::string::size_type slashPos = fileIt->find('/', topLevelLength+1); + std::string relativeDir = fileIt->substr(topLevelLength, + slashPos - topLevelLength); + cmCPackLogger(cmCPackLog::LOG_DEBUG, "RELATIVEDIR: \"" << relativeDir + << "\"" << std::endl); + + // do not recurse because the loop will do it + if(!data_tar.Add(*fileIt, topLevelLength, ".", false)) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Problem adding file to tar:" << std::endl + << "#top level directory: " + << strGenWDIR << std::endl + << "#file: " << *fileIt << std::endl + << "#error:" << data_tar.GetError() << std::endl); + return 0; + } + } + } // scope for file generation - std::string md5filename; - md5filename = this->GetOption("GEN_WDIR"); - md5filename += "/md5sums"; - { // the scope is needed for cmGeneratedFileStream + std::string md5filename = strGenWDIR + "/md5sums"; + { + // the scope is needed for cmGeneratedFileStream cmGeneratedFileStream out(md5filename.c_str()); - std::vector<std::string>::const_iterator fileIt; -// std::string topLevelWithTrailingSlash = toplevel; + std::string topLevelWithTrailingSlash = this->GetOption("CPACK_TEMPORARY_DIRECTORY"); topLevelWithTrailingSlash += '/'; - for ( fileIt = packageFiles.begin(); - fileIt != packageFiles.end(); ++ fileIt ) + for (std::vector<std::string>::const_iterator fileIt = + packageFiles.begin(); + fileIt != packageFiles.end(); ++ fileIt ) { - cmd = "\""; - cmd += cmSystemTools::GetCMakeCommand(); - cmd += "\" -E md5sum \""; - cmd += *fileIt; - cmd += "\""; - //std::string output; - //int retVal = -1; - res = cmSystemTools::RunSingleCommand(cmd.c_str(), &output, &output, - &retval, toplevel.c_str(), this->GeneratorVerbose, 0); - if ( !res || retval ) + // hash only regular files + if( cmSystemTools::FileIsDirectory(*fileIt) + || cmSystemTools::FileIsSymlink(*fileIt)) + { + continue; + } + + char md5sum[33]; + if(!cmSystemTools::ComputeFileMD5(*fileIt, md5sum)) { - cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running cmake -E md5sum " - << cmd << std::endl); + cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem computing the md5 of " + << *fileIt << std::endl); } + + md5sum[32] = 0; + + std::string output(md5sum); + output += " " + *fileIt + "\n"; // debian md5sums entries are like this: // 014f3604694729f3bf19263bac599765 usr/bin/ccmake // thus strip the full path (with the trailing slash) @@ -521,70 +553,116 @@ int cmCPackDebGenerator::createDeb() } // each line contains a eol. // Do not end the md5sum file with yet another (invalid) - } + } - // set md5sum file permissins to RW-R--R-- so that deb lintian doesn't warn - // about it - cmSystemTools::SetPermissions(md5filename.c_str(), - S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); - cmd = this->GetOption("GEN_CPACK_DEBIAN_FAKEROOT_EXECUTABLE"); - cmd += cmake_tar + "tar czf control.tar.gz ./control ./md5sums"; + + std::string filename_control_tar = strGenWDIR + "/control.tar.gz"; + // atomic file generation for control.tar + { + cmGeneratedFileStream fileStream_control_tar; + fileStream_control_tar.Open(filename_control_tar.c_str(), false, true); + if(!fileStream_control_tar) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Error opening the file \"" << filename_control_tar + << "\" for writing" << std::endl); + return 0; + } + cmArchiveWrite control_tar(fileStream_control_tar, + cmArchiveWrite::CompressGZip, + "paxr"); + + // sets permissions and uid/gid for the files + control_tar.SetUIDAndGID(0u, 0u); + control_tar.SetUNAMEAndGNAME("root", "root"); + + /* permissions are set according to + https://www.debian.org/doc/debian-policy/ch-files.html#s-permissions-owners + and + https://lintian.debian.org/tags/control-file-has-bad-permissions.html + */ + const mode_t permission644 = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; + const mode_t permissionExecute = S_IXUSR | S_IXGRP | S_IXOTH; + const mode_t permission755 = permission644 | permissionExecute; + + // for md5sum and control (that we have generated here), we use 644 + // (RW-R--R--) + // so that deb lintian doesn't warn about it + control_tar.SetPermissions(permission644); + + // adds control and md5sums + if( !control_tar.Add(md5filename, strGenWDIR.length(), ".") + || !control_tar.Add(strGenWDIR + "/control", strGenWDIR.length(), ".")) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Error adding file to tar:" << std::endl + << "#top level directory: " + << strGenWDIR << std::endl + << "#file: \"control\" or \"md5sums\"" << std::endl + << "#error:" << control_tar.GetError() << std::endl); + return 0; + } + + // for the other files, we use + // -either the original permission on the files + // -either a permission strictly defined by the Debian policies const char* controlExtra = this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA"); - if( controlExtra ) - { - std::vector<std::string> controlExtraList; - cmSystemTools::ExpandListArgument(controlExtra, controlExtraList); - for(std::vector<std::string>::iterator i = - controlExtraList.begin(); i != controlExtraList.end(); ++i) + if( controlExtra ) { - std::string filenamename = - cmsys::SystemTools::GetFilenameName(*i); - std::string localcopy = this->GetOption("GEN_WDIR"); - localcopy += "/"; - localcopy += filenamename; - // if we can copy the file, it means it does exist, let's add it: - if( cmsys::SystemTools::CopyFileIfDifferent( - *i, localcopy) ) + // permissions are now controlled by the original file permissions + + const bool permissionStrictPolicy = + this->IsSet("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION"); + + static const char* strictFiles[] = { + "config", "postinst", "postrm", "preinst", "prerm" + }; + std::set<std::string> setStrictFiles( + strictFiles, + strictFiles + sizeof(strictFiles)/sizeof(strictFiles[0])); + + // default + control_tar.ClearPermissions(); + + std::vector<std::string> controlExtraList; + cmSystemTools::ExpandListArgument(controlExtra, controlExtraList); + for(std::vector<std::string>::iterator i = controlExtraList.begin(); + i != controlExtraList.end(); ++i) { - // debian is picky and need relative to ./ path in the tar.* - cmd += " ./"; - cmd += filenamename; + std::string filenamename = + cmsys::SystemTools::GetFilenameName(*i); + std::string localcopy = strGenWDIR + "/" + filenamename; + + if(permissionStrictPolicy) + { + control_tar.SetPermissions(setStrictFiles.count(filenamename) ? + permission755 : permission644); + } + + // if we can copy the file, it means it does exist, let's add it: + if( cmsys::SystemTools::CopyFileIfDifferent(*i, localcopy) ) + { + control_tar.Add(localcopy, strGenWDIR.length(), "."); + } } } - } - res = cmSystemTools::RunSingleCommand(cmd.c_str(), &output, &output, - &retval, this->GetOption("GEN_WDIR"), this->GeneratorVerbose, 0); + } - if ( !res || retval ) - { - std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY"); - tmpFile += "/Deb.log"; - cmGeneratedFileStream ofs(tmpFile.c_str()); - ofs << "# Run command: " << cmd << std::endl - << "# Working directory: " << toplevel << std::endl - << "# Output:" << std::endl - << output << std::endl; - cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running tar command: " - << cmd << std::endl - << "Please check " << tmpFile << " for errors" << std::endl); - return 0; - } // ar -r your-package-name.deb debian-binary control.tar.* data.tar.* // since debian packages require BSD ar (most Linux distros and even // FreeBSD and NetBSD ship GNU ar) we use a copy of OpenBSD ar here. std::vector<std::string> arFiles; - std::string topLevelString = this->GetOption("GEN_WDIR"); - topLevelString += "/"; + std::string topLevelString = strGenWDIR + "/"; arFiles.push_back(topLevelString + "debian-binary"); arFiles.push_back(topLevelString + "control.tar.gz"); arFiles.push_back(topLevelString + "data.tar" + compression_suffix); - std::string outputFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY"); - outputFileName += "/"; - outputFileName += this->GetOption("CPACK_OUTPUT_FILE_NAME"); - res = ar_append(outputFileName.c_str(), arFiles); + std::string outputFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY"); + outputFileName += "/"; + outputFileName += this->GetOption("CPACK_OUTPUT_FILE_NAME"); + int res = ar_append(outputFileName.c_str(), arFiles); if ( res!=0 ) { std::string tmpFile = this->GetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME"); diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx index 92a4b2b..22d4bf0 100644 --- a/Source/CPack/cmCPackGenerator.cxx +++ b/Source/CPack/cmCPackGenerator.cxx @@ -16,7 +16,6 @@ #include "cmCPackLog.h" #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmGeneratedFileStream.h" #include "cmCPackComponentGroup.h" #include "cmXMLSafe.h" @@ -367,6 +366,7 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories( cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Install directory: " << top << std::endl); gl.RecurseOn(); + gl.SetRecurseListDirs(true); if ( !gl.FindFiles(findExpr) ) { cmCPackLogger(cmCPackLog::LOG_ERROR, @@ -379,7 +379,11 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories( for ( gfit = files.begin(); gfit != files.end(); ++ gfit ) { bool skip = false; - std::string &inFile = *gfit; + std::string inFile = *gfit; + if(cmSystemTools::FileIsDirectory(*gfit)) + { + inFile += '/'; + } for ( regIt= ignoreFilesRegex.begin(); regIt!= ignoreFilesRegex.end(); ++ regIt) @@ -713,13 +717,12 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects( cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cm.AddCMakePaths(); cm.SetProgressCallback(cmCPackGeneratorProgress, this); cmGlobalGenerator gg(&cm); cmsys::auto_ptr<cmMakefile> mf( new cmMakefile(&gg, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg( - gg.CreateLocalGenerator(mf.get())); std::string realInstallDirectory = tempInstallDirectory; if ( !installSubDirectory.empty() && installSubDirectory != "/" ) { @@ -869,6 +872,7 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects( cmsys::Glob glB; findExpr += "/*"; glB.RecurseOn(); + glB.SetRecurseListDirs(true); glB.FindFiles(findExpr); filesBefore = glB.GetFiles(); std::sort(filesBefore.begin(),filesBefore.end()); @@ -908,6 +912,7 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects( { cmsys::Glob glA; glA.RecurseOn(); + glA.SetRecurseListDirs(true); glA.FindFiles(findExpr); std::vector<std::string> filesAfter = glA.GetFiles(); std::sort(filesAfter.begin(),filesAfter.end()); @@ -1074,6 +1079,7 @@ int cmCPackGenerator::DoPackage() std::string findExpr = tempDirectory; findExpr += "/*"; gl.RecurseOn(); + gl.SetRecurseListDirs(true); gl.SetRecurseThroughSymlinks(false); if ( !gl.FindFiles(findExpr) ) { diff --git a/Source/CPack/cmCPackNSISGenerator.cxx b/Source/CPack/cmCPackNSISGenerator.cxx index 6cdda28..5ba639f 100644 --- a/Source/CPack/cmCPackNSISGenerator.cxx +++ b/Source/CPack/cmCPackNSISGenerator.cxx @@ -13,7 +13,6 @@ #include "cmCPackNSISGenerator.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" @@ -158,6 +157,28 @@ int cmCPackNSISGenerator::PackageFiles() installerIconCode.c_str()); } + if (this->IsSet("CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP")) + { + std::string installerBitmapCode = + "!define MUI_WELCOMEFINISHPAGE_BITMAP \""; + installerBitmapCode += + this->GetOption("CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP"); + installerBitmapCode += "\"\n"; + this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_WELCOMEFINISH_CODE", + installerBitmapCode.c_str()); + } + + if (this->IsSet("CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP")) + { + std::string installerBitmapCode = + "!define MUI_UNWELCOMEFINISHPAGE_BITMAP \""; + installerBitmapCode += + this->GetOption("CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP"); + installerBitmapCode += "\"\n"; + this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_UNWELCOMEFINISH_CODE", + installerBitmapCode.c_str()); + } + if(this->IsSet("CPACK_NSIS_MUI_FINISHPAGE_RUN")) { std::string installerRunCode = "!define MUI_FINISHPAGE_RUN \"$INSTDIR\\"; diff --git a/Source/CPack/cmCPackOSXX11Generator.cxx b/Source/CPack/cmCPackOSXX11Generator.cxx index d533af8..8940f54 100644 --- a/Source/CPack/cmCPackOSXX11Generator.cxx +++ b/Source/CPack/cmCPackOSXX11Generator.cxx @@ -13,7 +13,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CPack/cmCPackPackageMakerGenerator.cxx b/Source/CPack/cmCPackPackageMakerGenerator.cxx index 880663f..8fdc036 100644 --- a/Source/CPack/cmCPackPackageMakerGenerator.cxx +++ b/Source/CPack/cmCPackPackageMakerGenerator.cxx @@ -13,7 +13,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CPack/cmCPackSTGZGenerator.cxx b/Source/CPack/cmCPackSTGZGenerator.cxx index 109dcb7..68b893f 100644 --- a/Source/CPack/cmCPackSTGZGenerator.cxx +++ b/Source/CPack/cmCPackSTGZGenerator.cxx @@ -14,7 +14,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmCPackLog.h" diff --git a/Source/CPack/cpack.cxx b/Source/CPack/cpack.cxx index cb9cbc4..c08897f 100644 --- a/Source/CPack/cpack.cxx +++ b/Source/CPack/cpack.cxx @@ -18,7 +18,6 @@ #include "cmCPackGenerator.h" #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmMakefile.h" #include "cmCPackLog.h" @@ -200,12 +199,11 @@ int main (int argc, char const* const* argv) cmake cminst; cminst.SetHomeDirectory(""); cminst.SetHomeOutputDirectory(""); + cminst.GetCurrentSnapshot().SetDefaultDefinitions(); cminst.GetState()->RemoveUnscriptableCommands(); cmGlobalGenerator cmgg(&cminst); cmsys::auto_ptr<cmMakefile> globalMF( new cmMakefile(&cmgg, cminst.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> cmlg( - cmgg.CreateLocalGenerator(globalMF.get())); #if defined(__CYGWIN__) globalMF->AddDefinition("CMAKE_LEGACY_CYGWIN_WIN32", "0"); #endif diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx index 6dbb245..0d74f48 100644 --- a/Source/CTest/cmCTestBuildHandler.cxx +++ b/Source/CTest/cmCTestBuildHandler.cxx @@ -15,7 +15,6 @@ #include "cmCTest.h" #include "cmake.h" #include "cmMakefile.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmGeneratedFileStream.h" #include "cmXMLWriter.h" diff --git a/Source/CTest/cmCTestCurl.cxx b/Source/CTest/cmCTestCurl.cxx index b4c0137..fb6cc00 100644 --- a/Source/CTest/cmCTestCurl.cxx +++ b/Source/CTest/cmCTestCurl.cxx @@ -166,6 +166,10 @@ bool cmCTestCurl::UploadFile(std::string const& local_file, curlWriteMemoryCallback); ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION, curlDebugCallback); + // Be sure to set Content-Type to satisfy fussy modsecurity rules + struct curl_slist *headers = ::curl_slist_append(NULL, + "Content-Type: text/xml"); + ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, headers); std::vector<char> responseData; std::vector<char> debugData; ::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void *)&responseData); @@ -174,6 +178,8 @@ bool cmCTestCurl::UploadFile(std::string const& local_file, // Now run off and do what you've been told! ::curl_easy_perform(this->Curl); ::fclose(ftpfile); + ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, NULL); + ::curl_slist_free_all(headers); if ( responseData.size() > 0 ) { diff --git a/Source/CTest/cmCTestLaunch.cxx b/Source/CTest/cmCTestLaunch.cxx index fb0cce6..749a5be 100644 --- a/Source/CTest/cmCTestLaunch.cxx +++ b/Source/CTest/cmCTestLaunch.cxx @@ -728,7 +728,6 @@ int cmCTestLaunch::Main(int argc, const char* const argv[]) //---------------------------------------------------------------------------- #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmMakefile.h" #include "cmake.h" #include <cmsys/auto_ptr.hxx> @@ -737,10 +736,9 @@ void cmCTestLaunch::LoadConfig() cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg( - gg.CreateLocalGenerator(mf.get())); std::string fname = this->LogDir; fname += "CTestLaunchConfig.cmake"; if(cmSystemTools::FileExists(fname.c_str()) && diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx index 4832186..7c7f5df 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.cxx +++ b/Source/CTest/cmCTestMultiProcessHandler.cxx @@ -198,6 +198,10 @@ void cmCTestMultiProcessHandler::UnlockResources(int index) { this->LockedResources.erase(*i); } + if (this->Properties[index]->RunSerial) + { + this->SerialTestRunning = false; + } } //--------------------------------------------------------- @@ -451,11 +455,6 @@ bool cmCTestMultiProcessHandler::CheckOutput() this->WriteCheckpoint(test); this->UnlockResources(test); this->RunningCount -= GetProcessorsUsed(test); - if (this->Properties[test]->RunSerial) - { - this->SerialTestRunning = false; - } - delete p; } return true; diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx index c1ba279..ee15271 100644 --- a/Source/CTest/cmCTestScriptHandler.cxx +++ b/Source/CTest/cmCTestScriptHandler.cxx @@ -16,7 +16,6 @@ #include "cmake.h" #include "cmFunctionBlocker.h" #include "cmMakefile.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmGeneratedFileStream.h" @@ -86,7 +85,6 @@ cmCTestScriptHandler::cmCTestScriptHandler() this->EmptyBinDir = false; this->EmptyBinDirOnce = false; this->Makefile = 0; - this->LocalGenerator = 0; this->CMake = 0; this->GlobalGenerator = 0; @@ -128,9 +126,6 @@ void cmCTestScriptHandler::Initialize() delete this->Makefile; this->Makefile = 0; - delete this->LocalGenerator; - this->LocalGenerator = 0; - delete this->GlobalGenerator; this->GlobalGenerator = 0; @@ -141,7 +136,6 @@ void cmCTestScriptHandler::Initialize() cmCTestScriptHandler::~cmCTestScriptHandler() { delete this->Makefile; - delete this->LocalGenerator; delete this->GlobalGenerator; delete this->CMake; } @@ -179,15 +173,14 @@ int cmCTestScriptHandler::ProcessHandler() void cmCTestScriptHandler::UpdateElapsedTime() { - if (this->LocalGenerator) + if (this->Makefile) { // set the current elapsed time char timeString[20]; int itime = static_cast<unsigned int>(cmSystemTools::GetTime() - this->ScriptStartTime); sprintf(timeString,"%i",itime); - this->LocalGenerator->GetMakefile()->AddDefinition("CTEST_ELAPSED_TIME", - timeString); + this->Makefile->AddDefinition("CTEST_ELAPSED_TIME", timeString); } } @@ -316,28 +309,23 @@ void cmCTestScriptHandler::CreateCMake() { delete this->CMake; delete this->GlobalGenerator; - delete this->LocalGenerator; delete this->Makefile; } this->CMake = new cmake; this->CMake->SetHomeDirectory(""); this->CMake->SetHomeOutputDirectory(""); + this->CMake->GetCurrentSnapshot().SetDefaultDefinitions(); this->CMake->AddCMakePaths(); this->GlobalGenerator = new cmGlobalGenerator(this->CMake); cmState::Snapshot snapshot = this->CMake->GetCurrentSnapshot(); + std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); + snapshot.GetDirectory().SetCurrentSource(cwd); + snapshot.GetDirectory().SetCurrentBinary(cwd); this->Makefile = new cmMakefile(this->GlobalGenerator, snapshot); - this->LocalGenerator = - this->GlobalGenerator->CreateLocalGenerator(this->Makefile); this->CMake->SetProgressCallback(ctestScriptProgressCallback, this->CTest); - // Set CMAKE_CURRENT_SOURCE_DIR and CMAKE_CURRENT_BINARY_DIR. - // Also, some commands need Makefile->GetCurrentSourceDirectory(). - std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); - this->Makefile->SetCurrentSourceDirectory(cwd); - this->Makefile->SetCurrentBinaryDirectory(cwd); - // remove all cmake commands which are not scriptable, since they can't be // used in ctest scripts this->CMake->GetState()->RemoveUnscriptableCommands(); diff --git a/Source/CTest/cmCTestScriptHandler.h b/Source/CTest/cmCTestScriptHandler.h index 42c2f20..c9d0b6a 100644 --- a/Source/CTest/cmCTestScriptHandler.h +++ b/Source/CTest/cmCTestScriptHandler.h @@ -18,7 +18,6 @@ #include "cmListFileCache.h" class cmMakefile; -class cmLocalGenerator; class cmGlobalGenerator; class cmake; class cmCTestCommand; @@ -166,7 +165,6 @@ private: double ScriptStartTime; cmMakefile *Makefile; - cmLocalGenerator *LocalGenerator; cmGlobalGenerator *GlobalGenerator; cmake *CMake; }; diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx index e19e4f4..36576c5 100644 --- a/Source/CTest/cmCTestStartCommand.cxx +++ b/Source/CTest/cmCTestStartCommand.cxx @@ -12,7 +12,6 @@ #include "cmCTestStartCommand.h" #include "cmCTest.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmCTestVC.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx index 1e12f15..833cad6 100644 --- a/Source/CTest/cmCTestSubmitHandler.cxx +++ b/Source/CTest/cmCTestSubmitHandler.cxx @@ -338,6 +338,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix, CURLcode res; FILE* ftpfile; char error_buffer[1024]; + struct curl_slist *headers = ::curl_slist_append(NULL, + "Content-Type: text/xml"); /* In windows, this will init the winsock stuff */ ::curl_global_init(CURL_GLOBAL_ALL); @@ -420,6 +422,9 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix, ::curl_easy_setopt(curl, CURLOPT_PUT, 1); ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); + // Be sure to set Content-Type to satisfy fussy modsecurity rules + ::curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); + std::string local_file = *file; if ( !cmSystemTools::FileExists(local_file.c_str()) ) { @@ -477,6 +482,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix, cmCTestLog(this->CTest, ERROR_MESSAGE, " Cannot find file: " << local_file << std::endl); ::curl_easy_cleanup(curl); + ::curl_slist_free_all(headers); ::curl_global_cleanup(); return false; } @@ -621,6 +627,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix, << std::endl); } ::curl_easy_cleanup(curl); + ::curl_slist_free_all(headers); ::curl_global_cleanup(); return false; } @@ -630,6 +637,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix, " Uploaded: " + local_file << std::endl, this->Quiet); } } + ::curl_slist_free_all(headers); ::curl_global_cleanup(); return true; } diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index f9678e7..fa3b416 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -24,7 +24,6 @@ #include <cmsys/FStream.hxx> #include "cmMakefile.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmCommand.h" #include "cmSystemTools.h" #include "cmXMLWriter.h" @@ -1591,10 +1590,9 @@ void cmCTestTestHandler::GetListOfTests() cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg( - gg.CreateLocalGenerator(mf.get())); mf->AddDefinition("CTEST_CONFIGURATION_TYPE", this->CTest->GetConfigType().c_str()); diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h index 14067d5..c635430 100644 --- a/Source/CTest/cmCTestTestHandler.h +++ b/Source/CTest/cmCTestTestHandler.h @@ -65,6 +65,11 @@ public: void SetMaxIndex(int n) {this->MaxIndex = n;} int GetMaxIndex() {return this->MaxIndex;} + void SetTestOutputSizePassed(int n) + { this->CustomMaximumPassedTestOutputSize = n; } + void SetTestOutputSizeFailed(int n) + { this->CustomMaximumFailedTestOutputSize = n; } + ///! pass the -I argument down void SetTestsToRunInformation(const char*); diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx index 963e501..bf2f34a 100644 --- a/Source/CTest/cmCTestUpdateHandler.cxx +++ b/Source/CTest/cmCTestUpdateHandler.cxx @@ -15,7 +15,6 @@ #include "cmCTest.h" #include "cmake.h" #include "cmMakefile.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmVersion.h" #include "cmGeneratedFileStream.h" diff --git a/Source/Checks/cm_c11_thread_local.c b/Source/Checks/cm_c11_thread_local.c new file mode 100644 index 0000000..ab780f2 --- /dev/null +++ b/Source/Checks/cm_c11_thread_local.c @@ -0,0 +1,2 @@ +_Thread_local int i = 42; +int main(void) { return 0; } diff --git a/Source/Checks/cm_c11_thread_local.cmake b/Source/Checks/cm_c11_thread_local.cmake new file mode 100644 index 0000000..6b8d10b --- /dev/null +++ b/Source/Checks/cm_c11_thread_local.cmake @@ -0,0 +1,33 @@ +set(CMake_C11_THREAD_LOCAL_BROKEN 0) +if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND CMAKE_C11_STANDARD_COMPILE_OPTION) + if(NOT DEFINED CMake_C11_THREAD_LOCAL_WORKS) + message(STATUS "Checking if compiler supports C11 _Thread_local") + try_compile(CMake_C11_THREAD_LOCAL_WORKS + ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_CURRENT_LIST_DIR}/cm_c11_thread_local.c + CMAKE_FLAGS -DCMAKE_C_STANDARD=11 + OUTPUT_VARIABLE OUTPUT + ) + if(CMake_C11_THREAD_LOCAL_WORKS AND "${OUTPUT}" MATCHES "error: expected '=', ',', ';', 'asm' or '__attribute__' before 'int'") + set_property(CACHE CMake_C11_THREAD_LOCAL_WORKS PROPERTY VALUE 0) + endif() + if(CMake_C11_THREAD_LOCAL_WORKS) + message(STATUS "Checking if compiler supports C11 _Thread_local - yes") + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log + "Determining if compiler supports C11 _Thread_local passed with the following output:\n" + "${OUTPUT}\n" + "\n" + ) + else() + message(STATUS "Checking if compiler supports C11 _Thread_local - no") + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log + "Determining if compiler supports C11 _Thread_local failed with the following output:\n" + "${OUTPUT}\n" + "\n" + ) + endif() + endif() + if(NOT CMake_C11_THREAD_LOCAL_WORKS) + set(CMake_C11_THREAD_LOCAL_BROKEN 1) + endif() +endif() diff --git a/Source/CursesDialog/cmCursesLongMessageForm.cxx b/Source/CursesDialog/cmCursesLongMessageForm.cxx index 67e4aab..6144ddc 100644 --- a/Source/CursesDialog/cmCursesLongMessageForm.cxx +++ b/Source/CursesDialog/cmCursesLongMessageForm.cxx @@ -80,12 +80,13 @@ void cmCursesLongMessageForm::UpdateStatusBar() sprintf(version+sideSpace, "%s", vertmp); version[width] = '\0'; + char fmt_s[] = "%s"; curses_move(y-4,0); attron(A_STANDOUT); - printw(bar); + printw(fmt_s, bar); attroff(A_STANDOUT); curses_move(y-3,0); - printw(version); + printw(fmt_s, version); pos_form_cursor(this->Form); } @@ -101,8 +102,9 @@ void cmCursesLongMessageForm::PrintKeys() char firstLine[512]; sprintf(firstLine, "Press [e] to exit help"); + char fmt_s[] = "%s"; curses_move(y-2,0); - printw(firstLine); + printw(fmt_s, firstLine); pos_form_cursor(this->Form); } diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx index be17a9f..a2fc2c0 100644 --- a/Source/CursesDialog/cmCursesMainForm.cxx +++ b/Source/CursesDialog/cmCursesMainForm.cxx @@ -451,24 +451,25 @@ void cmCursesMainForm::PrintKeys(int process /* = 0 */) } curses_move(y-4,0); + char fmt_s[] = "%s"; char fmt[512] = "Press [enter] to edit option"; if ( process ) { strcpy(fmt, " "); } - printw(fmt); + printw(fmt_s, fmt); curses_move(y-3,0); - printw(firstLine); + printw(fmt_s, firstLine); curses_move(y-2,0); - printw(secondLine); + printw(fmt_s, secondLine); curses_move(y-1,0); - printw(thirdLine); + printw(fmt_s, thirdLine); if (cw) { sprintf(firstLine, "Page %d of %d", cw->GetPage(), this->NumberOfPages); curses_move(0,65-static_cast<unsigned int>(strlen(firstLine))-1); - printw(firstLine); + printw(fmt_s, firstLine); } // } @@ -612,13 +613,13 @@ void cmCursesMainForm::UpdateStatusBar(const char* message) version[width] = '\0'; // Now print both lines + char fmt_s[] = "%s"; curses_move(y-5,0); attron(A_STANDOUT); - char format[] = "%s"; - printw(format, bar); + printw(fmt_s, bar); attroff(A_STANDOUT); curses_move(y-4,0); - printw(version); + printw(fmt_s, version); pos_form_cursor(this->Form); } diff --git a/Source/CursesDialog/cmCursesStringWidget.cxx b/Source/CursesDialog/cmCursesStringWidget.cxx index acf262f..6eb15c1 100644 --- a/Source/CursesDialog/cmCursesStringWidget.cxx +++ b/Source/CursesDialog/cmCursesStringWidget.cxx @@ -168,17 +168,16 @@ bool cmCursesStringWidget::HandleInput(int& key, cmCursesMainForm* fm, else if ( key == 127 || key == KEY_BACKSPACE ) { - if ( form->curcol > 0 ) - { + FIELD *cur = current_field(form); form_driver(form, REQ_DEL_PREV); - } + if (current_field(form) != cur) + { + set_current_field(form, cur); + } } else if ( key == ctrl('d') ||key == KEY_DC ) { - if ( form->curcol >= 0 ) - { - form_driver(form, REQ_DEL_CHAR); - } + form_driver(form, REQ_DEL_CHAR); } else { @@ -221,6 +220,7 @@ bool cmCursesStringWidget::PrintKeys() } if (this->InEdit) { + char fmt_s[] = "%s"; char firstLine[512]; // Clean the toolbar for(int i=0; i<512; i++) @@ -229,17 +229,16 @@ bool cmCursesStringWidget::PrintKeys() } firstLine[511] = '\0'; curses_move(y-4,0); - printw(firstLine); + printw(fmt_s, firstLine); curses_move(y-3,0); - printw(firstLine); + printw(fmt_s, firstLine); curses_move(y-2,0); - printw(firstLine); + printw(fmt_s, firstLine); curses_move(y-1,0); - printw(firstLine); + printw(fmt_s, firstLine); - sprintf(firstLine, "Editing option, press [enter] to leave edit."); curses_move(y-3,0); - printw(firstLine); + printw(fmt_s, "Editing option, press [enter] to leave edit."); return true; } else diff --git a/Source/CursesDialog/cmCursesWidget.cxx b/Source/CursesDialog/cmCursesWidget.cxx index e5363f4..a12e4c2 100644 --- a/Source/CursesDialog/cmCursesWidget.cxx +++ b/Source/CursesDialog/cmCursesWidget.cxx @@ -49,7 +49,7 @@ void cmCursesWidget::Move(int x, int y, bool isNewPage) void cmCursesWidget::SetValue(const std::string& value) { this->Value = value; - set_field_buffer(this->Field, 0, value.c_str()); + set_field_buffer(this->Field, 0, const_cast<char *>(value.c_str())); } const char* cmCursesWidget::GetValue() diff --git a/Source/QtDialog/CMakeLists.txt b/Source/QtDialog/CMakeLists.txt index ad6a7fb..66fd18b 100644 --- a/Source/QtDialog/CMakeLists.txt +++ b/Source/QtDialog/CMakeLists.txt @@ -78,9 +78,12 @@ if (Qt5Widgets_FOUND) endif() endif() - if(WIN32 AND TARGET Qt5::Core) + if(TARGET Qt5::Core) get_property(_Qt5_Core_LOCATION TARGET Qt5::Core PROPERTY LOCATION) get_filename_component(Qt_BIN_DIR "${_Qt5_Core_LOCATION}" PATH) + if(APPLE) + get_filename_component(Qt_BIN_DIR "${Qt_BIN_DIR}" PATH) + endif() endif() else() set(QT_MIN_VERSION "4.4.0") @@ -94,12 +97,6 @@ else() set(CMake_QT_LIBRARIES ${QT_LIBRARIES}) - if(WIN32 AND EXISTS "${QT_QMAKE_EXECUTABLE}") - get_filename_component(_Qt_BIN_DIR "${QT_QMAKE_EXECUTABLE}" PATH) - if(EXISTS "${_Qt_BIN_DIR}/QtCore4.dll") - set(Qt_BIN_DIR ${_Qt_BIN_DIR}) - endif() - endif() endif() set(SRCS @@ -155,11 +152,8 @@ endif() set(CMAKE_INCLUDE_CURRENT_DIR ON) -add_executable(cmake-gui WIN32 MACOSX_BUNDLE ${SRCS}) +add_executable(cmake-gui WIN32 MACOSX_BUNDLE ${SRCS} ${MANIFEST_FILE}) target_link_libraries(cmake-gui CMakeLib ${QT_QTMAIN_LIBRARY} ${CMake_QT_LIBRARIES}) -if(Qt_BIN_DIR) - set_property(TARGET cmake-gui PROPERTY Qt_BIN_DIR ${Qt_BIN_DIR}) -endif() if(APPLE) file(STRINGS "${CMake_SOURCE_DIR}/Copyright.txt" copyright_line @@ -223,7 +217,7 @@ if(CMake_INSTALL_DEPENDENCIES AND (APPLE OR WIN32)) install(CODE " include(\"${CMake_SOURCE_DIR}/Modules/BundleUtilities.cmake\") set(BU_CHMOD_BUNDLE_ITEMS ON) - fixup_bundle(\"${fixup_exe}\" \"${QT_PLUGINS}\" \"${QT_LIBRARY_DIR};${QT_BINARY_DIR}\") + fixup_bundle(\"${fixup_exe}\" \"${QT_PLUGINS}\" \"${Qt_BIN_DIR};${QT_LIBRARY_DIR};${QT_BINARY_DIR}\") " ${COMPONENT}) endif() diff --git a/Source/bindexplib.cxx b/Source/bindexplib.cxx index 11e3f34..dc4db63 100644 --- a/Source/bindexplib.cxx +++ b/Source/bindexplib.cxx @@ -173,7 +173,7 @@ public: */ DumpSymbols(ObjectHeaderType* ih, - FILE* fout) { + FILE* fout, bool is64) { this->ObjectImageHeader = ih; this->SymbolTable = (SymbolTableType*) ((DWORD_PTR)this->ObjectImageHeader @@ -183,6 +183,7 @@ public: GetSectionHeaderOffset(this->ObjectImageHeader); this->ImportFlag = true; this->SymbolCount = this->ObjectImageHeader->NumberOfSymbols; + this->Is64Bit = is64; } /* @@ -287,7 +288,14 @@ public: symbol.erase(posAt); } } - if (symbol[0] == '_') symbol.erase(0,1); + // For 64 bit builds we don't need to remove _ + if(!this->Is64Bit) + { + if (symbol[0] == '_') + { + symbol.erase(0,1); + } + } if (this->ImportFlag) { this->ImportFlag = false; fprintf(this->FileOut,"EXPORTS \n"); @@ -355,6 +363,7 @@ private: PIMAGE_SECTION_HEADER SectionHeaders; ObjectHeaderType* ObjectImageHeader; SymbolTableType* SymbolTable; + bool Is64Bit; }; bool @@ -406,7 +415,8 @@ DumpFile(const char* filename, FILE *fout) * and IMAGE_FILE_HEADER.SizeOfOptionalHeader == 0; */ DumpSymbols<IMAGE_FILE_HEADER, IMAGE_SYMBOL> - symbolDumper((PIMAGE_FILE_HEADER) lpFileBase, fout); + symbolDumper((PIMAGE_FILE_HEADER) lpFileBase, fout, + (dosHeader->e_magic == IMAGE_FILE_MACHINE_AMD64)); symbolDumper.DumpObjFile(); } else { // check for /bigobj format @@ -414,7 +424,8 @@ DumpFile(const char* filename, FILE *fout) (cmANON_OBJECT_HEADER_BIGOBJ*) lpFileBase; if(h->Sig1 == 0x0 && h->Sig2 == 0xffff) { DumpSymbols<cmANON_OBJECT_HEADER_BIGOBJ, cmIMAGE_SYMBOL_EX> - symbolDumper((cmANON_OBJECT_HEADER_BIGOBJ*) lpFileBase, fout); + symbolDumper((cmANON_OBJECT_HEADER_BIGOBJ*) lpFileBase, fout, + (dosHeader->e_magic == IMAGE_FILE_MACHINE_AMD64)); symbolDumper.DumpObjFile(); } else { printf("unrecognized file format in '%s'\n", filename); diff --git a/Source/cmAddDependenciesCommand.cxx b/Source/cmAddDependenciesCommand.cxx index 3a74946..01e5253 100644 --- a/Source/cmAddDependenciesCommand.cxx +++ b/Source/cmAddDependenciesCommand.cxx @@ -10,7 +10,6 @@ See the License for more information. ============================================================================*/ #include "cmAddDependenciesCommand.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" // cmDependenciesCommand diff --git a/Source/cmAddExecutableCommand.cxx b/Source/cmAddExecutableCommand.cxx index d15fc1e..a84bb9d 100644 --- a/Source/cmAddExecutableCommand.cxx +++ b/Source/cmAddExecutableCommand.cxx @@ -174,8 +174,8 @@ bool cmAddExecutableCommand this->SetError(e.str()); return false; } - cmTarget::TargetType type = aliasedTarget->GetType(); - if(type != cmTarget::EXECUTABLE) + cmState::TargetType type = aliasedTarget->GetType(); + if(type != cmState::EXECUTABLE) { std::ostringstream e; e << "cannot create ALIAS target \"" << exename @@ -192,7 +192,7 @@ bool cmAddExecutableCommand this->SetError(e.str()); return false; } - this->Makefile->AddAlias(exename, aliasedTarget); + this->Makefile->AddAlias(exename, aliasedName); return true; } @@ -210,7 +210,7 @@ bool cmAddExecutableCommand } // Create the imported target. - this->Makefile->AddImportedTarget(exename, cmTarget::EXECUTABLE, + this->Makefile->AddImportedTarget(exename, cmState::EXECUTABLE, importGlobal); return true; } diff --git a/Source/cmAddLibraryCommand.cxx b/Source/cmAddLibraryCommand.cxx index a844cf1..5296cbb 100644 --- a/Source/cmAddLibraryCommand.cxx +++ b/Source/cmAddLibraryCommand.cxx @@ -25,10 +25,10 @@ bool cmAddLibraryCommand } // Library type defaults to value of BUILD_SHARED_LIBS, if it exists, // otherwise it defaults to static library. - cmTarget::TargetType type = cmTarget::SHARED_LIBRARY; + cmState::TargetType type = cmState::SHARED_LIBRARY; if (cmSystemTools::IsOff(this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) { - type = cmTarget::STATIC_LIBRARY; + type = cmState::STATIC_LIBRARY; } bool excludeFromAll = false; bool importTarget = false; @@ -50,7 +50,7 @@ bool cmAddLibraryCommand std::string libType = *s; if(libType == "STATIC") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting STATIC type."; @@ -58,12 +58,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::STATIC_LIBRARY; + type = cmState::STATIC_LIBRARY; haveSpecifiedType = true; } else if(libType == "SHARED") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting SHARED type."; @@ -71,12 +71,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::SHARED_LIBRARY; + type = cmState::SHARED_LIBRARY; haveSpecifiedType = true; } else if(libType == "MODULE") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting MODULE type."; @@ -84,12 +84,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::MODULE_LIBRARY; + type = cmState::MODULE_LIBRARY; haveSpecifiedType = true; } else if(libType == "OBJECT") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting OBJECT type."; @@ -97,12 +97,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::OBJECT_LIBRARY; + type = cmState::OBJECT_LIBRARY; haveSpecifiedType = true; } else if(libType == "UNKNOWN") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting UNKNOWN type."; @@ -110,12 +110,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::UNKNOWN_LIBRARY; + type = cmState::UNKNOWN_LIBRARY; haveSpecifiedType = true; } else if(libType == "ALIAS") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting ALIAS type."; @@ -149,12 +149,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::INTERFACE_LIBRARY; + type = cmState::INTERFACE_LIBRARY; haveSpecifiedType = true; } else if(*s == "EXCLUDE_FROM_ALL") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library may not be used with EXCLUDE_FROM_ALL."; @@ -174,7 +174,7 @@ bool cmAddLibraryCommand ++s; importGlobal = true; } - else if(type == cmTarget::INTERFACE_LIBRARY && *s == "GLOBAL") + else if(type == cmState::INTERFACE_LIBRARY && *s == "GLOBAL") { std::ostringstream e; e << "GLOBAL option may only be used with IMPORTED libraries."; @@ -187,7 +187,7 @@ bool cmAddLibraryCommand } } - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { if (s != args.end()) { @@ -220,7 +220,7 @@ bool cmAddLibraryCommand switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0037)) { case cmPolicies::WARN: - if(type != cmTarget::INTERFACE_LIBRARY) + if(type != cmState::INTERFACE_LIBRARY) { e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n"; issueMessage = true; @@ -293,12 +293,12 @@ bool cmAddLibraryCommand this->SetError(e.str()); return false; } - cmTarget::TargetType aliasedType = aliasedTarget->GetType(); - if(aliasedType != cmTarget::SHARED_LIBRARY - && aliasedType != cmTarget::STATIC_LIBRARY - && aliasedType != cmTarget::MODULE_LIBRARY - && aliasedType != cmTarget::OBJECT_LIBRARY - && aliasedType != cmTarget::INTERFACE_LIBRARY) + cmState::TargetType aliasedType = aliasedTarget->GetType(); + if(aliasedType != cmState::SHARED_LIBRARY + && aliasedType != cmState::STATIC_LIBRARY + && aliasedType != cmState::MODULE_LIBRARY + && aliasedType != cmState::OBJECT_LIBRARY + && aliasedType != cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "cannot create ALIAS target \"" << libName @@ -314,7 +314,7 @@ bool cmAddLibraryCommand this->SetError(e.str()); return false; } - this->Makefile->AddAlias(libName, aliasedTarget); + this->Makefile->AddAlias(libName, aliasedName); return true; } @@ -328,19 +328,19 @@ bool cmAddLibraryCommand CMAKE_${LANG}_CREATE_SHARED_LIBRARY is defined and if not default to STATIC. But at this point we know only the name of the target, but not yet its linker language. */ - if ((type == cmTarget::SHARED_LIBRARY || - type == cmTarget::MODULE_LIBRARY) && + if ((type == cmState::SHARED_LIBRARY || + type == cmState::MODULE_LIBRARY) && (this->Makefile->GetState()->GetGlobalPropertyAsBool( "TARGET_SUPPORTS_SHARED_LIBS") == false)) { std::ostringstream w; w << "ADD_LIBRARY called with " << - (type==cmTarget::SHARED_LIBRARY ? "SHARED" : "MODULE") << + (type==cmState::SHARED_LIBRARY ? "SHARED" : "MODULE") << " option but the target platform does not support dynamic linking. " "Building a STATIC library instead. This may lead to problems."; this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str()); - type = cmTarget::STATIC_LIBRARY; + type = cmState::STATIC_LIBRARY; } // Handle imported target creation. @@ -352,7 +352,7 @@ bool cmAddLibraryCommand this->SetError("called with IMPORTED argument but no library type."); return false; } - if(type == cmTarget::OBJECT_LIBRARY) + if(type == cmState::OBJECT_LIBRARY) { this->Makefile->IssueMessage( cmake::FATAL_ERROR, @@ -360,7 +360,7 @@ bool cmAddLibraryCommand ); return true; } - if(type == cmTarget::INTERFACE_LIBRARY) + if(type == cmState::INTERFACE_LIBRARY) { if (!cmGeneratorExpression::IsValidTargetName(libName)) { @@ -387,7 +387,7 @@ bool cmAddLibraryCommand } // A non-imported target may not have UNKNOWN type. - if(type == cmTarget::UNKNOWN_LIBRARY) + if(type == cmState::UNKNOWN_LIBRARY) { this->Makefile->IssueMessage( cmake::FATAL_ERROR, @@ -408,7 +408,7 @@ bool cmAddLibraryCommand std::vector<std::string> srclists; - if(type == cmTarget::INTERFACE_LIBRARY) + if(type == cmState::INTERFACE_LIBRARY) { if (!cmGeneratorExpression::IsValidTargetName(libName) || libName.find("::") != std::string::npos) diff --git a/Source/cmArchiveWrite.cxx b/Source/cmArchiveWrite.cxx index 9f56324..e62a2ed 100644 --- a/Source/cmArchiveWrite.cxx +++ b/Source/cmArchiveWrite.cxx @@ -18,6 +18,10 @@ #include <cm_libarchive.h> #include "cm_get_date.h" +#ifndef __LA_SSIZE_T +# define __LA_SSIZE_T la_ssize_t +#endif + //---------------------------------------------------------------------------- static std::string cm_archive_error_string(struct archive* a) { @@ -181,7 +185,10 @@ cmArchiveWrite::~cmArchiveWrite() } //---------------------------------------------------------------------------- -bool cmArchiveWrite::Add(std::string path, size_t skip, const char* prefix) +bool cmArchiveWrite::Add(std::string path, + size_t skip, + const char* prefix, + bool recursive) { if(this->Okay()) { @@ -189,20 +196,21 @@ bool cmArchiveWrite::Add(std::string path, size_t skip, const char* prefix) { path.erase(path.size()-1); } - this->AddPath(path.c_str(), skip, prefix); + this->AddPath(path.c_str(), skip, prefix, recursive); } return this->Okay(); } //---------------------------------------------------------------------------- bool cmArchiveWrite::AddPath(const char* path, - size_t skip, const char* prefix) + size_t skip, const char* prefix, + bool recursive) { if(!this->AddFile(path, skip, prefix)) { return false; } - if(!cmSystemTools::FileIsDirectory(path) || + if((!cmSystemTools::FileIsDirectory(path) || !recursive) || cmSystemTools::FileIsSymlink(path)) { return true; @@ -278,6 +286,33 @@ bool cmArchiveWrite::AddFile(const char* file, } archive_entry_set_mtime(e, t, 0); } + + // manages the uid/guid of the entry (if any) + if (this->Uid.IsSet() && this->Gid.IsSet()) + { + archive_entry_set_uid(e, this->Uid.Get()); + archive_entry_set_gid(e, this->Gid.Get()); + } + + if (this->Uname.size() && this->Gname.size()) + { + archive_entry_set_uname(e, this->Uname.c_str()); + archive_entry_set_gname(e, this->Gname.c_str()); + } + + + // manages the permissions + if (this->Permissions.IsSet()) + { + archive_entry_set_perm(e, this->Permissions.Get()); + } + + if (this->PermissionsMask.IsSet()) + { + mode_t perm = archive_entry_perm(e); + archive_entry_set_perm(e, perm & this->PermissionsMask.Get()); + } + // Clear acl and xattr fields not useful for distribution. archive_entry_acl_clear(e); archive_entry_xattr_clear(e); diff --git a/Source/cmArchiveWrite.h b/Source/cmArchiveWrite.h index e6f515d..8dbbb83 100644 --- a/Source/cmArchiveWrite.h +++ b/Source/cmArchiveWrite.h @@ -18,6 +18,22 @@ # error "cmArchiveWrite not allowed during bootstrap build!" #endif +template<typename T> +class cmArchiveWriteOptional +{ +public: + cmArchiveWriteOptional() {this->Clear();} + explicit cmArchiveWriteOptional(T val) {this->Set(val);} + + void Set(T val) {this->IsValueSet = true; this->Value=val;} + void Clear() {this->IsValueSet = false;} + bool IsSet() const {return this->IsValueSet;} + T Get() const {return Value;} +private: + T Value; + bool IsValueSet; +}; + /** \class cmArchiveWrite * \brief Wrapper around libarchive for writing. * @@ -52,7 +68,10 @@ public: * skip. The remaining part of the input path is appended to the * "prefix" value to construct the final name in the archive. */ - bool Add(std::string path, size_t skip = 0, const char* prefix = 0); + bool Add(std::string path, + size_t skip = 0, + const char* prefix = 0, + bool recursive = true); /** Returns true if there has been no error. */ operator safe_bool() const @@ -69,9 +88,65 @@ public: void SetVerbose(bool v) { this->Verbose = v; } void SetMTime(std::string const& t) { this->MTime = t; } + + //! Sets the permissions of the added files/folders + void SetPermissions(mode_t permissions_) + { + this->Permissions.Set(permissions_); + } + + //! Clears permissions - default is used instead + void ClearPermissions() { this->Permissions.Clear(); } + + //! Sets the permissions mask of files/folders + //! + //! The permissions will be copied from the existing file + //! or folder. The mask will then be applied to unset + //! some of them + void SetPermissionsMask(mode_t permissionsMask_) + { + this->PermissionsMask.Set(permissionsMask_); + } + + //! Clears permissions mask - default is used instead + void ClearPermissionsMask() + { + this->PermissionsMask.Clear(); + } + + //! Sets UID and GID to be used in the tar file + void SetUIDAndGID(int uid_, int gid_) + { + this->Uid.Set(uid_); + this->Gid.Set(gid_); + } + + //! Clears UID and GID to be used in the tar file - default is used instead + void ClearUIDAndGID() + { + this->Uid.Clear(); + this->Gid.Clear(); + } + + //! Sets UNAME and GNAME to be used in the tar file + void SetUNAMEAndGNAME(const std::string& uname_, const std::string& gname_) + { + this->Uname = uname_; + this->Gname = gname_; + } + + //! Clears UNAME and GNAME to be used in the tar file + //! default is used instead + void ClearUNAMEAndGNAME() + { + this->Uname = ""; + this->Gname = ""; + } + private: bool Okay() const { return this->Error.empty(); } - bool AddPath(const char* path, size_t skip, const char* prefix); + bool AddPath(const char* path, size_t skip, const char* prefix, + bool recursive = true); bool AddFile(const char* file, size_t skip, const char* prefix); bool AddData(const char* file, size_t size); @@ -87,6 +162,22 @@ private: std::string Format; std::string Error; std::string MTime; + + //! UID of the user in the tar file + cmArchiveWriteOptional<int> Uid; + + //! GUID of the user in the tar file + cmArchiveWriteOptional<int> Gid; + + //! UNAME/GNAME of the user (does not override UID/GID) + //!@{ + std::string Uname; + std::string Gname; + //!@} + + //! Permissions on files/folders + cmArchiveWriteOptional<mode_t> Permissions; + cmArchiveWriteOptional<mode_t> PermissionsMask; }; #endif diff --git a/Source/cmAuxSourceDirectoryCommand.cxx b/Source/cmAuxSourceDirectoryCommand.cxx index 5f5017d..92ac07d 100644 --- a/Source/cmAuxSourceDirectoryCommand.cxx +++ b/Source/cmAuxSourceDirectoryCommand.cxx @@ -60,10 +60,10 @@ bool cmAuxSourceDirectoryCommand::InitialPass std::string ext = file.substr(dotpos+1); std::string base = file.substr(0, dotpos); // Process only source files - if(!base.empty() - && std::find( this->Makefile->GetSourceExtensions().begin(), - this->Makefile->GetSourceExtensions().end(), ext ) - != this->Makefile->GetSourceExtensions().end() ) + std::vector<std::string> srcExts = + this->Makefile->GetCMakeInstance()->GetSourceExtensions(); + if(!base.empty() && + std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end()) { std::string fullname = templateDirectory; fullname += "/"; diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx index 62fafa5..64d4fca 100644 --- a/Source/cmBuildCommand.cxx +++ b/Source/cmBuildCommand.cxx @@ -11,7 +11,6 @@ ============================================================================*/ #include "cmBuildCommand.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" //---------------------------------------------------------------------- diff --git a/Source/cmBuildNameCommand.h b/Source/cmBuildNameCommand.h index 8f8038f..47455f8 100644 --- a/Source/cmBuildNameCommand.h +++ b/Source/cmBuildNameCommand.h @@ -23,7 +23,6 @@ public: cmExecutionStatus &status); virtual std::string GetName() const {return "build_name";} virtual bool IsScriptable() const { return true; } - virtual bool IsDiscouraged() const { return true; } }; diff --git a/Source/cmCPackPropertiesGenerator.cxx b/Source/cmCPackPropertiesGenerator.cxx index cbcdd81..35b3d59 100644 --- a/Source/cmCPackPropertiesGenerator.cxx +++ b/Source/cmCPackPropertiesGenerator.cxx @@ -18,7 +18,7 @@ void cmCPackPropertiesGenerator::GenerateScriptForConfig(std::ostream& os, const std::string& config, Indent const& indent) { std::string const& expandedFileName = - this->InstalledFile.GetNameExpression().Evaluate(this->LG->GetMakefile(), + this->InstalledFile.GetNameExpression().Evaluate(this->LG, config); cmInstalledFile::PropertyMapType const& properties = @@ -38,7 +38,7 @@ void cmCPackPropertiesGenerator::GenerateScriptForConfig(std::ostream& os, j = property.ValueExpressions.begin(); j != property.ValueExpressions.end(); ++j) { - std::string value = (*j)->Evaluate(LG->GetMakefile(), config); + std::string value = (*j)->Evaluate(this->LG, config); os << " " << cmOutputConverter::EscapeForCMake(value); } diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx index 7da334e..fb78446 100644 --- a/Source/cmCPluginAPI.cxx +++ b/Source/cmCPluginAPI.cxx @@ -51,14 +51,14 @@ void CCONV cmSetError(void *info, const char *err) unsigned int CCONV cmGetCacheMajorVersion(void *arg) { cmMakefile *mf = static_cast<cmMakefile *>(arg); - cmCacheManager *manager = mf->GetCMakeInstance()->GetCacheManager(); - return manager->GetCacheMajorVersion(); + cmState *state = mf->GetState(); + return state->GetCacheMajorVersion(); } unsigned int CCONV cmGetCacheMinorVersion(void *arg) { cmMakefile *mf = static_cast<cmMakefile *>(arg); - cmCacheManager *manager = mf->GetCMakeInstance()->GetCacheManager(); - return manager->GetCacheMinorVersion(); + cmState *state = mf->GetState(); + return state->GetCacheMinorVersion(); } unsigned int CCONV cmGetMajorVersion(void *) @@ -116,7 +116,7 @@ const char* CCONV cmGetProjectName(void *arg) { cmMakefile *mf = static_cast<cmMakefile *>(arg); static std::string name; - name = mf->GetProjectName(); + name = mf->GetStateSnapshot().GetProjectName(); return name.c_str(); } @@ -373,13 +373,13 @@ void CCONV cmAddLinkLibraryForTarget(void *arg, const char *tgt, switch (libtype) { case CM_LIBRARY_GENERAL: - mf->AddLinkLibraryForTarget(tgt,value, cmTarget::GENERAL); + mf->AddLinkLibraryForTarget(tgt,value, GENERAL_LibraryType); break; case CM_LIBRARY_DEBUG: - mf->AddLinkLibraryForTarget(tgt,value, cmTarget::DEBUG); + mf->AddLinkLibraryForTarget(tgt,value, DEBUG_LibraryType); break; case CM_LIBRARY_OPTIMIZED: - mf->AddLinkLibraryForTarget(tgt,value, cmTarget::OPTIMIZED); + mf->AddLinkLibraryForTarget(tgt,value, OPTIMIZED_LibraryType); break; } } @@ -395,7 +395,7 @@ void CCONV cmAddLibrary(void *arg, const char *libname, int shared, srcs2.push_back(srcs[i]); } mf->AddLibrary(libname, - (shared? cmTarget::SHARED_LIBRARY : cmTarget::STATIC_LIBRARY), + (shared? cmState::SHARED_LIBRARY : cmState::STATIC_LIBRARY), srcs2); } diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx index b2ad4a8..f3e7121 100644 --- a/Source/cmCTest.cxx +++ b/Source/cmCTest.cxx @@ -14,7 +14,6 @@ #include "cmCTest.h" #include "cmake.h" #include "cmMakefile.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include <cmsys/Base64.h> #include <cmsys/Directory.hxx> @@ -518,9 +517,9 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command) cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg(gg.CreateLocalGenerator(mf.get())); if ( !this->ReadCustomConfigurationFileTree(this->BinaryDir.c_str(), mf.get()) ) { @@ -2165,7 +2164,46 @@ bool cmCTest::HandleCommandLineArguments(size_t &i, { this->OutputTestOutputOnTestFailure = true; } - + if (this->CheckArgument(arg, "--test-output-size-passed") && + i < args.size() - 1) + { + i++; + long outputSize; + if (cmSystemTools::StringToLong(args[i].c_str(), &outputSize)) + { + if (cmCTestTestHandler *pCTestTestHandler = + static_cast<cmCTestTestHandler*>(this->TestingHandlers["test"])) + { + pCTestTestHandler->SetTestOutputSizePassed(int(outputSize)); + } + } + else + { + cmCTestLog(this, WARNING, + "Invalid value for '--test-output-size-passed': " << + args[i] << "\n"); + } + } + if (this->CheckArgument(arg, "--test-output-size-failed") && + i < args.size() - 1) + { + i++; + long outputSize; + if (cmSystemTools::StringToLong(args[i].c_str(), &outputSize)) + { + if (cmCTestTestHandler *pCTestTestHandler = + static_cast<cmCTestTestHandler*>(this->TestingHandlers["test"])) + { + pCTestTestHandler->SetTestOutputSizeFailed(int(outputSize)); + } + } + else + { + cmCTestLog(this, WARNING, + "Invalid value for '--test-output-size-failed': " << + args[i] << "\n"); + } + } if(this->CheckArgument(arg, "-N", "--show-only")) { this->ShowOnly = true; diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx index 54209c5..ce8af55 100644 --- a/Source/cmCacheManager.cxx +++ b/Source/cmCacheManager.cxx @@ -13,7 +13,6 @@ #include "cmCacheManager.h" #include "cmSystemTools.h" #include "cmGeneratedFileStream.h" -#include "cmMakefile.h" #include "cmake.h" #include "cmVersion.h" @@ -22,101 +21,10 @@ #include <cmsys/FStream.hxx> #include <cmsys/RegularExpression.hxx> -cmCacheManager::cmCacheManager(cmake* cm) +cmCacheManager::cmCacheManager() { this->CacheMajorVersion = 0; this->CacheMinorVersion = 0; - this->CMakeInstance = cm; -} - -bool cmCacheManager::LoadCache(const std::string& path) -{ - std::set<std::string> emptySet; - return this->LoadCache(path, true, emptySet, emptySet); -} - -static bool ParseEntryWithoutType(const std::string& entry, - std::string& var, - std::string& value) -{ - // input line is: key=value - static cmsys::RegularExpression reg( - "^([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); - // input line is: "key"=value - static cmsys::RegularExpression regQuoted( - "^\"([^\"]*)\"=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); - bool flag = false; - if(regQuoted.find(entry)) - { - var = regQuoted.match(1); - value = regQuoted.match(2); - flag = true; - } - else if (reg.find(entry)) - { - var = reg.match(1); - value = reg.match(2); - flag = true; - } - - // if value is enclosed in single quotes ('foo') then remove them - // it is used to enclose trailing space or tab - if (flag && - value.size() >= 2 && - value[0] == '\'' && - value[value.size() - 1] == '\'') - { - value = value.substr(1, - value.size() - 2); - } - - return flag; -} - -bool cmCacheManager::ParseEntry(const std::string& entry, - std::string& var, - std::string& value, - cmState::CacheEntryType& type) -{ - // input line is: key:type=value - static cmsys::RegularExpression reg( - "^([^=:]*):([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); - // input line is: "key":type=value - static cmsys::RegularExpression regQuoted( - "^\"([^\"]*)\":([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); - bool flag = false; - if(regQuoted.find(entry)) - { - var = regQuoted.match(1); - type = cmState::StringToCacheEntryType(regQuoted.match(2).c_str()); - value = regQuoted.match(3); - flag = true; - } - else if (reg.find(entry)) - { - var = reg.match(1); - type = cmState::StringToCacheEntryType(reg.match(2).c_str()); - value = reg.match(3); - flag = true; - } - - // if value is enclosed in single quotes ('foo') then remove them - // it is used to enclose trailing space or tab - if (flag && - value.size() >= 2 && - value[0] == '\'' && - value[value.size() - 1] == '\'') - { - value = value.substr(1, - value.size() - 2); - } - - if (!flag) - { - return ParseEntryWithoutType(entry, var, value); - } - - return flag; } void cmCacheManager::CleanCMakeFiles(const std::string& path) @@ -195,7 +103,7 @@ bool cmCacheManager::LoadCache(const std::string& path, } } e.SetProperty("HELPSTRING", helpString.c_str()); - if(cmCacheManager::ParseEntry(realbuffer, entryKey, e.Value, e.Type)) + if(cmState::ParseCacheEntry(realbuffer, entryKey, e.Value, e.Type)) { if ( excludes.find(entryKey) == excludes.end() ) { @@ -678,7 +586,6 @@ void cmCacheManager::AddCacheEntry(const std::string& key, } e.SetProperty("HELPSTRING", helpString? helpString : "(This variable does not exist and should not be used)"); - this->CMakeInstance->UnwatchUnusedCli(key); } bool cmCacheManager::CacheIterator::IsAtEnd() const diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h index 8462259..6f063eb 100644 --- a/Source/cmCacheManager.h +++ b/Source/cmCacheManager.h @@ -16,9 +16,7 @@ #include "cmPropertyMap.h" #include "cmState.h" -class cmMakefile; class cmMarkAsAdvancedCommand; -class cmake; /** \class cmCacheManager * \brief Control class for cmake's cache @@ -29,7 +27,7 @@ class cmake; class cmCacheManager { public: - cmCacheManager(cmake* cm); + cmCacheManager(); class CacheIterator; friend class cmCacheManager::CacheIterator; @@ -100,7 +98,6 @@ public: } ///! Load a cache for given makefile. Loads from path/CMakeCache.txt. - bool LoadCache(const std::string& path); bool LoadCache(const std::string& path, bool internal, std::set<std::string>& excludes, std::set<std::string>& includes); @@ -124,12 +121,6 @@ public: int GetSize() { return static_cast<int>(this->Cache.size()); } - ///! Break up a line like VAR:type="value" into var, type and value - static bool ParseEntry(const std::string& entry, - std::string& var, - std::string& value, - cmState::CacheEntryType& type); - ///! Get a value from the cache given a key const char* GetInitializedCacheValue(const std::string& key) const; @@ -241,7 +232,7 @@ private: void WritePropertyEntries(std::ostream& os, CacheIterator const& i); CacheEntryMap Cache; - // Only cmake and cmMakefile should be able to add cache values + // Only cmake and cmState should be able to add cache values // the commands should never use the cmCacheManager directly friend class cmState; // allow access to add cache values friend class cmake; // allow access to add cache values diff --git a/Source/cmCommand.h b/Source/cmCommand.h index 0548c6b..59bc396 100644 --- a/Source/cmCommand.h +++ b/Source/cmCommand.h @@ -102,15 +102,6 @@ public: } /** - * This determines if usage of the method is discouraged or not. - * This is currently only used for generating the documentation. - */ - virtual bool IsDiscouraged() const - { - return false; - } - - /** * This is used to avoid including this command * in documentation. This is mainly used by * cmMacroHelperCommand and cmFunctionHelperCommand diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx index 4840e89..bd47715 100644 --- a/Source/cmCommonTargetGenerator.cxx +++ b/Source/cmCommonTargetGenerator.cxx @@ -18,7 +18,6 @@ #include "cmMakefile.h" #include "cmSourceFile.h" #include "cmSystemTools.h" -#include "cmTarget.h" cmCommonTargetGenerator::cmCommonTargetGenerator( cmOutputConverter::RelativeRoot wd, @@ -26,7 +25,6 @@ cmCommonTargetGenerator::cmCommonTargetGenerator( ) : WorkingDirectory(wd) , GeneratorTarget(gt) - , Target(gt->Target) , Makefile(gt->Makefile) , LocalGenerator(static_cast<cmLocalCommonGenerator*>(gt->LocalGenerator)) , GlobalGenerator(static_cast<cmGlobalCommonGenerator*>( @@ -109,7 +107,7 @@ std::string cmCommonTargetGenerator::ComputeFortranModuleDirectory() const { std::string mod_dir; const char* target_mod_dir = - this->Target->GetProperty("Fortran_MODULE_DIRECTORY"); + this->GeneratorTarget->GetProperty("Fortran_MODULE_DIRECTORY"); const char* moddir_flag = this->Makefile->GetDefinition("CMAKE_Fortran_MODDIR_FLAG"); if(target_mod_dir && moddir_flag) @@ -123,7 +121,7 @@ std::string cmCommonTargetGenerator::ComputeFortranModuleDirectory() const else { // Interpret relative to the current output directory. - mod_dir = this->Makefile->GetCurrentBinaryDirectory(); + mod_dir = this->LocalGenerator->GetCurrentBinaryDirectory(); mod_dir += "/"; mod_dir += target_mod_dir; } @@ -214,7 +212,7 @@ cmCommonTargetGenerator this->LocalGenerator->GetFortranFormat(srcfmt); if(format == cmLocalGenerator::FortranFormatNone) { - const char* tgtfmt = this->Target->GetProperty("Fortran_FORMAT"); + const char* tgtfmt = this->GeneratorTarget->GetProperty("Fortran_FORMAT"); format = this->LocalGenerator->GetFortranFormat(tgtfmt); } const char* var = 0; @@ -265,7 +263,7 @@ std::string cmCommonTargetGenerator::GetFrameworkFlags(std::string const& l) for(std::vector<std::string>::iterator i = includes.begin(); i != includes.end(); ++i) { - if(this->Target->NameResolvesToFramework(*i)) + if(this->GlobalGenerator->NameResolvesToFramework(*i)) { std::string frameworkDir = *i; frameworkDir += "/../"; @@ -316,10 +314,11 @@ std::string cmCommonTargetGenerator::GetFlags(const std::string &l) this->AddFortranFlags(flags); } - this->LocalGenerator->AddCMP0018Flags(flags, this->Target, + this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget, lang, this->ConfigName); - this->LocalGenerator->AddVisibilityPresetFlags(flags, this->Target, + this->LocalGenerator->AddVisibilityPresetFlags(flags, + this->GeneratorTarget, lang); // Append old-style preprocessor definition flags. @@ -331,7 +330,7 @@ std::string cmCommonTargetGenerator::GetFlags(const std::string &l) AppendFlags(flags,this->GetFrameworkFlags(l)); // Add target-specific flags. - this->LocalGenerator->AddCompileOptions(flags, this->Target, + this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, lang, this->ConfigName); ByLanguageMap::value_type entry(l, flags); @@ -348,13 +347,14 @@ std::string cmCommonTargetGenerator::GetDefines(const std::string &l) std::set<std::string> defines; const char *lang = l.c_str(); // Add the export symbol definition for shared library objects. - if(const char* exportMacro = this->Target->GetExportMacro()) + if(const char* exportMacro = + this->GeneratorTarget->GetExportMacro()) { this->LocalGenerator->AppendDefines(defines, exportMacro); } // Add preprocessor definitions for this target and configuration. - this->LocalGenerator->AddCompileDefinitions(defines, this->Target, + this->LocalGenerator->AddCompileDefinitions(defines, this->GeneratorTarget, this->LocalGenerator->GetConfigName(), l); std::string definesString; @@ -383,7 +383,7 @@ std::vector<std::string> cmCommonTargetGenerator::GetLinkedTargetDirectories() const { std::vector<std::string> dirs; - std::set<cmTarget const*> emitted; + std::set<cmGeneratorTarget const*> emitted; if (cmComputeLinkInformation* cli = this->GeneratorTarget->GetLinkInformation(this->ConfigName)) { @@ -391,24 +391,38 @@ cmCommonTargetGenerator::GetLinkedTargetDirectories() const for(cmComputeLinkInformation::ItemVector::const_iterator i = items.begin(); i != items.end(); ++i) { - cmTarget const* linkee = i->Target; + cmGeneratorTarget const* linkee = i->Target; if(linkee && !linkee->IsImported() // We can ignore the INTERFACE_LIBRARY items because // Target->GetLinkInformation already processed their // link interface and they don't have any output themselves. - && linkee->GetType() != cmTarget::INTERFACE_LIBRARY + && linkee->GetType() != cmState::INTERFACE_LIBRARY && emitted.insert(linkee).second) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(linkee); - cmLocalGenerator* lg = gt->GetLocalGenerator(); - cmMakefile* mf = linkee->GetMakefile(); - std::string di = mf->GetCurrentBinaryDirectory(); + cmLocalGenerator* lg = linkee->GetLocalGenerator(); + std::string di = lg->GetCurrentBinaryDirectory(); di += "/"; - di += lg->GetTargetDirectory(*linkee); + di += lg->GetTargetDirectory(linkee); dirs.push_back(di); } } } return dirs; } + +std::string cmCommonTargetGenerator::GetManifests() +{ + std::vector<cmSourceFile const*> manifest_srcs; + this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName); + + std::vector<std::string> manifests; + for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin(); + mi != manifest_srcs.end(); ++mi) + { + manifests.push_back(this->Convert((*mi)->GetFullPath(), + this->WorkingDirectory, + cmOutputConverter::SHELL)); + } + + return cmJoin(manifests, " "); +} diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h index 0a49e12..3fb1fd0 100644 --- a/Source/cmCommonTargetGenerator.h +++ b/Source/cmCommonTargetGenerator.h @@ -21,7 +21,6 @@ class cmGlobalCommonGenerator; class cmLocalCommonGenerator; class cmMakefile; class cmSourceFile; -class cmTarget; /** \class cmCommonTargetGenerator * \brief Common infrastructure for Makefile and Ninja per-target generators @@ -49,7 +48,6 @@ protected: cmOutputConverter::RelativeRoot WorkingDirectory; cmGeneratorTarget* GeneratorTarget; - cmTarget* Target; cmMakefile* Makefile; cmLocalCommonGenerator* LocalGenerator; cmGlobalCommonGenerator* GlobalGenerator; @@ -88,6 +86,7 @@ protected: ByLanguageMap DefinesByLanguage; std::string GetIncludes(std::string const& l); ByLanguageMap IncludesByLanguage; + std::string GetManifests(); std::vector<std::string> GetLinkedTargetDirectories() const; }; diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx index 1b5c9f4..13098ad 100644 --- a/Source/cmComputeLinkDepends.cxx +++ b/Source/cmComputeLinkDepends.cxx @@ -185,7 +185,9 @@ cmComputeLinkDepends // The configuration being linked. this->HasConfig = !config.empty(); this->Config = (this->HasConfig)? config : std::string(); - this->LinkType = this->Target->Target->ComputeLinkType(this->Config); + std::vector<std::string> debugConfigs = + this->Makefile->GetCMakeInstance()->GetDebugConfigs(); + this->LinkType = CMP0003_ComputeLinkType(this->Config, debugConfigs); // Enable debug mode if requested. this->DebugMode = this->Makefile->IsOn("CMAKE_LINK_DEPENDS_DEBUG_MODE"); @@ -268,9 +270,9 @@ cmComputeLinkDepends::Compute() { int i = *li; LinkEntry const& e = this->EntryList[i]; - cmTarget const* t = e.Target; + cmGeneratorTarget const* t = e.Target; // Entries that we know the linker will re-use do not need to be repeated. - bool uniquify = t && t->GetType() == cmTarget::SHARED_LIBRARY; + bool uniquify = t && t->GetType() == cmState::SHARED_LIBRARY; if(!uniquify || emmitted.insert(i).second) { this->FinalLinkEntries.push_back(e); @@ -362,14 +364,12 @@ void cmComputeLinkDepends::FollowLinkEntry(BFSEntry const& qe) // Follow the item's dependencies. if(entry.Target) { - cmGeneratorTarget* gtgt = - this->GlobalGenerator->GetGeneratorTarget(entry.Target); // Follow the target dependencies. if(cmLinkInterface const* iface = - gtgt->GetLinkInterface(this->Config, this->Target->Target)) + entry.Target->GetLinkInterface(this->Config, this->Target)) { const bool isIface = - entry.Target->GetType() == cmTarget::INTERFACE_LIBRARY; + entry.Target->GetType() == cmState::INTERFACE_LIBRARY; // This target provides its own link interface information. this->AddLinkEntries(depender_index, iface->Libraries); @@ -463,10 +463,8 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep) // Target items may have their own dependencies. if(entry.Target) { - cmGeneratorTarget* gtgt = - this->GlobalGenerator->GetGeneratorTarget(entry.Target); if(cmLinkInterface const* iface = - gtgt->GetLinkInterface(this->Config, this->Target->Target)) + entry.Target->GetLinkInterface(this->Config, this->Target)) { // Follow public and private dependencies transitively. this->FollowSharedDeps(index, iface, true); @@ -486,24 +484,24 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index, // Look for entries meant for this configuration. std::vector<cmLinkItem> actual_libs; - cmTarget::LinkLibraryType llt = cmTarget::GENERAL; + cmTargetLinkLibraryType llt = GENERAL_LibraryType; bool haveLLT = false; for(std::vector<std::string>::const_iterator di = deplist.begin(); di != deplist.end(); ++di) { if(*di == "debug") { - llt = cmTarget::DEBUG; + llt = DEBUG_LibraryType; haveLLT = true; } else if(*di == "optimized") { - llt = cmTarget::OPTIMIZED; + llt = OPTIMIZED_LibraryType; haveLLT = true; } else if(*di == "general") { - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; haveLLT = true; } else if(!di->empty()) @@ -521,17 +519,17 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index, { if(strcmp(val, "debug") == 0) { - llt = cmTarget::DEBUG; + llt = DEBUG_LibraryType; } else if(strcmp(val, "optimized") == 0) { - llt = cmTarget::OPTIMIZED; + llt = OPTIMIZED_LibraryType; } } } // If the library is meant for this link type then use it. - if(llt == cmTarget::GENERAL || llt == this->LinkType) + if(llt == GENERAL_LibraryType || llt == this->LinkType) { cmLinkItem item(*di, this->FindTargetToLink(depender_index, *di)); actual_libs.push_back(item); @@ -543,7 +541,7 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index, } // Reset the link type until another explicit type is given. - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; haveLLT = false; } } @@ -635,14 +633,16 @@ cmComputeLinkDepends::AddLinkEntries( } //---------------------------------------------------------------------------- -cmTarget const* cmComputeLinkDepends::FindTargetToLink(int depender_index, - const std::string& name) +cmGeneratorTarget const* +cmComputeLinkDepends::FindTargetToLink(int depender_index, + const std::string& name) { // Look for a target in the scope of the depender. - cmTarget const* from = this->Target->Target; + cmGeneratorTarget const* from = this->Target; if(depender_index >= 0) { - if(cmTarget const* depender = this->EntryList[depender_index].Target) + if(cmGeneratorTarget const* depender = + this->EntryList[depender_index].Target) { from = depender; } @@ -934,12 +934,10 @@ int cmComputeLinkDepends::ComputeComponentCount(NodeList const& nl) int count = 2; for(NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) { - if(cmTarget const* target = this->EntryList[*ni].Target) + if(cmGeneratorTarget const* target = this->EntryList[*ni].Target) { - cmGeneratorTarget* gtgt = - this->GlobalGenerator->GetGeneratorTarget(target); if(cmLinkInterface const* iface = - gtgt->GetLinkInterface(this->Config, this->Target->Target)) + target->GetLinkInterface(this->Config, this->Target)) { if(iface->Multiplicity > count) { diff --git a/Source/cmComputeLinkDepends.h b/Source/cmComputeLinkDepends.h index 2cbb430..f10e4e4 100644 --- a/Source/cmComputeLinkDepends.h +++ b/Source/cmComputeLinkDepends.h @@ -13,7 +13,7 @@ #define cmComputeLinkDepends_h #include "cmStandardIncludes.h" -#include "cmTarget.h" +#include "cmLinkItem.h" #include "cmGraphAdjacencyList.h" @@ -23,7 +23,6 @@ class cmComputeComponentGraph; class cmGlobalGenerator; class cmMakefile; class cmGeneratorTarget; -class cmTarget; class cmake; /** \class cmComputeLinkDepends @@ -40,7 +39,7 @@ public: struct LinkEntry { std::string Item; - cmTarget const* Target; + cmGeneratorTarget const* Target; bool IsSharedDep; bool IsFlag; LinkEntry(): Item(), Target(0), IsSharedDep(false), IsFlag(false) {} @@ -53,7 +52,7 @@ public: EntryVector const& Compute(); void SetOldLinkDirMode(bool b); - std::set<cmTarget const*> const& GetOldWrongConfigItems() const + std::set<cmGeneratorTarget const*> const& GetOldWrongConfigItems() const { return this->OldWrongConfigItems; } private: @@ -66,8 +65,6 @@ private: std::string Config; EntryVector FinalLinkEntries; - typedef cmTarget::LinkLibraryVectorType LinkLibraryVectorType; - std::map<std::string, int>::iterator AllocateLinkEntry(std::string const& item); int AddLinkEntry(cmLinkItem const& item); @@ -75,8 +72,8 @@ private: void AddDirectLinkEntries(); template <typename T> void AddLinkEntries(int depender_index, std::vector<T> const& libs); - cmTarget const* FindTargetToLink(int depender_index, - const std::string& name); + cmGeneratorTarget const* FindTargetToLink(int depender_index, + const std::string& name); // One entry for each unique item. std::vector<LinkEntry> EntryList; @@ -153,11 +150,11 @@ private: // Record of the original link line. std::vector<int> OriginalEntries; - std::set<cmTarget const*> OldWrongConfigItems; + std::set<cmGeneratorTarget const*> OldWrongConfigItems; void CheckWrongConfigItem(cmLinkItem const& item); int ComponentOrderId; - cmTarget::LinkLibraryType LinkType; + cmTargetLinkLibraryType LinkType; bool HasConfig; bool DebugMode; bool OldLinkDirMode; diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx index d35b566..50d8324 100644 --- a/Source/cmComputeLinkInformation.cxx +++ b/Source/cmComputeLinkInformation.cxx @@ -19,7 +19,6 @@ #include "cmState.h" #include "cmOutputConverter.h" #include "cmMakefile.h" -#include "cmTarget.h" #include "cmGeneratorTarget.h" #include "cmake.h" #include "cmAlgorithms.h" @@ -284,14 +283,14 @@ cmComputeLinkInformation // Check whether we should skip dependencies on shared library files. this->LinkDependsNoShared = - this->Target->Target->GetPropertyAsBool("LINK_DEPENDS_NO_SHARED"); + this->Target->GetPropertyAsBool("LINK_DEPENDS_NO_SHARED"); // On platforms without import libraries there may be a special flag // to use when creating a plugin (module) that obtains symbols from // the program that will load it. this->LoaderFlag = 0; if(!this->UseImportLibrary && - this->Target->Target->GetType() == cmTarget::MODULE_LIBRARY) + this->Target->GetType() == cmState::MODULE_LIBRARY) { std::string loader_flag_var = "CMAKE_SHARED_MODULE_LOADER_"; loader_flag_var += this->LinkLanguage; @@ -309,10 +308,10 @@ cmComputeLinkInformation // Get options needed to specify RPATHs. this->RuntimeUseChrpath = false; - if(this->Target->Target->GetType() != cmTarget::STATIC_LIBRARY) + if(this->Target->GetType() != cmState::STATIC_LIBRARY) { const char* tType = - ((this->Target->Target->GetType() == cmTarget::EXECUTABLE)? + ((this->Target->GetType() == cmState::EXECUTABLE)? "EXECUTABLE" : "SHARED_LIBRARY"); std::string rtVar = "CMAKE_"; rtVar += tType; @@ -378,9 +377,9 @@ cmComputeLinkInformation // Add the search path entries requested by the user to path ordering. this->OrderLinkerSearchPath - ->AddUserDirectories(this->Target->Target->GetLinkDirectories()); + ->AddUserDirectories(this->Target->GetLinkDirectories()); this->OrderRuntimeSearchPath - ->AddUserDirectories(this->Target->Target->GetLinkDirectories()); + ->AddUserDirectories(this->Target->GetLinkDirectories()); // Set up the implicit link directories. this->LoadImplicitLinkInfo(); @@ -408,13 +407,13 @@ cmComputeLinkInformation // order to support such projects we need to add the directories // containing libraries linked with a full path to the -L path. this->OldLinkDirMode = - this->Target->Target->GetPolicyStatusCMP0003() != cmPolicies::NEW; + this->Target->GetPolicyStatusCMP0003() != cmPolicies::NEW; if(this->OldLinkDirMode) { // Construct a mask to not bother with this behavior for link // directories already specified by the user. std::vector<std::string> const& dirs = - this->Target->Target->GetLinkDirectories(); + this->Target->GetLinkDirectories(); this->OldLinkDirMask.insert(dirs.begin(), dirs.end()); } @@ -471,7 +470,7 @@ std::vector<std::string> const& cmComputeLinkInformation::GetFrameworkPaths() } //---------------------------------------------------------------------------- -std::set<cmTarget const*> const& +const std::set<const cmGeneratorTarget*>& cmComputeLinkInformation::GetSharedLibrariesLinked() { return this->SharedLibrariesLinked; @@ -481,10 +480,10 @@ cmComputeLinkInformation::GetSharedLibrariesLinked() bool cmComputeLinkInformation::Compute() { // Skip targets that do not link. - if(!(this->Target->GetType() == cmTarget::EXECUTABLE || - this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY || - this->Target->GetType() == cmTarget::STATIC_LIBRARY)) + if(!(this->Target->GetType() == cmState::EXECUTABLE || + this->Target->GetType() == cmState::SHARED_LIBRARY || + this->Target->GetType() == cmState::MODULE_LIBRARY || + this->Target->GetType() == cmState::STATIC_LIBRARY)) { return false; } @@ -521,7 +520,7 @@ bool cmComputeLinkInformation::Compute() // Restore the target link type so the correct system runtime // libraries are found. const char* lss = - this->Target->Target->GetProperty("LINK_SEARCH_END_STATIC"); + this->Target->GetProperty("LINK_SEARCH_END_STATIC"); if(cmSystemTools::IsOn(lss)) { this->SetCurrentLinkType(LinkStatic); @@ -537,16 +536,16 @@ bool cmComputeLinkInformation::Compute() // For CMake 2.4 bug-compatibility we need to consider the output // directories of targets linked in another configuration as link // directories. - std::set<cmTarget const*> const& wrongItems = cld.GetOldWrongConfigItems(); - for(std::set<cmTarget const*>::const_iterator i = wrongItems.begin(); - i != wrongItems.end(); ++i) + std::set<cmGeneratorTarget const*> const& wrongItems = + cld.GetOldWrongConfigItems(); + for(std::set<cmGeneratorTarget const*>::const_iterator i = + wrongItems.begin(); i != wrongItems.end(); ++i) { - cmTarget const* tgt = *i; - cmGeneratorTarget *gtgt = this->GlobalGenerator->GetGeneratorTarget(tgt); + cmGeneratorTarget const* tgt = *i; bool implib = (this->UseImportLibrary && - (tgt->GetType() == cmTarget::SHARED_LIBRARY)); - std::string lib = gtgt->GetFullPath(this->Config , implib, true); + (tgt->GetType() == cmState::SHARED_LIBRARY)); + std::string lib = tgt->GetFullPath(this->Config , implib, true); this->OldLinkDirItems.push_back(lib); } } @@ -572,7 +571,7 @@ bool cmComputeLinkInformation::Compute() "name." ; this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } return true; @@ -632,7 +631,7 @@ void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang) //---------------------------------------------------------------------------- void cmComputeLinkInformation::AddItem(std::string const& item, - cmTarget const* tgt) + cmGeneratorTarget const* tgt) { // Compute the proper name to use to link this library. const std::string& config = this->Config; @@ -646,7 +645,6 @@ void cmComputeLinkInformation::AddItem(std::string const& item, if(tgt && tgt->IsLinkable()) { - cmGeneratorTarget *gtgt = this->GlobalGenerator->GetGeneratorTarget(tgt); // This is a CMake target. Ask the target for its real name. if(impexe && this->LoaderFlag) { @@ -656,13 +654,13 @@ void cmComputeLinkInformation::AddItem(std::string const& item, std::string linkItem; linkItem = this->LoaderFlag; - std::string exe = gtgt->GetFullPath(config, this->UseImportLibrary, + std::string exe = tgt->GetFullPath(config, this->UseImportLibrary, true); linkItem += exe; this->Items.push_back(Item(linkItem, true, tgt)); this->Depends.push_back(exe); } - else if(tgt->GetType() == cmTarget::INTERFACE_LIBRARY) + else if(tgt->GetType() == cmState::INTERFACE_LIBRARY) { // Add the interface library as an item so it can be considered as part // of COMPATIBLE_INTERFACE_ enforcement. The generators will ignore @@ -674,12 +672,12 @@ void cmComputeLinkInformation::AddItem(std::string const& item, // Decide whether to use an import library. bool implib = (this->UseImportLibrary && - (impexe || tgt->GetType() == cmTarget::SHARED_LIBRARY)); + (impexe || tgt->GetType() == cmState::SHARED_LIBRARY)); // Pass the full path to the target file. - std::string lib = gtgt->GetFullPath(config, implib, true); + std::string lib = tgt->GetFullPath(config, implib, true); if(!this->LinkDependsNoShared || - tgt->GetType() != cmTarget::SHARED_LIBRARY) + tgt->GetType() != cmState::SHARED_LIBRARY) { this->Depends.push_back(lib); } @@ -716,7 +714,7 @@ void cmComputeLinkInformation::AddItem(std::string const& item, //---------------------------------------------------------------------------- void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, - cmTarget const* tgt) + const cmGeneratorTarget* tgt) { // If dropping shared library dependencies, ignore them. if(this->SharedDependencyMode == SharedDepModeNone) @@ -730,7 +728,7 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, { // The target will provide a full path. Make sure it is a shared // library. - if(tgt->GetType() != cmTarget::SHARED_LIBRARY) + if(tgt->GetType() != cmState::SHARED_LIBRARY) { return; } @@ -760,17 +758,13 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, return; } - cmGeneratorTarget *gtgt = 0; - // Get a full path to the dependent shared library. // Add it to the runtime path computation so that the target being // linked will be able to find it. std::string lib; if(tgt) { - gtgt = this->GlobalGenerator->GetGeneratorTarget(tgt); - - lib = gtgt->GetFullPath(this->Config, this->UseImportLibrary); + lib = tgt->GetFullPath(this->Config, this->UseImportLibrary); this->AddLibraryRuntimeInfo(lib, tgt); } else @@ -795,9 +789,9 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, } if(order) { - if(gtgt) + if(tgt) { - std::string soName = gtgt->GetSOName(this->Config); + std::string soName = tgt->GetSOName(this->Config); const char* soname = soName.empty()? 0 : soName.c_str(); order->AddRuntimeLibrary(lib, soname); } @@ -824,9 +818,9 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo() const char* target_type_str = 0; switch(this->Target->GetType()) { - case cmTarget::EXECUTABLE: target_type_str = "EXE"; break; - case cmTarget::SHARED_LIBRARY: target_type_str = "SHARED_LIBRARY"; break; - case cmTarget::MODULE_LIBRARY: target_type_str = "SHARED_MODULE"; break; + case cmState::EXECUTABLE: target_type_str = "EXE"; break; + case cmState::SHARED_LIBRARY: target_type_str = "SHARED_LIBRARY"; break; + case cmState::MODULE_LIBRARY: target_type_str = "SHARED_MODULE"; break; default: break; } if(target_type_str) @@ -860,7 +854,7 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo() // Lookup the starting link type from the target (linked statically?). const char* lss = - this->Target->Target->GetProperty("LINK_SEARCH_START_STATIC"); + this->Target->GetProperty("LINK_SEARCH_START_STATIC"); this->StartLinkType = cmSystemTools::IsOn(lss)? LinkStatic : LinkShared; this->CurrentLinkType = this->StartLinkType; } @@ -1082,7 +1076,7 @@ void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt) //---------------------------------------------------------------------------- void cmComputeLinkInformation::AddTargetItem(std::string const& item, - cmTarget const* target) + cmGeneratorTarget const* target) { // This is called to handle a link item that is a full path to a target. // If the target is not a static library make sure the link type is @@ -1090,13 +1084,13 @@ void cmComputeLinkInformation::AddTargetItem(std::string const& item, // shared and static libraries but static-mode can handle only // static libraries. If a previous user item changed the link type // to static we need to make sure it is back to shared. - if(target->GetType() != cmTarget::STATIC_LIBRARY) + if(target->GetType() != cmState::STATIC_LIBRARY) { this->SetCurrentLinkType(LinkShared); } // Keep track of shared library targets linked. - if(target->GetType() == cmTarget::SHARED_LIBRARY) + if(target->GetType() == cmState::SHARED_LIBRARY) { this->SharedLibrariesLinked.insert(target); } @@ -1146,7 +1140,7 @@ void cmComputeLinkInformation::AddFullItem(std::string const& item) // Full path libraries should specify a valid library file name. // See documentation of CMP0008. std::string generator = this->GlobalGenerator->GetName(); - if(this->Target->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW && + if(this->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW && (generator.find("Visual Studio") != generator.npos || generator.find("Xcode") != generator.npos)) { @@ -1227,7 +1221,7 @@ bool cmComputeLinkInformation::CheckImplicitDirItem(std::string const& item) } // Check the policy for whether we should use the approach below. - switch (this->Target->Target->GetPolicyStatusCMP0060()) + switch (this->Target->GetPolicyStatusCMP0060()) { case cmPolicies::WARN: if (this->CMP0060Warn) @@ -1537,7 +1531,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, this->OrderLinkerSearchPath->AddLinkLibrary(item); // Produce any needed message. - switch(this->Target->Target->GetPolicyStatusCMP0008()) + switch(this->Target->GetPolicyStatusCMP0008()) { case cmPolicies::WARN: { @@ -1554,7 +1548,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, << " " << item << "\n" << "which is a full-path but not a valid library file name."; this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } } case cmPolicies::OLD: @@ -1572,7 +1566,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, << " " << item << "\n" << "which is a full-path but not a valid library file name."; this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } break; } @@ -1589,7 +1583,7 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories() } // Enforce policy constraints. - switch(this->Target->Target->GetPolicyStatusCMP0003()) + switch(this->Target->GetPolicyStatusCMP0003()) { case cmPolicies::WARN: if(!this->CMakeInstance->GetState() @@ -1600,7 +1594,7 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories() std::ostringstream w; this->PrintLinkPolicyDiagnosis(w); this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } case cmPolicies::OLD: // OLD behavior is to add the paths containing libraries with @@ -1616,7 +1610,7 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories() e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0003) << "\n"; this->PrintLinkPolicyDiagnosis(e); this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); return false; } } @@ -1781,7 +1775,7 @@ cmComputeLinkInformation::GetRuntimeSearchPath() //---------------------------------------------------------------------------- void cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath, - cmTarget const* target) + cmGeneratorTarget const* target) { // Ignore targets on Apple where install_name is not @rpath. // The dependenty library can be found with other means such as @@ -1796,22 +1790,21 @@ cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath, // Libraries with unknown type must be handled using just the file // on disk. - if(target->GetType() == cmTarget::UNKNOWN_LIBRARY) + if(target->GetType() == cmState::UNKNOWN_LIBRARY) { this->AddLibraryRuntimeInfo(fullPath); return; } // Skip targets that are not shared libraries (modules cannot be linked). - if(target->GetType() != cmTarget::SHARED_LIBRARY) + if(target->GetType() != cmState::SHARED_LIBRARY) { return; } // Try to get the soname of the library. Only files with this name // could possibly conflict. - cmGeneratorTarget *gtgt = this->GlobalGenerator->GetGeneratorTarget(target); - std::string soName = gtgt->GetSOName(this->Config); + std::string soName = target->GetSOName(this->Config); const char* soname = soName.empty()? 0 : soName.c_str(); // Include this library in the runtime path ordering. @@ -1918,9 +1911,9 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs, // build tree. bool linking_for_install = (for_install || - this->Target->Target->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH")); + this->Target->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH")); bool use_install_rpath = - (outputRuntime && this->Target->Target->HaveInstallTreeRPATH() && + (outputRuntime && this->Target->HaveInstallTreeRPATH() && linking_for_install); bool use_build_rpath = (outputRuntime && this->Target->HaveBuildTreeRPATH(this->Config) && @@ -1928,14 +1921,14 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs, bool use_link_rpath = outputRuntime && linking_for_install && !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH") && - this->Target->Target->GetPropertyAsBool("INSTALL_RPATH_USE_LINK_PATH"); + this->Target->GetPropertyAsBool("INSTALL_RPATH_USE_LINK_PATH"); // Construct the RPATH. std::set<std::string> emitted; if(use_install_rpath) { const char* install_rpath = - this->Target->Target->GetProperty("INSTALL_RPATH"); + this->Target->GetProperty("INSTALL_RPATH"); cmCLI_ExpandListUnique(install_rpath, runtimeDirs, emitted); } if(use_build_rpath || use_link_rpath) @@ -1975,8 +1968,9 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs, else if(use_link_rpath) { // Do not add any path inside the source or build tree. - const char* topSourceDir = this->Makefile->GetHomeDirectory(); - const char* topBinaryDir = this->Makefile->GetHomeOutputDirectory(); + const char* topSourceDir = this->CMakeInstance->GetHomeDirectory(); + const char* topBinaryDir = + this->CMakeInstance->GetHomeOutputDirectory(); if(!cmSystemTools::ComparePath(*ri, topSourceDir) && !cmSystemTools::ComparePath(*ri, topBinaryDir) && !cmSystemTools::IsSubDirectory(*ri, topSourceDir) && diff --git a/Source/cmComputeLinkInformation.h b/Source/cmComputeLinkInformation.h index 8b83574..5eecf7d 100644 --- a/Source/cmComputeLinkInformation.h +++ b/Source/cmComputeLinkInformation.h @@ -19,7 +19,6 @@ class cmake; class cmGlobalGenerator; class cmMakefile; -class cmTarget; class cmGeneratorTarget; class cmOrderDirectories; @@ -39,11 +38,11 @@ public: Item(): Value(), IsPath(true), Target(0) {} Item(Item const& item): Value(item.Value), IsPath(item.IsPath), Target(item.Target) {} - Item(std::string const& v, bool p, cmTarget const* target = 0): + Item(std::string const& v, bool p, cmGeneratorTarget const* target = 0): Value(v), IsPath(p), Target(target) {} std::string Value; bool IsPath; - cmTarget const* Target; + cmGeneratorTarget const* Target; }; typedef std::vector<Item> ItemVector; ItemVector const& GetItems(); @@ -57,13 +56,13 @@ public: void GetRPath(std::vector<std::string>& runtimeDirs, bool for_install); std::string GetRPathString(bool for_install); std::string GetChrpathString(); - std::set<cmTarget const*> const& GetSharedLibrariesLinked(); + std::set<cmGeneratorTarget const*> const& GetSharedLibrariesLinked(); std::string const& GetRPathLinkFlag() const { return this->RPathLinkFlag; } std::string GetRPathLinkString(); private: - void AddItem(std::string const& item, cmTarget const* tgt); - void AddSharedDepItem(std::string const& item, cmTarget const* tgt); + void AddItem(std::string const& item, const cmGeneratorTarget* tgt); + void AddSharedDepItem(std::string const& item, cmGeneratorTarget const* tgt); // Output information. ItemVector Items; @@ -71,7 +70,7 @@ private: std::vector<std::string> Depends; std::vector<std::string> FrameworkPaths; std::vector<std::string> RuntimeSearchPath; - std::set<cmTarget const*> SharedLibrariesLinked; + std::set<cmGeneratorTarget const*> SharedLibrariesLinked; // Context information. cmGeneratorTarget const* Target; @@ -129,7 +128,7 @@ private: std::string NoCaseExpression(const char* str); // Handling of link items. - void AddTargetItem(std::string const& item, cmTarget const* target); + void AddTargetItem(std::string const& item, const cmGeneratorTarget* target); void AddFullItem(std::string const& item); bool CheckImplicitDirItem(std::string const& item); void AddUserItem(std::string const& item, bool pathNotKnown); @@ -183,7 +182,7 @@ private: bool CMP0060Warn; void AddLibraryRuntimeInfo(std::string const& fullPath, - cmTarget const* target); + const cmGeneratorTarget* target); void AddLibraryRuntimeInfo(std::string const& fullPath); }; diff --git a/Source/cmComputeTargetDepends.cxx b/Source/cmComputeTargetDepends.cxx index 9e37c35..586b5bf 100644 --- a/Source/cmComputeTargetDepends.cxx +++ b/Source/cmComputeTargetDepends.cxx @@ -175,13 +175,12 @@ void cmComputeTargetDepends::CollectTargets() this->GlobalGenerator->GetLocalGenerators(); for(unsigned int i = 0; i < lgens.size(); ++i) { - const cmTargets& targets = lgens[i]->GetMakefile()->GetTargets(); - for(cmTargets::const_iterator ti = targets.begin(); + const std::vector<cmGeneratorTarget*> targets = + lgens[i]->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin(); ti != targets.end(); ++ti) { - cmTarget const* target = &ti->second; - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(target); + cmGeneratorTarget* gt = *ti; int index = static_cast<int>(this->Targets.size()); this->TargetIndex[gt] = index; this->Targets.push_back(gt); @@ -207,7 +206,7 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index) { // Get the depender. cmGeneratorTarget const* depender = this->Targets[depender_index]; - if (depender->GetType() == cmTarget::INTERFACE_LIBRARY) + if (depender->GetType() == cmState::INTERFACE_LIBRARY) { return; } @@ -236,16 +235,16 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index) std::string objLib = (*oi)->GetObjectLibrary(); if (!objLib.empty() && emitted.insert(objLib).second) { - if(depender->GetType() != cmTarget::EXECUTABLE && - depender->GetType() != cmTarget::STATIC_LIBRARY && - depender->GetType() != cmTarget::SHARED_LIBRARY && - depender->GetType() != cmTarget::MODULE_LIBRARY) + if(depender->GetType() != cmState::EXECUTABLE && + depender->GetType() != cmState::STATIC_LIBRARY && + depender->GetType() != cmState::SHARED_LIBRARY && + depender->GetType() != cmState::MODULE_LIBRARY) { this->GlobalGenerator->GetCMakeInstance() ->IssueMessage(cmake::FATAL_ERROR, "Only executables and non-OBJECT libraries may " "reference target objects.", - depender->Target->GetBacktrace()); + depender->GetBacktrace()); return; } const_cast<cmGeneratorTarget*>(depender)->Target->AddUtility(objLib); @@ -272,7 +271,7 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index) // Loop over all utility dependencies. { - std::set<cmLinkItem> const& tutils = depender->Target->GetUtilityItems(); + std::set<cmLinkItem> const& tutils = depender->GetUtilityItems(); std::set<std::string> emitted; // A target should not depend on itself. emitted.insert(depender->GetName()); @@ -297,7 +296,7 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index, cmGeneratorTarget const* depender = this->Targets[depender_index]; if(cmLinkInterface const* iface = dependee->GetLinkInterface(config, - depender->Target)) + depender)) { for(std::vector<cmLinkItem>::const_iterator lib = iface->Libraries.begin(); @@ -319,12 +318,12 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index, std::set<std::string> &emitted) { cmGeneratorTarget const* depender = this->Targets[depender_index]; - cmTarget const* dependee = dependee_name.Target; + cmGeneratorTarget const* dependee = dependee_name.Target; // Skip targets that will not really be linked. This is probably a // name conflict between an external library and an executable // within the project. if(dependee && - dependee->GetType() == cmTarget::EXECUTABLE && + dependee->GetType() == cmState::EXECUTABLE && !dependee->IsExecutableWithExports()) { dependee = 0; @@ -332,9 +331,7 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index, if(dependee) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(dependee); - this->AddInterfaceDepends(depender_index, gt, "", emitted); + this->AddInterfaceDepends(depender_index, dependee, "", emitted); std::vector<std::string> configs; depender->Makefile->GetConfigurations(configs); for (std::vector<std::string>::const_iterator it = configs.begin(); @@ -342,7 +339,7 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index, { // A target should not depend on itself. emitted.insert(depender->GetName()); - this->AddInterfaceDepends(depender_index, gt, *it, emitted); + this->AddInterfaceDepends(depender_index, dependee, *it, emitted); } } } @@ -356,15 +353,15 @@ void cmComputeTargetDepends::AddTargetDepend( cmGeneratorTarget const* depender = this->Targets[depender_index]; // Check the target's makefile first. - cmTarget const* dependee = dependee_name.Target; + cmGeneratorTarget const* dependee = dependee_name.Target; if(!dependee && !linking && - (depender->GetType() != cmTarget::GLOBAL_TARGET)) + (depender->GetType() != cmState::GLOBAL_TARGET)) { cmake::MessageType messageType = cmake::AUTHOR_WARNING; bool issueMessage = false; std::ostringstream e; - switch(depender->Target->GetPolicyStatusCMP0046()) + switch(depender->GetPolicyStatusCMP0046()) { case cmPolicies::WARN: e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0046) << "\n"; @@ -385,7 +382,7 @@ void cmComputeTargetDepends::AddTargetDepend( << "\" of target \"" << depender->GetName() << "\" does not exist."; cmListFileBacktrace const* backtrace = - depender->Target->GetUtilityBacktrace(dependee_name); + depender->GetUtilityBacktrace(dependee_name); if(backtrace) { cm->IssueMessage(messageType, e.str(), *backtrace); @@ -402,7 +399,7 @@ void cmComputeTargetDepends::AddTargetDepend( // name conflict between an external library and an executable // within the project. if(linking && dependee && - dependee->GetType() == cmTarget::EXECUTABLE && + dependee->GetType() == cmState::EXECUTABLE && !dependee->IsExecutableWithExports()) { dependee = 0; @@ -410,9 +407,7 @@ void cmComputeTargetDepends::AddTargetDepend( if(dependee) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(dependee); - this->AddTargetDepend(depender_index, gt, linking); + this->AddTargetDepend(depender_index, dependee, linking); } } @@ -421,20 +416,18 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index, const cmGeneratorTarget* dependee, bool linking) { - if(dependee->Target->IsImported() || - dependee->GetType() == cmTarget::INTERFACE_LIBRARY) + if(dependee->IsImported() || + dependee->GetType() == cmState::INTERFACE_LIBRARY) { // Skip IMPORTED and INTERFACE targets but follow their utility // dependencies. - std::set<cmLinkItem> const& utils = dependee->Target->GetUtilityItems(); + std::set<cmLinkItem> const& utils = dependee->GetUtilityItems(); for(std::set<cmLinkItem>::const_iterator i = utils.begin(); i != utils.end(); ++i) { - if(cmTarget const* transitive_dependee = i->Target) + if(cmGeneratorTarget const* transitive_dependee = i->Target) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(transitive_dependee); - this->AddTargetDepend(depender_index, gt, false); + this->AddTargetDepend(depender_index, transitive_dependee, false); } } } @@ -529,7 +522,7 @@ cmComputeTargetDepends // Make sure the component is all STATIC_LIBRARY targets. for(NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) { - if(this->Targets[*ni]->GetType() != cmTarget::STATIC_LIBRARY) + if(this->Targets[*ni]->GetType() != cmState::STATIC_LIBRARY) { this->ComplainAboutBadComponent(ccg, c); return false; @@ -560,7 +553,7 @@ cmComputeTargetDepends // Describe the depender. e << " \"" << depender->GetName() << "\" of type " - << cmTarget::GetTargetTypeName(depender->Target->GetType()) << "\n"; + << cmState::GetTargetTypeName(depender->GetType()) << "\n"; // List its dependencies that are inside the component. EdgeList const& nl = this->InitialGraph[i]; diff --git a/Source/cmConditionEvaluator.cxx b/Source/cmConditionEvaluator.cxx index 7874803..5330acd 100644 --- a/Source/cmConditionEvaluator.cxx +++ b/Source/cmConditionEvaluator.cxx @@ -11,9 +11,14 @@ ============================================================================*/ #include "cmConditionEvaluator.h" +#include "cmOutputConverter.h" -cmConditionEvaluator::cmConditionEvaluator(cmMakefile& makefile): +cmConditionEvaluator::cmConditionEvaluator(cmMakefile& makefile, + const cmListFileContext &context, + const cmListFileBacktrace& bt): Makefile(makefile), + ExecutionContext(context), + Backtrace(bt), Policy12Status(makefile.GetPolicyStatus(cmPolicies::CMP0012)), Policy54Status(makefile.GetPolicyStatus(cmPolicies::CMP0054)), Policy57Status(makefile.GetPolicyStatus(cmPolicies::CMP0057)), @@ -98,6 +103,25 @@ bool cmConditionEvaluator::IsTrue( errorString, status, true); } +cmListFileContext cmConditionEvaluator::GetConditionContext( + cmMakefile* mf, + const cmCommandContext& command, + const std::string& filePath) +{ + cmListFileContext context = + cmListFileContext::FromCommandContext( + command, + filePath); + + if(!mf->GetCMakeInstance()->GetIsInTryCompile()) + { + cmOutputConverter converter(mf->GetStateSnapshot()); + context.FilePath = converter.Convert(context.FilePath, + cmOutputConverter::HOME); + } + return context; +} + //========================================================================= const char* cmConditionEvaluator::GetDefinitionIfUnquoted( cmExpandedCommandArgument const& argument) const @@ -113,7 +137,8 @@ const char* cmConditionEvaluator::GetDefinitionIfUnquoted( if(def && argument.WasQuoted() && this->Policy54Status == cmPolicies::WARN) { - if(!this->Makefile.HasCMP0054AlreadyBeenReported()) + if(!this->Makefile.HasCMP0054AlreadyBeenReported( + this->ExecutionContext)) { std::ostringstream e; e << (cmPolicies::GetPolicyWarning(cmPolicies::CMP0054)) << "\n"; @@ -122,7 +147,9 @@ const char* cmConditionEvaluator::GetDefinitionIfUnquoted( "when the policy is set to NEW. " "Since the policy is not set the OLD behavior will be used."; - this->Makefile.IssueMessage(cmake::AUTHOR_WARNING, e.str()); + this->Makefile.GetCMakeInstance() + ->IssueMessage(cmake::AUTHOR_WARNING, e.str(), + this->Backtrace); } } @@ -159,7 +186,8 @@ bool cmConditionEvaluator::IsKeyword(std::string const& keyword, if(isKeyword && argument.WasQuoted() && this->Policy54Status == cmPolicies::WARN) { - if(!this->Makefile.HasCMP0054AlreadyBeenReported()) + if(!this->Makefile.HasCMP0054AlreadyBeenReported( + this->ExecutionContext)) { std::ostringstream e; e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0054) << "\n"; @@ -168,7 +196,9 @@ bool cmConditionEvaluator::IsKeyword(std::string const& keyword, "when the policy is set to NEW. " "Since the policy is not set the OLD behavior will be used."; - this->Makefile.IssueMessage(cmake::AUTHOR_WARNING, e.str()); + this->Makefile.GetCMakeInstance() + ->IssueMessage(cmake::AUTHOR_WARNING, e.str(), + this->Backtrace); } } diff --git a/Source/cmConditionEvaluator.h b/Source/cmConditionEvaluator.h index c4e2d11..8600825 100644 --- a/Source/cmConditionEvaluator.h +++ b/Source/cmConditionEvaluator.h @@ -22,7 +22,9 @@ class cmConditionEvaluator public: typedef std::list<cmExpandedCommandArgument> cmArgumentList; - cmConditionEvaluator(cmMakefile& makefile); + cmConditionEvaluator(cmMakefile& makefile, + cmListFileContext const& context, + cmListFileBacktrace const& bt); // this is a shared function for both If and Else to determine if the // arguments were valid, and if so, was the response true. If there is @@ -31,6 +33,9 @@ public: std::string &errorString, cmake::MessageType &status); + static cmListFileContext GetConditionContext(cmMakefile* mf, + const cmCommandContext& command, std::string const& filePath); + private: // Filter the given variable definition based on policy CMP0054. const char* GetDefinitionIfUnquoted( @@ -91,6 +96,8 @@ private: cmake::MessageType &status); cmMakefile& Makefile; + cmListFileContext ExecutionContext; + cmListFileBacktrace Backtrace; cmPolicies::PolicyStatus Policy12Status; cmPolicies::PolicyStatus Policy54Status; cmPolicies::PolicyStatus Policy57Status; diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx index 9411555..4a1f770 100644 --- a/Source/cmCoreTryCompile.cxx +++ b/Source/cmCoreTryCompile.cxx @@ -29,12 +29,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) const char* sourceDirectory = argv[2].c_str(); const char* projectName = 0; std::string targetName; - std::vector<std::string> cmakeFlags; + std::vector<std::string> cmakeFlags(1, "CMAKE_FLAGS"); // fake argv[0] std::vector<std::string> compileDefs; std::string outputVariable; std::string copyFile; std::string copyFileError; - std::vector<cmTarget const*> targets; + std::vector<std::string> targets; std::string libsToLink = " "; bool useOldLinkLibs = true; char targetNameBuf[64]; @@ -53,10 +53,6 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) if(argv[i] == "CMAKE_FLAGS") { doing = DoingCMakeFlags; - // CMAKE_FLAGS is the first argument because we need an argv[0] that - // is not used, so it matches regular command line parsing which has - // the program name as arg 0 - cmakeFlags.push_back(argv[i]); } else if(argv[i] == "COMPILE_DEFINITIONS") { @@ -97,12 +93,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) { switch(tgt->GetType()) { - case cmTarget::SHARED_LIBRARY: - case cmTarget::STATIC_LIBRARY: - case cmTarget::INTERFACE_LIBRARY: - case cmTarget::UNKNOWN_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::STATIC_LIBRARY: + case cmState::INTERFACE_LIBRARY: + case cmState::UNKNOWN_LIBRARY: break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: if (tgt->IsExecutableWithExports()) { break; @@ -111,12 +107,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) this->Makefile->IssueMessage(cmake::FATAL_ERROR, "Only libraries may be used as try_compile or try_run IMPORTED " "LINK_LIBRARIES. Got " + std::string(tgt->GetName()) + " of " - "type " + tgt->GetTargetTypeName(tgt->GetType()) + "."); + "type " + cmState::GetTargetTypeName(tgt->GetType()) + "."); return -1; } if (tgt->IsImported()) { - targets.push_back(tgt); + targets.push_back(argv[i]); } } } @@ -379,9 +375,8 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) if (!targets.empty()) { std::string fname = "/" + std::string(targetName) + "Targets.cmake"; - cmExportTryCompileFileGenerator tcfg(gg); + cmExportTryCompileFileGenerator tcfg(gg, targets, this->Makefile); tcfg.SetExportFile((this->BinaryDirectory + fname).c_str()); - tcfg.SetExports(targets); tcfg.SetConfig(this->Makefile->GetSafeDefinition( "CMAKE_TRY_COMPILE_CONFIGURATION")); @@ -481,6 +476,16 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) fprintf(fout, "set(CMAKE_LINK_SEARCH_END_STATIC \"%s\")\n", lssDef); } + /* Set the appropriate policy information for ENABLE_EXPORTS */ + fprintf(fout, "cmake_policy(SET CMP0065 %s)\n", + this->Makefile->GetPolicyStatus(cmPolicies::CMP0065) == + cmPolicies::NEW ? "NEW" : "OLD"); + if(const char *ee = this->Makefile->GetDefinition( + "CMAKE_ENABLE_EXPORTS")) + { + fprintf(fout, "set(CMAKE_ENABLE_EXPORTS %s)\n", ee); + } + /* Put the executable at a known location (for COPY_FILE). */ fprintf(fout, "set(CMAKE_RUNTIME_OUTPUT_DIRECTORY \"%s\")\n", this->BinaryDirectory.c_str()); diff --git a/Source/cmCustomCommandGenerator.cxx b/Source/cmCustomCommandGenerator.cxx index 7f3b651..dc06678 100644 --- a/Source/cmCustomCommandGenerator.cxx +++ b/Source/cmCustomCommandGenerator.cxx @@ -43,15 +43,14 @@ std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const { std::string const& argv0 = this->CC.GetCommandLines()[c][0]; cmGeneratorTarget* target = - this->LG->GetMakefile()->FindGeneratorTargetToUse(argv0); - if(target && target->GetType() == cmTarget::EXECUTABLE && - (target->Target->IsImported() + this->LG->FindGeneratorTargetToUse(argv0); + if(target && target->GetType() == cmState::EXECUTABLE && + (target->IsImported() || !this->LG->GetMakefile()->IsOn("CMAKE_CROSSCOMPILING"))) { return target->GetLocation(this->Config); } - return this->GE->Parse(argv0)->Evaluate(this->LG->GetMakefile(), - this->Config); + return this->GE->Parse(argv0)->Evaluate(this->LG, this->Config); } //---------------------------------------------------------------------------- @@ -92,7 +91,7 @@ cmCustomCommandGenerator for(unsigned int j=1;j < commandLine.size(); ++j) { std::string arg = - this->GE->Parse(commandLine[j])->Evaluate(this->LG->GetMakefile(), + this->GE->Parse(commandLine[j])->Evaluate(this->LG, this->Config); cmd += " "; if(this->OldStyle) @@ -101,7 +100,7 @@ cmCustomCommandGenerator } else { - cmOutputConverter converter(this->LG->GetMakefile()->GetStateSnapshot()); + cmOutputConverter converter(this->LG->GetStateSnapshot()); cmd += converter.EscapeForShell(arg, this->MakeVars); } } @@ -146,7 +145,7 @@ std::vector<std::string> const& cmCustomCommandGenerator::GetDepends() const = this->GE->Parse(*i); std::vector<std::string> result; cmSystemTools::ExpandListArgument( - cge->Evaluate(this->LG->GetMakefile(), this->Config), result); + cge->Evaluate(this->LG, this->Config), result); for (std::vector<std::string>::iterator it = result.begin(); it != result.end(); ++it) { diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx index 856dcd4..80f560f 100644 --- a/Source/cmDependsFortran.cxx +++ b/Source/cmDependsFortran.cxx @@ -160,7 +160,7 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends, if (mod_dir.empty()) { mod_dir = - this->LocalGenerator->GetMakefile()->GetCurrentBinaryDirectory(); + this->LocalGenerator->GetCurrentBinaryDirectory(); } // Actually write dependencies to the streams. diff --git a/Source/cmEnableTestingCommand.cxx b/Source/cmEnableTestingCommand.cxx index aa41ef7..6a7fd46 100644 --- a/Source/cmEnableTestingCommand.cxx +++ b/Source/cmEnableTestingCommand.cxx @@ -10,7 +10,6 @@ See the License for more information. ============================================================================*/ #include "cmEnableTestingCommand.h" -#include "cmLocalGenerator.h" // we do this in the final pass so that we now the subdirs have all // been defined diff --git a/Source/cmExecProgramCommand.h b/Source/cmExecProgramCommand.h index 23d10f9..adefdf9 100644 --- a/Source/cmExecProgramCommand.h +++ b/Source/cmExecProgramCommand.h @@ -50,12 +50,6 @@ public: */ virtual bool IsScriptable() const { return true; } - /** This command is kept for compatibility with older CMake versions. */ - virtual bool IsDiscouraged() const - { - return true; - } - cmTypeMacro(cmExecProgramCommand, cmCommand); private: static bool RunCommand(const char* command, std::string& output, diff --git a/Source/cmExportBuildFileGenerator.cxx b/Source/cmExportBuildFileGenerator.cxx index fed0dbc..dcb2187 100644 --- a/Source/cmExportBuildFileGenerator.cxx +++ b/Source/cmExportBuildFileGenerator.cxx @@ -18,16 +18,24 @@ //---------------------------------------------------------------------------- cmExportBuildFileGenerator::cmExportBuildFileGenerator() - : Backtrace() { - this->Makefile = 0; + this->LG = 0; this->ExportSet = 0; } //---------------------------------------------------------------------------- +void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg) +{ + this->LG = lg; + if (this->ExportSet) + { + this->ExportSet->Compute(lg); + } +} + +//---------------------------------------------------------------------------- bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os) { - std::vector<cmGeneratorTarget*> allTargets; { std::string expectedTargets; std::string sep; @@ -37,11 +45,11 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os) tei = targets.begin(); tei != targets.end(); ++tei) { - cmGeneratorTarget *te = this->Makefile + cmGeneratorTarget *te = this->LG ->FindGeneratorTargetToUse(*tei); - expectedTargets += sep + this->Namespace + te->Target->GetExportName(); + expectedTargets += sep + this->Namespace + te->GetExportName(); sep = " "; - if(this->ExportedTargets.insert(te->Target).second) + if(this->ExportedTargets.insert(te).second) { this->Exports.push_back(te); } @@ -49,11 +57,12 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os) { std::ostringstream e; e << "given target \"" << te->GetName() << "\" more than once."; - this->Makefile->GetCMakeInstance() - ->IssueMessage(cmake::FATAL_ERROR, e.str(), this->Backtrace); + this->LG->GetGlobalGenerator()->GetCMakeInstance() + ->IssueMessage(cmake::FATAL_ERROR, e.str(), + this->LG->GetMakefile()->GetBacktrace()); return false; } - if (te->GetType() == cmTarget::INTERFACE_LIBRARY) + if (te->GetType() == cmState::INTERFACE_LIBRARY) { this->GenerateRequiredCMakeVersion(os, "3.0.0"); } @@ -70,45 +79,44 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os) tei != this->Exports.end(); ++tei) { cmGeneratorTarget* gte = *tei; - cmTarget* te = gte->Target; - this->GenerateImportTargetCode(os, te); + this->GenerateImportTargetCode(os, gte); - te->AppendBuildInterfaceIncludes(); + gte->Target->AppendBuildInterfaceIncludes(); ImportPropertyMap properties; - this->PopulateInterfaceProperty("INTERFACE_INCLUDE_DIRECTORIES", te, + this->PopulateInterfaceProperty("INTERFACE_INCLUDE_DIRECTORIES", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); - this->PopulateInterfaceProperty("INTERFACE_SOURCES", te, + this->PopulateInterfaceProperty("INTERFACE_SOURCES", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); - this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", te, + this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); - this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", te, + this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); - this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", te, + this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); - this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", te, + this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", - te, properties); + gte, properties); const bool newCMP0022Behavior = - te->GetPolicyStatusCMP0022() != cmPolicies::WARN - && te->GetPolicyStatusCMP0022() != cmPolicies::OLD; + gte->GetPolicyStatusCMP0022() != cmPolicies::WARN + && gte->GetPolicyStatusCMP0022() != cmPolicies::OLD; if (newCMP0022Behavior) { - this->PopulateInterfaceLinkLibrariesProperty(te, + this->PopulateInterfaceLinkLibrariesProperty(gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); } this->PopulateCompatibleInterfaceProperties(gte, properties); - this->GenerateInterfaceProperties(te, os, properties); + this->GenerateInterfaceProperties(gte, os, properties); } // Generate import file content for each configuration. @@ -140,14 +148,14 @@ cmExportBuildFileGenerator cmGeneratorTarget* target = *tei; ImportPropertyMap properties; - if (target->GetType() != cmTarget::INTERFACE_LIBRARY) + if (target->GetType() != cmState::INTERFACE_LIBRARY) { this->SetImportLocationProperty(config, suffix, target, properties); } if(!properties.empty()) { // Get the rest of the target details. - if (target->GetType() != cmTarget::INTERFACE_LIBRARY) + if (target->GetType() != cmState::INTERFACE_LIBRARY) { this->SetImportDetailProperties(config, suffix, target, @@ -165,7 +173,7 @@ cmExportBuildFileGenerator // properties); // Generate code in the export file. - this->GenerateImportPropertyCode(os, config, target->Target, + this->GenerateImportPropertyCode(os, config, target, properties); } } @@ -193,7 +201,7 @@ cmExportBuildFileGenerator std::string prop = "IMPORTED_LOCATION"; prop += suffix; std::string value; - if(target->Target->IsAppBundleOnApple()) + if(target->IsAppBundleOnApple()) { value = target->GetFullPath(config, false); } @@ -204,20 +212,16 @@ cmExportBuildFileGenerator properties[prop] = value; } - // Check whether this is a DLL platform. - bool dll_platform = - (mf->IsOn("WIN32") || mf->IsOn("CYGWIN") || mf->IsOn("MINGW")); - // Add the import library for windows DLLs. - if(dll_platform && - (target->GetType() == cmTarget::SHARED_LIBRARY || - target->Target->IsExecutableWithExports()) && + if(target->IsDLLPlatform() && + (target->GetType() == cmState::SHARED_LIBRARY || + target->IsExecutableWithExports()) && mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) { std::string prop = "IMPORTED_IMPLIB"; prop += suffix; std::string value = target->GetFullPath(config, true); - target->Target->GetImplibGNUtoMS(value, value, + target->GetImplibGNUtoMS(value, value, "${CMAKE_IMPORT_LIBRARY_SUFFIX}"); properties[prop] = value; } @@ -226,14 +230,18 @@ cmExportBuildFileGenerator //---------------------------------------------------------------------------- void cmExportBuildFileGenerator::HandleMissingTarget( - std::string& link_libs, std::vector<std::string>& missingTargets, - cmMakefile* mf, cmTarget* depender, cmTarget* dependee) + std::string& link_libs, + std::vector<std::string>& missingTargets, + cmGeneratorTarget* depender, + cmGeneratorTarget* dependee) { // The target is not in the export. if(!this->AppendMode) { const std::string name = dependee->GetName(); - std::vector<std::string> namespaces = this->FindNamespaces(mf, name); + cmGlobalGenerator* gg = + dependee->GetLocalGenerator()->GetGlobalGenerator(); + std::vector<std::string> namespaces = this->FindNamespaces(gg, name); int targetOccurrences = (int)namespaces.size(); if (targetOccurrences == 1) @@ -268,7 +276,7 @@ void cmExportBuildFileGenerator tei = this->ExportSet->GetTargetExports()->begin(); tei != this->ExportSet->GetTargetExports()->end(); ++tei) { - targets.push_back((*tei)->Target->GetName()); + targets.push_back((*tei)->TargetName); } return; } @@ -278,10 +286,9 @@ void cmExportBuildFileGenerator //---------------------------------------------------------------------------- std::vector<std::string> cmExportBuildFileGenerator -::FindNamespaces(cmMakefile* mf, const std::string& name) +::FindNamespaces(cmGlobalGenerator* gg, const std::string& name) { std::vector<std::string> namespaces; - cmGlobalGenerator* gg = mf->GetGlobalGenerator(); std::map<std::string, cmExportBuildFileGenerator*>& exportSets = gg->GetBuildExportSets(); @@ -304,8 +311,8 @@ cmExportBuildFileGenerator //---------------------------------------------------------------------------- void cmExportBuildFileGenerator -::ComplainAboutMissingTarget(cmTarget* depender, - cmTarget* dependee, +::ComplainAboutMissingTarget(cmGeneratorTarget* depender, + cmGeneratorTarget* dependee, int occurrences) { if(cmSystemTools::GetErrorOccuredFlag()) @@ -328,8 +335,9 @@ cmExportBuildFileGenerator e << "If the required target is not easy to reference in this call, " << "consider using the APPEND option with multiple separate calls."; - this->Makefile->GetCMakeInstance() - ->IssueMessage(cmake::FATAL_ERROR, e.str(), this->Backtrace); + this->LG->GetGlobalGenerator()->GetCMakeInstance() + ->IssueMessage(cmake::FATAL_ERROR, e.str(), + this->LG->GetMakefile()->GetBacktrace()); } std::string diff --git a/Source/cmExportBuildFileGenerator.h b/Source/cmExportBuildFileGenerator.h index ff3d2e1..85aae2f 100644 --- a/Source/cmExportBuildFileGenerator.h +++ b/Source/cmExportBuildFileGenerator.h @@ -43,10 +43,7 @@ public: /** Set whether to append generated code to the output file. */ void SetAppendMode(bool append) { this->AppendMode = append; } - void SetMakefile(cmMakefile *mf) { - this->Makefile = mf; - this->Backtrace = this->Makefile->GetBacktrace(); - } + void Compute(cmLocalGenerator* lg); protected: // Implement virtual methods from the superclass. @@ -57,12 +54,11 @@ protected: std::vector<std::string> &missingTargets); virtual void HandleMissingTarget(std::string& link_libs, std::vector<std::string>& missingTargets, - cmMakefile* mf, - cmTarget* depender, - cmTarget* dependee); + cmGeneratorTarget* depender, + cmGeneratorTarget* dependee); - void ComplainAboutMissingTarget(cmTarget* depender, - cmTarget* dependee, + void ComplainAboutMissingTarget(cmGeneratorTarget* depender, + cmGeneratorTarget* dependee, int occurrences); /** Fill in properties indicating built file locations. */ @@ -75,13 +71,12 @@ protected: const std::string& config); std::vector<std::string> - FindNamespaces(cmMakefile* mf, const std::string& name); + FindNamespaces(cmGlobalGenerator* gg, const std::string& name); std::vector<std::string> Targets; cmExportSet *ExportSet; std::vector<cmGeneratorTarget*> Exports; - cmMakefile* Makefile; - cmListFileBacktrace Backtrace; + cmLocalGenerator* LG; }; #endif diff --git a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx index 96ea77b..4eec66a 100644 --- a/Source/cmExportCommand.cxx +++ b/Source/cmExportCommand.cxx @@ -11,7 +11,6 @@ ============================================================================*/ #include "cmExportCommand.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmGeneratedFileStream.h" #include "cmake.h" @@ -169,7 +168,7 @@ bool cmExportCommand if(cmTarget* target = gg->FindTarget(*currentTarget)) { - if(target->GetType() == cmTarget::OBJECT_LIBRARY) + if(target->GetType() == cmState::OBJECT_LIBRARY) { std::ostringstream e; e << "given OBJECT library \"" << *currentTarget @@ -177,7 +176,7 @@ bool cmExportCommand this->SetError(e.str()); return false; } - if (target->GetType() == cmTarget::UTILITY) + if (target->GetType() == cmState::UTILITY) { this->SetError("given custom target \"" + *currentTarget + "\" which may not be exported."); @@ -222,7 +221,7 @@ bool cmExportCommand { ebfg->SetTargets(targets); } - ebfg->SetMakefile(this->Makefile); + this->Makefile->AddExportBuildFileGenerator(ebfg); ebfg->SetExportOld(this->ExportOld.IsEnabled()); // Compute the set of configurations exported. diff --git a/Source/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx index 9a7d73f..e8a2e6a 100644 --- a/Source/cmExportFileGenerator.cxx +++ b/Source/cmExportFileGenerator.cxx @@ -18,7 +18,6 @@ #include "cmLocalGenerator.h" #include "cmMakefile.h" #include "cmSystemTools.h" -#include "cmTarget.h" #include "cmTargetExport.h" #include "cmVersion.h" #include "cmComputeLinkInformation.h" @@ -155,7 +154,7 @@ void cmExportFileGenerator::GenerateImportConfig(std::ostream& os, //---------------------------------------------------------------------------- void cmExportFileGenerator::PopulateInterfaceProperty( const std::string& propName, - cmTarget *target, + cmGeneratorTarget *target, ImportPropertyMap &properties) { const char *input = target->GetProperty(propName); @@ -169,7 +168,7 @@ void cmExportFileGenerator::PopulateInterfaceProperty( void cmExportFileGenerator::PopulateInterfaceProperty( const std::string& propName, const std::string& outputName, - cmTarget *target, + cmGeneratorTarget *target, cmGeneratorExpression::PreprocessContext preprocessRule, ImportPropertyMap &properties, std::vector<std::string> &missingTargets) @@ -206,7 +205,7 @@ void cmExportFileGenerator::GenerateRequiredCMakeVersion(std::ostream& os, //---------------------------------------------------------------------------- bool cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty( - cmTarget *target, + cmGeneratorTarget *target, cmGeneratorExpression::PreprocessContext preprocessRule, ImportPropertyMap &properties, std::vector<std::string> &missingTargets) @@ -241,12 +240,14 @@ static bool isSubDirectory(const char* a, const char* b) //---------------------------------------------------------------------------- static bool checkInterfaceDirs(const std::string &prepro, - cmTarget *target, const std::string& prop) + cmGeneratorTarget *target, const std::string& prop) { const char* installDir = - target->GetMakefile()->GetSafeDefinition("CMAKE_INSTALL_PREFIX"); - const char* topSourceDir = target->GetMakefile()->GetHomeDirectory(); - const char* topBinaryDir = target->GetMakefile()->GetHomeOutputDirectory(); + target->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX"); + const char* topSourceDir = + target->GetLocalGenerator()->GetSourceDirectory(); + const char* topBinaryDir = + target->GetLocalGenerator()->GetBinaryDirectory(); std::vector<std::string> parts; cmGeneratorExpression::Split(prepro, parts); @@ -298,7 +299,7 @@ static bool checkInterfaceDirs(const std::string &prepro, e << "Target \"" << target->GetName() << "\" " << prop << " property contains relative path:\n" " \"" << *li << "\""; - target->GetMakefile()->IssueMessage(messageType, e.str()); + target->GetLocalGenerator()->IssueMessage(messageType, e.str()); } bool inBinary = isSubDirectory(li->c_str(), topBinaryDir); bool inSource = isSubDirectory(li->c_str(), topSourceDir); @@ -329,7 +330,7 @@ static bool checkInterfaceDirs(const std::string &prepro, "a subdirectory of the " << (inBinary ? "build" : "source") << " tree:\n \"" << (inBinary ? topBinaryDir : topSourceDir) << "\"" << std::endl; - target->GetMakefile()->IssueMessage(cmake::AUTHOR_WARNING, + target->GetLocalGenerator()->IssueMessage(cmake::AUTHOR_WARNING, s.str()); } case cmPolicies::OLD: @@ -352,7 +353,7 @@ static bool checkInterfaceDirs(const std::string &prepro, e << "Target \"" << target->GetName() << "\" " << prop << " property contains path:\n" " \"" << *li << "\"\nwhich is prefixed in the build directory."; - target->GetMakefile()->IssueMessage(messageType, e.str()); + target->GetLocalGenerator()->IssueMessage(messageType, e.str()); } if (!inSourceBuild) { @@ -361,7 +362,7 @@ static bool checkInterfaceDirs(const std::string &prepro, e << "Target \"" << target->GetName() << "\" " << prop << " property contains path:\n" " \"" << *li << "\"\nwhich is prefixed in the source directory."; - target->GetMakefile()->IssueMessage(messageType, e.str()); + target->GetLocalGenerator()->IssueMessage(messageType, e.str()); } } } @@ -396,11 +397,11 @@ void cmExportFileGenerator::PopulateSourcesInterface( ImportPropertyMap &properties, std::vector<std::string> &missingTargets) { - cmTarget *target = tei->Target; + cmGeneratorTarget* gt = tei->Target; assert(preprocessRule == cmGeneratorExpression::InstallInterface); const char *propName = "INTERFACE_SOURCES"; - const char *input = target->GetProperty(propName); + const char *input = gt->GetProperty(propName); if (!input) { @@ -418,10 +419,10 @@ void cmExportFileGenerator::PopulateSourcesInterface( true); if (!prepro.empty()) { - this->ResolveTargetsInGeneratorExpressions(prepro, target, + this->ResolveTargetsInGeneratorExpressions(prepro, gt, missingTargets); - if (!checkInterfaceDirs(prepro, target, propName)) + if (!checkInterfaceDirs(prepro, gt, propName)) { return; } @@ -436,7 +437,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface( ImportPropertyMap &properties, std::vector<std::string> &missingTargets) { - cmTarget *target = tei->Target; + cmGeneratorTarget *target = tei->Target; assert(preprocessRule == cmGeneratorExpression::InstallInterface); const char *propName = "INTERFACE_INCLUDE_DIRECTORIES"; @@ -450,18 +451,18 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface( true); this->ReplaceInstallPrefix(dirs); cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(dirs); - std::string exportDirs = cge->Evaluate(target->GetMakefile(), "", + std::string exportDirs = cge->Evaluate(target->GetLocalGenerator(), "", false, target); if (cge->GetHadContextSensitiveCondition()) { - cmMakefile* mf = target->GetMakefile(); + cmLocalGenerator* lg = target->GetLocalGenerator(); std::ostringstream e; e << "Target \"" << target->GetName() << "\" is installed with " "INCLUDES DESTINATION set to a context sensitive path. Paths which " "depend on the configuration, policy values or the link interface are " "not supported. Consider using target_include_directories instead."; - mf->IssueMessage(cmake::FATAL_ERROR, e.str()); + lg->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } @@ -500,7 +501,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface( //---------------------------------------------------------------------------- void cmExportFileGenerator::PopulateInterfaceProperty( const std::string& propName, - cmTarget *target, + cmGeneratorTarget* target, cmGeneratorExpression::PreprocessContext preprocessRule, ImportPropertyMap &properties, std::vector<std::string> &missingTargets) @@ -511,8 +512,9 @@ void cmExportFileGenerator::PopulateInterfaceProperty( //---------------------------------------------------------------------------- -void getPropertyContents(cmTarget const* tgt, const std::string& prop, - std::set<std::string> &ifaceProperties) +void getPropertyContents(cmGeneratorTarget const* tgt, + const std::string& prop, + std::set<std::string> &ifaceProperties) { const char *p = tgt->GetProperty(prop); if (!p) @@ -533,11 +535,11 @@ void getCompatibleInterfaceProperties(cmGeneratorTarget *target, if (!info) { - cmMakefile* mf = target->Target->GetMakefile(); + cmLocalGenerator* lg = target->GetLocalGenerator(); std::ostringstream e; e << "Exporting the target \"" << target->GetName() << "\" is not " "allowed since its linker language cannot be determined"; - mf->IssueMessage(cmake::FATAL_ERROR, e.str()); + lg->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } @@ -571,31 +573,30 @@ void cmExportFileGenerator::PopulateCompatibleInterfaceProperties( cmGeneratorTarget *gtarget, ImportPropertyMap &properties) { - cmTarget *target = gtarget->Target; this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_BOOL", - target, properties); + gtarget, properties); this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_STRING", - target, properties); + gtarget, properties); this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MIN", - target, properties); + gtarget, properties); this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MAX", - target, properties); + gtarget, properties); std::set<std::string> ifaceProperties; - getPropertyContents(target, "COMPATIBLE_INTERFACE_BOOL", ifaceProperties); - getPropertyContents(target, "COMPATIBLE_INTERFACE_STRING", ifaceProperties); - getPropertyContents(target, "COMPATIBLE_INTERFACE_NUMBER_MIN", + getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_BOOL", ifaceProperties); + getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_STRING", ifaceProperties); + getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_NUMBER_MIN", ifaceProperties); - getPropertyContents(target, "COMPATIBLE_INTERFACE_NUMBER_MAX", + getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_NUMBER_MAX", ifaceProperties); - if (target->GetType() != cmTarget::INTERFACE_LIBRARY) + if (gtarget->GetType() != cmState::INTERFACE_LIBRARY) { getCompatibleInterfaceProperties(gtarget, ifaceProperties, ""); std::vector<std::string> configNames; - target->GetMakefile()->GetConfigurations(configNames); + gtarget->Target->GetMakefile()->GetConfigurations(configNames); for (std::vector<std::string>::const_iterator ci = configNames.begin(); ci != configNames.end(); ++ci) @@ -608,12 +609,13 @@ void cmExportFileGenerator::PopulateCompatibleInterfaceProperties( it != ifaceProperties.end(); ++it) { this->PopulateInterfaceProperty("INTERFACE_" + *it, - target, properties); + gtarget, properties); } } //---------------------------------------------------------------------------- -void cmExportFileGenerator::GenerateInterfaceProperties(cmTarget const* target, +void cmExportFileGenerator::GenerateInterfaceProperties( + const cmGeneratorTarget* target, std::ostream& os, const ImportPropertyMap &properties) { @@ -635,12 +637,12 @@ void cmExportFileGenerator::GenerateInterfaceProperties(cmTarget const* target, //---------------------------------------------------------------------------- bool cmExportFileGenerator::AddTargetNamespace(std::string &input, - cmTarget* target, + cmGeneratorTarget* target, std::vector<std::string> &missingTargets) { - cmMakefile *mf = target->GetMakefile(); + cmLocalGenerator *lg = target->GetLocalGenerator(); - cmTarget *tgt = mf->FindTargetToUse(input); + cmGeneratorTarget *tgt = lg->FindGeneratorTargetToUse(input); if (!tgt) { return false; @@ -658,7 +660,7 @@ cmExportFileGenerator::AddTargetNamespace(std::string &input, { std::string namespacedTarget; this->HandleMissingTarget(namespacedTarget, missingTargets, - mf, target, tgt); + target, tgt); if (!namespacedTarget.empty()) { input = namespacedTarget; @@ -671,7 +673,7 @@ cmExportFileGenerator::AddTargetNamespace(std::string &input, void cmExportFileGenerator::ResolveTargetsInGeneratorExpressions( std::string &input, - cmTarget* target, + cmGeneratorTarget* target, std::vector<std::string> &missingTargets, FreeTargetsReplace replace) { @@ -708,14 +710,12 @@ cmExportFileGenerator::ResolveTargetsInGeneratorExpressions( void cmExportFileGenerator::ResolveTargetsInGeneratorExpression( std::string &input, - cmTarget* target, + cmGeneratorTarget* target, std::vector<std::string> &missingTargets) { std::string::size_type pos = 0; std::string::size_type lastPos = pos; - cmMakefile *mf = target->GetMakefile(); - while((pos = input.find("$<TARGET_PROPERTY:", lastPos)) != input.npos) { std::string::size_type nameStartPos = pos + @@ -776,7 +776,7 @@ cmExportFileGenerator::ResolveTargetsInGeneratorExpression( if (!errorString.empty()) { - mf->IssueMessage(cmake::FATAL_ERROR, errorString); + target->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, errorString); } } @@ -797,7 +797,7 @@ cmExportFileGenerator { // Add the transitive link dependencies for this configuration. cmLinkInterface const* iface = target->GetLinkInterface(config, - target->Target); + target); if (!iface) { return; @@ -830,20 +830,18 @@ cmExportFileGenerator } const bool newCMP0022Behavior = - target->Target - ->GetPolicyStatusCMP0022() != cmPolicies::WARN - && target->Target - ->GetPolicyStatusCMP0022() != cmPolicies::OLD; + target->GetPolicyStatusCMP0022() != cmPolicies::WARN + && target->GetPolicyStatusCMP0022() != cmPolicies::OLD; if(newCMP0022Behavior && !this->ExportOld) { - cmMakefile *mf = target->Target->GetMakefile(); + cmLocalGenerator *lg = target->GetLocalGenerator(); std::ostringstream e; e << "Target \"" << target->GetName() << "\" has policy CMP0022 enabled, " "but also has old-style LINK_INTERFACE_LIBRARIES properties " "populated, but it was exported without the " "EXPORT_LINK_INTERFACE_LIBRARIES to export the old-style properties"; - mf->IssueMessage(cmake::FATAL_ERROR, e.str()); + lg->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } @@ -857,7 +855,7 @@ cmExportFileGenerator preprocessRule); if (!prepro.empty()) { - this->ResolveTargetsInGeneratorExpressions(prepro, target->Target, + this->ResolveTargetsInGeneratorExpressions(prepro, target, missingTargets, ReplaceFreeTargets); properties["IMPORTED_LINK_INTERFACE_LIBRARIES" + suffix] = prepro; @@ -878,13 +876,10 @@ cmExportFileGenerator cmMakefile* mf = target->Makefile; // Add the soname for unix shared libraries. - if(target->GetType() == cmTarget::SHARED_LIBRARY || - target->GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY) { - // Check whether this is a DLL platform. - bool dll_platform = - (mf->IsOn("WIN32") || mf->IsOn("CYGWIN") || mf->IsOn("MINGW")); - if(!dll_platform) + if(!target->IsDLLPlatform()) { std::string prop; std::string value; @@ -909,7 +904,7 @@ cmExportFileGenerator // Add the transitive link dependencies for this configuration. if(cmLinkInterface const* iface = - target->GetLinkInterface(config, target->Target)) + target->GetLinkInterface(config, target)) { this->SetImportLinkProperty(suffix, target, "IMPORTED_LINK_INTERFACE_LANGUAGES", @@ -959,7 +954,7 @@ cmExportFileGenerator sep = ";"; std::string temp = *li; - this->AddTargetNamespace(temp, target->Target, missingTargets); + this->AddTargetNamespace(temp, target, missingTargets); link_entries += temp; } @@ -1041,7 +1036,7 @@ void cmExportFileGenerator::GenerateExpectedTargetsCode(std::ostream& os, //---------------------------------------------------------------------------- void cmExportFileGenerator -::GenerateImportTargetCode(std::ostream& os, cmTarget const* target) +::GenerateImportTargetCode(std::ostream& os, const cmGeneratorTarget* target) { // Construct the imported target name. std::string targetName = this->Namespace; @@ -1052,22 +1047,22 @@ cmExportFileGenerator os << "# Create imported target " << targetName << "\n"; switch(target->GetType()) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: os << "add_executable(" << targetName << " IMPORTED)\n"; break; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: os << "add_library(" << targetName << " STATIC IMPORTED)\n"; break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: os << "add_library(" << targetName << " SHARED IMPORTED)\n"; break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: os << "add_library(" << targetName << " MODULE IMPORTED)\n"; break; - case cmTarget::UNKNOWN_LIBRARY: + case cmState::UNKNOWN_LIBRARY: os << "add_library(" << targetName << " UNKNOWN IMPORTED)\n"; break; - case cmTarget::INTERFACE_LIBRARY: + case cmState::INTERFACE_LIBRARY: os << "add_library(" << targetName << " INTERFACE IMPORTED)\n"; break; default: // should never happen @@ -1107,7 +1102,7 @@ cmExportFileGenerator void cmExportFileGenerator ::GenerateImportPropertyCode(std::ostream& os, const std::string& config, - cmTarget const* target, + cmGeneratorTarget const* target, ImportPropertyMap const& properties) { // Construct the imported target name. @@ -1227,7 +1222,7 @@ cmExportFileGenerator::GenerateImportedFileCheckLoop(std::ostream& os) //---------------------------------------------------------------------------- void cmExportFileGenerator -::GenerateImportedFileChecksCode(std::ostream& os, cmTarget* target, +::GenerateImportedFileChecksCode(std::ostream& os, cmGeneratorTarget* target, ImportPropertyMap const& properties, const std::set<std::string>& importedLocations) { diff --git a/Source/cmExportFileGenerator.h b/Source/cmExportFileGenerator.h index 44f779b..18f0b00 100644 --- a/Source/cmExportFileGenerator.h +++ b/Source/cmExportFileGenerator.h @@ -75,11 +75,13 @@ protected: const std::string& config = ""); void GenerateImportFooterCode(std::ostream& os); void GenerateImportVersionCode(std::ostream& os); - void GenerateImportTargetCode(std::ostream& os, cmTarget const* target); + void GenerateImportTargetCode(std::ostream& os, + cmGeneratorTarget const* target); void GenerateImportPropertyCode(std::ostream& os, const std::string& config, - cmTarget const* target, + cmGeneratorTarget const* target, ImportPropertyMap const& properties); - void GenerateImportedFileChecksCode(std::ostream& os, cmTarget* target, + void GenerateImportedFileChecksCode(std::ostream& os, + cmGeneratorTarget* target, ImportPropertyMap const& properties, const std::set<std::string>& importedLocations); void GenerateImportedFileCheckLoop(std::ostream& os); @@ -118,23 +120,24 @@ protected: * export set. */ virtual void HandleMissingTarget(std::string& link_libs, std::vector<std::string>& missingTargets, - cmMakefile* mf, - cmTarget* depender, - cmTarget* dependee) = 0; + cmGeneratorTarget* depender, + cmGeneratorTarget* dependee) = 0; void PopulateInterfaceProperty(const std::string&, - cmTarget *target, + cmGeneratorTarget *target, cmGeneratorExpression::PreprocessContext, ImportPropertyMap &properties, std::vector<std::string> &missingTargets); - bool PopulateInterfaceLinkLibrariesProperty(cmTarget *target, + bool PopulateInterfaceLinkLibrariesProperty(cmGeneratorTarget* target, cmGeneratorExpression::PreprocessContext, ImportPropertyMap &properties, std::vector<std::string> &missingTargets); - void PopulateInterfaceProperty(const std::string& propName, cmTarget *target, + void PopulateInterfaceProperty(const std::string& propName, + cmGeneratorTarget* target, ImportPropertyMap &properties); void PopulateCompatibleInterfaceProperties(cmGeneratorTarget *target, ImportPropertyMap &properties); - void GenerateInterfaceProperties(cmTarget const* target, std::ostream& os, + void GenerateInterfaceProperties(cmGeneratorTarget const* target, + std::ostream& os, const ImportPropertyMap &properties); void PopulateIncludeDirectoriesInterface( cmTargetExport *target, @@ -159,7 +162,7 @@ protected: }; void ResolveTargetsInGeneratorExpressions(std::string &input, - cmTarget* target, + cmGeneratorTarget* target, std::vector<std::string> &missingTargets, FreeTargetsReplace replace = NoReplaceFreeTargets); @@ -182,20 +185,20 @@ protected: bool AppendMode; // The set of targets included in the export. - std::set<cmTarget*> ExportedTargets; + std::set<cmGeneratorTarget*> ExportedTargets; private: void PopulateInterfaceProperty(const std::string&, const std::string&, - cmTarget *target, + cmGeneratorTarget* target, cmGeneratorExpression::PreprocessContext, ImportPropertyMap &properties, std::vector<std::string> &missingTargets); - bool AddTargetNamespace(std::string &input, cmTarget* target, + bool AddTargetNamespace(std::string &input, cmGeneratorTarget* target, std::vector<std::string> &missingTargets); void ResolveTargetsInGeneratorExpression(std::string &input, - cmTarget* target, + cmGeneratorTarget* target, std::vector<std::string> &missingTargets); virtual void ReplaceInstallPrefix(std::string &input); diff --git a/Source/cmExportInstallFileGenerator.cxx b/Source/cmExportInstallFileGenerator.cxx index 7ffab0c..b695904 100644 --- a/Source/cmExportInstallFileGenerator.cxx +++ b/Source/cmExportInstallFileGenerator.cxx @@ -48,7 +48,8 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os) tei = this->IEGen->GetExportSet()->GetTargetExports()->begin(); tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei) { - expectedTargets += sep + this->Namespace + (*tei)->Target->GetExportName(); + expectedTargets += + sep + this->Namespace + (*tei)->Target->GetExportName(); sep = " "; cmTargetExport * te = *tei; if(this->ExportedTargets.insert(te->Target).second) @@ -131,12 +132,12 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os) tei = allTargets.begin(); tei != allTargets.end(); ++tei) { - cmTarget* te = (*tei)->Target; + cmGeneratorTarget* gt = (*tei)->Target; requiresConfigFiles = requiresConfigFiles - || te->GetType() != cmTarget::INTERFACE_LIBRARY; + || gt->GetType() != cmState::INTERFACE_LIBRARY; - this->GenerateImportTargetCode(os, te); + this->GenerateImportTargetCode(os, gt); ImportPropertyMap properties; @@ -147,32 +148,32 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os) cmGeneratorExpression::InstallInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", - te, + gt, cmGeneratorExpression::InstallInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", - te, + gt, cmGeneratorExpression::InstallInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", - te, + gt, cmGeneratorExpression::InstallInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", - te, + gt, cmGeneratorExpression::InstallInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", - te, + gt, cmGeneratorExpression::InstallInterface, properties, missingTargets); const bool newCMP0022Behavior = - te->GetPolicyStatusCMP0022() != cmPolicies::WARN - && te->GetPolicyStatusCMP0022() != cmPolicies::OLD; + gt->GetPolicyStatusCMP0022() != cmPolicies::WARN + && gt->GetPolicyStatusCMP0022() != cmPolicies::OLD; if (newCMP0022Behavior) { - if (this->PopulateInterfaceLinkLibrariesProperty(te, + if (this->PopulateInterfaceLinkLibrariesProperty(gt, cmGeneratorExpression::InstallInterface, properties, missingTargets) && !this->ExportOld) @@ -180,11 +181,11 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os) require2_8_12 = true; } } - if (te->GetType() == cmTarget::INTERFACE_LIBRARY) + if (gt->GetType() == cmState::INTERFACE_LIBRARY) { require3_0_0 = true; } - if(te->GetProperty("INTERFACE_SOURCES")) + if(gt->GetProperty("INTERFACE_SOURCES")) { // We can only generate INTERFACE_SOURCES in CMake 3.3, but CMake 3.1 // can consume them. @@ -192,14 +193,11 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os) } this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", - te, properties); - cmGeneratorTarget *gtgt = te->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(te); + gt, properties); - this->PopulateCompatibleInterfaceProperties(gtgt, properties); + this->PopulateCompatibleInterfaceProperties(gt, properties); - this->GenerateInterfaceProperties(te, os, properties); + this->GenerateInterfaceProperties(gt, os, properties); } if (require3_1_0) @@ -337,7 +335,7 @@ cmExportInstallFileGenerator { // Collect import properties for this target. cmTargetExport const* te = *tei; - if (te->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (te->Target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -362,8 +360,7 @@ cmExportInstallFileGenerator if(!properties.empty()) { // Get the rest of the target details. - cmGeneratorTarget *gtgt = te->Target->GetMakefile() - ->GetGlobalGenerator()->GetGeneratorTarget(te->Target); + cmGeneratorTarget *gtgt = te->Target; this->SetImportDetailProperties(config, suffix, gtgt, properties, missingTargets); @@ -378,8 +375,8 @@ cmExportInstallFileGenerator // properties); // Generate code in the export file. - this->GenerateImportPropertyCode(os, config, te->Target, properties); - this->GenerateImportedFileChecksCode(os, te->Target, properties, + this->GenerateImportPropertyCode(os, config, gtgt, properties); + this->GenerateImportedFileChecksCode(os, gtgt, properties, importedLocations); } } @@ -402,7 +399,7 @@ cmExportInstallFileGenerator } // Get the target to be installed. - cmTarget* target = itgen->GetTarget()->Target; + cmGeneratorTarget* target = itgen->GetTarget(); // Construct the installed location of the target. std::string dest = itgen->GetDestination(config); @@ -456,12 +453,13 @@ cmExportInstallFileGenerator //---------------------------------------------------------------------------- void -cmExportInstallFileGenerator::HandleMissingTarget( - std::string& link_libs, std::vector<std::string>& missingTargets, - cmMakefile* mf, cmTarget* depender, cmTarget* dependee) +cmExportInstallFileGenerator::HandleMissingTarget(std::string& link_libs, + std::vector<std::string>& missingTargets, + cmGeneratorTarget* depender, cmGeneratorTarget* dependee) { const std::string name = dependee->GetName(); - std::vector<std::string> namespaces = this->FindNamespaces(mf, name); + cmGlobalGenerator* gg = dependee->GetLocalGenerator()->GetGlobalGenerator(); + std::vector<std::string> namespaces = this->FindNamespaces(gg, name); int targetOccurrences = (int)namespaces.size(); if (targetOccurrences == 1) { @@ -482,10 +480,9 @@ cmExportInstallFileGenerator::HandleMissingTarget( //---------------------------------------------------------------------------- std::vector<std::string> cmExportInstallFileGenerator -::FindNamespaces(cmMakefile* mf, const std::string& name) +::FindNamespaces(cmGlobalGenerator* gg, const std::string& name) { std::vector<std::string> namespaces; - cmGlobalGenerator* gg = mf->GetGlobalGenerator(); const cmExportSetMap& exportSets = gg->GetExportSets(); for(cmExportSetMap::const_iterator expIt = exportSets.begin(); @@ -523,8 +520,8 @@ cmExportInstallFileGenerator //---------------------------------------------------------------------------- void cmExportInstallFileGenerator -::ComplainAboutMissingTarget(cmTarget* depender, - cmTarget* dependee, +::ComplainAboutMissingTarget(cmGeneratorTarget* depender, + cmGeneratorTarget* dependee, int occurrences) { std::ostringstream e; diff --git a/Source/cmExportInstallFileGenerator.h b/Source/cmExportInstallFileGenerator.h index b06fee5..13dae89 100644 --- a/Source/cmExportInstallFileGenerator.h +++ b/Source/cmExportInstallFileGenerator.h @@ -57,17 +57,16 @@ protected: std::vector<std::string> &missingTargets); virtual void HandleMissingTarget(std::string& link_libs, std::vector<std::string>& missingTargets, - cmMakefile* mf, - cmTarget* depender, - cmTarget* dependee); + cmGeneratorTarget* depender, + cmGeneratorTarget* dependee); virtual void ReplaceInstallPrefix(std::string &input); - void ComplainAboutMissingTarget(cmTarget* depender, - cmTarget* dependee, + void ComplainAboutMissingTarget(cmGeneratorTarget* depender, + cmGeneratorTarget* dependee, int occurrences); - std::vector<std::string> FindNamespaces(cmMakefile* mf, + std::vector<std::string> FindNamespaces(cmGlobalGenerator* gg, const std::string& name); diff --git a/Source/cmExportLibraryDependenciesCommand.cxx b/Source/cmExportLibraryDependenciesCommand.cxx index fde8fb1..21d961f 100644 --- a/Source/cmExportLibraryDependenciesCommand.cxx +++ b/Source/cmExportLibraryDependenciesCommand.cxx @@ -96,8 +96,8 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const cmTarget const& target = l->second; // Skip non-library targets. - if(target.GetType() < cmTarget::STATIC_LIBRARY - || target.GetType() > cmTarget::MODULE_LIBRARY) + if(target.GetType() < cmState::STATIC_LIBRARY + || target.GetType() > cmState::MODULE_LIBRARY) { continue; } @@ -120,15 +120,15 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const std::string ltValue; switch(li->second) { - case cmTarget::GENERAL: + case GENERAL_LibraryType: valueNew += "general;"; ltValue = "general"; break; - case cmTarget::DEBUG: + case DEBUG_LibraryType: valueNew += "debug;"; ltValue = "debug"; break; - case cmTarget::OPTIMIZED: + case OPTIMIZED_LibraryType: valueNew += "optimized;"; ltValue = "optimized"; break; diff --git a/Source/cmExportLibraryDependenciesCommand.h b/Source/cmExportLibraryDependenciesCommand.h index 2ea4e79..81aa21a 100644 --- a/Source/cmExportLibraryDependenciesCommand.h +++ b/Source/cmExportLibraryDependenciesCommand.h @@ -22,7 +22,6 @@ public: virtual bool InitialPass(std::vector<std::string> const& args, cmExecutionStatus &status); virtual std::string GetName() const { return "export_library_dependencies";} - virtual bool IsDiscouraged() const { return true; } virtual void FinalPass(); virtual bool HasFinalPass() const { return true; } diff --git a/Source/cmExportSet.cxx b/Source/cmExportSet.cxx index 4148fb5..0059b64 100644 --- a/Source/cmExportSet.cxx +++ b/Source/cmExportSet.cxx @@ -13,12 +13,22 @@ #include "cmExportSet.h" #include "cmTargetExport.h" #include "cmAlgorithms.h" +#include "cmLocalGenerator.h" cmExportSet::~cmExportSet() { cmDeleteAll(this->TargetExports); } +void cmExportSet::Compute(cmLocalGenerator* lg) +{ + for (std::vector<cmTargetExport*>::iterator it = this->TargetExports.begin(); + it != this->TargetExports.end(); ++it) + { + (*it)->Target = lg->FindGeneratorTargetToUse((*it)->TargetName); + } +} + void cmExportSet::AddTargetExport(cmTargetExport* te) { this->TargetExports.push_back(te); diff --git a/Source/cmExportSet.h b/Source/cmExportSet.h index a57aa12..d780a22 100644 --- a/Source/cmExportSet.h +++ b/Source/cmExportSet.h @@ -15,6 +15,7 @@ #include "cmSystemTools.h" class cmTargetExport; class cmInstallExportGenerator; +class cmLocalGenerator; /// A set of targets that were installed with the same EXPORT parameter. class cmExportSet @@ -25,6 +26,8 @@ public: /// Destructor ~cmExportSet(); + void Compute(cmLocalGenerator* lg); + void AddTargetExport(cmTargetExport* tgt); void AddInstallation(cmInstallExportGenerator const* installation); diff --git a/Source/cmExportTryCompileFileGenerator.cxx b/Source/cmExportTryCompileFileGenerator.cxx index ba66531..83127e7 100644 --- a/Source/cmExportTryCompileFileGenerator.cxx +++ b/Source/cmExportTryCompileFileGenerator.cxx @@ -14,22 +14,25 @@ #include "cmGeneratedFileStream.h" #include "cmGlobalGenerator.h" +#include "cmLocalGenerator.h" #include "cmGeneratorExpressionDAGChecker.h" //---------------------------------------------------------------------------- cmExportTryCompileFileGenerator::cmExportTryCompileFileGenerator( - cmGlobalGenerator* gg) + cmGlobalGenerator* gg, + const std::vector<std::string>& targets, + cmMakefile* mf) { - gg->CreateGenerationObjects(cmGlobalGenerator::ImportedOnly); + gg->CreateImportedGenerationObjects(mf, targets, this->Exports); } bool cmExportTryCompileFileGenerator::GenerateMainFile(std::ostream& os) { - std::set<cmTarget const*> emitted; - std::set<cmTarget const*> emittedDeps; + std::set<cmGeneratorTarget const*> emitted; + std::set<cmGeneratorTarget const*> emittedDeps; while(!this->Exports.empty()) { - cmTarget const* te = this->Exports.back(); + cmGeneratorTarget const* te = this->Exports.back(); this->Exports.pop_back(); if (emitted.insert(te).second) { @@ -54,9 +57,9 @@ bool cmExportTryCompileFileGenerator::GenerateMainFile(std::ostream& os) } std::string cmExportTryCompileFileGenerator::FindTargets( - const std::string& propName, - cmTarget const* tgt, - std::set<cmTarget const*> &emitted) + const std::string& propName, + cmGeneratorTarget const* tgt, + std::set<cmGeneratorTarget const*> &emitted) { const char *prop = tgt->GetProperty(propName); if(!prop) @@ -73,15 +76,19 @@ std::string cmExportTryCompileFileGenerator::FindTargets( cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop); cmTarget dummyHead; - dummyHead.SetType(cmTarget::EXECUTABLE, "try_compile_dummy_exe"); - dummyHead.SetMakefile(tgt->GetMakefile()); + dummyHead.SetType(cmState::EXECUTABLE, "try_compile_dummy_exe"); + dummyHead.SetMakefile(tgt->Target->GetMakefile()); - std::string result = cge->Evaluate(tgt->GetMakefile(), this->Config, - false, &dummyHead, tgt, &dagChecker); + cmGeneratorTarget gDummyHead(&dummyHead, tgt->GetLocalGenerator()); - const std::set<cmTarget const*> &allTargets = cge->GetAllTargetsSeen(); - for(std::set<cmTarget const*>::const_iterator li = allTargets.begin(); - li != allTargets.end(); ++li) + std::string result = cge->Evaluate(tgt->GetLocalGenerator(), this->Config, + false, &gDummyHead, + tgt, &dagChecker); + + const std::set<cmGeneratorTarget const*> &allTargets = + cge->GetAllTargetsSeen(); + for(std::set<cmGeneratorTarget const*>::const_iterator li = + allTargets.begin(); li != allTargets.end(); ++li) { if(emitted.insert(*li).second) { @@ -93,20 +100,23 @@ std::string cmExportTryCompileFileGenerator::FindTargets( //---------------------------------------------------------------------------- void -cmExportTryCompileFileGenerator::PopulateProperties(cmTarget const* target, - ImportPropertyMap& properties, - std::set<cmTarget const*> &emitted) +cmExportTryCompileFileGenerator::PopulateProperties( + const cmGeneratorTarget* target, + ImportPropertyMap& properties, + std::set<cmGeneratorTarget const*> &emitted) { - cmPropertyMap props = target->GetProperties(); - for(cmPropertyMap::const_iterator i = props.begin(); i != props.end(); ++i) + std::vector<std::string> props = target->GetPropertyKeys(); + for(std::vector<std::string>::const_iterator i = props.begin(); + i != props.end(); ++i) { - properties[i->first] = i->second.GetValue(); - if(i->first.find("IMPORTED_LINK_INTERFACE_LIBRARIES") == 0 - || i->first.find("IMPORTED_LINK_DEPENDENT_LIBRARIES") == 0 - || i->first.find("INTERFACE_LINK_LIBRARIES") == 0) + properties[*i] = target->GetProperty(*i); + + if(i->find("IMPORTED_LINK_INTERFACE_LIBRARIES") == 0 + || i->find("IMPORTED_LINK_DEPENDENT_LIBRARIES") == 0 + || i->find("INTERFACE_LINK_LIBRARIES") == 0) { - std::string evalResult = this->FindTargets(i->first, + std::string evalResult = this->FindTargets(*i, target, emitted); std::vector<std::string> depends; @@ -114,7 +124,8 @@ cmExportTryCompileFileGenerator::PopulateProperties(cmTarget const* target, for(std::vector<std::string>::const_iterator li = depends.begin(); li != depends.end(); ++li) { - cmTarget *tgt = target->GetMakefile()->FindTargetToUse(*li); + cmGeneratorTarget *tgt = + target->GetLocalGenerator()->FindGeneratorTargetToUse(*li); if(tgt && emitted.insert(tgt).second) { this->Exports.push_back(tgt); diff --git a/Source/cmExportTryCompileFileGenerator.h b/Source/cmExportTryCompileFileGenerator.h index 8838eca..fc135a4 100644 --- a/Source/cmExportTryCompileFileGenerator.h +++ b/Source/cmExportTryCompileFileGenerator.h @@ -20,11 +20,11 @@ class cmInstallTargetGenerator; class cmExportTryCompileFileGenerator: public cmExportFileGenerator { public: - cmExportTryCompileFileGenerator(cmGlobalGenerator* gg); + cmExportTryCompileFileGenerator(cmGlobalGenerator* gg, + std::vector<std::string> const& targets, + cmMakefile* mf); /** Set the list of targets to export. */ - void SetExports(const std::vector<cmTarget const*> &exports) - { this->Exports = exports; } void SetConfig(const std::string& config) { this->Config = config; } protected: @@ -37,22 +37,22 @@ protected: std::vector<std::string>&) {} virtual void HandleMissingTarget(std::string&, std::vector<std::string>&, - cmMakefile*, - cmTarget*, - cmTarget*) {} + cmGeneratorTarget*, + cmGeneratorTarget*) {} - void PopulateProperties(cmTarget const* target, + void PopulateProperties(cmGeneratorTarget const* target, ImportPropertyMap& properties, - std::set<cmTarget const*> &emitted); + std::set<const cmGeneratorTarget*>& emitted); std::string InstallNameDir(cmGeneratorTarget* target, const std::string& config); private: - std::string FindTargets(const std::string& prop, cmTarget const* tgt, - std::set<cmTarget const*> &emitted); + std::string FindTargets(const std::string& prop, + const cmGeneratorTarget* tgt, + std::set<const cmGeneratorTarget*>& emitted); - std::vector<cmTarget const*> Exports; + std::vector<cmGeneratorTarget const*> Exports; std::string Config; }; diff --git a/Source/cmExtraCodeBlocksGenerator.cxx b/Source/cmExtraCodeBlocksGenerator.cxx index dfd51c7..9348ef2 100644 --- a/Source/cmExtraCodeBlocksGenerator.cxx +++ b/Source/cmExtraCodeBlocksGenerator.cxx @@ -17,7 +17,6 @@ #include "cmake.h" #include "cmSourceFile.h" #include "cmGeneratedFileStream.h" -#include "cmTarget.h" #include "cmSystemTools.h" #include "cmXMLSafe.h" @@ -76,9 +75,8 @@ void cmExtraCodeBlocksGenerator::Generate() void cmExtraCodeBlocksGenerator::CreateProjectFile( const std::vector<cmLocalGenerator*>& lgs) { - const cmMakefile* mf=lgs[0]->GetMakefile(); - std::string outputDir=mf->GetCurrentBinaryDirectory(); - std::string projectName=mf->GetProjectName(); + std::string outputDir=lgs[0]->GetCurrentBinaryDirectory(); + std::string projectName=lgs[0]->GetProjectName(); std::string filename=outputDir+"/"; filename+=projectName+".cbp"; @@ -273,7 +271,7 @@ void cmExtraCodeBlocksGenerator } const std::string &relative = cmSystemTools::RelativePath( - it->second[0]->GetMakefile()->GetHomeDirectory(), + it->second[0]->GetSourceDirectory(), jt->c_str()); std::vector<std::string> splitted; cmSystemTools::SplitPath(relative, splitted, false); @@ -297,7 +295,7 @@ void cmExtraCodeBlocksGenerator tree.BuildVirtualFolder(virtualFolders); // And one for <Unit> std::string unitFiles; - tree.BuildUnit(unitFiles, std::string(mf->GetHomeDirectory()) + "/"); + tree.BuildUnit(unitFiles, std::string(lgs[0]->GetSourceDirectory()) + "/"); // figure out the compiler std::string compiler = this->GetCBCompilerId(mf); @@ -307,7 +305,7 @@ void cmExtraCodeBlocksGenerator "<CodeBlocks_project_file>\n" " <FileVersion major=\"1\" minor=\"6\" />\n" " <Project>\n" - " <Option title=\"" << mf->GetProjectName()<<"\" />\n" + " <Option title=\"" << lgs[0]->GetProjectName()<<"\" />\n" " <Option makefile_is_custom=\"1\" />\n" " <Option compiler=\"" << compiler << "\" />\n" " "<<virtualFolders<<"\n" @@ -320,50 +318,52 @@ void cmExtraCodeBlocksGenerator for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin(); lg!=lgs.end(); lg++) { - cmMakefile* makefile=(*lg)->GetMakefile(); - cmTargets& targets=makefile->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ti++) { - switch(ti->second.GetType()) + std::string targetName = (*ti)->GetName(); + switch((*ti)->GetType()) { - case cmTarget::GLOBAL_TARGET: + case cmState::GLOBAL_TARGET: { // Only add the global targets from CMAKE_BINARY_DIR, // not from the subdirs - if (strcmp(makefile->GetCurrentBinaryDirectory(), - makefile->GetHomeOutputDirectory())==0) + if (strcmp((*lg)->GetCurrentBinaryDirectory(), + (*lg)->GetBinaryDirectory())==0) { - this->AppendTarget(fout, ti->first, 0, + this->AppendTarget(fout, targetName, 0, make.c_str(), *lg, compiler.c_str()); } } break; - case cmTarget::UTILITY: + case cmState::UTILITY: // Add all utility targets, except the Nightly/Continuous/ // Experimental-"sub"targets as e.g. NightlyStart - if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly")) - || ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous")) - || ((ti->first.find("Experimental")==0) - && (ti->first!="Experimental"))) + if (((targetName.find("Nightly")==0) &&(targetName!="Nightly")) + || ((targetName.find("Continuous")==0) + &&(targetName!="Continuous")) + || ((targetName.find("Experimental")==0) + && (targetName!="Experimental"))) { break; } - this->AppendTarget(fout, ti->first, 0, + this->AppendTarget(fout, targetName, 0, make.c_str(), *lg, compiler.c_str()); break; - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: { - this->AppendTarget(fout, ti->first, &ti->second, + cmGeneratorTarget* gt = *ti; + this->AppendTarget(fout, targetName, gt, make.c_str(), *lg, compiler.c_str()); - std::string fastTarget = ti->first; + std::string fastTarget = targetName; fastTarget += "/fast"; - this->AppendTarget(fout, fastTarget, &ti->second, + this->AppendTarget(fout, fastTarget, gt, make.c_str(), *lg, compiler.c_str()); } break; @@ -383,25 +383,29 @@ void cmExtraCodeBlocksGenerator all_files_map_t allFiles; std::vector<std::string> cFiles; + std::vector<std::string> srcExts = + this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions(); + for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin(); lg!=lgs.end(); lg++) { cmMakefile* makefile=(*lg)->GetMakefile(); - cmTargets& targets=makefile->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ti++) { - switch(ti->second.GetType()) + switch((*ti)->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: - case cmTarget::UTILITY: // can have sources since 2.6.3 + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: + case cmState::UTILITY: // can have sources since 2.6.3 { std::vector<cmSourceFile*> sources; - ti->second.GetSourceFiles(sources, + cmGeneratorTarget* gt = *ti; + gt->GetSourceFiles(sources, makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); for (std::vector<cmSourceFile*>::const_iterator si=sources.begin(); si!=sources.end(); si++) @@ -419,9 +423,7 @@ void cmExtraCodeBlocksGenerator { std::string srcext = (*si)->GetExtension(); for(std::vector<std::string>::const_iterator - ext = mf->GetSourceExtensions().begin(); - ext != mf->GetSourceExtensions().end(); - ++ext) + ext = srcExts.begin(); ext != srcExts.end(); ++ext) { if (srcext == *ext) { @@ -439,7 +441,7 @@ void cmExtraCodeBlocksGenerator } CbpUnit &cbpUnit = allFiles[fullPath]; - cbpUnit.Targets.push_back(&(ti->second)); + cbpUnit.Targets.push_back(*ti); } } default: // intended fallthrough @@ -448,6 +450,9 @@ void cmExtraCodeBlocksGenerator } } + std::vector<std::string> headerExts = + this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions(); + // The following loop tries to add header files matching to implementation // files to the project. It does that by iterating over all // C/C++ source files, @@ -467,8 +472,8 @@ void cmExtraCodeBlocksGenerator // check if there's a matching header around for(std::vector<std::string>::const_iterator - ext = mf->GetHeaderExtensions().begin(); - ext != mf->GetHeaderExtensions().end(); + ext = headerExts.begin(); + ext != headerExts.end(); ++ext) { std::string hname=headerBasename; @@ -499,8 +504,9 @@ void cmExtraCodeBlocksGenerator fout<<" <Unit filename=\""<< cmXMLSafe(unitFilename) <<"\">\n"; - for(std::vector<const cmTarget*>::const_iterator ti = unit.Targets.begin(); - ti != unit.Targets.end(); ++ti) + for(std::vector<const cmGeneratorTarget*>::const_iterator ti = + unit.Targets.begin(); + ti != unit.Targets.end(); ++ti) { std::string const& targetName = (*ti)->GetName(); fout<<" <Option target=\""<< cmXMLSafe(targetName) <<"\"/>\n"; @@ -520,15 +526,14 @@ void cmExtraCodeBlocksGenerator // Write a dummy file for OBJECT libraries, so C::B can reference some file std::string cmExtraCodeBlocksGenerator::CreateDummyTargetFile( cmLocalGenerator* lg, - cmTarget* target) const + cmGeneratorTarget* target) const { - cmMakefile *mf = lg->GetMakefile(); // this file doesn't seem to be used by C::B in custom makefile mode, // but we generate a unique file for each OBJECT library so in case // C::B uses it in some way, the targets don't interfere with each other. - std::string filename = mf->GetCurrentBinaryDirectory(); + std::string filename = lg->GetCurrentBinaryDirectory(); filename += "/"; - filename += lg->GetTargetDirectory(*target); + filename += lg->GetTargetDirectory(target); filename += "/"; filename += target->GetName(); filename += ".objlib"; @@ -547,21 +552,21 @@ std::string cmExtraCodeBlocksGenerator::CreateDummyTargetFile( // Generate the xml code for one target. void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, const std::string& targetName, - cmTarget* target, + cmGeneratorTarget* target, const char* make, const cmLocalGenerator* lg, const char* compiler) { cmMakefile const* makefile = lg->GetMakefile(); - std::string makefileName = makefile->GetCurrentBinaryDirectory(); + std::string makefileName = lg->GetCurrentBinaryDirectory(); makefileName += "/Makefile"; fout<<" <Target title=\"" << targetName << "\">\n"; if (target!=0) { int cbTargetType = this->GetCBTargetType(target); - std::string workingDir = makefile->GetCurrentBinaryDirectory(); - if ( target->GetType()==cmTarget::EXECUTABLE) + std::string workingDir = lg->GetCurrentBinaryDirectory(); + if ( target->GetType()==cmState::EXECUTABLE) { // Determine the directory where the executable target is created, and // set the working directory to this dir. @@ -584,16 +589,14 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, std::string buildType = makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); std::string location; - if ( target->GetType()==cmTarget::OBJECT_LIBRARY) + if ( target->GetType()==cmState::OBJECT_LIBRARY) { location = this->CreateDummyTargetFile(const_cast<cmLocalGenerator*>(lg), target); } else { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(target); - location = gt->GetLocation(buildType); + location = target->GetLocation(buildType); } fout<<" <Option output=\"" << location @@ -604,12 +607,9 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, " <Option compiler=\"" << compiler << "\" />\n" " <Compiler>\n"; - cmGeneratorTarget *gtgt = this->GlobalGenerator - ->GetGeneratorTarget(target); - // the compilerdefines for this target std::vector<std::string> cdefs; - gtgt->GetCompileDefinitions(cdefs, buildType, "C"); + target->GetCompileDefinitions(cdefs, buildType, "C"); // Expand the list. for(std::vector<std::string>::const_iterator di = cdefs.begin(); @@ -623,7 +623,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, std::set<std::string> uniqIncludeDirs; std::vector<std::string> includes; - lg->GetIncludeDirectories(includes, gtgt, "C", buildType); + lg->GetIncludeDirectories(includes, target, "C", buildType); uniqIncludeDirs.insert(includes.begin(), includes.end()); @@ -657,7 +657,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, else // e.g. all and the GLOBAL and UTILITY targets { fout<<" <Option working_dir=\"" - << makefile->GetCurrentBinaryDirectory() << "\" />\n" + << lg->GetCurrentBinaryDirectory() << "\" />\n" <<" <Option type=\"" << 4 << "\" />\n"; } @@ -691,8 +691,6 @@ std::string cmExtraCodeBlocksGenerator::GetCBCompilerId(const cmMakefile* mf) compilerIdVar = "CMAKE_C_COMPILER_ID"; } - std::string hostSystemName = mf->GetSafeDefinition("CMAKE_HOST_SYSTEM_NAME"); - std::string systemName = mf->GetSafeDefinition("CMAKE_SYSTEM_NAME"); std::string compilerId = mf->GetSafeDefinition(compilerIdVar); std::string compiler = "gcc"; // default to gcc if (compilerId == "MSVC") @@ -724,9 +722,9 @@ std::string cmExtraCodeBlocksGenerator::GetCBCompilerId(const cmMakefile* mf) // Translate the cmake target type into the CodeBlocks target type id -int cmExtraCodeBlocksGenerator::GetCBTargetType(cmTarget* target) +int cmExtraCodeBlocksGenerator::GetCBTargetType(cmGeneratorTarget* target) { - if ( target->GetType()==cmTarget::EXECUTABLE) + if ( target->GetType()==cmState::EXECUTABLE) { if ((target->GetPropertyAsBool("WIN32_EXECUTABLE")) || (target->GetPropertyAsBool("MACOSX_BUNDLE"))) @@ -738,13 +736,13 @@ int cmExtraCodeBlocksGenerator::GetCBTargetType(cmTarget* target) return 1; } } - else if (( target->GetType()==cmTarget::STATIC_LIBRARY) - || (target->GetType()==cmTarget::OBJECT_LIBRARY)) + else if (( target->GetType()==cmState::STATIC_LIBRARY) + || (target->GetType()==cmState::OBJECT_LIBRARY)) { return 2; } - else if ((target->GetType()==cmTarget::SHARED_LIBRARY) - || (target->GetType()==cmTarget::MODULE_LIBRARY)) + else if ((target->GetType()==cmState::SHARED_LIBRARY) + || (target->GetType()==cmState::MODULE_LIBRARY)) { return 3; } diff --git a/Source/cmExtraCodeBlocksGenerator.h b/Source/cmExtraCodeBlocksGenerator.h index e5ede9a..0c3846d 100644 --- a/Source/cmExtraCodeBlocksGenerator.h +++ b/Source/cmExtraCodeBlocksGenerator.h @@ -17,7 +17,7 @@ class cmLocalGenerator; class cmMakefile; -class cmTarget; +class cmGeneratorTarget; class cmGeneratedFileStream; /** \class cmExtraCodeBlocksGenerator @@ -41,7 +41,7 @@ public: private: struct CbpUnit { - std::vector<const cmTarget*> Targets; + std::vector<const cmGeneratorTarget*> Targets; }; void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs); @@ -49,15 +49,15 @@ private: void CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs, const std::string& filename); std::string CreateDummyTargetFile(cmLocalGenerator* lg, - cmTarget* target) const; + cmGeneratorTarget* target) const; std::string GetCBCompilerId(const cmMakefile* mf); - int GetCBTargetType(cmTarget* target); + int GetCBTargetType(cmGeneratorTarget* target); std::string BuildMakeCommand(const std::string& make, const char* makefile, const std::string& target); void AppendTarget(cmGeneratedFileStream& fout, const std::string& targetName, - cmTarget* target, + cmGeneratorTarget* target, const char* make, const cmLocalGenerator* lg, const char* compiler); diff --git a/Source/cmExtraCodeLiteGenerator.cxx b/Source/cmExtraCodeLiteGenerator.cxx index c2cff14..67aa157 100644 --- a/Source/cmExtraCodeLiteGenerator.cxx +++ b/Source/cmExtraCodeLiteGenerator.cxx @@ -68,15 +68,15 @@ void cmExtraCodeLiteGenerator::Generate() const cmMakefile* mf =it->second[0]->GetMakefile(); this->ConfigName = GetConfigurationName( mf ); - if (strcmp(mf->GetCurrentBinaryDirectory(), - mf->GetHomeOutputDirectory()) == 0) + if (strcmp(it->second[0]->GetCurrentBinaryDirectory(), + it->second[0]->GetBinaryDirectory()) == 0) { - workspaceOutputDir = mf->GetCurrentBinaryDirectory(); - workspaceProjectName = mf->GetProjectName(); - workspaceSourcePath = mf->GetHomeDirectory(); + workspaceOutputDir = it->second[0]->GetCurrentBinaryDirectory(); + workspaceProjectName = it->second[0]->GetProjectName(); + workspaceSourcePath = it->second[0]->GetSourceDirectory(); workspaceFileName = workspaceOutputDir+"/"; workspaceFileName += workspaceProjectName + ".workspace"; - this->WorkspacePath = mf->GetCurrentBinaryDirectory();; + this->WorkspacePath = it->second[0]->GetCurrentBinaryDirectory();; fout.Open(workspaceFileName.c_str(), false, false); fout << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" @@ -91,9 +91,8 @@ void cmExtraCodeLiteGenerator::Generate() ++it) { // retrive project information - const cmMakefile* mf = it->second[0]->GetMakefile(); - std::string outputDir = mf->GetCurrentBinaryDirectory(); - std::string projectName = mf->GetProjectName(); + std::string outputDir = it->second[0]->GetCurrentBinaryDirectory(); + std::string projectName = it->second[0]->GetProjectName(); std::string filename = outputDir + "/" + projectName + ".project"; // Make the project file relative to the workspace @@ -121,9 +120,8 @@ void cmExtraCodeLiteGenerator::Generate() void cmExtraCodeLiteGenerator::CreateProjectFile( const std::vector<cmLocalGenerator*>& lgs) { - const cmMakefile* mf = lgs[0]->GetMakefile(); - std::string outputDir = mf->GetCurrentBinaryDirectory(); - std::string projectName = mf->GetProjectName(); + std::string outputDir = lgs[0]->GetCurrentBinaryDirectory(); + std::string projectName = lgs[0]->GetProjectName(); std::string filename = outputDir + "/"; filename += projectName + ".project"; @@ -143,7 +141,7 @@ void cmExtraCodeLiteGenerator //////////////////////////////////// fout << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" - "<CodeLite_Project Name=\"" << mf->GetProjectName() + "<CodeLite_Project Name=\"" << lgs[0]->GetProjectName() << "\" InternalType=\"\">\n"; // Collect all used source files in the project @@ -151,35 +149,40 @@ void cmExtraCodeLiteGenerator // which may have an acompanying header, one for all other files std::string projectType; + std::vector<std::string> srcExts = + this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions(); + std::vector<std::string> headerExts = + this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions(); + std::map<std::string, cmSourceFile*> cFiles; std::set<std::string> otherFiles; for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin(); lg!=lgs.end(); lg++) { cmMakefile* makefile=(*lg)->GetMakefile(); - cmTargets& targets=makefile->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ti++) { - switch(ti->second.GetType()) + switch((*ti)->GetType()) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: { projectType = "Executable"; } break; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: { projectType = "Static Library"; } break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: { projectType = "Dynamic Library"; } break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: { projectType = "Dynamic Library"; } @@ -188,15 +191,16 @@ void cmExtraCodeLiteGenerator break; } - switch(ti->second.GetType()) + switch((*ti)->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: { std::vector<cmSourceFile*> sources; - ti->second.GetSourceFiles(sources, + cmGeneratorTarget* gt = *ti; + gt->GetSourceFiles(sources, makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); for (std::vector<cmSourceFile*>::const_iterator si=sources.begin(); si!=sources.end(); si++) @@ -208,9 +212,7 @@ void cmExtraCodeLiteGenerator { std::string srcext = (*si)->GetExtension(); for(std::vector<std::string>::const_iterator - ext = mf->GetSourceExtensions().begin(); - ext != mf->GetSourceExtensions().end(); - ++ext) + ext = srcExts.begin(); ext != srcExts.end(); ++ext) { if (srcext == *ext) { @@ -254,8 +256,8 @@ void cmExtraCodeLiteGenerator // check if there's a matching header around for(std::vector<std::string>::const_iterator - ext = mf->GetHeaderExtensions().begin(); - ext != mf->GetHeaderExtensions().end(); + ext = headerExts.begin(); + ext != headerExts.end(); ++ext) { std::string hname=headerBasename; diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx index 44bf586..aedf6f4 100644 --- a/Source/cmExtraEclipseCDT4Generator.cxx +++ b/Source/cmExtraEclipseCDT4Generator.cxx @@ -79,8 +79,8 @@ void cmExtraEclipseCDT4Generator //---------------------------------------------------------------------------- void cmExtraEclipseCDT4Generator::Generate() { - const cmMakefile* mf - = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); + cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0]; + const cmMakefile* mf = lg->GetMakefile(); std::string eclipseVersion = mf->GetSafeDefinition("CMAKE_ECLIPSE_VERSION"); cmsys::RegularExpression regex(".*([0-9]+\\.[0-9]+).*"); @@ -106,8 +106,8 @@ void cmExtraEclipseCDT4Generator::Generate() } // TODO: Decide if these are local or member variables - this->HomeDirectory = mf->GetHomeDirectory(); - this->HomeOutputDirectory = mf->GetHomeOutputDirectory(); + this->HomeDirectory = lg->GetSourceDirectory(); + this->HomeOutputDirectory = lg->GetBinaryDirectory(); this->GenerateLinkedResources = mf->IsOn( "CMAKE_ECLIPSE_GENERATE_LINKED_RESOURCES"); @@ -157,9 +157,8 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile() assert(this->HomeDirectory != this->HomeOutputDirectory); // set up the project name: <project>-Source@<baseSourcePathName> - const cmMakefile* mf - = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); - std::string name = this->GenerateProjectName(mf->GetProjectName(), "Source", + cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0]; + std::string name = this->GenerateProjectName(lg->GetProjectName(), "Source", this->GetPathBasename(this->HomeDirectory)); const std::string filename = this->HomeDirectory + "/.project"; @@ -197,8 +196,11 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile() //---------------------------------------------------------------------------- void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout, - const char* envVar, cmMakefile* mf) + const char* envVar, + cmLocalGenerator* lg) { + cmMakefile* mf = lg->GetMakefile(); + // get the variables from the environment and from the cache and then // figure out which one to use: @@ -206,7 +208,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout, std::string cacheEntryName = "CMAKE_ECLIPSE_ENVVAR_"; cacheEntryName += envVar; - const char* cacheValue = mf->GetState()->GetInitializedCacheValue( + const char* cacheValue = lg->GetState()->GetInitializedCacheValue( cacheEntryName); // now we have both, decide which one to use @@ -224,7 +226,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout, mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(), cacheEntryName.c_str(), cmState::STRING, true); - mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory()); + mf->GetCMakeInstance()->SaveCache(lg->GetBinaryDirectory()); } else if (envVarValue==0 && cacheValue!=0) { @@ -245,7 +247,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout, mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(), cacheEntryName.c_str(), cmState::STRING, true); - mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory()); + mf->GetCMakeInstance()->SaveCache(lg->GetBinaryDirectory()); } } @@ -259,8 +261,8 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout, //---------------------------------------------------------------------------- void cmExtraEclipseCDT4Generator::CreateProjectFile() { - cmMakefile* mf - = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); + cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0]; + cmMakefile* mf = lg->GetMakefile(); const std::string filename = this->HomeOutputDirectory + "/.project"; @@ -280,7 +282,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile() "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<projectDescription>\n" "\t<name>" << - this->GenerateProjectName(mf->GetProjectName(), + this->GenerateProjectName(lg->GetProjectName(), mf->GetSafeDefinition("CMAKE_BUILD_TYPE"), this->GetPathBasename(this->HomeOutputDirectory)) << "</name>\n" @@ -361,17 +363,17 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile() // but not necessarily when eclipse is open if (compilerId == "MSVC") { - AddEnvVar(fout, "PATH", mf); - AddEnvVar(fout, "INCLUDE", mf); - AddEnvVar(fout, "LIB", mf); - AddEnvVar(fout, "LIBPATH", mf); + AddEnvVar(fout, "PATH", lg); + AddEnvVar(fout, "INCLUDE", lg); + AddEnvVar(fout, "LIB", lg); + AddEnvVar(fout, "LIBPATH", lg); } else if (compilerId == "Intel") { // if the env.var is set, use this one and put it in the cache // if the env.var is not set, but the value is in the cache, // use it from the cache: - AddEnvVar(fout, "INTEL_LICENSE_FILE", mf); + AddEnvVar(fout, "INTEL_LICENSE_FILE", lg); } fout << "</value>\n" @@ -495,7 +497,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile() std::string sourceLinkedResourceName = "[Source directory]"; std::string linkSourceDirectory = this->GetEclipsePath( - mf->GetCurrentSourceDirectory()); + lg->GetCurrentSourceDirectory()); // .project dir can't be subdir of a linked resource dir if (!cmSystemTools::IsSubDirectory(this->HomeOutputDirectory, linkSourceDirectory)) @@ -534,24 +536,26 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets( ++lgIt) { cmMakefile* makefile = (*lgIt)->GetMakefile(); - const cmTargets& targets = makefile->GetTargets(); + const std::vector<cmGeneratorTarget*> targets = + (*lgIt)->GetGeneratorTargets(); - for(cmTargets::const_iterator ti=targets.begin(); ti!=targets.end();++ti) + for(std::vector<cmGeneratorTarget*>::const_iterator ti=targets.begin(); + ti!=targets.end();++ti) { std::string linkName2 = linkName; linkName2 += "/"; - switch(ti->second.GetType()) + switch((*ti)->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: { - const char* prefix = (ti->second.GetType()==cmTarget::EXECUTABLE ? + const char* prefix = ((*ti)->GetType()==cmState::EXECUTABLE ? "[exe] " : "[lib] "); linkName2 += prefix; - linkName2 += ti->first; + linkName2 += (*ti)->GetName(); this->AppendLinkedResource(fout, linkName2, "virtual:/virtual", VirtualFolder); if (!this->GenerateLinkedResources) @@ -560,9 +564,9 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets( } std::vector<cmSourceGroup> sourceGroups=makefile->GetSourceGroups(); // get the files from the source lists then add them to the groups - cmTarget* tgt = const_cast<cmTarget*>(&ti->second); + cmGeneratorTarget* gt = const_cast<cmGeneratorTarget*>(*ti); std::vector<cmSourceFile*> files; - tgt->GetSourceFiles(files, + gt->GetSourceFiles(files, makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); for(std::vector<cmSourceFile*>::const_iterator sfIt = files.begin(); sfIt != files.end(); @@ -634,7 +638,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects( ++it) { std::string linkSourceDirectory = this->GetEclipsePath( - it->second[0]->GetMakefile()->GetCurrentSourceDirectory()); + it->second[0]->GetCurrentSourceDirectory()); // a linked resource must not point to a parent directory of .project or // .project itself if ((baseDir != linkSourceDirectory) && @@ -694,8 +698,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const { std::set<std::string> emmited; - const cmMakefile* mf - = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); + cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0]; + const cmMakefile* mf = lg->GetMakefile(); const std::string filename = this->HomeOutputDirectory + "/.cproject"; @@ -961,18 +965,13 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) { - cmGeneratorTargetsType targets = (*it)->GetMakefile() - ->GetGeneratorTargets(); - for (cmGeneratorTargetsType::iterator l = targets.begin(); + std::vector<cmGeneratorTarget*> targets = (*it)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator l = targets.begin(); l != targets.end(); ++l) { - if (l->first->IsImported()) - { - continue; - } std::vector<std::string> includeDirs; std::string config = mf->GetSafeDefinition("CMAKE_BUILD_TYPE"); - (*it)->GetIncludeDirectories(includeDirs, l->second, "C", config); + (*it)->GetIncludeDirectories(includeDirs, *l, "C", config); this->AppendIncludeDirectories(fout, includeDirs, emmited); } } @@ -1031,52 +1030,54 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) { - const cmTargets& targets = (*it)->GetMakefile()->GetTargets(); - cmMakefile* makefile=(*it)->GetMakefile(); - std::string subdir = (*it)->Convert(makefile->GetCurrentBinaryDirectory(), + const std::vector<cmGeneratorTarget*> targets = + (*it)->GetGeneratorTargets(); + std::string subdir = (*it)->Convert((*it)->GetCurrentBinaryDirectory(), cmLocalGenerator::HOME_OUTPUT); if (subdir == ".") { subdir = ""; } - for(cmTargets::const_iterator ti=targets.begin(); ti!=targets.end(); ++ti) + for(std::vector<cmGeneratorTarget*>::const_iterator ti = + targets.begin(); ti!=targets.end(); ++ti) { - switch(ti->second.GetType()) + std::string targetName = (*ti)->GetName(); + switch((*ti)->GetType()) { - case cmTarget::GLOBAL_TARGET: + case cmState::GLOBAL_TARGET: { // Only add the global targets from CMAKE_BINARY_DIR, // not from the subdirs if (subdir.empty()) { - this->AppendTarget(fout, ti->first, make, makeArgs, subdir, ": "); + this->AppendTarget(fout, targetName, make, makeArgs, subdir, ": "); } } break; - case cmTarget::UTILITY: + case cmState::UTILITY: // Add all utility targets, except the Nightly/Continuous/ // Experimental-"sub"targets as e.g. NightlyStart - if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly")) - || ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous")) - || ((ti->first.find("Experimental")==0) - && (ti->first!="Experimental"))) + if (((targetName.find("Nightly")==0) &&(targetName!="Nightly")) + || ((targetName.find("Continuous")==0)&&(targetName!="Continuous")) + || ((targetName.find("Experimental")==0) + && (targetName!="Experimental"))) { break; } - this->AppendTarget(fout, ti->first, make, makeArgs, subdir, ": "); + this->AppendTarget(fout, targetName, make, makeArgs, subdir, ": "); break; - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: { - const char* prefix = (ti->second.GetType()==cmTarget::EXECUTABLE ? + const char* prefix = ((*ti)->GetType()==cmState::EXECUTABLE ? "[exe] " : "[lib] "); - this->AppendTarget(fout, ti->first, make, makeArgs, subdir, prefix); - std::string fastTarget = ti->first; + this->AppendTarget(fout, targetName, make, makeArgs, subdir, prefix); + std::string fastTarget = targetName; fastTarget += "/fast"; this->AppendTarget(fout, fastTarget, make, makeArgs, subdir, prefix); @@ -1085,20 +1086,21 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const { std::string virtDir = "[Targets]/"; virtDir += prefix; - virtDir += ti->first; + virtDir += targetName; std::string buildArgs = "-C \""; - buildArgs += makefile->GetHomeOutputDirectory(); + buildArgs += (*it)->GetBinaryDirectory(); buildArgs += "\" "; buildArgs += makeArgs; this->AppendTarget(fout, "Build", make, buildArgs, virtDir, "", - ti->first.c_str()); + targetName.c_str()); std::string cleanArgs = "-E chdir \""; - cleanArgs += makefile->GetCurrentBinaryDirectory(); + cleanArgs += (*it)->GetCurrentBinaryDirectory(); cleanArgs += "\" \""; cleanArgs += cmSystemTools::GetCMakeCommand(); cleanArgs += "\" -P \""; - cleanArgs += (*it)->GetTargetDirectory(ti->second); + cmGeneratorTarget* gt = *ti; + cleanArgs += (*it)->GetTargetDirectory(gt); cleanArgs += "/cmake_clean.cmake\""; this->AppendTarget(fout, "Clean", cmSystemTools::GetCMakeCommand(), cleanArgs, virtDir, "", ""); @@ -1149,8 +1151,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const fout << "</cconfiguration>\n" "</storageModule>\n" "<storageModule moduleId=\"cdtBuildSystem\" version=\"4.0.0\">\n" - "<project id=\"" << this->EscapeForXML(mf->GetProjectName()) - << ".null.1\" name=\"" << this->EscapeForXML(mf->GetProjectName()) + "<project id=\"" << this->EscapeForXML(lg->GetProjectName()) + << ".null.1\" name=\"" << this->EscapeForXML(lg->GetProjectName()) << "\"/>\n" "</storageModule>\n" "</cproject>\n" diff --git a/Source/cmExtraEclipseCDT4Generator.h b/Source/cmExtraEclipseCDT4Generator.h index ef99760..16675f2 100644 --- a/Source/cmExtraEclipseCDT4Generator.h +++ b/Source/cmExtraEclipseCDT4Generator.h @@ -100,7 +100,7 @@ private: std::set<std::string>& emittedDirs); static void AddEnvVar(cmGeneratedFileStream& fout, const char* envVar, - cmMakefile* mf); + cmLocalGenerator* lg); void CreateLinksToSubprojects(cmGeneratedFileStream& fout, const std::string& baseDir); diff --git a/Source/cmExtraKateGenerator.cxx b/Source/cmExtraKateGenerator.cxx index f83b5cf..ff5d3ab 100644 --- a/Source/cmExtraKateGenerator.cxx +++ b/Source/cmExtraKateGenerator.cxx @@ -17,7 +17,6 @@ #include "cmake.h" #include "cmSourceFile.h" #include "cmGeneratedFileStream.h" -#include "cmTarget.h" #include "cmSystemTools.h" #include <cmsys/SystemTools.hxx> @@ -46,21 +45,22 @@ cmExtraKateGenerator::cmExtraKateGenerator() void cmExtraKateGenerator::Generate() { - const cmMakefile* mf - = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); - this->ProjectName = this->GenerateProjectName(mf->GetProjectName(), + cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0]; + const cmMakefile* mf = lg->GetMakefile(); + this->ProjectName = this->GenerateProjectName(lg->GetProjectName(), mf->GetSafeDefinition("CMAKE_BUILD_TYPE"), - this->GetPathBasename(mf->GetHomeOutputDirectory())); + this->GetPathBasename(lg->GetBinaryDirectory())); this->UseNinja = (this->GlobalGenerator->GetName() == "Ninja"); - this->CreateKateProjectFile(mf); - this->CreateDummyKateProjectFile(mf); + this->CreateKateProjectFile(lg); + this->CreateDummyKateProjectFile(lg); } -void cmExtraKateGenerator::CreateKateProjectFile(const cmMakefile* mf) const +void cmExtraKateGenerator::CreateKateProjectFile( + const cmLocalGenerator* lg) const { - std::string filename = mf->GetHomeOutputDirectory(); + std::string filename = lg->GetBinaryDirectory(); filename += "/.kateproject"; cmGeneratedFileStream fout(filename.c_str()); if (!fout) @@ -68,31 +68,29 @@ void cmExtraKateGenerator::CreateKateProjectFile(const cmMakefile* mf) const return; } - std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"); - std::string args = mf->GetSafeDefinition("CMAKE_KATE_MAKE_ARGUMENTS"); - fout << "{\n" "\t\"name\": \"" << this->ProjectName << "\",\n" - "\t\"directory\": \"" << mf->GetHomeDirectory() << "\",\n" - "\t\"files\": [ { " << this->GenerateFilesString(mf) << "} ],\n"; - this->WriteTargets(mf, fout); + "\t\"directory\": \"" << lg->GetSourceDirectory() << "\",\n" + "\t\"files\": [ { " << this->GenerateFilesString(lg) << "} ],\n"; + this->WriteTargets(lg, fout); fout << "}\n"; } void -cmExtraKateGenerator::WriteTargets(const cmMakefile* mf, +cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg, cmGeneratedFileStream& fout) const { + cmMakefile const* mf = lg->GetMakefile(); const std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"); const std::string makeArgs = mf->GetSafeDefinition( "CMAKE_KATE_MAKE_ARGUMENTS"); - const char* homeOutputDir = mf->GetHomeOutputDirectory(); + const char* homeOutputDir = lg->GetBinaryDirectory(); fout << "\t\"build\": {\n" - "\t\t\"directory\": \"" << mf->GetHomeOutputDirectory() << "\",\n" + "\t\t\"directory\": \"" << lg->GetBinaryDirectory() << "\",\n" "\t\t\"default_target\": \"all\",\n" "\t\t\"clean_target\": \"clean\",\n"; @@ -120,16 +118,18 @@ cmExtraKateGenerator::WriteTargets(const cmMakefile* mf, it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) { - const cmTargets& targets = (*it)->GetMakefile()->GetTargets(); - cmMakefile* makefile=(*it)->GetMakefile(); - std::string currentDir = makefile->GetCurrentBinaryDirectory(); - bool topLevel = (currentDir == makefile->GetHomeOutputDirectory()); + const std::vector<cmGeneratorTarget*> targets = + (*it)->GetGeneratorTargets(); + std::string currentDir = (*it)->GetCurrentBinaryDirectory(); + bool topLevel = (currentDir == (*it)->GetBinaryDirectory()); - for(cmTargets::const_iterator ti=targets.begin(); ti!=targets.end(); ++ti) + for(std::vector<cmGeneratorTarget*>::const_iterator ti = + targets.begin(); ti!=targets.end(); ++ti) { - switch(ti->second.GetType()) + std::string targetName = (*ti)->GetName(); + switch((*ti)->GetType()) { - case cmTarget::GLOBAL_TARGET: + case cmState::GLOBAL_TARGET: { bool insertTarget = false; // Only add the global targets from CMAKE_BINARY_DIR, @@ -139,9 +139,9 @@ cmExtraKateGenerator::WriteTargets(const cmMakefile* mf, insertTarget = true; // only add the "edit_cache" target if it's not ccmake, because // this will not work within the IDE - if (ti->first == "edit_cache") + if (targetName == "edit_cache") { - const char* editCommand = makefile->GetDefinition + const char* editCommand = (*it)->GetMakefile()->GetDefinition ("CMAKE_EDIT_COMMAND"); if (editCommand == 0) { @@ -155,34 +155,35 @@ cmExtraKateGenerator::WriteTargets(const cmMakefile* mf, } if (insertTarget) { - this->AppendTarget(fout, ti->first, make, makeArgs, + this->AppendTarget(fout, targetName, make, makeArgs, currentDir, homeOutputDir); } } break; - case cmTarget::UTILITY: + case cmState::UTILITY: // Add all utility targets, except the Nightly/Continuous/ // Experimental-"sub"targets as e.g. NightlyStart - if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly")) - || ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous")) - || ((ti->first.find("Experimental")==0) - && (ti->first!="Experimental"))) + if (((targetName.find("Nightly")==0) &&(targetName!="Nightly")) + || ((targetName.find("Continuous")==0) + &&(targetName!="Continuous")) + || ((targetName.find("Experimental")==0) + && (targetName!="Experimental"))) { break; } - this->AppendTarget(fout, ti->first, make, makeArgs, + this->AppendTarget(fout, targetName, make, makeArgs, currentDir, homeOutputDir); break; - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: { - this->AppendTarget(fout, ti->first, make, makeArgs, + this->AppendTarget(fout, targetName, make, makeArgs, currentDir, homeOutputDir); - std::string fastTarget = ti->first; + std::string fastTarget = targetName; fastTarget += "/fast"; this->AppendTarget(fout, fastTarget, make, makeArgs, currentDir, homeOutputDir); @@ -234,9 +235,10 @@ cmExtraKateGenerator::AppendTarget(cmGeneratedFileStream& fout, void -cmExtraKateGenerator::CreateDummyKateProjectFile(const cmMakefile* mf) const +cmExtraKateGenerator::CreateDummyKateProjectFile( + const cmLocalGenerator* lg) const { - std::string filename = mf->GetHomeOutputDirectory(); + std::string filename = lg->GetBinaryDirectory(); filename += "/"; filename += this->ProjectName; filename += ".kateproject"; @@ -252,23 +254,23 @@ cmExtraKateGenerator::CreateDummyKateProjectFile(const cmMakefile* mf) const std::string -cmExtraKateGenerator::GenerateFilesString(const cmMakefile* mf) const +cmExtraKateGenerator::GenerateFilesString(const cmLocalGenerator* lg) const { - std::string s = mf->GetHomeDirectory(); + std::string s = lg->GetSourceDirectory(); s += "/.git"; if(cmSystemTools::FileExists(s.c_str())) { return std::string("\"git\": 1 "); } - s = mf->GetHomeDirectory(); + s = lg->GetSourceDirectory(); s += "/.svn"; if(cmSystemTools::FileExists(s.c_str())) { return std::string("\"svn\": 1 "); } - s = mf->GetHomeDirectory(); + s = lg->GetSourceDirectory(); s += "/"; std::set<std::string> files; diff --git a/Source/cmExtraKateGenerator.h b/Source/cmExtraKateGenerator.h index f800feb..281c1ef 100644 --- a/Source/cmExtraKateGenerator.h +++ b/Source/cmExtraKateGenerator.h @@ -16,8 +16,6 @@ #include "cmExternalMakefileProjectGenerator.h" class cmLocalGenerator; -class cmMakefile; -class cmTarget; class cmGeneratedFileStream; /** \class cmExtraKateGenerator @@ -39,9 +37,10 @@ public: virtual void Generate(); private: - void CreateKateProjectFile(const cmMakefile* mf) const; - void CreateDummyKateProjectFile(const cmMakefile* mf) const; - void WriteTargets(const cmMakefile* mf, cmGeneratedFileStream& fout) const; + void CreateKateProjectFile(const cmLocalGenerator* lg) const; + void CreateDummyKateProjectFile(const cmLocalGenerator* lg) const; + void WriteTargets(const cmLocalGenerator* lg, + cmGeneratedFileStream& fout) const; void AppendTarget(cmGeneratedFileStream& fout, const std::string& target, const std::string& make, @@ -49,7 +48,7 @@ private: const std::string& path, const char* homeOutputDir) const; - std::string GenerateFilesString(const cmMakefile* mf) const; + std::string GenerateFilesString(const cmLocalGenerator* lg) const; std::string GetPathBasename(const std::string& path) const; std::string GenerateProjectName(const std::string& name, const std::string& type, diff --git a/Source/cmExtraSublimeTextGenerator.cxx b/Source/cmExtraSublimeTextGenerator.cxx index 163a75b..92d38b9 100644 --- a/Source/cmExtraSublimeTextGenerator.cxx +++ b/Source/cmExtraSublimeTextGenerator.cxx @@ -20,7 +20,6 @@ #include "cmMakefile.h" #include "cmSourceFile.h" #include "cmSystemTools.h" -#include "cmTarget.h" #include <cmsys/SystemTools.hxx> @@ -77,9 +76,8 @@ void cmExtraSublimeTextGenerator::Generate() void cmExtraSublimeTextGenerator::CreateProjectFile( const std::vector<cmLocalGenerator*>& lgs) { - const cmMakefile* mf=lgs[0]->GetMakefile(); - std::string outputDir=mf->GetCurrentBinaryDirectory(); - std::string projectName=mf->GetProjectName(); + std::string outputDir=lgs[0]->GetCurrentBinaryDirectory(); + std::string projectName=lgs[0]->GetProjectName(); const std::string filename = outputDir + "/" + projectName + ".sublime-project"; @@ -99,8 +97,8 @@ void cmExtraSublimeTextGenerator } const std::string &sourceRootRelativeToOutput = cmSystemTools::RelativePath( - mf->GetHomeOutputDirectory(), - mf->GetHomeDirectory()); + lgs[0]->GetBinaryDirectory(), + lgs[0]->GetSourceDirectory()); // Write the folder entries to the project file fout << "{\n"; fout << "\t\"folders\":\n\t[\n\t"; @@ -108,8 +106,8 @@ void cmExtraSublimeTextGenerator { fout << "\t{\n\t\t\t\"path\": \"" << sourceRootRelativeToOutput << "\""; const std::string &outputRelativeToSourceRoot = - cmSystemTools::RelativePath(mf->GetHomeDirectory(), - mf->GetHomeOutputDirectory()); + cmSystemTools::RelativePath(lgs[0]->GetSourceDirectory(), + lgs[0]->GetBinaryDirectory()); if ((!outputRelativeToSourceRoot.empty()) && ((outputRelativeToSourceRoot.length() < 3) || (outputRelativeToSourceRoot.substr(0, 3) != "../"))) @@ -163,52 +161,54 @@ void cmExtraSublimeTextGenerator:: lg!=lgs.end(); lg++) { cmMakefile* makefile=(*lg)->GetMakefile(); - cmTargets& targets=makefile->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ti++) { - switch(ti->second.GetType()) + std::string targetName = (*ti)->GetName(); + switch((*ti)->GetType()) { - case cmTarget::GLOBAL_TARGET: + case cmState::GLOBAL_TARGET: { // Only add the global targets from CMAKE_BINARY_DIR, // not from the subdirs - if (strcmp(makefile->GetCurrentBinaryDirectory(), - makefile->GetHomeOutputDirectory())==0) + if (strcmp((*lg)->GetCurrentBinaryDirectory(), + (*lg)->GetBinaryDirectory())==0) { - this->AppendTarget(fout, ti->first, *lg, 0, + this->AppendTarget(fout, targetName, *lg, 0, make.c_str(), makefile, compiler.c_str(), sourceFileFlags, false); } } break; - case cmTarget::UTILITY: + case cmState::UTILITY: // Add all utility targets, except the Nightly/Continuous/ // Experimental-"sub"targets as e.g. NightlyStart - if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly")) - || ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous")) - || ((ti->first.find("Experimental")==0) - && (ti->first!="Experimental"))) + if (((targetName.find("Nightly")==0) &&(targetName!="Nightly")) + || ((targetName.find("Continuous")==0) + &&(targetName!="Continuous")) + || ((targetName.find("Experimental")==0) + && (targetName!="Experimental"))) { break; } - this->AppendTarget(fout, ti->first, *lg, 0, + this->AppendTarget(fout, targetName, *lg, 0, make.c_str(), makefile, compiler.c_str(), sourceFileFlags, false); break; - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: { - this->AppendTarget(fout, ti->first, *lg, &ti->second, + this->AppendTarget(fout, targetName, *lg, *ti, make.c_str(), makefile, compiler.c_str(), sourceFileFlags, false); - std::string fastTarget = ti->first; + std::string fastTarget = targetName; fastTarget += "/fast"; - this->AppendTarget(fout, fastTarget, *lg, &ti->second, + this->AppendTarget(fout, fastTarget, *lg, *ti, make.c_str(), makefile, compiler.c_str(), sourceFileFlags, false); } @@ -224,7 +224,7 @@ void cmExtraSublimeTextGenerator:: AppendTarget(cmGeneratedFileStream& fout, const std::string& targetName, cmLocalGenerator* lg, - cmTarget* target, + cmGeneratorTarget* target, const char* make, const cmMakefile* makefile, const char*, //compiler @@ -234,8 +234,6 @@ void cmExtraSublimeTextGenerator:: if (target != 0) { - cmGeneratorTarget *gtgt = this->GlobalGenerator - ->GetGeneratorTarget(target); std::vector<cmSourceFile*> sourceFiles; target->GetSourceFiles(sourceFiles, makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); @@ -255,9 +253,9 @@ void cmExtraSublimeTextGenerator:: } std::vector<std::string>& flags = sourceFileFlagsIter->second; std::string flagsString = - this->ComputeFlagsForObject(*iter, lg, target, gtgt); + this->ComputeFlagsForObject(*iter, lg, target); std::string definesString = - this->ComputeDefines(*iter, lg, target, gtgt); + this->ComputeDefines(*iter, lg, target); flags.clear(); cmsys::RegularExpression flagRegex; // Regular expression to extract compiler flags from a string @@ -302,7 +300,7 @@ void cmExtraSublimeTextGenerator:: { fout << ",\n\t"; } - fout << "\t{\n\t\t\t\"name\": \"" << makefile->GetProjectName() << " - " << + fout << "\t{\n\t\t\t\"name\": \"" << lg->GetProjectName() << " - " << targetName << "\",\n"; fout << "\t\t\t\"cmd\": [" << this->BuildMakeCommand(make, makefileName.c_str(), targetName) << @@ -365,7 +363,6 @@ std::string cmExtraSublimeTextGenerator::BuildMakeCommand( std::string cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source, cmLocalGenerator* lg, - cmTarget *target, cmGeneratorTarget* gtgt) { std::string flags; @@ -390,7 +387,7 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source, // } // Add shared-library flags if needed. - lg->AddCMP0018Flags(flags, target, language, config); + lg->AddCMP0018Flags(flags, gtgt, language, config); // Add include directory flags. { @@ -405,7 +402,7 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source, lg->AppendFlags(flags, makefile->GetDefineFlags()); // Add target-specific flags. - lg->AddCompileOptions(flags, target, language, config); + lg->AddCompileOptions(flags, gtgt, language, config); // Add source file specific flags. lg->AppendFlags(flags, source->GetProperty("COMPILE_FLAGS")); @@ -419,8 +416,8 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source, // void cmMakefileTargetGenerator::WriteTargetLanguageFlags(). std::string cmExtraSublimeTextGenerator:: -ComputeDefines(cmSourceFile *source, cmLocalGenerator* lg, cmTarget *target, - cmGeneratorTarget*) +ComputeDefines(cmSourceFile *source, cmLocalGenerator* lg, + cmGeneratorTarget* target) { std::set<std::string> defines; diff --git a/Source/cmExtraSublimeTextGenerator.h b/Source/cmExtraSublimeTextGenerator.h index 4173b7d..cf31ee0 100644 --- a/Source/cmExtraSublimeTextGenerator.h +++ b/Source/cmExtraSublimeTextGenerator.h @@ -18,7 +18,6 @@ class cmLocalGenerator; class cmMakefile; -class cmTarget; class cmGeneratedFileStream; class cmGeneratorTarget; @@ -67,7 +66,7 @@ private: void AppendTarget(cmGeneratedFileStream& fout, const std::string& targetName, cmLocalGenerator* lg, - cmTarget* target, + cmGeneratorTarget* target, const char* make, const cmMakefile* makefile, const char* compiler, @@ -79,11 +78,10 @@ private: */ std::string ComputeFlagsForObject(cmSourceFile *source, cmLocalGenerator* lg, - cmTarget *target, cmGeneratorTarget* gtgt); std::string ComputeDefines(cmSourceFile *source, cmLocalGenerator* lg, - cmTarget *target, cmGeneratorTarget* gtgt); + cmGeneratorTarget* gtgt); }; #endif diff --git a/Source/cmFLTKWrapUICommand.cxx b/Source/cmFLTKWrapUICommand.cxx index 12adfd9..d17d664 100644 --- a/Source/cmFLTKWrapUICommand.cxx +++ b/Source/cmFLTKWrapUICommand.cxx @@ -129,45 +129,6 @@ void cmFLTKWrapUICommand::FinalPass() cmSystemTools::Message(msg.c_str(),"Warning"); return; } - std::vector<cmSourceFile*> srcs; - target->GetSourceFiles(srcs, ""); - bool found = false; - for (unsigned int i = 0; i < srcs.size(); ++i) - { - if (srcs[i]->GetFullPath() == - this->GeneratedSourcesClasses[0]->GetFullPath()) - { - found = true; - break; - } - } - if (!found) - { - std::string msg = - "In CMake 2.2 the FLTK_WRAP_UI command sets a variable to the list of " - "source files that should be added to your executable or library. It " - "appears that you have not added these source files to your target. " - "You should change your CMakeLists.txt file to " - "directly add the generated files to the target. " - "For example FTLK_WRAP_UI(foo src1 src2 src3) " - "will create a variable named foo_FLTK_UI_SRCS that contains the list " - "of sources to add to your target when you call ADD_LIBRARY or " - "ADD_EXECUTABLE. For now CMake will add the sources to your target " - "for you as was done in CMake 2.0 and earlier. In the future this may " - "become an error."; - msg +="The problem was found while processing the source directory: "; - msg += this->Makefile->GetCurrentSourceDirectory(); - cmSystemTools::Message(msg.c_str(),"Warning"); - // first we add the rules for all the .fl to .h and .cxx files - size_t lastHeadersClass = this->GeneratedSourcesClasses.size(); - - // Generate code for all the .fl files - for(size_t classNum = 0; classNum < lastHeadersClass; classNum++) - { - this->Makefile->GetTargets()[this->Target] - .AddSource(this->GeneratedSourcesClasses[classNum]->GetFullPath()); - } - } } diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx index 87faf84..df95d9d 100644 --- a/Source/cmFileCommand.cxx +++ b/Source/cmFileCommand.cxx @@ -15,7 +15,6 @@ #include "cmHexFileConverter.h" #include "cmInstallType.h" #include "cmFileTimeComparison.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmCryptoHash.h" #include "cmAlgorithms.h" diff --git a/Source/cmFileTimeComparison.cxx b/Source/cmFileTimeComparison.cxx index 13e2a66..279b61d 100644 --- a/Source/cmFileTimeComparison.cxx +++ b/Source/cmFileTimeComparison.cxx @@ -148,7 +148,7 @@ int cmFileTimeComparisonInternal::Compare(cmFileTimeComparison_Type* s1, cmFileTimeComparison_Type* s2) { #if !defined(_WIN32) || defined(__CYGWIN__) -# if cmsys_STAT_HAS_ST_MTIM +# if CMake_STAT_HAS_ST_MTIM // Compare using nanosecond resolution. if(s1->st_mtim.tv_sec < s2->st_mtim.tv_sec) { @@ -166,6 +166,24 @@ int cmFileTimeComparisonInternal::Compare(cmFileTimeComparison_Type* s1, { return 1; } +# elif CMake_STAT_HAS_ST_MTIMESPEC + // Compare using nanosecond resolution. + if(s1->st_mtimespec.tv_sec < s2->st_mtimespec.tv_sec) + { + return -1; + } + else if(s1->st_mtimespec.tv_sec > s2->st_mtimespec.tv_sec) + { + return 1; + } + else if(s1->st_mtimespec.tv_nsec < s2->st_mtimespec.tv_nsec) + { + return -1; + } + else if(s1->st_mtimespec.tv_nsec > s2->st_mtimespec.tv_nsec) + { + return 1; + } # else // Compare using 1 second resolution. if(s1->st_mtime < s2->st_mtime) @@ -190,7 +208,7 @@ bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1, cmFileTimeComparison_Type* s2) { #if !defined(_WIN32) || defined(__CYGWIN__) -# if cmsys_STAT_HAS_ST_MTIM +# if CMake_STAT_HAS_ST_MTIM // Times are integers in units of 1ns. long long bil = 1000000000; long long t1 = s1->st_mtim.tv_sec * bil + s1->st_mtim.tv_nsec; @@ -207,6 +225,23 @@ bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1, { return false; } +# elif CMake_STAT_HAS_ST_MTIMESPEC + // Times are integers in units of 1ns. + long long bil = 1000000000; + long long t1 = s1->st_mtimespec.tv_sec * bil + s1->st_mtimespec.tv_nsec; + long long t2 = s2->st_mtimespec.tv_sec * bil + s2->st_mtimespec.tv_nsec; + if(t1 < t2) + { + return (t2 - t1) >= bil; + } + else if(t2 < t1) + { + return (t1 - t2) >= bil; + } + else + { + return false; + } # else // Times are integers in units of 1s. if(s1->st_mtime < s2->st_mtime) diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx index 7959ffe..fa9b381 100644 --- a/Source/cmFindBase.cxx +++ b/Source/cmFindBase.cxx @@ -207,6 +207,10 @@ void cmFindBase::ExpandPaths() { this->FillCMakeEnvironmentPath(); } + } + this->FillUserHintsPath(); + if(!this->NoDefaultPath) + { if(!this->NoSystemEnvironmentPath) { this->FillSystemEnvironmentPath(); @@ -216,8 +220,6 @@ void cmFindBase::ExpandPaths() this->FillCMakeSystemVariablePath(); } } - - this->FillUserHintsPath(); this->FillUserGuessPath(); } diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx index 9b9071d..64176e7 100644 --- a/Source/cmFindPackageCommand.cxx +++ b/Source/cmFindPackageCommand.cxx @@ -1133,6 +1133,10 @@ void cmFindPackageCommand::ComputePrefixes() { this->FillPrefixesCMakeEnvironment(); } + } + this->FillPrefixesUserHints(); + if(!this->NoDefaultPath) + { if(!this->NoSystemEnvironmentPath) { this->FillPrefixesSystemEnvironment(); @@ -1150,7 +1154,6 @@ void cmFindPackageCommand::ComputePrefixes() this->FillPrefixesSystemRegistry(); } } - this->FillPrefixesUserHints(); this->FillPrefixesUserGuess(); this->ComputeFinalPaths(); diff --git a/Source/cmFunctionBlocker.h b/Source/cmFunctionBlocker.h index 68bf762..a3b8078 100644 --- a/Source/cmFunctionBlocker.h +++ b/Source/cmFunctionBlocker.h @@ -39,7 +39,7 @@ public: /** Set/Get the context in which this blocker is created. */ void SetStartingContext(cmListFileContext const& lfc) { this->StartingContext = lfc; } - cmListFileContext const& GetStartingContext() + cmListFileContext const& GetStartingContext() const { return this->StartingContext; } private: cmListFileContext StartingContext; diff --git a/Source/cmGeneratedFileStream.h b/Source/cmGeneratedFileStream.h index 2aa6beb..8df3e1a 100644 --- a/Source/cmGeneratedFileStream.h +++ b/Source/cmGeneratedFileStream.h @@ -56,10 +56,10 @@ protected: // Whether the real file stream was valid when it was closed. bool Okay; - // Whether the destionation file is compressed + // Whether the destination file is compressed bool Compress; - // Whether the destionation file is compressed + // Whether the destination file is compressed bool CompressExtraExtension; }; diff --git a/Source/cmGeneratorExpression.cxx b/Source/cmGeneratorExpression.cxx index 80a4f81..6796a01 100644 --- a/Source/cmGeneratorExpression.cxx +++ b/Source/cmGeneratorExpression.cxx @@ -11,10 +11,9 @@ ============================================================================*/ #include "cmGeneratorExpression.h" -#include "cmMakefile.h" -#include "cmTarget.h" #include "assert.h" #include "cmAlgorithms.h" +#include "cmSystemTools.h" #include "cmGeneratorExpressionEvaluator.h" #include "cmGeneratorExpressionLexer.h" @@ -48,13 +47,13 @@ cmGeneratorExpression::~cmGeneratorExpression() } //---------------------------------------------------------------------------- -const char *cmCompiledGeneratorExpression::Evaluate( - cmMakefile* mf, const std::string& config, bool quiet, - cmTarget const* headTarget, +const char *cmCompiledGeneratorExpression::Evaluate(cmLocalGenerator* lg, + const std::string& config, bool quiet, + const cmGeneratorTarget* headTarget, cmGeneratorExpressionDAGChecker *dagChecker, std::string const& language) const { - return this->Evaluate(mf, + return this->Evaluate(lg, config, quiet, headTarget, @@ -65,13 +64,13 @@ const char *cmCompiledGeneratorExpression::Evaluate( //---------------------------------------------------------------------------- const char *cmCompiledGeneratorExpression::Evaluate( - cmMakefile* mf, const std::string& config, bool quiet, - cmTarget const* headTarget, - cmTarget const* currentTarget, + cmLocalGenerator* lg, const std::string& config, bool quiet, + const cmGeneratorTarget* headTarget, + const cmGeneratorTarget* currentTarget, cmGeneratorExpressionDAGChecker *dagChecker, std::string const& language) const { - cmGeneratorExpressionContext context(mf, config, quiet, headTarget, + cmGeneratorExpressionContext context(lg, config, quiet, headTarget, currentTarget ? currentTarget : headTarget, this->EvaluateForBuildsystem, this->Backtrace, language); @@ -463,10 +462,11 @@ bool cmGeneratorExpression::IsValidTargetName(const std::string &input) //---------------------------------------------------------------------------- void -cmCompiledGeneratorExpression::GetMaxLanguageStandard(cmTarget const* tgt, +cmCompiledGeneratorExpression::GetMaxLanguageStandard( + const cmGeneratorTarget* tgt, std::map<std::string, std::string>& mapping) { - typedef std::map<cmTarget const*, + typedef std::map<cmGeneratorTarget const*, std::map<std::string, std::string> > MapType; MapType::const_iterator it = this->MaxLanguageStandard.find(tgt); if (it != this->MaxLanguageStandard.end()) diff --git a/Source/cmGeneratorExpression.h b/Source/cmGeneratorExpression.h index cd19bc0..efd381b 100644 --- a/Source/cmGeneratorExpression.h +++ b/Source/cmGeneratorExpression.h @@ -19,8 +19,8 @@ #include <cmsys/RegularExpression.hxx> #include <cmsys/auto_ptr.hxx> -class cmTarget; -class cmMakefile; +class cmGeneratorTarget; +class cmLocalGenerator; class cmListFileBacktrace; struct cmGeneratorExpressionEvaluator; @@ -78,26 +78,26 @@ private: class cmCompiledGeneratorExpression { public: - const char* Evaluate(cmMakefile* mf, const std::string& config, + const char* Evaluate(cmLocalGenerator* lg, const std::string& config, bool quiet = false, - cmTarget const* headTarget = 0, - cmTarget const* currentTarget = 0, + cmGeneratorTarget const* headTarget = 0, + cmGeneratorTarget const* currentTarget = 0, cmGeneratorExpressionDAGChecker *dagChecker = 0, std::string const& language = std::string()) const; - const char* Evaluate(cmMakefile* mf, const std::string& config, + const char* Evaluate(cmLocalGenerator* lg, const std::string& config, bool quiet, - cmTarget const* headTarget, + cmGeneratorTarget const* headTarget, cmGeneratorExpressionDAGChecker *dagChecker, std::string const& language = std::string()) const; /** Get set of targets found during evaluations. */ - std::set<cmTarget*> const& GetTargets() const + std::set<cmGeneratorTarget*> const& GetTargets() const { return this->DependTargets; } std::set<std::string> const& GetSeenTargetProperties() const { return this->SeenTargetProperties; } - std::set<cmTarget const*> const& GetAllTargetsSeen() const + std::set<cmGeneratorTarget const*> const& GetAllTargetsSeen() const { return this->AllTargetsSeen; } ~cmCompiledGeneratorExpression(); @@ -119,7 +119,7 @@ public: { return this->HadHeadSensitiveCondition; } - std::set<cmTarget const*> GetSourceSensitiveTargets() const + std::set<cmGeneratorTarget const*> GetSourceSensitiveTargets() const { return this->SourceSensitiveTargets; } @@ -129,7 +129,7 @@ public: this->EvaluateForBuildsystem = eval; } - void GetMaxLanguageStandard(cmTarget const* tgt, + void GetMaxLanguageStandard(cmGeneratorTarget const* tgt, std::map<std::string, std::string>& mapping); private: @@ -149,15 +149,15 @@ private: const std::string Input; bool NeedsEvaluation; - mutable std::set<cmTarget*> DependTargets; - mutable std::set<cmTarget const*> AllTargetsSeen; + mutable std::set<cmGeneratorTarget*> DependTargets; + mutable std::set<cmGeneratorTarget const*> AllTargetsSeen; mutable std::set<std::string> SeenTargetProperties; - mutable std::map<cmTarget const*, std::map<std::string, std::string> > - MaxLanguageStandard; + mutable std::map<cmGeneratorTarget const*, + std::map<std::string, std::string> > MaxLanguageStandard; mutable std::string Output; mutable bool HadContextSensitiveCondition; mutable bool HadHeadSensitiveCondition; - mutable std::set<cmTarget const*> SourceSensitiveTargets; + mutable std::set<cmGeneratorTarget const*> SourceSensitiveTargets; bool EvaluateForBuildsystem; }; diff --git a/Source/cmGeneratorExpressionContext.cxx b/Source/cmGeneratorExpressionContext.cxx index 947015e..5c9462f 100644 --- a/Source/cmGeneratorExpressionContext.cxx +++ b/Source/cmGeneratorExpressionContext.cxx @@ -11,16 +11,17 @@ ============================================================================*/ #include "cmGeneratorExpressionContext.h" +#include "cmGeneratorTarget.h" cmGeneratorExpressionContext::cmGeneratorExpressionContext( - cmMakefile* mf, std::string const& config, - bool quiet, cmTarget const* headTarget, - cmTarget const* currentTarget, + cmLocalGenerator* lg, std::string const& config, + bool quiet, cmGeneratorTarget const* headTarget, + const cmGeneratorTarget* currentTarget, bool evaluateForBuildsystem, cmListFileBacktrace const& backtrace, std::string const& language) : Backtrace(backtrace), - Makefile(mf), + LG(lg), Config(config), Language(language), HeadTarget(headTarget), diff --git a/Source/cmGeneratorExpressionContext.h b/Source/cmGeneratorExpressionContext.h index ed83509..e802138 100644 --- a/Source/cmGeneratorExpressionContext.h +++ b/Source/cmGeneratorExpressionContext.h @@ -18,32 +18,35 @@ #include <map> #include <string> -class cmTarget; +class cmGeneratorTarget; +class cmLocalGenerator; //---------------------------------------------------------------------------- struct cmGeneratorExpressionContext { - cmGeneratorExpressionContext(cmMakefile* mf, std::string const& config, - bool quiet, cmTarget const* headTarget, - cmTarget const* currentTarget, + cmGeneratorExpressionContext(cmLocalGenerator* lg, std::string const& config, + bool quiet, const cmGeneratorTarget* headTarget, + cmGeneratorTarget const* currentTarget, bool evaluateForBuildsystem, cmListFileBacktrace const& backtrace, std::string const& language); cmListFileBacktrace Backtrace; - std::set<cmTarget*> DependTargets; - std::set<cmTarget const*> AllTargets; + std::set<cmGeneratorTarget*> DependTargets; + std::set<cmGeneratorTarget const*> AllTargets; std::set<std::string> SeenTargetProperties; - std::set<cmTarget const*> SourceSensitiveTargets; - std::map<cmTarget const*, std::map<std::string, std::string> > + std::set<cmGeneratorTarget const*> SourceSensitiveTargets; + std::map<cmGeneratorTarget const*, std::map<std::string, std::string> > MaxLanguageStandard; - cmMakefile *Makefile; + cmLocalGenerator *LG; std::string Config; std::string Language; - cmTarget const* HeadTarget; // The target whose property is being evaluated. - cmTarget const* CurrentTarget; // The dependent of HeadTarget which appears - // directly or indirectly in the property. + // The target whose property is being evaluated. + cmGeneratorTarget const* HeadTarget; + // The dependent of HeadTarget which appears + // directly or indirectly in the property. + cmGeneratorTarget const* CurrentTarget; bool Quiet; bool HadError; bool HadContextSensitiveCondition; diff --git a/Source/cmGeneratorExpressionDAGChecker.cxx b/Source/cmGeneratorExpressionDAGChecker.cxx index 851aacd..c3b0272 100644 --- a/Source/cmGeneratorExpressionDAGChecker.cxx +++ b/Source/cmGeneratorExpressionDAGChecker.cxx @@ -12,7 +12,7 @@ #include "cmGeneratorExpressionDAGChecker.h" -#include "cmMakefile.h" +#include "cmLocalGenerator.h" #include "cmAlgorithms.h" //---------------------------------------------------------------------------- @@ -110,7 +110,7 @@ void cmGeneratorExpressionDAGChecker::ReportError( << " " << expr << "\n" << "Self reference on target \"" << context->HeadTarget->GetName() << "\".\n"; - context->Makefile->GetCMakeInstance() + context->LG->GetCMakeInstance() ->IssueMessage(cmake::FATAL_ERROR, e.str(), parent->Backtrace); return; @@ -121,7 +121,7 @@ void cmGeneratorExpressionDAGChecker::ReportError( e << "Error evaluating generator expression:\n" << " " << expr << "\n" << "Dependency loop found."; - context->Makefile->GetCMakeInstance() + context->LG->GetCMakeInstance() ->IssueMessage(cmake::FATAL_ERROR, e.str(), context->Backtrace); } @@ -134,7 +134,7 @@ void cmGeneratorExpressionDAGChecker::ReportError( << " " << (parent->Content ? parent->Content->GetOriginalExpression() : expr) << "\n"; - context->Makefile->GetCMakeInstance() + context->LG->GetCMakeInstance() ->IssueMessage(cmake::FATAL_ERROR, e.str(), parent->Backtrace); parent = parent->Parent; diff --git a/Source/cmGeneratorExpressionEvaluationFile.cxx b/Source/cmGeneratorExpressionEvaluationFile.cxx index e4d9f10..4ac2a0d 100644 --- a/Source/cmGeneratorExpressionEvaluationFile.cxx +++ b/Source/cmGeneratorExpressionEvaluationFile.cxx @@ -44,7 +44,7 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg, std::string rawCondition = this->Condition->GetInput(); if (!rawCondition.empty()) { - std::string condResult = this->Condition->Evaluate(lg->GetMakefile(), + std::string condResult = this->Condition->Evaluate(lg, config, false, 0, 0, 0, lang); if (condResult == "0") @@ -62,10 +62,10 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg, } const std::string outputFileName - = this->OutputFileExpr->Evaluate(lg->GetMakefile(), config, + = this->OutputFileExpr->Evaluate(lg, config, false, 0, 0, 0, lang); const std::string outputContent - = inputExpression->Evaluate(lg->GetMakefile(), + = inputExpression->Evaluate(lg, config, false, 0, 0, 0, lang); @@ -110,7 +110,7 @@ void cmGeneratorExpressionEvaluationFile::CreateOutputFile( for(std::vector<std::string>::const_iterator le = enabledLanguages.begin(); le != enabledLanguages.end(); ++le) { - std::string name = this->OutputFileExpr->Evaluate(lg->GetMakefile(), + std::string name = this->OutputFileExpr->Evaluate(lg, config, false, 0, 0, 0, *le); cmSourceFile* sf = lg->GetMakefile()->GetOrCreateSource(name); @@ -139,7 +139,7 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator *lg) { std::ostringstream e; e << "Evaluation file \"" << this->Input << "\" cannot be read."; - lg->GetMakefile()->IssueMessage(cmake::FATAL_ERROR, e.str()); + lg->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } diff --git a/Source/cmGeneratorExpressionEvaluator.h b/Source/cmGeneratorExpressionEvaluator.h index 7c1bd8c..407f83f 100644 --- a/Source/cmGeneratorExpressionEvaluator.h +++ b/Source/cmGeneratorExpressionEvaluator.h @@ -12,13 +12,11 @@ #ifndef cmGeneratorExpressionEvaluator_h #define cmGeneratorExpressionEvaluator_h -#include <vector> -#include <string> - #include "cmListFileCache.h" #include "cmGeneratorExpressionContext.h" -class cmTarget; +#include <vector> +#include <string> struct cmGeneratorExpressionDAGChecker; struct cmGeneratorExpressionNode; diff --git a/Source/cmGeneratorExpressionNode.cxx b/Source/cmGeneratorExpressionNode.cxx index 31b6766..32b2f82 100644 --- a/Source/cmGeneratorExpressionNode.cxx +++ b/Source/cmGeneratorExpressionNode.cxx @@ -13,18 +13,21 @@ #include "cmGeneratorExpressionNode.h" #include "cmGlobalGenerator.h" #include "cmAlgorithms.h" +#include "cmOutputConverter.h" +#include "cmMakefile.h" //---------------------------------------------------------------------------- std::string cmGeneratorExpressionNode::EvaluateDependentExpression( - std::string const& prop, cmMakefile *makefile, + std::string const& prop, cmLocalGenerator *lg, cmGeneratorExpressionContext *context, - cmTarget const* headTarget, cmTarget const* currentTarget, + cmGeneratorTarget const* headTarget, + cmGeneratorTarget const* currentTarget, cmGeneratorExpressionDAGChecker *dagChecker) { cmGeneratorExpression ge(context->Backtrace); cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop); cge->SetEvaluateForBuildsystem(context->EvaluateForBuildsystem); - std::string result = cge->Evaluate(makefile, + std::string result = cge->Evaluate(lg, context->Config, context->Quiet, headTarget, @@ -366,7 +369,8 @@ struct CompilerIdNode : public cmGeneratorExpressionNode const std::string &lang) const { const char *compilerId = - context->Makefile->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID"); + context->LG->GetMakefile() + ->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID"); if (parameters.empty()) { return compilerId ? compilerId : ""; @@ -390,13 +394,13 @@ struct CompilerIdNode : public cmGeneratorExpressionNode if (cmsysString_strcasecmp(parameters.begin()->c_str(), compilerId) == 0) { - switch(context->Makefile->GetPolicyStatus(cmPolicies::CMP0044)) + switch(context->LG->GetPolicyStatus(cmPolicies::CMP0044)) { case cmPolicies::WARN: { std::ostringstream e; e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0044); - context->Makefile->GetCMakeInstance() + context->LG->GetCMakeInstance() ->IssueMessage(cmake::AUTHOR_WARNING, e.str(), context->Backtrace); } @@ -469,8 +473,9 @@ struct CompilerVersionNode : public cmGeneratorExpressionNode cmGeneratorExpressionDAGChecker *, const std::string &lang) const { - const char *compilerVersion = context->Makefile->GetSafeDefinition( - "CMAKE_" + lang + "_COMPILER_VERSION"); + const char *compilerVersion = + context->LG->GetMakefile()->GetSafeDefinition( + "CMAKE_" + lang + "_COMPILER_VERSION"); if (parameters.empty()) { return compilerVersion ? compilerVersion : ""; @@ -552,7 +557,7 @@ struct PlatformIdNode : public cmGeneratorExpressionNode cmGeneratorExpressionDAGChecker *) const { const char *platformId = - context->Makefile->GetSafeDefinition("CMAKE_SYSTEM_NAME"); + context->LG->GetMakefile()->GetSafeDefinition("CMAKE_SYSTEM_NAME"); if (parameters.empty()) { return platformId ? platformId : ""; @@ -701,7 +706,7 @@ static const struct ConfigurationTestNode : public cmGeneratorExpressionNode const char* loc = 0; const char* imp = 0; std::string suffix; - if (context->CurrentTarget->GetMappedConfig(context->Config, + if (context->CurrentTarget->Target->GetMappedConfig(context->Config, &loc, &imp, suffix)) @@ -767,7 +772,7 @@ static const struct CompileLanguageNode : public cmGeneratorExpressionNode } std::vector<std::string> enabledLanguages; - cmGlobalGenerator* gg = context->Makefile->GetGlobalGenerator(); + cmGlobalGenerator* gg = context->LG->GetGlobalGenerator(); gg->GetEnabledLanguages(enabledLanguages); if (!parameters.empty() && std::find(enabledLanguages.begin(), enabledLanguages.end(), @@ -830,8 +835,8 @@ template <typename T> std::string getLinkedTargetsContent( std::vector<T> const &libraries, - cmTarget const* target, - cmTarget const* headTarget, + cmGeneratorTarget const* target, + cmGeneratorTarget const* headTarget, cmGeneratorExpressionContext *context, cmGeneratorExpressionDAGChecker *dagChecker, const std::string &interfacePropertyName) @@ -857,8 +862,10 @@ getLinkedTargetsContent( { linkedTargetsContent = cmGeneratorExpressionNode::EvaluateDependentExpression(depString, - target->GetMakefile(), context, - headTarget, target, dagChecker); + target->GetLocalGenerator(), + context, + headTarget, + target, dagChecker); } linkedTargetsContent = cmGeneratorExpression::StripEmptyListElements(linkedTargetsContent); @@ -887,7 +894,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode } static cmsys::RegularExpression propertyNameValidator("^[A-Za-z0-9_]+$"); - cmTarget const* target = context->HeadTarget; + cmGeneratorTarget const* target = context->HeadTarget; std::string propertyName = *parameters.begin(); if (parameters.size() == 1) @@ -937,16 +944,17 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode } if(propertyName == "ALIASED_TARGET") { - if(context->Makefile->IsAlias(targetName)) + if(context->LG->GetMakefile()->IsAlias(targetName)) { - if(cmTarget* tgt = context->Makefile->FindTargetToUse(targetName)) + if(cmGeneratorTarget* tgt = + context->LG->FindGeneratorTargetToUse(targetName)) { return tgt->GetName(); } } return ""; } - target = context->Makefile->FindTargetToUse(targetName); + target = context->LG->FindGeneratorTargetToUse(targetName); if (!target) { @@ -990,9 +998,6 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode assert(target); - cmGeneratorTarget* gtgt = - context->Makefile->GetGlobalGenerator()->GetGeneratorTarget(target); - if (propertyName == "LINKER_LANGUAGE") { if (target->LinkLanguagePropagatesToDependents() && @@ -1004,7 +1009,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode "link libraries for a static library"); return std::string(); } - return gtgt->GetLinkerLanguage(context->Config); + return target->GetLinkerLanguage(context->Config); } cmGeneratorExpressionDAGChecker dagChecker(context->Backtrace, @@ -1096,20 +1101,21 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode "COMPILE_DEFINITIONS_")) { cmPolicies::PolicyStatus polSt = - context->Makefile->GetPolicyStatus(cmPolicies::CMP0043); + context->LG->GetPolicyStatus(cmPolicies::CMP0043); if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD) { interfacePropertyName = "INTERFACE_COMPILE_DEFINITIONS"; } } #undef POPULATE_INTERFACE_PROPERTY_NAME - cmTarget const* headTarget = context->HeadTarget && isInterfaceProperty + cmGeneratorTarget const* headTarget = + context->HeadTarget && isInterfaceProperty ? context->HeadTarget : target; if(isInterfaceProperty) { if(cmLinkInterfaceLibraries const* iface = - gtgt->GetLinkInterfaceLibraries(context->Config, headTarget, true)) + target->GetLinkInterfaceLibraries(context->Config, headTarget, true)) { linkedTargetsContent = getLinkedTargetsContent(iface->Libraries, target, @@ -1134,44 +1140,44 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode if (!prop) { if (target->IsImported() - || target->GetType() == cmTarget::INTERFACE_LIBRARY) + || target->GetType() == cmState::INTERFACE_LIBRARY) { return linkedTargetsContent; } - if (gtgt->IsLinkInterfaceDependentBoolProperty(propertyName, + if (target->IsLinkInterfaceDependentBoolProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; - return gtgt->GetLinkInterfaceDependentBoolProperty( + return target->GetLinkInterfaceDependentBoolProperty( propertyName, context->Config) ? "1" : "0"; } - if (gtgt->IsLinkInterfaceDependentStringProperty(propertyName, + if (target->IsLinkInterfaceDependentStringProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; const char *propContent = - gtgt->GetLinkInterfaceDependentStringProperty( + target->GetLinkInterfaceDependentStringProperty( propertyName, context->Config); return propContent ? propContent : ""; } - if (gtgt->IsLinkInterfaceDependentNumberMinProperty(propertyName, + if (target->IsLinkInterfaceDependentNumberMinProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; const char *propContent = - gtgt->GetLinkInterfaceDependentNumberMinProperty( + target->GetLinkInterfaceDependentNumberMinProperty( propertyName, context->Config); return propContent ? propContent : ""; } - if (gtgt->IsLinkInterfaceDependentNumberMaxProperty(propertyName, + if (target->IsLinkInterfaceDependentNumberMaxProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; const char *propContent = - gtgt->GetLinkInterfaceDependentNumberMaxProperty( + target->GetLinkInterfaceDependentNumberMaxProperty( propertyName, context->Config); return propContent ? propContent : ""; @@ -1183,22 +1189,22 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode if (!target->IsImported() && dagCheckerParent && !dagCheckerParent->EvaluatingLinkLibraries()) { - if (gtgt->IsLinkInterfaceDependentNumberMinProperty(propertyName, + if (target->IsLinkInterfaceDependentNumberMinProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; const char *propContent = - gtgt->GetLinkInterfaceDependentNumberMinProperty( + target->GetLinkInterfaceDependentNumberMinProperty( propertyName, context->Config); return propContent ? propContent : ""; } - if (gtgt->IsLinkInterfaceDependentNumberMaxProperty(propertyName, + if (target->IsLinkInterfaceDependentNumberMaxProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; const char *propContent = - gtgt->GetLinkInterfaceDependentNumberMaxProperty( + target->GetLinkInterfaceDependentNumberMaxProperty( propertyName, context->Config); return propContent ? propContent : ""; @@ -1207,7 +1213,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode if(!interfacePropertyName.empty()) { std::string result = this->EvaluateDependentExpression(prop, - context->Makefile, context, + context->LG, context, headTarget, target, &dagChecker); if (!linkedTargetsContent.empty()) { @@ -1263,7 +1269,7 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode std::string tgtName = parameters.front(); cmGeneratorTarget* gt = - context->Makefile->FindGeneratorTargetToUse(tgtName); + context->LG->FindGeneratorTargetToUse(tgtName); if (!gt) { std::ostringstream e; @@ -1272,7 +1278,7 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode reportError(context, content->GetOriginalExpression(), e.str()); return std::string(); } - if (gt->GetType() != cmTarget::OBJECT_LIBRARY) + if (gt->GetType() != cmState::OBJECT_LIBRARY) { std::ostringstream e; e << "Objects of target \"" << tgtName @@ -1306,7 +1312,8 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode assert(!map_it->second.empty()); result += sep; std::string objFile = obj_dir + map_it->second; - cmSourceFile* sf = context->Makefile->GetOrCreateSource(objFile, true); + cmSourceFile* sf = + context->LG->GetMakefile()->GetOrCreateSource(objFile, true); sf->SetObjectLibrary(tgtName); sf->SetProperty("EXTERNAL_OBJECT", "1"); result += objFile; @@ -1328,7 +1335,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode const GeneratorExpressionContent *content, cmGeneratorExpressionDAGChecker *dagChecker) const { - cmTarget const* target = context->HeadTarget; + cmGeneratorTarget const* target = context->HeadTarget; if (!target) { reportError(context, content->GetOriginalExpression(), @@ -1348,7 +1355,8 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode { std::string error; std::string lang; - if (!context->Makefile->CompileFeatureKnown(context->HeadTarget, + if (!context->LG->GetMakefile()->CompileFeatureKnown( + context->HeadTarget->Target, *it, lang, &error)) { reportError(context, content->GetOriginalExpression(), error); @@ -1359,7 +1367,8 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode if (availableFeatures.find(lang) == availableFeatures.end()) { const char* featuresKnown - = context->Makefile->CompileFeaturesAvailable(lang, &error); + = context->LG->GetMakefile()->CompileFeaturesAvailable(lang, + &error); if (!featuresKnown) { reportError(context, content->GetOriginalExpression(), error); @@ -1377,7 +1386,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode { std::vector<std::string> const& langAvailable = availableFeatures[lit->first]; - const char* standardDefault = context->Makefile + const char* standardDefault = context->LG->GetMakefile() ->GetDefinition("CMAKE_" + lit->first + "_STANDARD_DEFAULT"); for (std::vector<std::string>::const_iterator it = lit->second.begin(); it != lit->second.end(); ++it) @@ -1393,7 +1402,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode // All features known for the language are always available. continue; } - if (!context->Makefile->HaveStandardAvailable(target, + if (!context->LG->GetMakefile()->HaveStandardAvailable(target->Target, lit->first, *it)) { if (evalLL) @@ -1428,7 +1437,7 @@ static const char* targetPolicyWhitelist[] = { #undef TARGET_POLICY_STRING }; -cmPolicies::PolicyStatus statusForTarget(cmTarget const* tgt, +cmPolicies::PolicyStatus statusForTarget(cmGeneratorTarget const* tgt, const char *policy) { #define RETURN_POLICY(POLICY) \ @@ -1489,11 +1498,11 @@ static const struct TargetPolicyNode : public cmGeneratorExpressionNode const char *policy = targetPolicyWhitelist[i]; if (parameters.front() == policy) { - cmMakefile *mf = context->HeadTarget->GetMakefile(); + cmLocalGenerator* lg = context->HeadTarget->GetLocalGenerator(); switch(statusForTarget(context->HeadTarget, policy)) { case cmPolicies::WARN: - mf->IssueMessage(cmake::AUTHOR_WARNING, + lg->IssueMessage(cmake::AUTHOR_WARNING, cmPolicies::GetPolicyWarning(policyForString(policy))); case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: @@ -1571,21 +1580,21 @@ struct TargetFilesystemArtifactResultCreator<ArtifactSonameTag> const GeneratorExpressionContent *content) { // The target soname file (.so.1). - if(target->Target->IsDLLPlatform()) + if(target->IsDLLPlatform()) { ::reportError(context, content->GetOriginalExpression(), "TARGET_SONAME_FILE is not allowed " "for DLL target platforms."); return std::string(); } - if(target->GetType() != cmTarget::SHARED_LIBRARY) + if(target->GetType() != cmState::SHARED_LIBRARY) { ::reportError(context, content->GetOriginalExpression(), "TARGET_SONAME_FILE is allowed only for " "SHARED libraries."); return std::string(); } - std::string result = target->Target->GetDirectory(context->Config); + std::string result = target->GetDirectory(context->Config); result += "/"; result += target->GetSOName(context->Config); return result; @@ -1611,18 +1620,18 @@ struct TargetFilesystemArtifactResultCreator<ArtifactPdbTag> std::string pdbSupportVar = "CMAKE_" + language + "_LINKER_SUPPORTS_PDB"; - if(!context->Makefile->IsOn(pdbSupportVar)) + if(!context->LG->GetMakefile()->IsOn(pdbSupportVar)) { ::reportError(context, content->GetOriginalExpression(), "TARGET_PDB_FILE is not supported by the target linker."); return std::string(); } - cmTarget::TargetType targetType = target->Target->GetType(); + cmState::TargetType targetType = target->GetType(); - if(targetType != cmTarget::SHARED_LIBRARY && - targetType != cmTarget::MODULE_LIBRARY && - targetType != cmTarget::EXECUTABLE) + if(targetType != cmState::SHARED_LIBRARY && + targetType != cmState::MODULE_LIBRARY && + targetType != cmState::EXECUTABLE) { ::reportError(context, content->GetOriginalExpression(), "TARGET_PDB_FILE is allowed only for " @@ -1630,7 +1639,7 @@ struct TargetFilesystemArtifactResultCreator<ArtifactPdbTag> return std::string(); } - std::string result = target->Target->GetPDBDirectory(context->Config); + std::string result = target->GetPDBDirectory(context->Config); result += "/"; result += target->GetPDBName(context->Config); return result; @@ -1646,7 +1655,7 @@ struct TargetFilesystemArtifactResultCreator<ArtifactLinkerTag> const GeneratorExpressionContent *content) { // The file used to link to the target (.so, .lib, .a). - if(!target->Target->IsLinkable()) + if(!target->IsLinkable()) { ::reportError(context, content->GetOriginalExpression(), "TARGET_LINKER_FILE is allowed only for libraries and " @@ -1654,7 +1663,7 @@ struct TargetFilesystemArtifactResultCreator<ArtifactLinkerTag> return std::string(); } return target->GetFullPath(context->Config, - target->Target->HasImportLibrary()); + target->HasImportLibrary()); } }; @@ -1725,15 +1734,15 @@ struct TargetFilesystemArtifact : public cmGeneratorExpressionNode return std::string(); } cmGeneratorTarget* target = - context->Makefile->FindGeneratorTargetToUse(name); + context->LG->FindGeneratorTargetToUse(name); if(!target) { ::reportError(context, content->GetOriginalExpression(), "No target \"" + name + "\""); return std::string(); } - if(target->GetType() >= cmTarget::OBJECT_LIBRARY && - target->GetType() != cmTarget::UNKNOWN_LIBRARY) + if(target->GetType() >= cmState::OBJECT_LIBRARY && + target->GetType() != cmState::UNKNOWN_LIBRARY) { ::reportError(context, content->GetOriginalExpression(), "Target \"" + name + "\" is not an executable or library."); @@ -1748,8 +1757,8 @@ struct TargetFilesystemArtifact : public cmGeneratorExpressionNode "be used while evaluating link libraries"); return std::string(); } - context->DependTargets.insert(target->Target); - context->AllTargets.insert(target->Target); + context->DependTargets.insert(target); + context->AllTargets.insert(target); std::string result = TargetFilesystemArtifactResultCreator<ArtifactT>::Create( @@ -1792,6 +1801,27 @@ static const TargetFilesystemArtifactNodeGroup<ArtifactPdbTag> targetPdbNodeGroup; //---------------------------------------------------------------------------- +static const struct ShellPathNode : public cmGeneratorExpressionNode +{ + ShellPathNode() {} + + std::string Evaluate(const std::vector<std::string> ¶meters, + cmGeneratorExpressionContext *context, + const GeneratorExpressionContent *content, + cmGeneratorExpressionDAGChecker *) const + { + if (!cmSystemTools::FileIsFullPath(parameters.front())) + { + reportError(context, content->GetOriginalExpression(), + "\"" + parameters.front() + "\" is not an absolute path."); + return std::string(); + } + cmOutputConverter converter(context->LG->GetStateSnapshot()); + return converter.ConvertDirectorySeparatorsForShell(parameters.front()); + } +} shellPathNode; + +//---------------------------------------------------------------------------- const cmGeneratorExpressionNode* cmGeneratorExpressionNode::GetNode(const std::string &identifier) { @@ -1846,6 +1876,7 @@ cmGeneratorExpressionNode::GetNode(const std::string &identifier) nodeMap["JOIN"] = &joinNode; nodeMap["LINK_ONLY"] = &linkOnlyNode; nodeMap["COMPILE_LANGUAGE"] = &languageNode; + nodeMap["SHELL_PATH"] = &shellPathNode; } NodeMap::const_iterator i = nodeMap.find(identifier); if (i == nodeMap.end()) @@ -1869,7 +1900,7 @@ void reportError(cmGeneratorExpressionContext *context, e << "Error evaluating generator expression:\n" << " " << expr << "\n" << result; - context->Makefile->GetCMakeInstance() + context->LG->GetCMakeInstance() ->IssueMessage(cmake::FATAL_ERROR, e.str(), context->Backtrace); } diff --git a/Source/cmGeneratorExpressionNode.h b/Source/cmGeneratorExpressionNode.h index 847a00a..854811b 100644 --- a/Source/cmGeneratorExpressionNode.h +++ b/Source/cmGeneratorExpressionNode.h @@ -12,8 +12,6 @@ #ifndef cmGeneratorExpressionNode_h #define cmGeneratorExpressionNode_h -#include "cmMakefile.h" - #include "cmGeneratorExpressionEvaluator.h" #include "cmGeneratorExpressionParser.h" #include "cmGeneratorExpressionDAGChecker.h" @@ -54,9 +52,10 @@ struct cmGeneratorExpressionNode ) const = 0; static std::string EvaluateDependentExpression( - std::string const& prop, cmMakefile *makefile, + std::string const& prop, cmLocalGenerator *lg, cmGeneratorExpressionContext *context, - cmTarget const* headTarget, cmTarget const* currentTarget, + const cmGeneratorTarget* headTarget, + const cmGeneratorTarget* currentTarget, cmGeneratorExpressionDAGChecker *dagChecker); static const cmGeneratorExpressionNode* GetNode( diff --git a/Source/cmGeneratorExpressionParser.h b/Source/cmGeneratorExpressionParser.h index 28f1441..5bd6777 100644 --- a/Source/cmGeneratorExpressionParser.h +++ b/Source/cmGeneratorExpressionParser.h @@ -19,8 +19,6 @@ #include "cmListFileCache.h" -class cmMakefile; -class cmTarget; struct cmGeneratorExpressionEvaluator; //---------------------------------------------------------------------------- diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx index 09387b7..1f74eda 100644 --- a/Source/cmGeneratorTarget.cxx +++ b/Source/cmGeneratorTarget.cxx @@ -62,7 +62,7 @@ void reportBadObjLib(std::vector<cmSourceFile*> const& badObjLib, e << "but may contain only sources that compile, header files, and " "other files that would not affect linking of a normal library."; cm->IssueMessage(cmake::FATAL_ERROR, e.str(), - target->Target->GetBacktrace()); + target->GetBacktrace()); } } @@ -75,6 +75,7 @@ struct IDLSourcesTag {}; struct ResxTag {}; struct ModuleDefinitionFileTag {}; struct AppManifestTag{}; +struct ManifestsTag{}; struct CertificatesTag{}; struct XamlTag{}; @@ -154,7 +155,7 @@ struct TagVisitor : Data(data), Target(target), GlobalGenerator(target->GetLocalGenerator()->GetGlobalGenerator()), Header(CM_HEADER_REGEX), - IsObjLib(target->GetType() == cmTarget::OBJECT_LIBRARY) + IsObjLib(target->GetType() == cmState::OBJECT_LIBRARY) { } @@ -171,7 +172,7 @@ struct TagVisitor { DoAccept<IsSameTag<Tag, CustomCommandsTag>::Result>::Do(this->Data, sf); } - else if(this->Target->GetType() == cmTarget::UTILITY) + else if(this->Target->GetType() == cmState::UTILITY) { DoAccept<IsSameTag<Tag, ExtraSourcesTag>::Result>::Do(this->Data, sf); } @@ -216,6 +217,10 @@ struct TagVisitor { DoAccept<IsSameTag<Tag, AppManifestTag>::Result>::Do(this->Data, sf); } + else if (ext == "manifest") + { + DoAccept<IsSameTag<Tag, ManifestsTag>::Result>::Do(this->Data, sf); + } else if (ext == "pfx") { DoAccept<IsSameTag<Tag, CertificatesTag>::Result>::Do(this->Data, sf); @@ -264,12 +269,17 @@ cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg) DebugIncludesDone(false), DebugCompileOptionsDone(false), DebugCompileFeaturesDone(false), - DebugCompileDefinitionsDone(false) + DebugCompileDefinitionsDone(false), + DebugSourcesDone(false), + LinkImplementationLanguageIsContextDependent(true), + UtilityItemsDone(false) { this->Makefile = this->Target->GetMakefile(); this->LocalGenerator = lg; this->GlobalGenerator = this->LocalGenerator->GetGlobalGenerator(); + this->GlobalGenerator->ComputeTargetObjectDirectory(this); + CreatePropertyGeneratorExpressions( t->GetIncludeDirectoriesEntries(), t->GetIncludeDirectoriesBacktraces(), @@ -289,6 +299,17 @@ cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg) t->GetCompileDefinitionsEntries(), t->GetCompileDefinitionsBacktraces(), this->CompileDefinitionsEntries); + + CreatePropertyGeneratorExpressions( + t->GetSourceEntries(), + t->GetSourceBacktraces(), + this->SourceEntries, true); + + this->DLLPlatform = (this->Makefile->IsOn("WIN32") || + this->Makefile->IsOn("CYGWIN") || + this->Makefile->IsOn("MINGW")); + + this->PolicyMap = t->PolicyMap; } cmGeneratorTarget::~cmGeneratorTarget() @@ -297,6 +318,7 @@ cmGeneratorTarget::~cmGeneratorTarget() cmDeleteAll(this->CompileOptionsEntries); cmDeleteAll(this->CompileFeaturesEntries); cmDeleteAll(this->CompileDefinitionsEntries); + cmDeleteAll(this->SourceEntries); cmDeleteAll(this->LinkInformation); this->LinkInformation.clear(); } @@ -307,7 +329,7 @@ cmLocalGenerator* cmGeneratorTarget::GetLocalGenerator() const } //---------------------------------------------------------------------------- -int cmGeneratorTarget::GetType() const +cmState::TargetType cmGeneratorTarget::GetType() const { return this->Target->GetType(); } @@ -319,12 +341,88 @@ std::string cmGeneratorTarget::GetName() const } //---------------------------------------------------------------------------- +std::string cmGeneratorTarget::GetExportName() const +{ + const char *exportName = this->GetProperty("EXPORT_NAME"); + + if (exportName && *exportName) + { + if (!cmGeneratorExpression::IsValidTargetName(exportName)) + { + std::ostringstream e; + e << "EXPORT_NAME property \"" << exportName << "\" for \"" + << this->GetName() << "\": is not valid."; + cmSystemTools::Error(e.str().c_str()); + return ""; + } + return exportName; + } + return this->GetName(); +} + +//---------------------------------------------------------------------------- const char *cmGeneratorTarget::GetProperty(const std::string& prop) const { return this->Target->GetProperty(prop); } //---------------------------------------------------------------------------- +const char* cmGeneratorTarget::GetOutputTargetType(bool implib) const +{ + switch(this->GetType()) + { + case cmState::SHARED_LIBRARY: + if(this->IsDLLPlatform()) + { + if(implib) + { + // A DLL import library is treated as an archive target. + return "ARCHIVE"; + } + else + { + // A DLL shared library is treated as a runtime target. + return "RUNTIME"; + } + } + else + { + // For non-DLL platforms shared libraries are treated as + // library targets. + return "LIBRARY"; + } + case cmState::STATIC_LIBRARY: + // Static libraries are always treated as archive targets. + return "ARCHIVE"; + case cmState::MODULE_LIBRARY: + if(implib) + { + // Module libraries are always treated as library targets. + return "ARCHIVE"; + } + else + { + // Module import libraries are treated as archive targets. + return "LIBRARY"; + } + case cmState::EXECUTABLE: + if(implib) + { + // Executable import libraries are treated as archive targets. + return "ARCHIVE"; + } + else + { + // Executables are always treated as runtime targets. + return "RUNTIME"; + } + default: + break; + } + return ""; +} + +//---------------------------------------------------------------------------- std::string cmGeneratorTarget::GetOutputName(const std::string& config, bool implib) const { @@ -340,7 +438,7 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config, // Compute output name. std::vector<std::string> props; - std::string type = this->Target->GetOutputTargetType(implib); + std::string type = this->GetOutputTargetType(implib); std::string configUpper = cmSystemTools::UpperCase(config); if(!type.empty() && !configUpper.empty()) { @@ -366,7 +464,7 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config, for(std::vector<std::string>::const_iterator it = props.begin(); it != props.end(); ++it) { - if (const char* outNameProp = this->Target->GetProperty(*it)) + if (const char* outNameProp = this->GetProperty(*it)) { outName = outNameProp; break; @@ -381,35 +479,67 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config, // Now evaluate genex and update the previously-prepared map entry. cmGeneratorExpression ge; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outName); - i->second = cge->Evaluate(this->Makefile, config); + i->second = cge->Evaluate(this->LocalGenerator, config); } else if(i->second.empty()) { // An empty map entry indicates we have been called recursively // from the above block. - this->Makefile->GetCMakeInstance()->IssueMessage( + this->LocalGenerator->GetCMakeInstance() + ->IssueMessage( cmake::FATAL_ERROR, "Target '" + this->GetName() + "' OUTPUT_NAME depends on itself.", - this->Target->GetBacktrace()); + this->GetBacktrace()); } return i->second; } +void cmGeneratorTarget::AddSource(const std::string& src) +{ + this->Target->AddSource(src); + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + cmGeneratorExpression ge(lfbt); + cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(src); + cge->SetEvaluateForBuildsystem(true); + this->SourceEntries.push_back( + new TargetPropertyEntry(cge)); + this->SourceFilesMap.clear(); + this->LinkImplementationLanguageIsContextDependent = true; +} + +void cmGeneratorTarget::AddTracedSources(std::vector<std::string> const& srcs) +{ + this->Target->AddTracedSources(srcs); + if (!srcs.empty()) + { + std::string srcFiles = cmJoin(srcs, ";"); + this->SourceFilesMap.clear(); + this->LinkImplementationLanguageIsContextDependent = true; + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + cmGeneratorExpression ge(lfbt); + cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles); + cge->SetEvaluateForBuildsystem(true); + this->SourceEntries.push_back( + new cmGeneratorTarget::TargetPropertyEntry(cge)); + } +} + //---------------------------------------------------------------------------- std::vector<cmSourceFile*> const* cmGeneratorTarget::GetSourceDepends(cmSourceFile const* sf) const { - SourceEntriesType::const_iterator i = this->SourceEntries.find(sf); - if(i != this->SourceEntries.end()) + SourceEntriesType::const_iterator i = this->SourceDepends.find(sf); + if(i != this->SourceDepends.end()) { return &i->second.Depends; } return 0; } -static void handleSystemIncludesDep(cmMakefile *mf, cmTarget const* depTgt, +static void handleSystemIncludesDep(cmLocalGenerator *lg, + cmGeneratorTarget const* depTgt, const std::string& config, - cmTarget *headTarget, + cmGeneratorTarget const* headTarget, cmGeneratorExpressionDAGChecker *dagChecker, std::vector<std::string>& result, bool excludeImported) @@ -419,7 +549,7 @@ static void handleSystemIncludesDep(cmMakefile *mf, cmTarget const* depTgt, { cmGeneratorExpression ge; cmSystemTools::ExpandListArgument(ge.Parse(dirs) - ->Evaluate(mf, + ->Evaluate(lg, config, false, headTarget, depTgt, dagChecker), result); } @@ -433,7 +563,7 @@ static void handleSystemIncludesDep(cmMakefile *mf, cmTarget const* depTgt, { cmGeneratorExpression ge; cmSystemTools::ExpandListArgument(ge.Parse(dirs) - ->Evaluate(mf, + ->Evaluate(lg, config, false, headTarget, depTgt, dagChecker), result); } @@ -442,7 +572,7 @@ static void handleSystemIncludesDep(cmMakefile *mf, cmTarget const* depTgt, #define IMPLEMENT_VISIT_IMPL(DATA, DATATYPE) \ { \ std::vector<cmSourceFile*> sourceFiles; \ - this->Target->GetSourceFiles(sourceFiles, config); \ + this->GetSourceFiles(sourceFiles, config); \ TagVisitor<DATA ## Tag DATATYPE> visitor(this, data); \ for(std::vector<cmSourceFile*>::const_iterator si = sourceFiles.begin(); \ si != sourceFiles.end(); ++si) \ @@ -510,12 +640,12 @@ const char* cmGeneratorTarget::GetFeature(const std::string& feature, std::string featureConfig = feature; featureConfig += "_"; featureConfig += cmSystemTools::UpperCase(config); - if(const char* value = this->Target->GetProperty(featureConfig)) + if(const char* value = this->GetProperty(featureConfig)) { return value; } } - if(const char* value = this->Target->GetProperty(feature)) + if(const char* value = this->GetProperty(feature)) { return value; } @@ -626,6 +756,15 @@ cmGeneratorTarget //---------------------------------------------------------------------------- void cmGeneratorTarget +::GetManifests(std::vector<cmSourceFile const*>& data, + const std::string& config) const +{ + IMPLEMENT_VISIT(Manifests); +} + +//---------------------------------------------------------------------------- +void +cmGeneratorTarget ::GetCertificates(std::vector<cmSourceFile const*>& data, const std::string& config) const { @@ -649,7 +788,24 @@ cmGeneratorTarget::GetExpectedXamlSources(std::set<std::string>& srcs, { XamlData data; IMPLEMENT_VISIT_IMPL(Xaml, COMMA cmGeneratorTarget::XamlData) - srcs = data.ExpectedXamlSources; + srcs = data.ExpectedXamlSources; +} + +std::set<cmLinkItem> const& cmGeneratorTarget::GetUtilityItems() const +{ + if(!this->UtilityItemsDone) + { + this->UtilityItemsDone = true; + std::set<std::string> const& utilities = this->GetUtilities(); + for(std::set<std::string>::const_iterator i = utilities.begin(); + i != utilities.end(); ++i) + { + cmGeneratorTarget* gt = + this->LocalGenerator->FindGeneratorTargetToUse(*i); + this->UtilityItems.insert(cmLinkItem(*i, gt)); + } + } + return this->UtilityItems; } //---------------------------------------------------------------------------- @@ -666,7 +822,7 @@ void cmGeneratorTarget const char* cmGeneratorTarget::GetLocation(const std::string& config) const { static std::string location; - if (this->Target->IsImported()) + if (this->IsImported()) { location = this->Target->ImportedGetFullPath(config, false); } @@ -677,11 +833,34 @@ const char* cmGeneratorTarget::GetLocation(const std::string& config) const return location.c_str(); } +std::vector<cmCustomCommand> const& +cmGeneratorTarget::GetPreBuildCommands() const +{ + return this->Target->GetPreBuildCommands(); +} + +std::vector<cmCustomCommand> const& +cmGeneratorTarget::GetPreLinkCommands() const +{ + return this->Target->GetPreLinkCommands(); +} + +std::vector<cmCustomCommand> const& +cmGeneratorTarget::GetPostBuildCommands() const +{ + return this->Target->GetPostBuildCommands(); +} + bool cmGeneratorTarget::IsImported() const { return this->Target->IsImported(); } +bool cmGeneratorTarget::IsImportedGloballyVisible() const +{ + return this->Target->IsImportedGloballyVisible(); +} + //---------------------------------------------------------------------------- const char* cmGeneratorTarget::GetLocationForBuild() const { @@ -693,7 +872,7 @@ const char* cmGeneratorTarget::GetLocationForBuild() const } // Now handle the deprecated build-time configuration location. - location = this->Target->GetDirectory(); + location = this->GetDirectory(); const char* cfgid = this->Makefile->GetDefinition("CMAKE_CFG_INTDIR"); if(cfgid && strcmp(cfgid, ".") != 0) { @@ -701,7 +880,7 @@ const char* cmGeneratorTarget::GetLocationForBuild() const location += cfgid; } - if(this->Target->IsAppBundleOnApple()) + if(this->IsAppBundleOnApple()) { std::string macdir = this->BuildMacContentDirectory("", "", false); @@ -721,7 +900,7 @@ const char* cmGeneratorTarget::GetLocationForBuild() const bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir, const std::string& config) const { - assert(this->GetType() != cmTarget::INTERFACE_LIBRARY); + assert(this->GetType() != cmState::INTERFACE_LIBRARY); std::string config_upper; if(!config.empty()) { @@ -739,7 +918,7 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir, "SYSTEM_INCLUDE_DIRECTORIES", 0, 0); bool excludeImported - = this->Target->GetPropertyAsBool("NO_SYSTEM_FROM_IMPORTED"); + = this->GetPropertyAsBool("NO_SYSTEM_FROM_IMPORTED"); std::vector<std::string> result; for (std::set<std::string>::const_iterator @@ -748,17 +927,17 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir, { cmGeneratorExpression ge; cmSystemTools::ExpandListArgument(ge.Parse(*it) - ->Evaluate(this->Makefile, - config, false, this->Target, + ->Evaluate(this->LocalGenerator, + config, false, this, &dagChecker), result); } - std::vector<cmTarget const*> const& deps = + std::vector<cmGeneratorTarget const*> const& deps = this->GetLinkImplementationClosure(config); - for(std::vector<cmTarget const*>::const_iterator + for(std::vector<cmGeneratorTarget const*>::const_iterator li = deps.begin(), le = deps.end(); li != le; ++li) { - handleSystemIncludesDep(this->Makefile, *li, config, this->Target, + handleSystemIncludesDep(this->LocalGenerator, *li, config, this, &dagChecker, result, excludeImported); } @@ -786,10 +965,258 @@ bool cmGeneratorTarget::GetPropertyAsBool(const std::string& prop) const } //---------------------------------------------------------------------------- +static void AddInterfaceEntries( + cmGeneratorTarget const* thisTarget, std::string const& config, + std::string const& prop, + std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries) +{ + if(cmLinkImplementationLibraries const* impl = + thisTarget->GetLinkImplementationLibraries(config)) + { + for (std::vector<cmLinkImplItem>::const_iterator + it = impl->Libraries.begin(), end = impl->Libraries.end(); + it != end; ++it) + { + if(it->Target) + { + std::string genex = + "$<TARGET_PROPERTY:" + *it + "," + prop + ">"; + cmGeneratorExpression ge(it->Backtrace); + cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex); + cge->SetEvaluateForBuildsystem(true); + entries.push_back( + new cmGeneratorTarget::TargetPropertyEntry(cge, *it)); + } + } + } +} + +//---------------------------------------------------------------------------- +static bool processSources(cmGeneratorTarget const* tgt, + const std::vector<cmGeneratorTarget::TargetPropertyEntry*> &entries, + std::vector<std::string> &srcs, + UNORDERED_SET<std::string> &uniqueSrcs, + cmGeneratorExpressionDAGChecker *dagChecker, + std::string const& config, bool debugSources) +{ + cmMakefile *mf = tgt->Target->GetMakefile(); + + bool contextDependent = false; + + for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator + it = entries.begin(), end = entries.end(); it != end; ++it) + { + cmLinkImplItem const& item = (*it)->LinkImplItem; + std::string const& targetName = item; + std::vector<std::string> entrySources; + cmSystemTools::ExpandListArgument((*it)->ge->Evaluate( + tgt->GetLocalGenerator(), + config, + false, + tgt, + tgt, + dagChecker), + entrySources); + + if ((*it)->ge->GetHadContextSensitiveCondition()) + { + contextDependent = true; + } + + for(std::vector<std::string>::iterator i = entrySources.begin(); + i != entrySources.end(); ++i) + { + std::string& src = *i; + cmSourceFile* sf = mf->GetOrCreateSource(src); + std::string e; + std::string fullPath = sf->GetFullPath(&e); + if(fullPath.empty()) + { + if(!e.empty()) + { + cmake* cm = tgt->GetLocalGenerator()->GetCMakeInstance(); + cm->IssueMessage(cmake::FATAL_ERROR, e, + tgt->GetBacktrace()); + } + return contextDependent; + } + + if (!targetName.empty() && !cmSystemTools::FileIsFullPath(src.c_str())) + { + std::ostringstream err; + if (!targetName.empty()) + { + err << "Target \"" << targetName << "\" contains relative " + "path in its INTERFACE_SOURCES:\n" + " \"" << src << "\""; + } + else + { + err << "Found relative path while evaluating sources of " + "\"" << tgt->GetName() << "\":\n \"" << src << "\"\n"; + } + tgt->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, err.str()); + return contextDependent; + } + src = fullPath; + } + std::string usedSources; + for(std::vector<std::string>::iterator + li = entrySources.begin(); li != entrySources.end(); ++li) + { + std::string src = *li; + + if(uniqueSrcs.insert(src).second) + { + srcs.push_back(src); + if (debugSources) + { + usedSources += " * " + src + "\n"; + } + } + } + if (!usedSources.empty()) + { + tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(cmake::LOG, + std::string("Used sources for target ") + + tgt->GetName() + ":\n" + + usedSources, (*it)->ge->GetBacktrace()); + } + } + return contextDependent; +} + +//---------------------------------------------------------------------------- +void cmGeneratorTarget::GetSourceFiles(std::vector<std::string> &files, + const std::string& config) const +{ + assert(this->GetType() != cmState::INTERFACE_LIBRARY); + + if (!this->LocalGenerator->GetGlobalGenerator()->GetConfigureDoneCMP0026()) + { + // At configure-time, this method can be called as part of getting the + // LOCATION property or to export() a file to be include()d. However + // there is no cmGeneratorTarget at configure-time, so search the SOURCES + // for TARGET_OBJECTS instead for backwards compatibility with OLD + // behavior of CMP0024 and CMP0026 only. + + cmStringRange sourceEntries = this->Target->GetSourceEntries(); + for(cmStringRange::const_iterator + i = sourceEntries.begin(); + i != sourceEntries.end(); ++i) + { + std::string const& entry = *i; + + std::vector<std::string> items; + cmSystemTools::ExpandListArgument(entry, items); + for (std::vector<std::string>::const_iterator + li = items.begin(); li != items.end(); ++li) + { + if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") && + (*li)[li->size() - 1] == '>') + { + continue; + } + files.push_back(*li); + } + } + return; + } + + std::vector<std::string> debugProperties; + const char *debugProp = + this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES"); + if (debugProp) + { + cmSystemTools::ExpandListArgument(debugProp, debugProperties); + } + + bool debugSources = !this->DebugSourcesDone + && std::find(debugProperties.begin(), + debugProperties.end(), + "SOURCES") + != debugProperties.end(); + + if (this->LocalGenerator->GetGlobalGenerator()->GetConfigureDoneCMP0026()) + { + this->DebugSourcesDone = true; + } + + cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), + "SOURCES", 0, 0); + + UNORDERED_SET<std::string> uniqueSrcs; + bool contextDependentDirectSources = processSources(this, + this->SourceEntries, + files, + uniqueSrcs, + &dagChecker, + config, + debugSources); + + std::vector<cmGeneratorTarget::TargetPropertyEntry*> + linkInterfaceSourcesEntries; + + AddInterfaceEntries( + this, config, "INTERFACE_SOURCES", + linkInterfaceSourcesEntries); + + std::vector<std::string>::size_type numFilesBefore = files.size(); + bool contextDependentInterfaceSources = processSources(this, + linkInterfaceSourcesEntries, + files, + uniqueSrcs, + &dagChecker, + config, + debugSources); + + if (!contextDependentDirectSources + && !(contextDependentInterfaceSources && numFilesBefore < files.size())) + { + this->LinkImplementationLanguageIsContextDependent = false; + } + + cmDeleteAll(linkInterfaceSourcesEntries); +} + +//---------------------------------------------------------------------------- void cmGeneratorTarget::GetSourceFiles(std::vector<cmSourceFile*> &files, const std::string& config) const { - this->Target->GetSourceFiles(files, config); + + // Lookup any existing link implementation for this configuration. + std::string key = cmSystemTools::UpperCase(config); + + if(!this->LinkImplementationLanguageIsContextDependent) + { + files = this->SourceFilesMap.begin()->second; + return; + } + + SourceFilesMapType::iterator + it = this->SourceFilesMap.find(key); + if(it != this->SourceFilesMap.end()) + { + files = it->second; + } + else + { + std::vector<std::string> srcs; + this->GetSourceFiles(srcs, config); + + std::set<cmSourceFile*> emitted; + + for(std::vector<std::string>::const_iterator i = srcs.begin(); + i != srcs.end(); ++i) + { + cmSourceFile* sf = this->Makefile->GetOrCreateSource(*i); + if (emitted.insert(sf).second) + { + files.push_back(sf); + } + } + this->SourceFilesMap[key] = files; + } } //---------------------------------------------------------------------------- @@ -805,13 +1232,13 @@ cmGeneratorTarget::GetCompilePDBName(const std::string& config) const std::string configUpper = cmSystemTools::UpperCase(config); std::string configProp = "COMPILE_PDB_NAME_"; configProp += configUpper; - const char* config_name = this->Target->GetProperty(configProp); + const char* config_name = this->GetProperty(configProp); if(config_name && *config_name) { return prefix + config_name + ".pdb"; } - const char* name = this->Target->GetProperty("COMPILE_PDB_NAME"); + const char* name = this->GetProperty("COMPILE_PDB_NAME"); if(name && *name) { return prefix + name + ".pdb"; @@ -828,7 +1255,7 @@ cmGeneratorTarget::GetCompilePDBPath(const std::string& config) const std::string name = this->GetCompilePDBName(config); if(dir.empty() && !name.empty()) { - dir = this->Target->GetPDBDirectory(config); + dir = this->GetPDBDirectory(config); } if(!dir.empty()) { @@ -842,7 +1269,7 @@ bool cmGeneratorTarget::HasSOName(const std::string& config) const { // soname is supported only for shared libraries and modules, // and then only when the platform supports an soname flag. - return ((this->GetType() == cmTarget::SHARED_LIBRARY) && + return ((this->GetType() == cmState::SHARED_LIBRARY) && !this->GetPropertyAsBool("NO_SONAME") && this->Makefile->GetSONameFlag(this->GetLinkerLanguage(config))); } @@ -853,9 +1280,9 @@ cmGeneratorTarget::NeedRelinkBeforeInstall(const std::string& config) const { // Only executables and shared libraries can have an rpath and may // need relinking. - if(this->GetType() != cmTarget::EXECUTABLE && - this->GetType() != cmTarget::SHARED_LIBRARY && - this->GetType() != cmTarget::MODULE_LIBRARY) + if(this->GetType() != cmState::EXECUTABLE && + this->GetType() != cmState::SHARED_LIBRARY && + this->GetType() != cmState::MODULE_LIBRARY) { return false; } @@ -910,16 +1337,16 @@ cmGeneratorTarget::NeedRelinkBeforeInstall(const std::string& config) const // will likely change between the build tree and install tree and // this target must be relinked. return this->HaveBuildTreeRPATH(config) - || this->Target->HaveInstallTreeRPATH(); + || this->HaveInstallTreeRPATH(); } //---------------------------------------------------------------------------- bool cmGeneratorTarget::IsChrpathUsed(const std::string& config) const { // Only certain target types have an rpath. - if(!(this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY || - this->GetType() == cmTarget::EXECUTABLE)) + if(!(this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY || + this->GetType() == cmState::EXECUTABLE)) { return false; } @@ -980,14 +1407,144 @@ bool cmGeneratorTarget::IsChrpathUsed(const std::string& config) const return false; } +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsImportedSharedLibWithoutSOName( + const std::string& config) const +{ + if(this->IsImported() && this->GetType() == cmState::SHARED_LIBRARY) + { + if(cmGeneratorTarget::ImportInfo const* info = + this->GetImportInfo(config)) + { + return info->NoSOName; + } + } + return false; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::HasMacOSXRpathInstallNameDir( + const std::string& config) const +{ + bool install_name_is_rpath = false; + bool macosx_rpath = false; + + if(!this->IsImported()) + { + if(this->GetType() != cmState::SHARED_LIBRARY) + { + return false; + } + const char* install_name = this->GetProperty("INSTALL_NAME_DIR"); + bool use_install_name = + this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH"); + if(install_name && use_install_name && + std::string(install_name) == "@rpath") + { + install_name_is_rpath = true; + } + else if(install_name && use_install_name) + { + return false; + } + if(!install_name_is_rpath) + { + macosx_rpath = this->MacOSXRpathInstallNameDirDefault(); + } + } + else + { + // Lookup the imported soname. + if(cmGeneratorTarget::ImportInfo const* info = + this->GetImportInfo(config)) + { + if(!info->NoSOName && !info->SOName.empty()) + { + if(info->SOName.find("@rpath/") == 0) + { + install_name_is_rpath = true; + } + } + else + { + std::string install_name; + cmSystemTools::GuessLibraryInstallName(info->Location, install_name); + if(install_name.find("@rpath") != std::string::npos) + { + install_name_is_rpath = true; + } + } + } + } + + if(!install_name_is_rpath && !macosx_rpath) + { + return false; + } + + if(!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG")) + { + std::ostringstream w; + w << "Attempting to use"; + if(macosx_rpath) + { + w << " MACOSX_RPATH"; + } + else + { + w << " @rpath"; + } + w << " without CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG being set."; + w << " This could be because you are using a Mac OS X version"; + w << " less than 10.5 or because CMake's platform configuration is"; + w << " corrupt."; + cmake* cm = this->LocalGenerator->GetCMakeInstance(); + cm->IssueMessage(cmake::FATAL_ERROR, w.str(), + this->GetBacktrace()); + } + + return true; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::MacOSXRpathInstallNameDirDefault() const +{ + // we can't do rpaths when unsupported + if(!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG")) + { + return false; + } + + const char* macosx_rpath_str = this->GetProperty("MACOSX_RPATH"); + if(macosx_rpath_str) + { + return this->GetPropertyAsBool("MACOSX_RPATH"); + } + + cmPolicies::PolicyStatus cmp0042 = this->GetPolicyStatusCMP0042(); + + if(cmp0042 == cmPolicies::WARN) + { + this->LocalGenerator->GetGlobalGenerator()-> + AddCMP0042WarnTarget(this->GetName()); + } + + if(cmp0042 == cmPolicies::NEW) + { + return true; + } + + return false; +} //---------------------------------------------------------------------------- std::string cmGeneratorTarget::GetSOName(const std::string& config) const { - if(this->Target->IsImported()) + if(this->IsImported()) { // Lookup the imported soname. - if(cmTarget::ImportInfo const* info = this->Target->GetImportInfo(config)) + if(cmGeneratorTarget::ImportInfo const* info = + this->GetImportInfo(config)) { if(info->NoSOName) { @@ -1044,9 +1601,9 @@ cmGeneratorTarget::GetAppBundleDirectory(const std::string& config, //---------------------------------------------------------------------------- bool cmGeneratorTarget::IsBundleOnApple() const { - return this->Target->IsFrameworkOnApple() - || this->Target->IsAppBundleOnApple() - || this->Target->IsCFBundleOnApple(); + return this->IsFrameworkOnApple() + || this->IsAppBundleOnApple() + || this->IsCFBundleOnApple(); } //---------------------------------------------------------------------------- @@ -1056,10 +1613,10 @@ std::string cmGeneratorTarget::GetCFBundleDirectory(const std::string& config, std::string fpath; fpath += this->GetOutputName(config, false); fpath += "."; - const char *ext = this->Target->GetProperty("BUNDLE_EXTENSION"); + const char *ext = this->GetProperty("BUNDLE_EXTENSION"); if (!ext) { - if (this->Target->IsXCTestOnApple()) + if (this->IsXCTestOnApple()) { ext = "xctest"; } @@ -1089,7 +1646,7 @@ cmGeneratorTarget::GetFrameworkDirectory(const std::string& config, if(!rootDir && !this->Makefile->PlatformIsAppleIos()) { fpath += "/Versions/"; - fpath += this->Target->GetFrameworkVersion(); + fpath += this->GetFrameworkVersion(); } return fpath; } @@ -1098,9 +1655,9 @@ cmGeneratorTarget::GetFrameworkDirectory(const std::string& config, std::string cmGeneratorTarget::GetFullName(const std::string& config, bool implib) const { - if(this->Target->IsImported()) + if(this->IsImported()) { - return this->Target->GetFullNameImported(config, implib); + return this->GetFullNameImported(config, implib); } else { @@ -1126,13 +1683,13 @@ cmGeneratorTarget::GetInstallNameDirForBuildTree( !this->GetPropertyAsBool("SKIP_BUILD_RPATH")) { std::string dir; - if(this->Target->MacOSXRpathInstallNameDirDefault()) + if(this->MacOSXRpathInstallNameDirDefault()) { dir = "@rpath"; } else { - dir = this->Target->GetDirectory(config); + dir = this->GetDirectory(config); } dir += "/"; return dir; @@ -1162,7 +1719,7 @@ std::string cmGeneratorTarget::GetInstallNameDirForInstallTree() const } if(!install_name_dir) { - if(this->Target->MacOSXRpathInstallNameDirDefault()) + if(this->MacOSXRpathInstallNameDirDefault()) { dir = "@rpath/"; } @@ -1175,6 +1732,63 @@ std::string cmGeneratorTarget::GetInstallNameDirForInstallTree() const } } +cmListFileBacktrace cmGeneratorTarget::GetBacktrace() const +{ + return this->Target->GetBacktrace(); +} + +const std::vector<std::string>&cmGeneratorTarget::GetLinkDirectories() const +{ + return this->Target->GetLinkDirectories(); +} + +const std::set<std::string>& cmGeneratorTarget::GetUtilities() const +{ + return this->Target->GetUtilities(); +} + +const cmListFileBacktrace* +cmGeneratorTarget::GetUtilityBacktrace(const std::string& u) const +{ + return this->Target->GetUtilityBacktrace(u); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::HaveWellDefinedOutputFiles() const +{ + return + this->GetType() == cmState::STATIC_LIBRARY || + this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY || + this->GetType() == cmState::EXECUTABLE; +} + +//---------------------------------------------------------------------------- +const char* cmGeneratorTarget::GetExportMacro() const +{ + // Define the symbol for targets that export symbols. + if(this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY || + this->IsExecutableWithExports()) + { + if(const char* custom_export_name = this->GetProperty("DEFINE_SYMBOL")) + { + this->ExportMacro = custom_export_name; + } + else + { + std::string in = this->GetName(); + in += "_EXPORTS"; + this->ExportMacro = cmSystemTools::MakeCidentifier(in); + } + return this->ExportMacro.c_str(); + } + else + { + return 0; + } +} + //---------------------------------------------------------------------------- class cmTargetCollectLinkLanguages { @@ -1182,10 +1796,10 @@ public: cmTargetCollectLinkLanguages(cmGeneratorTarget const* target, const std::string& config, UNORDERED_SET<std::string>& languages, - cmTarget const* head): + cmGeneratorTarget const* head): Config(config), Languages(languages), HeadTarget(head), - Makefile(target->Target->GetMakefile()), Target(target) - { this->Visited.insert(target->Target); } + Target(target) + { this->Visited.insert(target); } void Visit(cmLinkItem const& item) { @@ -1196,7 +1810,8 @@ public: bool noMessage = false; cmake::MessageType messageType = cmake::FATAL_ERROR; std::stringstream e; - switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0028)) + switch(this->Target->GetLocalGenerator() + ->GetPolicyStatus(cmPolicies::CMP0028)) { case cmPolicies::WARN: { @@ -1220,8 +1835,8 @@ public: << "\" but the target was not found. Perhaps a find_package() " "call is missing for an IMPORTED target, or an ALIAS target is " "missing?"; - this->Makefile->GetCMakeInstance()->IssueMessage( - messageType, e.str(), this->Target->Target->GetBacktrace()); + this->Target->GetLocalGenerator()->GetCMakeInstance()->IssueMessage( + messageType, e.str(), this->Target->GetBacktrace()); } } return; @@ -1230,11 +1845,8 @@ public: { return; } - cmGeneratorTarget* gtgt = - this->Target->GetLocalGenerator()->GetGlobalGenerator() - ->GetGeneratorTarget(item.Target); cmLinkInterface const* iface = - gtgt->GetLinkInterface(this->Config, this->HeadTarget); + item.Target->GetLinkInterface(this->Config, this->HeadTarget); if(!iface) { return; } for(std::vector<std::string>::const_iterator @@ -1252,10 +1864,9 @@ public: private: std::string Config; UNORDERED_SET<std::string>& Languages; - cmTarget const* HeadTarget; - cmMakefile* Makefile; + cmGeneratorTarget const* HeadTarget; const cmGeneratorTarget* Target; - std::set<cmTarget const*> Visited; + std::set<cmGeneratorTarget const*> Visited; }; //---------------------------------------------------------------------------- @@ -1280,14 +1891,12 @@ class cmTargetSelectLinker { int Preference; cmGeneratorTarget const* Target; - cmMakefile* Makefile; cmGlobalGenerator* GG; std::set<std::string> Preferred; public: cmTargetSelectLinker(cmGeneratorTarget const* target) : Preference(0), Target(target) { - this->Makefile = this->Target->Makefile; this->GG = this->Target->GetLocalGenerator()->GetGlobalGenerator(); } void Consider(const char* lang) @@ -1321,9 +1930,9 @@ public: e << " " << *li << "\n"; } e << "Set the LINKER_LANGUAGE property for this target."; - cmake* cm = this->Makefile->GetCMakeInstance(); + cmake* cm = this->Target->GetLocalGenerator()->GetCMakeInstance(); cm->IssueMessage(cmake::FATAL_ERROR, e.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } return *this->Preferred.begin(); } @@ -1345,7 +1954,7 @@ void cmGeneratorTarget::ComputeLinkClosure(const std::string& config, } // Add interface languages from linked targets. - cmTargetCollectLinkLanguages cll(this, config, languages, this->Target); + cmTargetCollectLinkLanguages cll(this, config, languages, this); for(std::vector<cmLinkImplItem>::const_iterator li = impl->Libraries.begin(); li != impl->Libraries.end(); ++li) { @@ -1412,15 +2021,15 @@ cmGeneratorTarget::BuildMacContentDirectory(const std::string& base, bool contentOnly) const { std::string fpath = base; - if(this->Target->IsAppBundleOnApple()) + if(this->IsAppBundleOnApple()) { fpath += this->GetAppBundleDirectory(config, contentOnly); } - if(this->Target->IsFrameworkOnApple()) + if(this->IsFrameworkOnApple()) { fpath += this->GetFrameworkDirectory(config, contentOnly); } - if(this->Target->IsCFBundleOnApple()) + if(this->IsCFBundleOnApple()) { fpath += this->GetCFBundleDirectory(config, contentOnly); } @@ -1433,10 +2042,10 @@ cmGeneratorTarget::GetMacContentDirectory(const std::string& config, bool implib) const { // Start with the output directory for the target. - std::string fpath = this->Target->GetDirectory(config, implib); + std::string fpath = this->GetDirectory(config, implib); fpath += "/"; bool contentOnly = true; - if(this->Target->IsFrameworkOnApple()) + if(this->IsFrameworkOnApple()) { // additional files with a framework go into the version specific // directory @@ -1457,12 +2066,12 @@ cmGeneratorTarget::CompileInfo const* cmGeneratorTarget::GetCompileInfo( return 0; } - if(this->GetType() > cmTarget::OBJECT_LIBRARY) + if(this->GetType() > cmState::OBJECT_LIBRARY) { std::string msg = "cmTarget::GetCompileInfo called for "; msg += this->GetName(); msg += " which has type "; - msg += cmTarget::GetTargetTypeName(this->Target->GetType()); + msg += cmState::GetTargetTypeName(this->GetType()); this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg); return 0; } @@ -1478,8 +2087,7 @@ cmGeneratorTarget::CompileInfo const* cmGeneratorTarget::GetCompileInfo( if(i == this->CompileInfoMap.end()) { CompileInfo info; - this->Target - ->ComputePDBOutputDir("COMPILE_PDB", config, info.CompilePdbDir); + this->ComputePDBOutputDir("COMPILE_PDB", config, info.CompilePdbDir); CompileInfoMapType::value_type entry(config_upper, info); i = this->CompileInfoMap.insert(entry).first; } @@ -1495,6 +2103,11 @@ cmGeneratorTarget::GetModuleDefinitionFile(const std::string& config) const return data; } +bool cmGeneratorTarget::IsDLLPlatform() const +{ + return this->DLLPlatform; +} + //---------------------------------------------------------------------------- void cmGeneratorTarget::UseObjectLibraries(std::vector<std::string>& objs, @@ -1502,27 +2115,26 @@ cmGeneratorTarget::UseObjectLibraries(std::vector<std::string>& objs, { std::vector<cmSourceFile const*> objectFiles; this->GetExternalObjects(objectFiles, config); - std::vector<cmTarget*> objectLibraries; + std::vector<cmGeneratorTarget*> objectLibraries; for(std::vector<cmSourceFile const*>::const_iterator it = objectFiles.begin(); it != objectFiles.end(); ++it) { std::string objLib = (*it)->GetObjectLibrary(); - if (cmTarget* tgt = this->Makefile->FindTargetToUse(objLib)) + if (cmGeneratorTarget* tgt = + this->LocalGenerator->FindGeneratorTargetToUse(objLib)) { objectLibraries.push_back(tgt); } } - std::vector<cmTarget*>::const_iterator end + std::vector<cmGeneratorTarget*>::const_iterator end = cmRemoveDuplicates(objectLibraries); - for(std::vector<cmTarget*>::const_iterator + for(std::vector<cmGeneratorTarget*>::const_iterator ti = objectLibraries.begin(); ti != end; ++ti) { - cmTarget* objLib = *ti; - cmGeneratorTarget* ogt = - this->GlobalGenerator->GetGeneratorTarget(objLib); + cmGeneratorTarget* ogt = *ti; std::vector<cmSourceFile const*> objectSources; ogt->GetObjectSources(objectSources, config); for(std::vector<cmSourceFile const*>::const_iterator @@ -1553,28 +2165,27 @@ void cmGeneratorTarget::GetAutoUicOptions(std::vector<std::string> &result, this->GetName(), "AUTOUIC_OPTIONS", 0, 0); cmSystemTools::ExpandListArgument(ge.Parse(prop) - ->Evaluate(this->Makefile, + ->Evaluate(this->LocalGenerator, config, false, - this->Target, + this, &dagChecker), result); } //---------------------------------------------------------------------------- void processILibs(const std::string& config, - cmTarget const* headTarget, + cmGeneratorTarget const* headTarget, cmLinkItem const& item, cmGlobalGenerator* gg, - std::vector<cmTarget const*>& tgts, - std::set<cmTarget const*>& emitted) + std::vector<cmGeneratorTarget const*>& tgts, + std::set<cmGeneratorTarget const*>& emitted) { if (item.Target && emitted.insert(item.Target).second) { tgts.push_back(item.Target); - cmGeneratorTarget* gt = gg->GetGeneratorTarget(item.Target); if(cmLinkInterfaceLibraries const* iface = - gt->GetLinkInterfaceLibraries(config, headTarget, true)) + item.Target->GetLinkInterfaceLibraries(config, headTarget, true)) { for(std::vector<cmLinkItem>::const_iterator it = iface->Libraries.begin(); @@ -1587,7 +2198,7 @@ void processILibs(const std::string& config, } //---------------------------------------------------------------------------- -const std::vector<const cmTarget*>& +const std::vector<const cmGeneratorTarget*>& cmGeneratorTarget::GetLinkImplementationClosure( const std::string& config) const { @@ -1596,16 +2207,16 @@ cmGeneratorTarget::GetLinkImplementationClosure( if(!tgts.Done) { tgts.Done = true; - std::set<cmTarget const*> emitted; + std::set<cmGeneratorTarget const*> emitted; cmLinkImplementationLibraries const* impl - = this->Target->GetLinkImplementationLibraries(config); + = this->GetLinkImplementationLibraries(config); for(std::vector<cmLinkImplItem>::const_iterator it = impl->Libraries.begin(); it != impl->Libraries.end(); ++it) { - processILibs(config, this->Target, *it, + processILibs(config, this, *it, this->LocalGenerator->GetGlobalGenerator(), tgts , emitted); } @@ -1620,9 +2231,9 @@ public: cmTargetTraceDependencies(cmGeneratorTarget* target); void Trace(); private: - cmTarget* Target; cmGeneratorTarget* GeneratorTarget; cmMakefile* Makefile; + cmLocalGenerator* LocalGenerator; cmGlobalGenerator const* GlobalGenerator; typedef cmGeneratorTarget::SourceEntry SourceEntry; SourceEntry* CurrentEntry; @@ -1646,15 +2257,16 @@ private: //---------------------------------------------------------------------------- cmTargetTraceDependencies ::cmTargetTraceDependencies(cmGeneratorTarget* target): - Target(target->Target), GeneratorTarget(target) + GeneratorTarget(target) { // Convenience. - this->Makefile = this->Target->GetMakefile(); - this->GlobalGenerator = target->GetLocalGenerator()->GetGlobalGenerator(); + this->Makefile = target->Target->GetMakefile(); + this->LocalGenerator = target->GetLocalGenerator(); + this->GlobalGenerator = this->LocalGenerator->GetGlobalGenerator(); this->CurrentEntry = 0; // Queue all the source files already specified for the target. - if (this->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + if (target->GetType() != cmState::INTERFACE_LIBRARY) { std::vector<std::string> configs; this->Makefile->GetConfigurations(configs); @@ -1667,14 +2279,14 @@ cmTargetTraceDependencies ci != configs.end(); ++ci) { std::vector<cmSourceFile*> sources; - this->Target->GetSourceFiles(sources, *ci); + this->GeneratorTarget->GetSourceFiles(sources, *ci); for(std::vector<cmSourceFile*>::const_iterator si = sources.begin(); si != sources.end(); ++si) { cmSourceFile* sf = *si; - const std::set<cmTarget const*> tgts = + const std::set<cmGeneratorTarget const*> tgts = this->GlobalGenerator->GetFilenameTargetDepends(sf); - if (tgts.find(this->Target) != tgts.end()) + if (tgts.find(this->GeneratorTarget) != tgts.end()) { std::ostringstream e; e << "Evaluation output file\n \"" << sf->GetFullPath() @@ -1693,9 +2305,12 @@ cmTargetTraceDependencies } // Queue pre-build, pre-link, and post-build rule dependencies. - this->CheckCustomCommands(this->Target->GetPreBuildCommands()); - this->CheckCustomCommands(this->Target->GetPreLinkCommands()); - this->CheckCustomCommands(this->Target->GetPostBuildCommands()); + this->CheckCustomCommands( + this->GeneratorTarget->GetPreBuildCommands()); + this->CheckCustomCommands( + this->GeneratorTarget->GetPreLinkCommands()); + this->CheckCustomCommands( + this->GeneratorTarget->GetPostBuildCommands()); } //---------------------------------------------------------------------------- @@ -1707,7 +2322,7 @@ void cmTargetTraceDependencies::Trace() // Get the next source from the queue. cmSourceFile* sf = this->SourceQueue.front(); this->SourceQueue.pop(); - this->CurrentEntry = &this->GeneratorTarget->SourceEntries[sf]; + this->CurrentEntry = &this->GeneratorTarget->SourceDepends[sf]; // Queue dependencies added explicitly by the user. if(const char* additionalDeps = sf->GetProperty("OBJECT_DEPENDS")) @@ -1739,7 +2354,7 @@ void cmTargetTraceDependencies::Trace() } this->CurrentEntry = 0; - this->Target->AddTracedSources(this->NewSources); + this->GeneratorTarget->AddTracedSources(this->NewSources); } //---------------------------------------------------------------------------- @@ -1804,15 +2419,16 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep) // Check for a target with this name. if(cmGeneratorTarget* t - = this->Makefile->FindGeneratorTargetToUse(util)) + = this->GeneratorTarget-> + GetLocalGenerator()->FindGeneratorTargetToUse(util)) { // If we find the target and the dep was given as a full path, // then make sure it was not a full path to something else, and // the fact that the name matched a target was just a coincidence. if(cmSystemTools::FileIsFullPath(dep.c_str())) { - if(t->GetType() >= cmTarget::EXECUTABLE && - t->GetType() <= cmTarget::MODULE_LIBRARY) + if(t->GetType() >= cmState::EXECUTABLE && + t->GetType() <= cmState::MODULE_LIBRARY) { // This is really only for compatibility so we do not need to // worry about configuration names and output names. @@ -1823,7 +2439,7 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep) tLocation = cmSystemTools::CollapseFullPath(tLocation); if(depLocation == tLocation) { - this->Target->AddUtility(util); + this->GeneratorTarget->Target->AddUtility(util); return true; } } @@ -1832,7 +2448,7 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep) { // The original name of the dependency was not a full path. It // must name a target, so add the target-level dependency. - this->Target->AddUtility(util); + this->GeneratorTarget->Target->AddUtility(util); return true; } } @@ -1851,22 +2467,23 @@ cmTargetTraceDependencies cmGeneratorExpression ge(cc.GetBacktrace()); // Add target-level dependencies referenced by generator expressions. - std::set<cmTarget*> targets; + std::set<cmGeneratorTarget*> targets; for(cmCustomCommandLines::const_iterator cit = cc.GetCommandLines().begin(); cit != cc.GetCommandLines().end(); ++cit) { std::string const& command = *cit->begin(); // Check for a target with this name. - if(cmTarget* t = this->Makefile->FindTargetToUse(command)) + if(cmGeneratorTarget* t = + this->LocalGenerator->FindGeneratorTargetToUse(command)) { - if(t->GetType() == cmTarget::EXECUTABLE) + if(t->GetType() == cmState::EXECUTABLE) { // The command refers to an executable target built in // this project. Add the target-level dependency to make // sure the executable is up to date before this custom // command possibly runs. - this->Target->AddUtility(command); + this->GeneratorTarget->Target->AddUtility(command); } } @@ -1876,16 +2493,16 @@ cmTargetTraceDependencies { const cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*cli); - cge->Evaluate(this->Makefile, "", true); - std::set<cmTarget*> geTargets = cge->GetTargets(); + cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "", true); + std::set<cmGeneratorTarget*> geTargets = cge->GetTargets(); targets.insert(geTargets.begin(), geTargets.end()); } } - for(std::set<cmTarget*>::iterator ti = targets.begin(); + for(std::set<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ++ti) { - this->Target->AddUtility((*ti)->GetName()); + this->GeneratorTarget->Target->AddUtility((*ti)->GetName()); } // Queue the custom command dependencies. @@ -1948,7 +2565,7 @@ void cmGeneratorTarget::TraceDependencies() // would find nothing anyway, but when building CMake itself the "install" // target command ends up referencing the "cmake" target but we do not // really want the dependency because "install" depend on "all" anyway. - if(this->GetType() == cmTarget::GLOBAL_TARGET) + if(this->GetType() == cmState::GLOBAL_TARGET) { return; } @@ -1977,11 +2594,11 @@ void cmGeneratorTarget::GetAppleArchs(const std::string& config, { std::string defVarName = "OSX_ARCHITECTURES_"; defVarName += cmSystemTools::UpperCase(config); - archs = this->Target->GetProperty(defVarName); + archs = this->GetProperty(defVarName); } if(!archs) { - archs = this->Target->GetProperty("OSX_ARCHITECTURES"); + archs = this->GetProperty("OSX_ARCHITECTURES"); } if(archs) { @@ -1996,7 +2613,7 @@ cmGeneratorTarget::GetCreateRuleVariable(std::string const& lang, { switch(this->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: { std::string var = "CMAKE_" + lang + "_CREATE_STATIC_LIBRARY"; if(this->GetFeatureAsBool( @@ -2010,11 +2627,11 @@ cmGeneratorTarget::GetCreateRuleVariable(std::string const& lang, } return var; } - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return "CMAKE_" + lang + "_CREATE_SHARED_LIBRARY"; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: return "CMAKE_" + lang + "_CREATE_SHARED_MODULE"; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return "CMAKE_" + lang + "_LINK_EXECUTABLE"; default: break; @@ -2030,8 +2647,6 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, const std::string& config, bool debugIncludes, const std::string& language) { - cmMakefile *mf = tgt->Target->GetMakefile(); - for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator it = entries.begin(), end = entries.end(); it != end; ++it) { @@ -2040,10 +2655,11 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, bool const fromImported = item.Target && item.Target->IsImported(); bool const checkCMP0027 = item.FromGenex; std::vector<std::string> entryIncludes; - cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(mf, + cmSystemTools::ExpandListArgument((*it)->ge->Evaluate( + tgt->GetLocalGenerator(), config, false, - tgt->Target, + tgt, dagChecker, language), entryIncludes); @@ -2058,7 +2674,7 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, cmake::MessageType messageType = cmake::FATAL_ERROR; if (checkCMP0027) { - switch(tgt->Target->GetPolicyStatusCMP0027()) + switch(tgt->GetPolicyStatusCMP0027()) { case cmPolicies::WARN: e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0027) << "\n"; @@ -2097,7 +2713,7 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, } else { - switch(tgt->Target->GetPolicyStatusCMP0021()) + switch(tgt->GetPolicyStatusCMP0021()) { case cmPolicies::WARN: { @@ -2143,7 +2759,7 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, } if (!usedIncludes.empty()) { - mf->GetCMakeInstance()->IssueMessage(cmake::LOG, + tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(cmake::LOG, std::string("Used includes for target ") + tgt->GetName() + ":\n" + usedIncludes, (*it)->ge->GetBacktrace()); @@ -2151,34 +2767,6 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, } } - -//---------------------------------------------------------------------------- -static void AddInterfaceEntries( - cmGeneratorTarget const* thisTarget, std::string const& config, - std::string const& prop, - std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries) -{ - if(cmLinkImplementationLibraries const* impl = - thisTarget->Target->GetLinkImplementationLibraries(config)) - { - for (std::vector<cmLinkImplItem>::const_iterator - it = impl->Libraries.begin(), end = impl->Libraries.end(); - it != end; ++it) - { - if(it->Target) - { - std::string genex = - "$<TARGET_PROPERTY:" + *it + "," + prop + ">"; - cmGeneratorExpression ge(it->Backtrace); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex); - cge->SetEvaluateForBuildsystem(true); - entries.push_back( - new cmGeneratorTarget::TargetPropertyEntry(cge, *it)); - } - } - } -} - //---------------------------------------------------------------------------- std::vector<std::string> cmGeneratorTarget::GetIncludeDirectories(const std::string& config, @@ -2204,7 +2792,7 @@ cmGeneratorTarget::GetIncludeDirectories(const std::string& config, "INCLUDE_DIRECTORIES") != debugProperties.end(); - if (this->Makefile->IsConfigured()) + if (this->GlobalGenerator->GetConfigureDoneCMP0026()) { this->DebugIncludesDone = true; } @@ -2227,7 +2815,7 @@ cmGeneratorTarget::GetIncludeDirectories(const std::string& config, if(this->Makefile->IsOn("APPLE")) { cmLinkImplementationLibraries const* impl = - this->Target->GetLinkImplementationLibraries(config); + this->GetLinkImplementationLibraries(config); for(std::vector<cmLinkImplItem>::const_iterator it = impl->Libraries.begin(); it != impl->Libraries.end(); ++it) @@ -2274,16 +2862,15 @@ static void processCompileOptionsInternal(cmGeneratorTarget const* tgt, const std::string& config, bool debugOptions, const char *logName, std::string const& language) { - cmMakefile *mf = tgt->Target->GetMakefile(); - for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator it = entries.begin(), end = entries.end(); it != end; ++it) { std::vector<std::string> entryOptions; - cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(mf, + cmSystemTools::ExpandListArgument((*it)->ge->Evaluate( + tgt->GetLocalGenerator(), config, false, - tgt->Target, + tgt, dagChecker, language), entryOptions); @@ -2304,7 +2891,7 @@ static void processCompileOptionsInternal(cmGeneratorTarget const* tgt, } if (!usedOptions.empty()) { - mf->GetCMakeInstance()->IssueMessage(cmake::LOG, + tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(cmake::LOG, std::string("Used compile ") + logName + std::string(" for target ") + tgt->GetName() + ":\n" @@ -2351,7 +2938,7 @@ void cmGeneratorTarget::GetCompileOptions(std::vector<std::string> &result, "COMPILE_OPTIONS") != debugProperties.end(); - if (this->Makefile->IsConfigured()) + if (this->GlobalGenerator->GetConfigureDoneCMP0026()) { this->DebugCompileOptionsDone = true; } @@ -2421,7 +3008,7 @@ void cmGeneratorTarget::GetCompileFeatures(std::vector<std::string> &result, "COMPILE_FEATURES") != debugProperties.end(); - if (this->Makefile->IsConfigured()) + if (this->GlobalGenerator->GetConfigureDoneCMP0026()) { this->DebugCompileFeaturesDone = true; } @@ -2489,7 +3076,7 @@ void cmGeneratorTarget::GetCompileDefinitions(std::vector<std::string> &list, "COMPILE_DEFINITIONS") != debugProperties.end(); - if (this->Makefile->IsConfigured()) + if (this->GlobalGenerator->GetConfigureDoneCMP0026()) { this->DebugCompileDefinitionsDone = true; } @@ -2512,7 +3099,7 @@ void cmGeneratorTarget::GetCompileDefinitions(std::vector<std::string> &list, { std::string configPropName = "COMPILE_DEFINITIONS_" + cmSystemTools::UpperCase(config); - const char *configProp = this->Target->GetProperty(configPropName); + const char *configProp = this->GetProperty(configPropName); if (configProp) { switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0043)) @@ -2557,7 +3144,7 @@ void cmGeneratorTarget::GetCompileDefinitions(std::vector<std::string> &list, void cmGeneratorTarget::ComputeTargetManifest( const std::string& config) const { - if (this->Target->IsImported()) + if (this->IsImported()) { return; } @@ -2569,13 +3156,13 @@ void cmGeneratorTarget::ComputeTargetManifest( std::string realName; std::string impName; std::string pdbName; - if(this->GetType() == cmTarget::EXECUTABLE) + if(this->GetType() == cmState::EXECUTABLE) { this->GetExecutableNames(name, realName, impName, pdbName, config); } - else if(this->GetType() == cmTarget::STATIC_LIBRARY || - this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY) + else if(this->GetType() == cmState::STATIC_LIBRARY || + this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY) { this->GetLibraryNames(name, soName, realName, impName, pdbName, config); @@ -2586,7 +3173,7 @@ void cmGeneratorTarget::ComputeTargetManifest( } // Get the directory. - std::string dir = this->Target->GetDirectory(config, false); + std::string dir = this->GetDirectory(config, false); // Add each name. std::string f; @@ -2620,7 +3207,7 @@ void cmGeneratorTarget::ComputeTargetManifest( } if(!impName.empty()) { - f = this->Target->GetDirectory(config, true); + f = this->GetDirectory(config, true); f += "/"; f += impName; gg->AddToManifest(f); @@ -2631,7 +3218,7 @@ void cmGeneratorTarget::ComputeTargetManifest( std::string cmGeneratorTarget::GetFullPath(const std::string& config, bool implib, bool realname) const { - if(this->Target->IsImported()) + if(this->IsImported()) { return this->Target->ImportedGetFullPath(config, implib); } @@ -2645,9 +3232,9 @@ std::string cmGeneratorTarget::NormalGetFullPath(const std::string& config, bool implib, bool realname) const { - std::string fpath = this->Target->GetDirectory(config, implib); + std::string fpath = this->GetDirectory(config, implib); fpath += "/"; - if(this->Target->IsAppBundleOnApple()) + if(this->IsAppBundleOnApple()) { fpath = this->BuildMacContentDirectory(fpath, config, false); fpath += "/"; @@ -2676,14 +3263,14 @@ cmGeneratorTarget::NormalGetRealName(const std::string& config) const // This should not be called for imported targets. // TODO: Split cmTarget into a class hierarchy to get compile-time // enforcement of the limited imported target API. - if(this->Target->IsImported()) + if(this->IsImported()) { std::string msg = "NormalGetRealName called on imported target: "; msg += this->GetName(); this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg); } - if(this->GetType() == cmTarget::EXECUTABLE) + if(this->GetType() == cmState::EXECUTABLE) { // Compute the real name that will be built. std::string name; @@ -2718,7 +3305,7 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name, // This should not be called for imported targets. // TODO: Split cmTarget into a class hierarchy to get compile-time // enforcement of the limited imported target API. - if(this->Target->IsImported()) + if(this->IsImported()) { std::string msg = "GetLibraryNames called on imported target: "; msg += this->GetName(); @@ -2731,7 +3318,7 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name, const char* version = this->GetProperty("VERSION"); const char* soversion = this->GetProperty("SOVERSION"); if(!this->HasSOName(config) || - this->Target->IsFrameworkOnApple()) + this->IsFrameworkOnApple()) { // Versioning is supported only for shared libraries and modules, // and then only when the platform supports an soname flag. @@ -2759,13 +3346,13 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name, // The library name. name = prefix+base+suffix; - if(this->Target->IsFrameworkOnApple()) + if(this->IsFrameworkOnApple()) { realName = prefix; if(!this->Makefile->PlatformIsAppleIos()) { realName += "Versions/"; - realName += this->Target->GetFrameworkVersion(); + realName += this->GetFrameworkVersion(); realName += "/"; } realName += base; @@ -2774,17 +3361,17 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name, else { // The library's soname. - this->Target->ComputeVersionedName(soName, prefix, base, suffix, + this->ComputeVersionedName(soName, prefix, base, suffix, name, soversion); // The library's real name on disk. - this->Target->ComputeVersionedName(realName, prefix, base, suffix, + this->ComputeVersionedName(realName, prefix, base, suffix, name, version); } // The import library name. - if(this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY) { impName = this->GetFullNameInternal(config, true); } @@ -2807,7 +3394,7 @@ void cmGeneratorTarget::GetExecutableNames(std::string& name, // This should not be called for imported targets. // TODO: Split cmTarget into a class hierarchy to get compile-time // enforcement of the limited imported target API. - if(this->Target->IsImported()) + if(this->IsImported()) { std::string msg = "GetExecutableNames called on imported target: "; @@ -2822,7 +3409,7 @@ void cmGeneratorTarget::GetExecutableNames(std::string& name, #else // Check for executable version properties. const char* version = this->GetProperty("VERSION"); - if(this->GetType() != cmTarget::EXECUTABLE || this->Makefile->IsOn("XCODE")) + if(this->GetType() != cmState::EXECUTABLE || this->Makefile->IsOn("XCODE")) { version = 0; } @@ -2871,6 +3458,24 @@ std::string cmGeneratorTarget::GetFullNameInternal(const std::string& config, } //---------------------------------------------------------------------------- +const char* +cmGeneratorTarget::ImportedGetLocation(const std::string& config) const +{ + static std::string location; + assert(this->IsImported()); + location = this->Target->ImportedGetFullPath(config, false); + return location.c_str(); +} + +//---------------------------------------------------------------------------- +std::string cmGeneratorTarget::GetFullNameImported(const std::string& config, + bool implib) const +{ + return cmSystemTools::GetFilenameName( + this->Target->ImportedGetFullPath(config, implib)); +} + +//---------------------------------------------------------------------------- void cmGeneratorTarget::GetFullNameInternal(const std::string& config, bool implib, std::string& outPrefix, @@ -2878,10 +3483,10 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, std::string& outSuffix) const { // Use just the target name for non-main target types. - if(this->GetType() != cmTarget::STATIC_LIBRARY && - this->GetType() != cmTarget::SHARED_LIBRARY && - this->GetType() != cmTarget::MODULE_LIBRARY && - this->GetType() != cmTarget::EXECUTABLE) + if(this->GetType() != cmState::STATIC_LIBRARY && + this->GetType() != cmState::SHARED_LIBRARY && + this->GetType() != cmState::MODULE_LIBRARY && + this->GetType() != cmState::EXECUTABLE) { outPrefix = ""; outBase = this->GetName(); @@ -2902,9 +3507,9 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, // The implib option is only allowed for shared libraries, module // libraries, and executables. - if(this->GetType() != cmTarget::SHARED_LIBRARY && - this->GetType() != cmTarget::MODULE_LIBRARY && - this->GetType() != cmTarget::EXECUTABLE) + if(this->GetType() != cmState::SHARED_LIBRARY && + this->GetType() != cmState::MODULE_LIBRARY && + this->GetType() != cmState::EXECUTABLE) { implib = false; } @@ -2924,8 +3529,7 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, configPostfix = this->GetProperty(configProp); // Mac application bundles and frameworks have no postfix. if(configPostfix && - (this->Target->IsAppBundleOnApple() - || this->Target->IsFrameworkOnApple())) + (this->IsAppBundleOnApple() || this->IsFrameworkOnApple())) { configPostfix = 0; } @@ -2962,7 +3566,7 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, // frameworks have directory prefix but no suffix std::string fw_prefix; - if(this->Target->IsFrameworkOnApple()) + if(this->IsFrameworkOnApple()) { fw_prefix = this->GetOutputName(config, false); fw_prefix += ".framework/"; @@ -2970,7 +3574,7 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, targetSuffix = 0; } - if(this->Target->IsCFBundleOnApple()) + if(this->IsCFBundleOnApple()) { fw_prefix = this->GetCFBundleDirectory(config, false); fw_prefix += "/"; @@ -2990,7 +3594,7 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, // Name shared libraries with their version number on some platforms. if(const char* soversion = this->GetProperty("SOVERSION")) { - if(this->GetType() == cmTarget::SHARED_LIBRARY && !implib && + if(this->GetType() == cmState::SHARED_LIBRARY && !implib && this->Makefile->IsOn("CMAKE_SHARED_LIBRARY_NAME_WITH_VERSION")) { outBase += "-"; @@ -3042,14 +3646,14 @@ std::string cmGeneratorTarget::GetPDBName(const std::string& config) const return prefix+base+".pdb"; } -bool cmStrictTargetComparison::operator()(cmTarget const* t1, - cmTarget const* t2) const +bool cmGeneratorTarget::StrictTargetComparison::operator()( + cmGeneratorTarget const* t1, cmGeneratorTarget const* t2) const { int nameResult = strcmp(t1->GetName().c_str(), t2->GetName().c_str()); if (nameResult == 0) { - return strcmp(t1->GetMakefile()->GetCurrentBinaryDirectory(), - t2->GetMakefile()->GetCurrentBinaryDirectory()) < 0; + return strcmp(t1->GetLocalGenerator()->GetCurrentBinaryDirectory(), + t2->GetLocalGenerator()->GetCurrentBinaryDirectory()) < 0; } return nameResult < 0; } @@ -3096,7 +3700,7 @@ void cmGeneratorTarget::ConstructSourceFileFlags() const this->SourceFileFlagsConstructed = true; // Process public headers to mark the source files. - if(const char* files = this->Target->GetProperty("PUBLIC_HEADER")) + if(const char* files = this->GetProperty("PUBLIC_HEADER")) { std::vector<std::string> relFiles; cmSystemTools::ExpandListArgument(files, relFiles); @@ -3114,7 +3718,7 @@ void cmGeneratorTarget::ConstructSourceFileFlags() const // Process private headers after public headers so that they take // precedence if a file is listed in both. - if(const char* files = this->Target->GetProperty("PRIVATE_HEADER")) + if(const char* files = this->GetProperty("PRIVATE_HEADER")) { std::vector<std::string> relFiles; cmSystemTools::ExpandListArgument(files, relFiles); @@ -3131,7 +3735,7 @@ void cmGeneratorTarget::ConstructSourceFileFlags() const } // Mark sources listed as resources. - if(const char* files = this->Target->GetProperty("RESOURCE")) + if(const char* files = this->GetProperty("RESOURCE")) { std::vector<std::string> relFiles; cmSystemTools::ExpandListArgument(files, relFiles); @@ -3159,10 +3763,10 @@ cmGeneratorTarget::GetCompatibleInterfaces(std::string const& config) const compat.Done = true; compat.PropsBool.insert("POSITION_INDEPENDENT_CODE"); compat.PropsString.insert("AUTOUIC_OPTIONS"); - std::vector<cmTarget const*> const& deps = + std::vector<cmGeneratorTarget const*> const& deps = this->GetLinkImplementationClosure(config); - for(std::vector<cmTarget const*>::const_iterator li = deps.begin(); - li != deps.end(); ++li) + for(std::vector<cmGeneratorTarget const*>::const_iterator li = + deps.begin(); li != deps.end(); ++li) { #define CM_READ_COMPATIBLE_INTERFACE(X, x) \ if(const char* prop = (*li)->GetProperty("COMPATIBLE_INTERFACE_" #X)) \ @@ -3185,8 +3789,8 @@ cmGeneratorTarget::GetCompatibleInterfaces(std::string const& config) const bool cmGeneratorTarget::IsLinkInterfaceDependentBoolProperty( const std::string &p, const std::string& config) const { - if (this->Target->GetType() == cmTarget::OBJECT_LIBRARY - || this->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (this->GetType() == cmState::OBJECT_LIBRARY + || this->GetType() == cmState::INTERFACE_LIBRARY) { return false; } @@ -3197,8 +3801,8 @@ bool cmGeneratorTarget::IsLinkInterfaceDependentBoolProperty( bool cmGeneratorTarget::IsLinkInterfaceDependentStringProperty( const std::string &p, const std::string& config) const { - if (this->Target->GetType() == cmTarget::OBJECT_LIBRARY - || this->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (this->GetType() == cmState::OBJECT_LIBRARY + || this->GetType() == cmState::INTERFACE_LIBRARY) { return false; } @@ -3209,8 +3813,8 @@ bool cmGeneratorTarget::IsLinkInterfaceDependentStringProperty( bool cmGeneratorTarget::IsLinkInterfaceDependentNumberMinProperty( const std::string &p, const std::string& config) const { - if (this->Target->GetType() == cmTarget::OBJECT_LIBRARY - || this->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (this->GetType() == cmState::OBJECT_LIBRARY + || this->GetType() == cmState::INTERFACE_LIBRARY) { return false; } @@ -3221,8 +3825,8 @@ bool cmGeneratorTarget::IsLinkInterfaceDependentNumberMinProperty( bool cmGeneratorTarget::IsLinkInterfaceDependentNumberMaxProperty( const std::string &p, const std::string& config) const { - if (this->Target->GetType() == cmTarget::OBJECT_LIBRARY - || this->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (this->GetType() == cmState::OBJECT_LIBRARY + || this->GetType() == cmState::INTERFACE_LIBRARY) { return false; } @@ -3279,7 +3883,7 @@ const char * getLinkInterfaceDependentProperty(cmGeneratorTarget const* tgt, //---------------------------------------------------------------------------- template<typename PropertyType> void checkPropertyConsistency(cmGeneratorTarget const* depender, - cmTarget const* dependee, + cmGeneratorTarget const* dependee, const std::string& propName, std::set<std::string> &emitted, const std::string& config, @@ -3295,7 +3899,7 @@ void checkPropertyConsistency(cmGeneratorTarget const* depender, std::vector<std::string> props; cmSystemTools::ExpandListArgument(prop, props); std::string pdir = - dependee->GetMakefile()->GetRequiredDefinition("CMAKE_ROOT"); + dependee->Target->GetMakefile()->GetRequiredDefinition("CMAKE_ROOT"); pdir += "/Help/prop_tgt/"; for(std::vector<std::string>::iterator pi = props.begin(); @@ -3508,18 +4112,20 @@ std::string compatibilityAgree(CompatibleType t, bool dominant) //---------------------------------------------------------------------------- template<typename PropertyType> -PropertyType getTypedProperty(cmTarget const* tgt, const std::string& prop); +PropertyType getTypedProperty(cmGeneratorTarget const* tgt, + const std::string& prop); //---------------------------------------------------------------------------- template<> -bool getTypedProperty<bool>(cmTarget const* tgt, const std::string& prop) +bool getTypedProperty<bool>(cmGeneratorTarget const* tgt, + const std::string& prop) { return tgt->GetPropertyAsBool(prop); } //---------------------------------------------------------------------------- template<> -const char *getTypedProperty<const char *>(cmTarget const* tgt, +const char *getTypedProperty<const char *>(cmGeneratorTarget const* tgt, const std::string& prop) { return tgt->GetProperty(prop); @@ -3649,16 +4255,18 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt, CompatibleType t, PropertyType *) { - PropertyType propContent = getTypedProperty<PropertyType>(tgt->Target, p); - const bool explicitlySet = tgt->Target->GetProperties() - .find(p) - != tgt->Target->GetProperties().end(); + PropertyType propContent = getTypedProperty<PropertyType>(tgt, p); + std::vector<std::string> headPropKeys = tgt->GetPropertyKeys(); + const bool explicitlySet = + std::find(headPropKeys.begin(), headPropKeys.end(), + p) != headPropKeys.end(); + const bool impliedByUse = - tgt->Target->IsNullImpliedByLinkLibraries(p); + tgt->IsNullImpliedByLinkLibraries(p); assert((impliedByUse ^ explicitlySet) || (!impliedByUse && !explicitlySet)); - std::vector<cmTarget const*> const& deps = + std::vector<cmGeneratorTarget const*> const& deps = tgt->GetLinkImplementationClosure(config); if(deps.empty()) @@ -3685,7 +4293,7 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt, } std::string interfaceProperty = "INTERFACE_" + p; - for(std::vector<cmTarget const*>::const_iterator li = + for(std::vector<cmGeneratorTarget const*>::const_iterator li = deps.begin(); li != deps.end(); ++li) { @@ -3695,11 +4303,13 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt, // target itself has a POSITION_INDEPENDENT_CODE which disagrees // with a dependency. - cmTarget const* theTarget = *li; + cmGeneratorTarget const* theTarget = *li; + + std::vector<std::string> propKeys = theTarget->GetPropertyKeys(); - const bool ifaceIsSet = theTarget->GetProperties() - .find(interfaceProperty) - != theTarget->GetProperties().end(); + const bool ifaceIsSet = + std::find(propKeys.begin(), propKeys.end(), + interfaceProperty) != propKeys.end(); PropertyType ifacePropContent = getTypedProperty<PropertyType>(theTarget, interfaceProperty); @@ -3903,6 +4513,93 @@ cmGeneratorTarget::GetLinkInformation(const std::string& config) const } //---------------------------------------------------------------------------- +void cmGeneratorTarget::GetTargetVersion(int& major, int& minor) const +{ + int patch; + this->GetTargetVersion(false, major, minor, patch); +} + +//---------------------------------------------------------------------------- +void cmGeneratorTarget::GetTargetVersion(bool soversion, + int& major, int& minor, int& patch) const +{ + // Set the default values. + major = 0; + minor = 0; + patch = 0; + + assert(this->GetType() != cmState::INTERFACE_LIBRARY); + + // Look for a VERSION or SOVERSION property. + const char* prop = soversion? "SOVERSION" : "VERSION"; + if(const char* version = this->GetProperty(prop)) + { + // Try to parse the version number and store the results that were + // successfully parsed. + int parsed_major; + int parsed_minor; + int parsed_patch; + switch(sscanf(version, "%d.%d.%d", + &parsed_major, &parsed_minor, &parsed_patch)) + { + case 3: patch = parsed_patch; // no break! + case 2: minor = parsed_minor; // no break! + case 1: major = parsed_major; // no break! + default: break; + } + } +} + +//---------------------------------------------------------------------------- +std::string cmGeneratorTarget::GetFrameworkVersion() const +{ + assert(this->GetType() != cmState::INTERFACE_LIBRARY); + + if(const char* fversion = this->GetProperty("FRAMEWORK_VERSION")) + { + return fversion; + } + else if(const char* tversion = this->GetProperty("VERSION")) + { + return tversion; + } + else + { + return "A"; + } +} + +//---------------------------------------------------------------------------- +void cmGeneratorTarget::ComputeVersionedName(std::string& vName, + std::string const& prefix, + std::string const& base, + std::string const& suffix, + std::string const& name, + const char* version) const +{ + vName = this->Makefile->IsOn("APPLE") ? (prefix+base) : name; + if(version) + { + vName += "."; + vName += version; + } + vName += this->Makefile->IsOn("APPLE") ? suffix : std::string(); +} + +std::vector<std::string> cmGeneratorTarget::GetPropertyKeys() const +{ + cmPropertyMap propsObject = this->Target->GetProperties(); + std::vector<std::string> props; + props.reserve(propsObject.size()); + for (cmPropertyMap::const_iterator it = propsObject.begin(); + it != propsObject.end(); ++it) + { + props.push_back(it->first); + } + return props; +} + +//---------------------------------------------------------------------------- void cmGeneratorTarget::ReportPropertyOrigin(const std::string &p, const std::string &result, @@ -3923,7 +4620,7 @@ cmGeneratorTarget::ReportPropertyOrigin(const std::string &p, p) != debugProperties.end(); - if (this->Target->GetMakefile()->IsConfigured()) + if (this->GlobalGenerator->GetConfigureDoneCMP0026()) { this->DebugCompatiblePropertiesDone[p] = true; } @@ -3939,7 +4636,7 @@ cmGeneratorTarget::ReportPropertyOrigin(const std::string &p, areport += result; areport += "\"):\n" + report; - this->Makefile->GetCMakeInstance()->IssueMessage(cmake::LOG, areport); + this->LocalGenerator->GetCMakeInstance()->IssueMessage(cmake::LOG, areport); } //---------------------------------------------------------------------------- @@ -3949,12 +4646,12 @@ void cmGeneratorTarget::LookupLinkItems(std::vector<std::string> const& names, for(std::vector<std::string>::const_iterator i = names.begin(); i != names.end(); ++i) { - std::string name = this->Target->CheckCMP0004(*i); + std::string name = this->CheckCMP0004(*i); if(name == this->GetName() || name.empty()) { continue; } - items.push_back(cmLinkItem(name, this->Target->FindTargetToLink(name))); + items.push_back(cmLinkItem(name, this->FindTargetToLink(name))); } } @@ -3962,7 +4659,7 @@ void cmGeneratorTarget::LookupLinkItems(std::vector<std::string> const& names, void cmGeneratorTarget::ExpandLinkItems(std::string const& prop, std::string const& value, std::string const& config, - cmTarget const* headTarget, + cmGeneratorTarget const* headTarget, bool usage_requirements_only, std::vector<cmLinkItem>& items, bool& hadHeadSensitiveCondition) const @@ -3978,11 +4675,11 @@ void cmGeneratorTarget::ExpandLinkItems(std::string const& prop, std::vector<std::string> libs; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value); cmSystemTools::ExpandListArgument(cge->Evaluate( - this->Makefile, + this->LocalGenerator, config, false, headTarget, - this->Target, &dagChecker), libs); + this, &dagChecker), libs); this->LookupLinkItems(libs, items); hadHeadSensitiveCondition = cge->GetHadHeadSensitiveCondition(); } @@ -3990,7 +4687,7 @@ void cmGeneratorTarget::ExpandLinkItems(std::string const& prop, //---------------------------------------------------------------------------- cmLinkInterface const* cmGeneratorTarget::GetLinkInterface(const std::string& config, - cmTarget const* head) const + cmGeneratorTarget const* head) const { // Imported targets have their own link interface. if(this->IsImported()) @@ -4000,8 +4697,8 @@ cmGeneratorTarget::GetLinkInterface(const std::string& config, // Link interfaces are not supported for executables that do not // export symbols. - if(this->GetType() == cmTarget::EXECUTABLE && - !this->Target->IsExecutableWithExports()) + if(this->GetType() == cmState::EXECUTABLE && + !this->IsExecutableWithExports()) { return 0; } @@ -4039,13 +4736,13 @@ cmGeneratorTarget::GetLinkInterface(const std::string& config, //---------------------------------------------------------------------------- void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, cmOptionalLinkInterface &iface, - cmTarget const* headTarget) const + cmGeneratorTarget const* headTarget) const { if(iface.ExplicitLibraries) { - if(this->GetType() == cmTarget::SHARED_LIBRARY - || this->GetType() == cmTarget::STATIC_LIBRARY - || this->GetType() == cmTarget::INTERFACE_LIBRARY) + if(this->GetType() == cmState::SHARED_LIBRARY + || this->GetType() == cmState::STATIC_LIBRARY + || this->GetType() == cmState::INTERFACE_LIBRARY) { // Shared libraries may have runtime implementation dependencies // on other shared libraries that are not in the interface. @@ -4055,7 +4752,7 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, { emitted.insert(*li); } - if (this->GetType() != cmTarget::INTERFACE_LIBRARY) + if (this->GetType() != cmState::INTERFACE_LIBRARY) { cmLinkImplementation const* impl = this->GetLinkImplementation(config); @@ -4067,7 +4764,7 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, if(li->Target) { // This is a runtime dependency on another shared library. - if(li->Target->GetType() == cmTarget::SHARED_LIBRARY) + if(li->Target->GetType() == cmState::SHARED_LIBRARY) { iface.SharedDeps.push_back(*li); } @@ -4084,18 +4781,18 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, } } } - else if (this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN - || this->Target->GetPolicyStatusCMP0022() == cmPolicies::OLD) + else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN + || this->GetPolicyStatusCMP0022() == cmPolicies::OLD) { // The link implementation is the default link interface. cmLinkImplementationLibraries const* - impl = this->Target->GetLinkImplementationLibrariesInternal(config, - headTarget); + impl = this->GetLinkImplementationLibrariesInternal(config, + headTarget); iface.ImplementationIsInterface = true; iface.WrongConfigLibraries = impl->WrongConfigLibraries; } - if(this->Target->LinkLanguagePropagatesToDependents()) + if(this->LinkLanguagePropagatesToDependents()) { // Targets using this archive need its language runtime libraries. if(cmLinkImplementation const* impl = @@ -4105,7 +4802,7 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, } } - if(this->GetType() == cmTarget::STATIC_LIBRARY) + if(this->GetType() == cmState::STATIC_LIBRARY) { // Construct the property name suffix for this configuration. std::string suffix = "_"; @@ -4137,7 +4834,7 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, //---------------------------------------------------------------------------- const cmLinkInterfaceLibraries * cmGeneratorTarget::GetLinkInterfaceLibraries(const std::string& config, - cmTarget const* head, + cmGeneratorTarget const* head, bool usage_requirements_only) const { // Imported targets have their own link interface. @@ -4149,8 +4846,8 @@ cmGeneratorTarget::GetLinkInterfaceLibraries(const std::string& config, // Link interfaces are not supported for executables that do not // export symbols. - if(this->GetType() == cmTarget::EXECUTABLE && - !this->Target->IsExecutableWithExports()) + if(this->GetType() == cmState::EXECUTABLE && + !this->IsExecutableWithExports()) { return 0; } @@ -4181,11 +4878,261 @@ cmGeneratorTarget::GetLinkInterfaceLibraries(const std::string& config, } //---------------------------------------------------------------------------- +std::string cmGeneratorTarget::GetDirectory(const std::string& config, + bool implib) const +{ + if (this->IsImported()) + { + // Return the directory from which the target is imported. + return + cmSystemTools::GetFilenamePath( + this->Target->ImportedGetFullPath(config, implib)); + } + else if(OutputInfo const* info = this->GetOutputInfo(config)) + { + // Return the directory in which the target will be built. + return implib? info->ImpDir : info->OutDir; + } + return ""; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::UsesDefaultOutputDir(const std::string& config, + bool implib) const +{ + std::string dir; + return this->ComputeOutputDir(config, implib, dir); +} + +//---------------------------------------------------------------------------- +cmGeneratorTarget::OutputInfo const* cmGeneratorTarget::GetOutputInfo( + const std::string& config) const +{ + // There is no output information for imported targets. + if(this->IsImported()) + { + return 0; + } + + // Only libraries and executables have well-defined output files. + if(!this->HaveWellDefinedOutputFiles()) + { + std::string msg = "cmGeneratorTarget::GetOutputInfo called for "; + msg += this->GetName(); + msg += " which has type "; + msg += cmState::GetTargetTypeName(this->GetType()); + this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg); + return 0; + } + + // Lookup/compute/cache the output information for this configuration. + std::string config_upper; + if(!config.empty()) + { + config_upper = cmSystemTools::UpperCase(config); + } + OutputInfoMapType::iterator i = + this->OutputInfoMap.find(config_upper); + if(i == this->OutputInfoMap.end()) + { + // Add empty info in map to detect potential recursion. + OutputInfo info; + OutputInfoMapType::value_type entry(config_upper, info); + i = this->OutputInfoMap.insert(entry).first; + + // Compute output directories. + this->ComputeOutputDir(config, false, info.OutDir); + this->ComputeOutputDir(config, true, info.ImpDir); + if(!this->ComputePDBOutputDir("PDB", config, info.PdbDir)) + { + info.PdbDir = info.OutDir; + } + + // Now update the previously-prepared map entry. + i->second = info; + } + else if(i->second.empty()) + { + // An empty map entry indicates we have been called recursively + // from the above block. + this->LocalGenerator->GetCMakeInstance()->IssueMessage( + cmake::FATAL_ERROR, + "Target '" + this->GetName() + "' OUTPUT_DIRECTORY depends on itself.", + this->GetBacktrace()); + return 0; + } + return &i->second; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::ComputeOutputDir(const std::string& config, + bool implib, std::string& out) const +{ + bool usesDefaultOutputDir = false; + std::string conf = config; + + // Look for a target property defining the target output directory + // based on the target type. + std::string targetTypeName = this->GetOutputTargetType(implib); + const char* propertyName = 0; + std::string propertyNameStr = targetTypeName; + if(!propertyNameStr.empty()) + { + propertyNameStr += "_OUTPUT_DIRECTORY"; + propertyName = propertyNameStr.c_str(); + } + + // Check for a per-configuration output directory target property. + std::string configUpper = cmSystemTools::UpperCase(conf); + const char* configProp = 0; + std::string configPropStr = targetTypeName; + if(!configPropStr.empty()) + { + configPropStr += "_OUTPUT_DIRECTORY_"; + configPropStr += configUpper; + configProp = configPropStr.c_str(); + } + + // Select an output directory. + if(const char* config_outdir = this->GetProperty(configProp)) + { + // Use the user-specified per-configuration output directory. + cmGeneratorExpression ge; + cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + ge.Parse(config_outdir); + out = cge->Evaluate(this->LocalGenerator, config); + + // Skip per-configuration subdirectory. + conf = ""; + } + else if(const char* outdir = this->GetProperty(propertyName)) + { + // Use the user-specified output directory. + cmGeneratorExpression ge; + cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + ge.Parse(outdir); + out = cge->Evaluate(this->LocalGenerator, config); + + // Skip per-configuration subdirectory if the value contained a + // generator expression. + if (out != outdir) + { + conf = ""; + } + } + else if(this->GetType() == cmState::EXECUTABLE) + { + // Lookup the output path for executables. + out = this->Makefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH"); + } + else if(this->GetType() == cmState::STATIC_LIBRARY || + this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY) + { + // Lookup the output path for libraries. + out = this->Makefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH"); + } + if(out.empty()) + { + // Default to the current output directory. + usesDefaultOutputDir = true; + out = "."; + } + + // Convert the output path to a full path in case it is + // specified as a relative path. Treat a relative path as + // relative to the current output directory for this makefile. + out = (cmSystemTools::CollapseFullPath + (out, this->LocalGenerator->GetCurrentBinaryDirectory())); + + // The generator may add the configuration's subdirectory. + if(!conf.empty()) + { + bool iosPlatform = this->Makefile->PlatformIsAppleIos(); + std::string suffix = + usesDefaultOutputDir && iosPlatform ? "${EFFECTIVE_PLATFORM_NAME}" : ""; + this->LocalGenerator->GetGlobalGenerator()-> + AppendDirectoryForConfig("/", conf, suffix, out); + } + + return usesDefaultOutputDir; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::ComputePDBOutputDir(const std::string& kind, + const std::string& config, + std::string& out) const +{ + // Look for a target property defining the target output directory + // based on the target type. + const char* propertyName = 0; + std::string propertyNameStr = kind; + if(!propertyNameStr.empty()) + { + propertyNameStr += "_OUTPUT_DIRECTORY"; + propertyName = propertyNameStr.c_str(); + } + std::string conf = config; + + // Check for a per-configuration output directory target property. + std::string configUpper = cmSystemTools::UpperCase(conf); + const char* configProp = 0; + std::string configPropStr = kind; + if(!configPropStr.empty()) + { + configPropStr += "_OUTPUT_DIRECTORY_"; + configPropStr += configUpper; + configProp = configPropStr.c_str(); + } + + // Select an output directory. + if(const char* config_outdir = this->GetProperty(configProp)) + { + // Use the user-specified per-configuration output directory. + out = config_outdir; + + // Skip per-configuration subdirectory. + conf = ""; + } + else if(const char* outdir = this->GetProperty(propertyName)) + { + // Use the user-specified output directory. + out = outdir; + } + if(out.empty()) + { + return false; + } + + // Convert the output path to a full path in case it is + // specified as a relative path. Treat a relative path as + // relative to the current output directory for this makefile. + out = (cmSystemTools::CollapseFullPath + (out, this->LocalGenerator->GetCurrentBinaryDirectory())); + + // The generator may add the configuration's subdirectory. + if(!conf.empty()) + { + this->LocalGenerator->GetGlobalGenerator()-> + AppendDirectoryForConfig("/", conf, "", out); + } + return true; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::HaveInstallTreeRPATH() const +{ + const char* install_rpath = this->GetProperty("INSTALL_RPATH"); + return (install_rpath && *install_rpath) && + !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH"); +} + +//---------------------------------------------------------------------------- void cmGeneratorTarget::ComputeLinkInterfaceLibraries( const std::string& config, cmOptionalLinkInterface& iface, - cmTarget const* headTarget, + cmGeneratorTarget const* headTarget, bool usage_requirements_only) const { // Construct the property name suffix for this configuration. @@ -4203,15 +5150,15 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( // libraries and executables that export symbols. const char* explicitLibraries = 0; std::string linkIfaceProp; - if(this->Target->GetPolicyStatusCMP0022() != cmPolicies::OLD && - this->Target->GetPolicyStatusCMP0022() != cmPolicies::WARN) + if(this->GetPolicyStatusCMP0022() != cmPolicies::OLD && + this->GetPolicyStatusCMP0022() != cmPolicies::WARN) { // CMP0022 NEW behavior is to use INTERFACE_LINK_LIBRARIES. linkIfaceProp = "INTERFACE_LINK_LIBRARIES"; explicitLibraries = this->GetProperty(linkIfaceProp); } - else if(this->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->IsExecutableWithExports()) + else if(this->GetType() == cmState::SHARED_LIBRARY || + this->IsExecutableWithExports()) { // CMP0022 OLD behavior is to use LINK_INTERFACE_LIBRARIES if set on a // shared lib or executable. @@ -4230,7 +5177,7 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( } if(explicitLibraries && - this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN && + this->GetPolicyStatusCMP0022() == cmPolicies::WARN && !this->PolicyWarnedCMP0022) { // Compare the explicitly set old link interface properties to the @@ -4258,8 +5205,8 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( // There is no implicit link interface for executables or modules // so if none was explicitly set then there is no link interface. if(!explicitLibraries && - (this->GetType() == cmTarget::EXECUTABLE || - (this->GetType() == cmTarget::MODULE_LIBRARY))) + (this->GetType() == cmState::EXECUTABLE || + (this->GetType() == cmState::MODULE_LIBRARY))) { return; } @@ -4275,8 +5222,8 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( iface.Libraries, iface.HadHeadSensitiveCondition); } - else if (this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN - || this->Target->GetPolicyStatusCMP0022() == cmPolicies::OLD) + else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN + || this->GetPolicyStatusCMP0022() == cmPolicies::OLD) // If CMP0022 is NEW then the plain tll signature sets the // INTERFACE_LINK_LIBRARIES, so if we get here then the project // cleared the property explicitly and we should not fall back @@ -4284,11 +5231,10 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( { // The link implementation is the default link interface. cmLinkImplementationLibraries const* impl = - this->Target->GetLinkImplementationLibrariesInternal(config, - headTarget); + this->GetLinkImplementationLibrariesInternal(config, headTarget); iface.Libraries.insert(iface.Libraries.end(), impl->Libraries.begin(), impl->Libraries.end()); - if(this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN && + if(this->GetPolicyStatusCMP0022() == cmPolicies::WARN && !this->PolicyWarnedCMP0022 && !usage_requirements_only) { // Compare the link implementation fallback link interface to the @@ -4299,8 +5245,9 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( { bool hadHeadSensitiveConditionDummy = false; this->ExpandLinkItems(newProp, newExplicitLibraries, config, - headTarget, usage_requirements_only, - ifaceLibs, hadHeadSensitiveConditionDummy); + headTarget, + usage_requirements_only, + ifaceLibs, hadHeadSensitiveConditionDummy); } if (ifaceLibs != iface.Libraries) { @@ -4334,10 +5281,10 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( //---------------------------------------------------------------------------- const cmLinkInterface * cmGeneratorTarget::GetImportLinkInterface(const std::string& config, - cmTarget const* headTarget, + cmGeneratorTarget const* headTarget, bool usage_requirements_only) const { - cmTarget::ImportInfo const* info = this->Target->GetImportInfo(config); + cmGeneratorTarget::ImportInfo const* info = this->GetImportInfo(config); if(!info) { return 0; @@ -4375,6 +5322,223 @@ cmGeneratorTarget::GetImportLinkInterface(const std::string& config, return &iface; } +//---------------------------------------------------------------------------- +cmGeneratorTarget::ImportInfo const* +cmGeneratorTarget::GetImportInfo(const std::string& config) const +{ + // There is no imported information for non-imported targets. + if(!this->IsImported()) + { + return 0; + } + + // Lookup/compute/cache the import information for this + // configuration. + std::string config_upper; + if(!config.empty()) + { + config_upper = cmSystemTools::UpperCase(config); + } + else + { + config_upper = "NOCONFIG"; + } + + ImportInfoMapType::const_iterator i = + this->ImportInfoMap.find(config_upper); + if(i == this->ImportInfoMap.end()) + { + ImportInfo info; + this->ComputeImportInfo(config_upper, info); + ImportInfoMapType::value_type entry(config_upper, info); + i = this->ImportInfoMap.insert(entry).first; + } + + if(this->GetType() == cmState::INTERFACE_LIBRARY) + { + return &i->second; + } + // If the location is empty then the target is not available for + // this configuration. + if(i->second.Location.empty() && i->second.ImportLibrary.empty()) + { + return 0; + } + + // Return the import information. + return &i->second; +} + +//---------------------------------------------------------------------------- +void cmGeneratorTarget::ComputeImportInfo(std::string const& desired_config, + ImportInfo& info) const +{ + // This method finds information about an imported target from its + // properties. The "IMPORTED_" namespace is reserved for properties + // defined by the project exporting the target. + + // Initialize members. + info.NoSOName = false; + + const char* loc = 0; + const char* imp = 0; + std::string suffix; + if (!this->Target->GetMappedConfig(desired_config, &loc, &imp, suffix)) + { + return; + } + + // Get the link interface. + { + std::string linkProp = "INTERFACE_LINK_LIBRARIES"; + const char *propertyLibs = this->GetProperty(linkProp); + + if (this->GetType() != cmState::INTERFACE_LIBRARY) + { + if(!propertyLibs) + { + linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES"; + linkProp += suffix; + propertyLibs = this->GetProperty(linkProp); + } + + if(!propertyLibs) + { + linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES"; + propertyLibs = this->GetProperty(linkProp); + } + } + if(propertyLibs) + { + info.LibrariesProp = linkProp; + info.Libraries = propertyLibs; + } + } + if(this->GetType() == cmState::INTERFACE_LIBRARY) + { + return; + } + + // A provided configuration has been chosen. Load the + // configuration's properties. + + // Get the location. + if(loc) + { + info.Location = loc; + } + else + { + std::string impProp = "IMPORTED_LOCATION"; + impProp += suffix; + if(const char* config_location = this->GetProperty(impProp)) + { + info.Location = config_location; + } + else if(const char* location = this->GetProperty("IMPORTED_LOCATION")) + { + info.Location = location; + } + } + + // Get the soname. + if(this->GetType() == cmState::SHARED_LIBRARY) + { + std::string soProp = "IMPORTED_SONAME"; + soProp += suffix; + if(const char* config_soname = this->GetProperty(soProp)) + { + info.SOName = config_soname; + } + else if(const char* soname = this->GetProperty("IMPORTED_SONAME")) + { + info.SOName = soname; + } + } + + // Get the "no-soname" mark. + if(this->GetType() == cmState::SHARED_LIBRARY) + { + std::string soProp = "IMPORTED_NO_SONAME"; + soProp += suffix; + if(const char* config_no_soname = this->GetProperty(soProp)) + { + info.NoSOName = cmSystemTools::IsOn(config_no_soname); + } + else if(const char* no_soname = this->GetProperty("IMPORTED_NO_SONAME")) + { + info.NoSOName = cmSystemTools::IsOn(no_soname); + } + } + + // Get the import library. + if(imp) + { + info.ImportLibrary = imp; + } + else if(this->GetType() == cmState::SHARED_LIBRARY || + this->IsExecutableWithExports()) + { + std::string impProp = "IMPORTED_IMPLIB"; + impProp += suffix; + if(const char* config_implib = this->GetProperty(impProp)) + { + info.ImportLibrary = config_implib; + } + else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB")) + { + info.ImportLibrary = implib; + } + } + + // Get the link dependencies. + { + std::string linkProp = "IMPORTED_LINK_DEPENDENT_LIBRARIES"; + linkProp += suffix; + if(const char* config_libs = this->GetProperty(linkProp)) + { + info.SharedDeps = config_libs; + } + else if(const char* libs = + this->GetProperty("IMPORTED_LINK_DEPENDENT_LIBRARIES")) + { + info.SharedDeps = libs; + } + } + + // Get the link languages. + if(this->LinkLanguagePropagatesToDependents()) + { + std::string linkProp = "IMPORTED_LINK_INTERFACE_LANGUAGES"; + linkProp += suffix; + if(const char* config_libs = this->GetProperty(linkProp)) + { + info.Languages = config_libs; + } + else if(const char* libs = + this->GetProperty("IMPORTED_LINK_INTERFACE_LANGUAGES")) + { + info.Languages = libs; + } + } + + // Get the cyclic repetition count. + if(this->GetType() == cmState::STATIC_LIBRARY) + { + std::string linkProp = "IMPORTED_LINK_INTERFACE_MULTIPLICITY"; + linkProp += suffix; + if(const char* config_reps = this->GetProperty(linkProp)) + { + sscanf(config_reps, "%u", &info.Multiplicity); + } + else if(const char* reps = + this->GetProperty("IMPORTED_LINK_INTERFACE_MULTIPLICITY")) + { + sscanf(reps, "%u", &info.Multiplicity); + } + } +} + cmHeadToLinkInterfaceMap& cmGeneratorTarget::GetHeadToLinkInterfaceMap(const std::string &config) const { @@ -4395,17 +5559,17 @@ const cmLinkImplementation * cmGeneratorTarget::GetLinkImplementation(const std::string& config) const { // There is no link implementation for imported targets. - if(this->Target->IsImported()) + if(this->IsImported()) { return 0; } - cmOptionalLinkImplementation& impl = this->Target->GetLinkImplMap(config); + std::string CONFIG = cmSystemTools::UpperCase(config); + cmOptionalLinkImplementation& impl = this->LinkImplMap[CONFIG][this]; if(!impl.LibrariesDone) { impl.LibrariesDone = true; - this->Target->ComputeLinkImplementationLibraries(config, impl, - this->Target); + this->ComputeLinkImplementationLibraries(config, impl, this); } if(!impl.LanguagesDone) { @@ -4428,12 +5592,12 @@ bool cmGeneratorTarget::GetConfigCommonSourceFiles( std::vector<std::string>::const_iterator it = configs.begin(); const std::string& firstConfig = *it; - this->Target->GetSourceFiles(files, firstConfig); + this->GetSourceFiles(files, firstConfig); for ( ; it != configs.end(); ++it) { std::vector<cmSourceFile*> configFiles; - this->Target->GetSourceFiles(configFiles, *it); + this->GetSourceFiles(configFiles, *it); if (configFiles != files) { std::string firstConfigFiles; @@ -4473,6 +5637,105 @@ bool cmGeneratorTarget::GetConfigCommonSourceFiles( } //---------------------------------------------------------------------------- +void cmGeneratorTarget::GetObjectLibrariesCMP0026( + std::vector<cmGeneratorTarget*>& objlibs) const +{ + // At configure-time, this method can be called as part of getting the + // LOCATION property or to export() a file to be include()d. However + // there is no cmGeneratorTarget at configure-time, so search the SOURCES + // for TARGET_OBJECTS instead for backwards compatibility with OLD + // behavior of CMP0024 and CMP0026 only. + cmStringRange rng = this->Target->GetSourceEntries(); + for(std::vector<std::string>::const_iterator + i = rng.begin(); i != rng.end(); ++i) + { + std::string const& entry = *i; + + std::vector<std::string> files; + cmSystemTools::ExpandListArgument(entry, files); + for (std::vector<std::string>::const_iterator + li = files.begin(); li != files.end(); ++li) + { + if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") && + (*li)[li->size() - 1] == '>') + { + std::string objLibName = li->substr(17, li->size()-18); + + if (cmGeneratorExpression::Find(objLibName) != std::string::npos) + { + continue; + } + cmGeneratorTarget *objLib = + this->LocalGenerator->FindGeneratorTargetToUse(objLibName); + if(objLib) + { + objlibs.push_back(objLib); + } + } + } + } +} + +//---------------------------------------------------------------------------- +std::string cmGeneratorTarget::CheckCMP0004(std::string const& item) const +{ + // Strip whitespace off the library names because we used to do this + // in case variables were expanded at generate time. We no longer + // do the expansion but users link to libraries like " ${VAR} ". + std::string lib = item; + std::string::size_type pos = lib.find_first_not_of(" \t\r\n"); + if(pos != lib.npos) + { + lib = lib.substr(pos, lib.npos); + } + pos = lib.find_last_not_of(" \t\r\n"); + if(pos != lib.npos) + { + lib = lib.substr(0, pos+1); + } + if(lib != item) + { + cmake* cm = this->LocalGenerator->GetCMakeInstance(); + switch(this->GetPolicyStatusCMP0004()) + { + case cmPolicies::WARN: + { + std::ostringstream w; + w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0004) << "\n" + << "Target \"" << this->GetName() << "\" links to item \"" + << item << "\" which has leading or trailing whitespace."; + cm->IssueMessage(cmake::AUTHOR_WARNING, w.str(), + this->GetBacktrace()); + } + case cmPolicies::OLD: + break; + case cmPolicies::NEW: + { + std::ostringstream e; + e << "Target \"" << this->GetName() << "\" links to item \"" + << item << "\" which has leading or trailing whitespace. " + << "This is now an error according to policy CMP0004."; + cm->IssueMessage(cmake::FATAL_ERROR, e.str(), + this->GetBacktrace()); + } + break; + case cmPolicies::REQUIRED_IF_USED: + case cmPolicies::REQUIRED_ALWAYS: + { + std::ostringstream e; + e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0004) << "\n" + << "Target \"" << this->GetName() << "\" links to item \"" + << item << "\" which has leading or trailing whitespace."; + cm->IssueMessage(cmake::FATAL_ERROR, e.str(), + this->GetBacktrace()); + } + break; + } + } + return lib; +} + +//---------------------------------------------------------------------------- void cmGeneratorTarget::GetLanguages(std::set<std::string>& languages, const std::string& config) const { @@ -4490,16 +5753,15 @@ void cmGeneratorTarget::GetLanguages(std::set<std::string>& languages, std::vector<cmGeneratorTarget*> objectLibraries; std::vector<cmSourceFile const*> externalObjects; - if (!this->Makefile->IsConfigured()) + if (!this->GlobalGenerator->GetConfigureDoneCMP0026()) { - std::vector<cmTarget*> objectTargets; - this->Target->GetObjectLibrariesCMP0026(objectTargets); + std::vector<cmGeneratorTarget*> objectTargets; + this->GetObjectLibrariesCMP0026(objectTargets); objectLibraries.reserve(objectTargets.size()); - for (std::vector<cmTarget*>::const_iterator it = objectTargets.begin(); - it != objectTargets.end(); ++it) + for (std::vector<cmGeneratorTarget*>::const_iterator it = + objectTargets.begin(); it != objectTargets.end(); ++it) { - objectLibraries.push_back(this->GlobalGenerator - ->GetGeneratorTarget(*it)); + objectLibraries.push_back(*it); } } else @@ -4509,10 +5771,10 @@ void cmGeneratorTarget::GetLanguages(std::set<std::string>& languages, i = externalObjects.begin(); i != externalObjects.end(); ++i) { std::string objLib = (*i)->GetObjectLibrary(); - if (cmTarget* tgt = this->Makefile->FindTargetToUse(objLib)) + if (cmGeneratorTarget* tgt = + this->LocalGenerator->FindGeneratorTargetToUse(objLib)) { - objectLibraries.push_back(this->GlobalGenerator - ->GetGeneratorTarget(tgt)); + objectLibraries.push_back(tgt); } } } @@ -4540,14 +5802,317 @@ void cmGeneratorTarget::ComputeLinkImplementationLanguages( //---------------------------------------------------------------------------- bool cmGeneratorTarget::HaveBuildTreeRPATH(const std::string& config) const { - if (this->Target->GetPropertyAsBool("SKIP_BUILD_RPATH")) + if (this->GetPropertyAsBool("SKIP_BUILD_RPATH")) { return false; } if(cmLinkImplementationLibraries const* impl = - this->Target->GetLinkImplementationLibraries(config)) + this->GetLinkImplementationLibraries(config)) { return !impl->Libraries.empty(); } return false; } + +//---------------------------------------------------------------------------- +cmLinkImplementationLibraries const* +cmGeneratorTarget::GetLinkImplementationLibraries( + const std::string& config) const +{ + return this->GetLinkImplementationLibrariesInternal(config, this); +} + +//---------------------------------------------------------------------------- +cmLinkImplementationLibraries const* +cmGeneratorTarget::GetLinkImplementationLibrariesInternal( + const std::string& config, cmGeneratorTarget const* head) const +{ + // There is no link implementation for imported targets. + if(this->IsImported()) + { + return 0; + } + + // Populate the link implementation libraries for this configuration. + std::string CONFIG = cmSystemTools::UpperCase(config); + HeadToLinkImplementationMap& hm = + this->LinkImplMap[CONFIG]; + + // If the link implementation does not depend on the head target + // then return the one we computed first. + if(!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition) + { + return &hm.begin()->second; + } + + cmOptionalLinkImplementation& impl = hm[head]; + if(!impl.LibrariesDone) + { + impl.LibrariesDone = true; + this->ComputeLinkImplementationLibraries(config, impl, head); + } + return &impl; +} + +//---------------------------------------------------------------------------- +bool +cmGeneratorTarget::IsNullImpliedByLinkLibraries(const std::string &p) const +{ + return this->LinkImplicitNullProperties.find(p) + != this->LinkImplicitNullProperties.end(); +} + +//---------------------------------------------------------------------------- +void cmGeneratorTarget::ComputeLinkImplementationLibraries( + const std::string& config, + cmOptionalLinkImplementation& impl, + cmGeneratorTarget const* head) const +{ + cmStringRange entryRange = + this->Target->GetLinkImplementationEntries(); + cmBacktraceRange btRange = + this->Target->GetLinkImplementationBacktraces(); + cmBacktraceRange::const_iterator btIt = btRange.begin(); + // Collect libraries directly linked in this configuration. + for (cmStringRange::const_iterator le = entryRange.begin(), + end = entryRange.end(); le != end; ++le, ++btIt) + { + std::vector<std::string> llibs; + cmGeneratorExpressionDAGChecker dagChecker( + this->GetName(), + "LINK_LIBRARIES", 0, 0); + cmGeneratorExpression ge(*btIt); + cmsys::auto_ptr<cmCompiledGeneratorExpression> const cge = + ge.Parse(*le); + std::string const evaluated = + cge->Evaluate(this->LocalGenerator, config, false, head, &dagChecker); + cmSystemTools::ExpandListArgument(evaluated, llibs); + if(cge->GetHadHeadSensitiveCondition()) + { + impl.HadHeadSensitiveCondition = true; + } + + for(std::vector<std::string>::const_iterator li = llibs.begin(); + li != llibs.end(); ++li) + { + // Skip entries that resolve to the target itself or are empty. + std::string name = this->CheckCMP0004(*li); + if(name == this->GetName() || name.empty()) + { + if(name == this->GetName()) + { + bool noMessage = false; + cmake::MessageType messageType = cmake::FATAL_ERROR; + std::ostringstream e; + switch(this->GetPolicyStatusCMP0038()) + { + case cmPolicies::WARN: + { + e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0038) << "\n"; + messageType = cmake::AUTHOR_WARNING; + } + break; + case cmPolicies::OLD: + noMessage = true; + case cmPolicies::REQUIRED_IF_USED: + case cmPolicies::REQUIRED_ALWAYS: + case cmPolicies::NEW: + // Issue the fatal message. + break; + } + + if(!noMessage) + { + e << "Target \"" << this->GetName() << "\" links to itself."; + this->LocalGenerator->GetCMakeInstance()->IssueMessage( + messageType, e.str(), this->GetBacktrace()); + if (messageType == cmake::FATAL_ERROR) + { + return; + } + } + } + continue; + } + + // The entry is meant for this configuration. + impl.Libraries.push_back( + cmLinkImplItem(name, this->FindTargetToLink(name), + *btIt, evaluated != *le)); + } + + std::set<std::string> const& seenProps = cge->GetSeenTargetProperties(); + for (std::set<std::string>::const_iterator it = seenProps.begin(); + it != seenProps.end(); ++it) + { + if (!this->GetProperty(*it)) + { + this->LinkImplicitNullProperties.insert(*it); + } + } + cge->GetMaxLanguageStandard(this, + this->MaxLanguageStandards); + } + + // Get the list of configurations considered to be DEBUG. + std::vector<std::string> debugConfigs = + this->Makefile->GetCMakeInstance()->GetDebugConfigs(); + + cmTargetLinkLibraryType linkType = + CMP0003_ComputeLinkType(config, debugConfigs); + cmTarget::LinkLibraryVectorType const& oldllibs = + this->Target->GetOriginalLinkLibraries(); + for(cmTarget::LinkLibraryVectorType::const_iterator li = oldllibs.begin(); + li != oldllibs.end(); ++li) + { + if(li->second != GENERAL_LibraryType && li->second != linkType) + { + std::string name = this->CheckCMP0004(li->first); + if(name == this->GetName() || name.empty()) + { + continue; + } + // Support OLD behavior for CMP0003. + impl.WrongConfigLibraries.push_back( + cmLinkItem(name, this->FindTargetToLink(name))); + } + } +} + +//---------------------------------------------------------------------------- +cmGeneratorTarget* +cmGeneratorTarget::FindTargetToLink(std::string const& name) const +{ + cmGeneratorTarget* tgt = + this->LocalGenerator->FindGeneratorTargetToUse(name); + + // Skip targets that will not really be linked. This is probably a + // name conflict between an external library and an executable + // within the project. + if(tgt && tgt->GetType() == cmState::EXECUTABLE && + !tgt->IsExecutableWithExports()) + { + tgt = 0; + } + + if(tgt && tgt->GetType() == cmState::OBJECT_LIBRARY) + { + std::ostringstream e; + e << "Target \"" << this->GetName() << "\" links to " + "OBJECT library \"" << tgt->GetName() << "\" but this is not " + "allowed. " + "One may link only to STATIC or SHARED libraries, or to executables " + "with the ENABLE_EXPORTS property set."; + cmake* cm = this->LocalGenerator->GetCMakeInstance(); + cm->IssueMessage(cmake::FATAL_ERROR, e.str(), + this->GetBacktrace()); + tgt = 0; + } + + return tgt; +} + +//---------------------------------------------------------------------------- +std::string +cmGeneratorTarget::GetPDBDirectory(const std::string& config) const +{ + if(OutputInfo const* info = this->GetOutputInfo(config)) + { + // Return the directory in which the target will be built. + return info->PdbDir; + } + return ""; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::HasImplibGNUtoMS() const +{ + return this->HasImportLibrary() + && this->GetPropertyAsBool("GNUtoMS"); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::GetImplibGNUtoMS(std::string const& gnuName, + std::string& out, const char* newExt) const +{ + if(this->HasImplibGNUtoMS() && + gnuName.size() > 6 && gnuName.substr(gnuName.size()-6) == ".dll.a") + { + out = gnuName.substr(0, gnuName.size()-6); + out += newExt? newExt : ".lib"; + return true; + } + return false; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsExecutableWithExports() const +{ + return (this->GetType() == cmState::EXECUTABLE && + this->GetPropertyAsBool("ENABLE_EXPORTS")); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::HasImportLibrary() const +{ + return (this->IsDLLPlatform() && + (this->GetType() == cmState::SHARED_LIBRARY || + this->IsExecutableWithExports())); +} + +//---------------------------------------------------------------------------- +std::string cmGeneratorTarget::GetSupportDirectory() const +{ + std::string dir = this->LocalGenerator->GetCurrentBinaryDirectory(); + dir += cmake::GetCMakeFilesDirectory(); + dir += "/"; + dir += this->GetName(); +#if defined(__VMS) + dir += "_dir"; +#else + dir += ".dir"; +#endif + return dir; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsLinkable() const +{ + return (this->GetType() == cmState::STATIC_LIBRARY || + this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY || + this->GetType() == cmState::UNKNOWN_LIBRARY || + this->GetType() == cmState::INTERFACE_LIBRARY || + this->IsExecutableWithExports()); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsFrameworkOnApple() const +{ + return (this->GetType() == cmState::SHARED_LIBRARY && + this->Makefile->IsOn("APPLE") && + this->GetPropertyAsBool("FRAMEWORK")); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsAppBundleOnApple() const +{ + return (this->GetType() == cmState::EXECUTABLE && + this->Makefile->IsOn("APPLE") && + this->GetPropertyAsBool("MACOSX_BUNDLE")); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsXCTestOnApple() const +{ + return (this->IsCFBundleOnApple() && + this->GetPropertyAsBool("XCTEST")); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsCFBundleOnApple() const +{ + return (this->GetType() == cmState::MODULE_LIBRARY && + this->Makefile->IsOn("APPLE") && + this->GetPropertyAsBool("BUNDLE")); +} diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h index 06d9a1f..da59a98 100644 --- a/Source/cmGeneratorTarget.h +++ b/Source/cmGeneratorTarget.h @@ -31,8 +31,21 @@ public: cmLocalGenerator* GetLocalGenerator() const; bool IsImported() const; + bool IsImportedGloballyVisible() const; const char *GetLocation(const std::string& config) const; + std::vector<cmCustomCommand> const &GetPreBuildCommands() const; + std::vector<cmCustomCommand> const &GetPreLinkCommands() const; + std::vector<cmCustomCommand> const &GetPostBuildCommands() const; + +#define DECLARE_TARGET_POLICY(POLICY) \ + cmPolicies::PolicyStatus GetPolicyStatus ## POLICY () const \ + { return this->PolicyMap.Get(cmPolicies::POLICY); } + + CM_FOR_EACH_TARGET_POLICY(DECLARE_TARGET_POLICY) + +#undef DECLARE_TARGET_POLICY + /** Get the location of the target in the build tree with a placeholder referencing the configuration in the native build system. This location is suitable for use as the LOCATION target property. */ @@ -41,8 +54,11 @@ public: cmComputeLinkInformation* GetLinkInformation(const std::string& config) const; - int GetType() const; + cmState::TargetType GetType() const; std::string GetName() const; + std::string GetExportName() const; + + std::vector<std::string> GetPropertyKeys() const; const char *GetProperty(const std::string& prop) const; bool GetPropertyAsBool(const std::string& prop) const; void GetSourceFiles(std::vector<cmSourceFile*>& files, @@ -71,6 +87,8 @@ public: const std::string& config) const; void GetAppManifest(std::vector<cmSourceFile const*>&, const std::string& config) const; + void GetManifests(std::vector<cmSourceFile const*>&, + const std::string& config) const; void GetCertificates(std::vector<cmSourceFile const*>&, const std::string& config) const; void GetXamlSources(std::vector<cmSourceFile const*>&, @@ -80,6 +98,8 @@ public: void GetExpectedXamlSources(std::set<std::string>&, const std::string& config) const; + std::set<cmLinkItem>const& GetUtilityItems() const; + void ComputeObjectMapping(); const char* GetFeature(const std::string& feature, @@ -107,19 +127,19 @@ public: const std::string& config) const; cmLinkInterface const* GetLinkInterface(const std::string& config, - cmTarget const* headTarget) const; + const cmGeneratorTarget* headTarget) const; void ComputeLinkInterface(const std::string& config, cmOptionalLinkInterface& iface, - cmTarget const* head) const; + const cmGeneratorTarget* head) const; cmLinkInterfaceLibraries const* GetLinkInterfaceLibraries(const std::string& config, - cmTarget const* headTarget, + const cmGeneratorTarget* headTarget, bool usage_requirements_only) const; void ComputeLinkInterfaceLibraries(const std::string& config, cmOptionalLinkInterface &iface, - cmTarget const* head, + const cmGeneratorTarget* head, bool usage_requirements_only) const; /** Get the full path to the target according to the settings in its @@ -147,6 +167,10 @@ public: std::string GetFrameworkDirectory(const std::string& config, bool rootDir) const; + /** Return the framework version string. Undefined if + IsFrameworkOnApple returns false. */ + std::string GetFrameworkVersion() const; + /** @return the Mac CFBundle directory without the base */ std::string GetCFBundleDirectory(const std::string& config, bool contentOnly) const; @@ -160,6 +184,20 @@ public: * install tree. For example: "\@rpath/" or "\@loader_path/". */ std::string GetInstallNameDirForInstallTree() const; + cmListFileBacktrace GetBacktrace() const; + + const std::vector<std::string>& GetLinkDirectories() const; + + std::set<std::string>const& GetUtilities() const; + cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const; + + bool LinkLanguagePropagatesToDependents() const + { return this->GetType() == cmState::STATIC_LIBRARY; } + + /** Get the macro to define when building sources in this target. + If no macro should be defined null is returned. */ + const char* GetExportMacro() const; + /** Get the soname of the target. Allowed only for a shared library. */ std::string GetSOName(const std::string& config) const; @@ -184,6 +222,12 @@ public: std::string GetModuleDefinitionFile(const std::string& config) const; + /** Return whether or not the target is for a DLL platform. */ + bool IsDLLPlatform() const; + + /** @return whether this target have a well defined output file name. */ + bool HaveWellDefinedOutputFiles() const; + /** Link information from the transitive closure of the link implementation and the interfaces of its dependencies. */ struct LinkClosure @@ -205,6 +249,15 @@ public: cmOptionalLinkImplementation& impl ) const; + cmLinkImplementationLibraries const* + GetLinkImplementationLibraries(const std::string& config) const; + + void ComputeLinkImplementationLibraries(const std::string& config, + cmOptionalLinkImplementation& impl, + const cmGeneratorTarget* head) const; + + cmGeneratorTarget* FindTargetToLink(std::string const& name) const; + // Compute the set of languages compiled by the target. This is // computed every time it is called because the languages can change // when source file properties are changed and we do not have enough @@ -213,6 +266,12 @@ public: void GetLanguages(std::set<std::string>& languages, std::string const& config) const; + void + GetObjectLibrariesCMP0026(std::vector<cmGeneratorTarget*>& objlibs) const; + + std::string GetFullNameImported(const std::string& config, + bool implib) const; + bool GetConfigCommonSourceFiles(std::vector<cmSourceFile*>& files) const; bool HaveBuildTreeRPATH(const std::string& config) const; @@ -259,6 +318,13 @@ public: */ void TraceDependencies(); + /** Get the directory in which this target will be built. If the + configuration name is given then the generator will add its + subdirectory for that configuration. Otherwise just the canonical + output directory is given. */ + std::string GetDirectory(const std::string& config = "", + bool implib = false) const; + /** Get the directory in which to place the target compiler .pdb file. If the configuration name is given then the generator will add its subdirectory for that configuration. Otherwise just the canonical @@ -269,6 +335,22 @@ public: std::vector<cmSourceFile*> const* GetSourceDepends(cmSourceFile const* sf) const; + /** Return whether this target uses the default value for its output + directory. */ + bool UsesDefaultOutputDir(const std::string& config, bool implib) const; + + // Cache target output paths for each configuration. + struct OutputInfo + { + std::string OutDir; + std::string ImpDir; + std::string PdbDir; + bool empty() const + { return OutDir.empty() && ImpDir.empty() && PdbDir.empty(); } + }; + + OutputInfo const* GetOutputInfo(const std::string& config) const; + /** Get the name of the pdb file for the target. */ std::string GetPDBName(const std::string& config="") const; @@ -285,6 +367,8 @@ public: typedef std::map<std::string, CompileInfo> CompileInfoMapType; mutable CompileInfoMapType CompileInfoMap; + bool IsNullImpliedByLinkLibraries(const std::string &p) const; + /** Get the name of the compiler pdb file for the target. */ std::string GetCompilePDBName(const std::string& config="") const; @@ -294,6 +378,9 @@ public: // Get the target base name. std::string GetOutputName(const std::string& config, bool implib) const; + void AddSource(const std::string& src); + void AddTracedSources(std::vector<std::string> const& srcs); + /** * Flags for a given source file as used in this target. Typically assigned * via SET_TARGET_PROPERTIES when the property is a list of source files. @@ -340,9 +427,47 @@ public: /** Return true if builtin chrpath will work for this target */ bool IsChrpathUsed(const std::string& config) const; + /** Get the directory in which this targets .pdb files will be placed. + If the configuration name is given then the generator will add its + subdirectory for that configuration. Otherwise just the canonical + pdb output directory is given. */ + std::string GetPDBDirectory(const std::string& config) const; + ///! Return the preferred linker language for this target std::string GetLinkerLanguage(const std::string& config = "") const; + /** Does this target have a GNU implib to convert to MS format? */ + bool HasImplibGNUtoMS() const; + + /** Convert the given GNU import library name (.dll.a) to a name with a new + extension (.lib or ${CMAKE_IMPORT_LIBRARY_SUFFIX}). */ + bool GetImplibGNUtoMS(std::string const& gnuName, std::string& out, + const char* newExt = 0) const; + + bool IsExecutableWithExports() const; + + /** Return whether or not the target has a DLL import library. */ + bool HasImportLibrary() const; + + /** Get a build-tree directory in which to place target support files. */ + std::string GetSupportDirectory() const; + + /** Return whether this target may be used to link another target. */ + bool IsLinkable() const; + + /** Return whether this target is a shared library Framework on + Apple. */ + bool IsFrameworkOnApple() const; + + /** Return whether this target is an executable Bundle on Apple. */ + bool IsAppBundleOnApple() const; + + /** Return whether this target is a XCTest on Apple. */ + bool IsXCTestOnApple() const; + + /** Return whether this target is a CFBundle (plugin) on Apple. */ + bool IsCFBundleOnApple() const; + struct SourceFileFlags GetTargetSourceFileFlags(const cmSourceFile* sf) const; @@ -364,15 +489,42 @@ public: class TargetPropertyEntry; + bool HaveInstallTreeRPATH() const; + + /** Whether this library has \@rpath and platform supports it. */ + bool HasMacOSXRpathInstallNameDir(const std::string& config) const; + + /** Whether this library defaults to \@rpath. */ + bool MacOSXRpathInstallNameDirDefault() const; + + /** Test for special case of a third-party shared library that has + no soname at all. */ + bool IsImportedSharedLibWithoutSOName(const std::string& config) const; + + const char* ImportedGetLocation(const std::string& config) const; + + /** Get the target major and minor version numbers interpreted from + the VERSION property. Version 0 is returned if the property is + not set or cannot be parsed. */ + void GetTargetVersion(int& major, int& minor) const; + + /** Get the target major, minor, and patch version numbers + interpreted from the VERSION or SOVERSION property. Version 0 + is returned if the property is not set or cannot be parsed. */ + void + GetTargetVersion(bool soversion, int& major, int& minor, int& patch) const; + private: friend class cmTargetTraceDependencies; struct SourceEntry { std::vector<cmSourceFile*> Depends; }; typedef std::map<cmSourceFile const*, SourceEntry> SourceEntriesType; - SourceEntriesType SourceEntries; + SourceEntriesType SourceDepends; mutable std::map<cmSourceFile const*, std::string> Objects; std::set<cmSourceFile const*> ExplicitObjectName; mutable std::map<std::string, std::vector<std::string> > SystemIncludesCache; + mutable std::string ExportMacro; + void ConstructSourceFileFlags() const; mutable bool SourceFileFlagsConstructed; mutable std::map<cmSourceFile const*, SourceFileFlags> SourceFlagsMap; @@ -388,6 +540,16 @@ private: typedef std::map<std::string, LinkClosure> LinkClosureMapType; mutable LinkClosureMapType LinkClosureMap; + // Returns ARCHIVE, LIBRARY, or RUNTIME based on platform and type. + const char* GetOutputTargetType(bool implib) const; + + void ComputeVersionedName(std::string& vName, + std::string const& prefix, + std::string const& base, + std::string const& suffix, + std::string const& name, + const char* version) const; + struct CompatibleInterfacesBase { std::set<std::string> PropsBool; @@ -415,7 +577,7 @@ private: cmGeneratorTarget(cmGeneratorTarget const&); void operator=(cmGeneratorTarget const&); - struct LinkImplClosure: public std::vector<cmTarget const*> + struct LinkImplClosure: public std::vector<cmGeneratorTarget const*> { LinkImplClosure(): Done(false) {} bool Done; @@ -432,44 +594,108 @@ private: cmHeadToLinkInterfaceMap& GetHeadToLinkInterfaceUsageRequirementsMap( std::string const& config) const; + // Cache import information from properties for each configuration. + struct ImportInfo + { + ImportInfo(): NoSOName(false), Multiplicity(0) {} + bool NoSOName; + int Multiplicity; + std::string Location; + std::string SOName; + std::string ImportLibrary; + std::string Languages; + std::string Libraries; + std::string LibrariesProp; + std::string SharedDeps; + }; + + typedef std::map<std::string, ImportInfo> ImportInfoMapType; + mutable ImportInfoMapType ImportInfoMap; + void ComputeImportInfo(std::string const& desired_config, + ImportInfo& info) const; + ImportInfo const* GetImportInfo(const std::string& config) const; + + /** Strip off leading and trailing whitespace from an item named in + the link dependencies of this target. */ + std::string CheckCMP0004(std::string const& item) const; + cmLinkInterface const* - GetImportLinkInterface(const std::string& config, cmTarget const* head, + GetImportLinkInterface(const std::string& config, + const cmGeneratorTarget* head, bool usage_requirements_only) const; + typedef std::map<std::string, std::vector<cmSourceFile*> > + SourceFilesMapType; + mutable SourceFilesMapType SourceFilesMap; + std::vector<TargetPropertyEntry*> IncludeDirectoriesEntries; std::vector<TargetPropertyEntry*> CompileOptionsEntries; std::vector<TargetPropertyEntry*> CompileFeaturesEntries; std::vector<TargetPropertyEntry*> CompileDefinitionsEntries; + std::vector<TargetPropertyEntry*> SourceEntries; + mutable std::set<std::string> LinkImplicitNullProperties; void ExpandLinkItems(std::string const& prop, std::string const& value, - std::string const& config, cmTarget const* headTarget, + std::string const& config, + const cmGeneratorTarget* headTarget, bool usage_requirements_only, std::vector<cmLinkItem>& items, bool& hadHeadSensitiveCondition) const; void LookupLinkItems(std::vector<std::string> const& names, std::vector<cmLinkItem>& items) const; + void GetSourceFiles(std::vector<std::string>& files, + const std::string& config) const; + + struct HeadToLinkImplementationMap: + public std::map<cmGeneratorTarget const*, cmOptionalLinkImplementation> {}; + typedef std::map<std::string, + HeadToLinkImplementationMap> LinkImplMapType; + mutable LinkImplMapType LinkImplMap; + + cmLinkImplementationLibraries const* + GetLinkImplementationLibrariesInternal(const std::string& config, + const cmGeneratorTarget* head) const; + bool + ComputeOutputDir(const std::string& config, + bool implib, std::string& out) const; + + typedef std::map<std::string, OutputInfo> OutputInfoMapType; + mutable OutputInfoMapType OutputInfoMap; + typedef std::pair<std::string, bool> OutputNameKey; typedef std::map<OutputNameKey, std::string> OutputNameMapType; mutable OutputNameMapType OutputNameMap; + mutable std::set<cmLinkItem> UtilityItems; + cmPolicies::PolicyMap PolicyMap; mutable bool PolicyWarnedCMP0022; mutable bool DebugIncludesDone; mutable bool DebugCompileOptionsDone; mutable bool DebugCompileFeaturesDone; mutable bool DebugCompileDefinitionsDone; + mutable bool DebugSourcesDone; + mutable bool LinkImplementationLanguageIsContextDependent; + mutable bool UtilityItemsDone; + bool DLLPlatform; + + bool ComputePDBOutputDir(const std::string& kind, const std::string& config, + std::string& out) const; public: - std::vector<cmTarget const*> const& - GetLinkImplementationClosure(const std::string& config) const; + const std::vector<const cmGeneratorTarget*>& + GetLinkImplementationClosure(const std::string& config) const; -}; + mutable std::map<std::string, std::string> MaxLanguageStandards; + std::map<std::string, std::string> const& + GetMaxLanguageStandards() const + { + return this->MaxLanguageStandards; + } -struct cmStrictTargetComparison { - bool operator()(cmTarget const* t1, cmTarget const* t2) const; + struct StrictTargetComparison { + bool operator()(cmGeneratorTarget const* t1, + cmGeneratorTarget const* t2) const; + }; }; -typedef std::map<cmTarget const*, - cmGeneratorTarget*, - cmStrictTargetComparison> cmGeneratorTargetsType; - #endif diff --git a/Source/cmGetCMakePropertyCommand.cxx b/Source/cmGetCMakePropertyCommand.cxx index 248ce59..1a91183 100644 --- a/Source/cmGetCMakePropertyCommand.cxx +++ b/Source/cmGetCMakePropertyCommand.cxx @@ -12,7 +12,6 @@ #include "cmGetCMakePropertyCommand.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmake.h" #include "cmState.h" #include "cmAlgorithms.h" diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx index 4c42f53..617a811 100644 --- a/Source/cmGetPropertyCommand.cxx +++ b/Source/cmGetPropertyCommand.cxx @@ -15,7 +15,6 @@ #include "cmState.h" #include "cmTest.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSourceFile.h" #include "cmPropertyDefinition.h" diff --git a/Source/cmGhsMultiTargetGenerator.cxx b/Source/cmGhsMultiTargetGenerator.cxx index 846b6e2..18e140e 100644 --- a/Source/cmGhsMultiTargetGenerator.cxx +++ b/Source/cmGhsMultiTargetGenerator.cxx @@ -22,23 +22,22 @@ std::string const cmGhsMultiTargetGenerator::DDOption("-dynamic"); cmGhsMultiTargetGenerator::cmGhsMultiTargetGenerator(cmGeneratorTarget *target) - : Target(target->Target) - , GeneratorTarget(target) + : GeneratorTarget(target) , LocalGenerator(static_cast<cmLocalGhsMultiGenerator *>( target->GetLocalGenerator())) , Makefile(target->Target->GetMakefile()) - , TargetGroup(DetermineIfTargetGroup(target->Target)) + , TargetGroup(DetermineIfTargetGroup(target)) , DynamicDownload(false) { - this->RelBuildFilePath = this->GetRelBuildFilePath(target->Target); + this->RelBuildFilePath = this->GetRelBuildFilePath(target); this->RelOutputFileName = - this->RelBuildFilePath + this->Target->GetName() + ".a"; + this->RelBuildFilePath + target->GetName() + ".a"; this->RelBuildFileName = this->RelBuildFilePath; - this->RelBuildFileName += this->GetBuildFileName(target->Target); + this->RelBuildFileName += this->GetBuildFileName(target); - std::string absPathToRoot = this->GetAbsPathToRoot(target->Target); + std::string absPathToRoot = this->GetAbsPathToRoot(target); absPathToRoot = this->AddSlashIfNeededToPath(absPathToRoot); this->AbsBuildFilePath = absPathToRoot + this->RelBuildFilePath; this->AbsBuildFileName = absPathToRoot + this->RelBuildFileName; @@ -51,7 +50,8 @@ cmGhsMultiTargetGenerator::~cmGhsMultiTargetGenerator() } std::string -cmGhsMultiTargetGenerator::GetRelBuildFilePath(const cmTarget *target) +cmGhsMultiTargetGenerator::GetRelBuildFilePath( + const cmGeneratorTarget *target) { std::string output; char const *folderProp = target->GetProperty("FOLDER"); @@ -66,13 +66,13 @@ cmGhsMultiTargetGenerator::GetRelBuildFilePath(const cmTarget *target) } std::string -cmGhsMultiTargetGenerator::GetAbsPathToRoot(const cmTarget *target) +cmGhsMultiTargetGenerator::GetAbsPathToRoot(const cmGeneratorTarget *target) { - return target->GetMakefile()->GetHomeOutputDirectory(); + return target->GetLocalGenerator()->GetBinaryDirectory(); } std::string -cmGhsMultiTargetGenerator::GetAbsBuildFilePath(const cmTarget *target) +cmGhsMultiTargetGenerator::GetAbsBuildFilePath(const cmGeneratorTarget *target) { std::string output; output = cmGhsMultiTargetGenerator::GetAbsPathToRoot(target); @@ -82,7 +82,7 @@ cmGhsMultiTargetGenerator::GetAbsBuildFilePath(const cmTarget *target) } std::string -cmGhsMultiTargetGenerator::GetRelBuildFileName(const cmTarget *target) +cmGhsMultiTargetGenerator::GetRelBuildFileName(const cmGeneratorTarget *target) { std::string output; output = cmGhsMultiTargetGenerator::GetRelBuildFilePath(target); @@ -91,7 +91,8 @@ cmGhsMultiTargetGenerator::GetRelBuildFileName(const cmTarget *target) return output; } -std::string cmGhsMultiTargetGenerator::GetBuildFileName(const cmTarget *target) +std::string +cmGhsMultiTargetGenerator::GetBuildFileName(const cmGeneratorTarget *target) { std::string output; output = target->GetName(); @@ -146,15 +147,11 @@ void cmGhsMultiTargetGenerator::Generate() this->WriteCompilerFlags(config, language); this->WriteCompilerDefinitions(config, language); this->WriteIncludes(config, language); - if (this->Target->GetType() == cmTarget::EXECUTABLE) + if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { this->WriteTargetLinkLibraries(); } this->WriteCustomCommands(); - if (this->DynamicDownload) - { - *this->GetFolderBuildStreams() << " " << this->DDOption << std::endl; - } this->WriteSources(objectSources); } @@ -163,7 +160,8 @@ void cmGhsMultiTargetGenerator::Generate() bool cmGhsMultiTargetGenerator::IncludeThisTarget() { bool output = true; - char const *excludeFromAll = this->Target->GetProperty("EXCLUDE_FROM_ALL"); + char const *excludeFromAll = + this->GeneratorTarget->GetProperty("EXCLUDE_FROM_ALL"); if (NULL != excludeFromAll && '1' == excludeFromAll[0] && '\0' == excludeFromAll[1]) { @@ -176,23 +174,24 @@ std::vector<cmSourceFile *> cmGhsMultiTargetGenerator::GetSources() const { std::vector<cmSourceFile *> output; std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); - this->Target->GetSourceFiles(output, config); + this->GeneratorTarget->GetSourceFiles(output, config); return output; } GhsMultiGpj::Types cmGhsMultiTargetGenerator::GetGpjTag() const { - return cmGhsMultiTargetGenerator::GetGpjTag(this->Target); + return cmGhsMultiTargetGenerator::GetGpjTag(this->GeneratorTarget); } -GhsMultiGpj::Types cmGhsMultiTargetGenerator::GetGpjTag(const cmTarget *target) +GhsMultiGpj::Types cmGhsMultiTargetGenerator::GetGpjTag( + const cmGeneratorTarget *target) { GhsMultiGpj::Types output; if (cmGhsMultiTargetGenerator::DetermineIfTargetGroup(target)) { output = GhsMultiGpj::INTERGRITY_APPLICATION; } - else if (target->GetType() == cmTarget::STATIC_LIBRARY) + else if (target->GetType() == cmState::STATIC_LIBRARY) { output = GhsMultiGpj::LIBRARY; } @@ -216,13 +215,13 @@ void cmGhsMultiTargetGenerator::WriteTypeSpecifics(const std::string &config, std::string outputDir(this->GetOutputDirectory(config)); std::string outputFilename(this->GetOutputFilename(config)); - if (this->Target->GetType() == cmTarget::STATIC_LIBRARY) + if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) { - *this->GetFolderBuildStreams() << " {optgroup=GhsCommonOptions} -o \"" + *this->GetFolderBuildStreams() << " -o \"" << outputDir << outputFilename << ".a\"" << std::endl; } - else if (this->Target->GetType() == cmTarget::EXECUTABLE) + else if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { if (notKernel && !this->IsTargetGroup()) { @@ -230,14 +229,16 @@ void cmGhsMultiTargetGenerator::WriteTypeSpecifics(const std::string &config, } if (this->IsTargetGroup()) { - *this->GetFolderBuildStreams() << " -non_shared" << std::endl; - *this->GetFolderBuildStreams() << " -o \"" << outputDir - << outputFilename << ".elf\"" + *this->GetFolderBuildStreams() + << " -o \"" << outputDir + << outputFilename << ".elf\"" << std::endl; + *this->GetFolderBuildStreams() << " :extraOutputFile=\"" << outputDir + << outputFilename << ".elf.ael\"" << std::endl; } else { - *this->GetFolderBuildStreams() << " {optgroup=GhsCommonOptions} -o \"" + *this->GetFolderBuildStreams() << " -o \"" << outputDir << outputFilename << ".as\"" << std::endl; } @@ -264,8 +265,11 @@ void cmGhsMultiTargetGenerator::SetCompilerFlags(std::string const &config, this->LocalGenerator->AddLanguageFlags( flags, lang + std::string("_GHS_KERNEL"), config); } - this->LocalGenerator->AddCMP0018Flags(flags, this->Target, lang, config); - this->LocalGenerator->AddVisibilityPresetFlags(flags, this->Target, lang); + this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget, + lang, config); + this->LocalGenerator->AddVisibilityPresetFlags(flags, + this->GeneratorTarget, + lang); // Append old-style preprocessor definition flags. if (std::string(" ") != std::string(this->Makefile->GetDefineFlags())) @@ -275,7 +279,8 @@ void cmGhsMultiTargetGenerator::SetCompilerFlags(std::string const &config, } // Add target-specific flags. - this->LocalGenerator->AddCompileOptions(flags, this->Target, lang, config); + this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, + lang, config); std::map<std::string, std::string>::value_type entry(language, flags); i = this->FlagsByLanguage.insert(entry).first; @@ -292,13 +297,14 @@ std::string cmGhsMultiTargetGenerator::GetDefines(const std::string &language, std::set<std::string> defines; const char *lang = language.c_str(); // Add the export symbol definition for shared library objects. - if (const char *exportMacro = this->Target->GetExportMacro()) + if (const char *exportMacro = this->GeneratorTarget->GetExportMacro()) { this->LocalGenerator->AppendDefines(defines, exportMacro); } // Add preprocessor definitions for this target and configuration. - this->LocalGenerator->AddCompileDefinitions(defines, this->Target, config, + this->LocalGenerator->AddCompileDefinitions(defines, + this->GeneratorTarget, config, language); std::string definesString; @@ -361,13 +367,13 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries() for (cmTargetDependSet::iterator tdsI = tds.begin(); tdsI != tds.end(); ++tdsI) { - const cmTarget *tg = (*tdsI)->Target; + const cmGeneratorTarget *tg = *tdsI; *this->GetFolderBuildStreams() << " -L\"" << GetAbsBuildFilePath(tg) << "\"" << std::endl; } // library targets cmTarget::LinkLibraryVectorType llv = - this->Target->GetOriginalLinkLibraries(); + this->GeneratorTarget->Target->GetOriginalLinkLibraries(); for (cmTarget::LinkLibraryVectorType::const_iterator llvI = llv.begin(); llvI != llv.end(); ++llvI) { @@ -385,10 +391,12 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries() void cmGhsMultiTargetGenerator::WriteCustomCommands() { - WriteCustomCommandsHelper(this->Target->GetPreBuildCommands(), - cmTarget::PRE_BUILD); - WriteCustomCommandsHelper(this->Target->GetPostBuildCommands(), - cmTarget::POST_BUILD); + WriteCustomCommandsHelper( + this->GeneratorTarget->GetPreBuildCommands(), + cmTarget::PRE_BUILD); + WriteCustomCommandsHelper( + this->GeneratorTarget->GetPostBuildCommands(), + cmTarget::POST_BUILD); } void cmGhsMultiTargetGenerator::WriteCustomCommandsHelper( @@ -451,17 +459,20 @@ void cmGhsMultiTargetGenerator::WriteSources( cmSystemTools::ConvertToUnixSlashes(sgPath); cmGlobalGhsMultiGenerator::AddFilesUpToPath( this->GetFolderBuildStreams(), &this->FolderBuildStreams, - this->Makefile->GetHomeOutputDirectory(), sgPath, + this->LocalGenerator->GetBinaryDirectory(), sgPath, GhsMultiGpj::SUBPROJECT, this->RelBuildFilePath); - if ((*si)->GetExtension() == ".int") + std::string fullSourcePath((*si)->GetFullPath()); + if ((*si)->GetExtension() == "int" || (*si)->GetExtension() == "bsp") { - *this->FolderBuildStreams[sgPath] << "\"" << (*si)->GetFullPath() << "\"" - << std::endl; + *this->FolderBuildStreams[sgPath] << fullSourcePath << std::endl; } else { - *this->FolderBuildStreams[sgPath] << (*si)->GetFullPath() << std::endl; + //WORKAROUND: GHS MULTI needs the path to use backslashes without quotes + // to open files in search as of version 6.1.6 + cmsys::SystemTools::ReplaceString(fullSourcePath, "/", "\\"); + *this->FolderBuildStreams[sgPath] << fullSourcePath << std::endl; } if ("ld" != (*si)->GetExtension() && "int" != (*si)->GetExtension() && @@ -509,7 +520,7 @@ cmGhsMultiTargetGenerator::GetOutputDirectory(const std::string &config) const std::string outputDir(AbsBuildFilePath); const char *runtimeOutputProp = - this->Target->GetProperty("RUNTIME_OUTPUT_DIRECTORY"); + this->GeneratorTarget->GetProperty("RUNTIME_OUTPUT_DIRECTORY"); if (NULL != runtimeOutputProp) { outputDir = runtimeOutputProp; @@ -517,7 +528,8 @@ cmGhsMultiTargetGenerator::GetOutputDirectory(const std::string &config) const std::string configCapped(cmSystemTools::UpperCase(config)); const char *runtimeOutputSProp = - this->Target->GetProperty("RUNTIME_OUTPUT_DIRECTORY_" + configCapped); + this->GeneratorTarget + ->GetProperty("RUNTIME_OUTPUT_DIRECTORY_" + configCapped); if (NULL != runtimeOutputSProp) { outputDir = runtimeOutputSProp; @@ -535,9 +547,10 @@ cmGhsMultiTargetGenerator::GetOutputDirectory(const std::string &config) const std::string cmGhsMultiTargetGenerator::GetOutputFilename(const std::string &config) const { - std::string outputFilename(this->Target->GetName()); + std::string outputFilename(this->GeneratorTarget->GetName()); - const char *outputNameProp = this->Target->GetProperty("OUTPUT_NAME"); + const char *outputNameProp = + this->GeneratorTarget->GetProperty("OUTPUT_NAME"); if (NULL != outputNameProp) { outputFilename = outputNameProp; @@ -545,7 +558,7 @@ cmGhsMultiTargetGenerator::GetOutputFilename(const std::string &config) const std::string configCapped(cmSystemTools::UpperCase(config)); const char *outputNameSProp = - this->Target->GetProperty(configCapped + "_OUTPUT_NAME"); + this->GeneratorTarget->GetProperty(configCapped + "_OUTPUT_NAME"); if (NULL != outputNameSProp) { outputFilename = outputNameSProp; @@ -565,12 +578,13 @@ bool cmGhsMultiTargetGenerator::IsNotKernel(std::string const &config, return output; } -bool cmGhsMultiTargetGenerator::DetermineIfTargetGroup(const cmTarget *target) +bool cmGhsMultiTargetGenerator::DetermineIfTargetGroup( + const cmGeneratorTarget *target) { bool output = false; std::vector<cmSourceFile *> sources; std::string config = - target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); + target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); target->GetSourceFiles(sources, config); for (std::vector<cmSourceFile *>::const_iterator sources_i = sources.begin(); sources.end() != sources_i; ++sources_i) diff --git a/Source/cmGhsMultiTargetGenerator.h b/Source/cmGhsMultiTargetGenerator.h index c29a31e..327fdef 100644 --- a/Source/cmGhsMultiTargetGenerator.h +++ b/Source/cmGhsMultiTargetGenerator.h @@ -36,7 +36,7 @@ public: bool IncludeThisTarget(); std::vector<cmSourceFile *> GetSources() const; GhsMultiGpj::Types GetGpjTag() const; - static GhsMultiGpj::Types GetGpjTag(const cmTarget *target); + static GhsMultiGpj::Types GetGpjTag(const cmGeneratorTarget* target); const char *GetAbsBuildFilePath() const { return this->AbsBuildFilePath.c_str(); @@ -54,11 +54,11 @@ public: return this->AbsOutputFileName.c_str(); } - static std::string GetRelBuildFilePath(const cmTarget *target); - static std::string GetAbsPathToRoot(const cmTarget *target); - static std::string GetAbsBuildFilePath(const cmTarget *target); - static std::string GetRelBuildFileName(const cmTarget *target); - static std::string GetBuildFileName(const cmTarget *target); + static std::string GetRelBuildFilePath(const cmGeneratorTarget *target); + static std::string GetAbsPathToRoot(const cmGeneratorTarget *target); + static std::string GetAbsBuildFilePath(const cmGeneratorTarget *target); + static std::string GetRelBuildFileName(const cmGeneratorTarget *target); + static std::string GetBuildFileName(const cmGeneratorTarget *target); static std::string AddSlashIfNeededToPath(std::string const &input); private: @@ -95,11 +95,10 @@ private: std::string GetOutputFilename(const std::string &config) const; bool IsNotKernel(std::string const &config, const std::string &language); - static bool DetermineIfTargetGroup(const cmTarget *target); + static bool DetermineIfTargetGroup(const cmGeneratorTarget* target); bool DetermineIfDynamicDownload(std::string const &config, const std::string &language); - cmTarget *Target; cmGeneratorTarget* GeneratorTarget; cmLocalGhsMultiGenerator *LocalGenerator; cmMakefile *Makefile; diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index 49f3b29..3d2db42 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -14,20 +14,6 @@ #if defined(_MSC_VER) && _MSC_VER >= 1800 # define KWSYS_WINDOWS_DEPRECATED_GetVersionEx #endif -typedef struct { - ULONG dwOSVersionInfoSize; - ULONG dwMajorVersion; - ULONG dwMinorVersion; - ULONG dwBuildNumber; - ULONG dwPlatformId; - WCHAR szCSDVersion[128]; - USHORT wServicePackMajor; - USHORT wServicePackMinor; - USHORT wSuiteMask; - UCHAR wProductType; - UCHAR wReserved; -} CMRTL_OSVERSIONINFOEXW; - #endif #include "cmGlobalGenerator.h" @@ -36,7 +22,7 @@ typedef struct { #include "cmake.h" #include "cmState.h" #include "cmMakefile.h" -#include "cmQtAutoGenerators.h" +#include "cmQtAutoGeneratorInitializer.h" #include "cmSourceFile.h" #include "cmVersion.h" #include "cmTargetExport.h" @@ -62,6 +48,18 @@ typedef struct { #include <assert.h> +bool cmTarget::StrictTargetComparison::operator()(cmTarget const* t1, + cmTarget const* t2) const +{ + int nameResult = strcmp(t1->GetName().c_str(), t2->GetName().c_str()); + if (nameResult == 0) + { + return strcmp(t1->GetMakefile()->GetCurrentBinaryDirectory(), + t2->GetMakefile()->GetCurrentBinaryDirectory()) < 0; + } + return nameResult < 0; +} + cmGlobalGenerator::cmGlobalGenerator(cmake* cm) : CMakeInstance(cm) { @@ -86,6 +84,8 @@ cmGlobalGenerator::cmGlobalGenerator(cmake* cm) this->ExtraGenerator = 0; this->CurrentMakefile = 0; this->TryCompileOuterMakefile = 0; + + this->ConfigureDoneCMP0026AndCMP0024 = false; } cmGlobalGenerator::~cmGlobalGenerator() @@ -246,6 +246,16 @@ bool cmGlobalGenerator::GenerateImportFile(const std::string &file) if (it != this->BuildExportSets.end()) { bool result = it->second->GenerateImportFile(); + + if (!this->ConfigureDoneCMP0026AndCMP0024) + { + for (std::vector<cmMakefile*>::const_iterator mit = + this->Makefiles.begin(); mit != this->Makefiles.end(); ++mit) + { + (*mit)->RemoveExportBuildFileGeneratorCMP0024(it->second); + } + } + delete it->second; it->second = 0; this->BuildExportSets.erase(it); @@ -411,7 +421,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages, bool fatalError = false; mf->AddDefinition("RUN_CONFIGURE", true); - std::string rootBin = mf->GetHomeOutputDirectory(); + std::string rootBin = this->CMakeInstance->GetHomeOutputDirectory(); rootBin += cmake::GetCMakeFilesDirectory(); // If the configuration files path has been set, @@ -446,45 +456,26 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages, if (!mf->GetDefinition("CMAKE_SYSTEM")) { #if defined(_WIN32) && !defined(__CYGWIN__) - CMRTL_OSVERSIONINFOEXW osviex; + /* Windows version number data. */ + OSVERSIONINFOEXW osviex; ZeroMemory(&osviex, sizeof(osviex)); osviex.dwOSVersionInfoSize = sizeof(osviex); - typedef LONG (FAR WINAPI *cmRtlGetVersion)(CMRTL_OSVERSIONINFOEXW*); - cmRtlGetVersion rtlGetVersion = reinterpret_cast<cmRtlGetVersion>( - GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "RtlGetVersion")); - if (rtlGetVersion && rtlGetVersion(&osviex) == 0) - { - std::ostringstream windowsVersionString; - windowsVersionString << osviex.dwMajorVersion << "." - << osviex.dwMinorVersion << "." - << osviex.dwBuildNumber; - windowsVersionString.str(); - mf->AddDefinition("CMAKE_HOST_SYSTEM_VERSION", - windowsVersionString.str().c_str()); - } - else - { - // RtlGetVersion failed, so use the deprecated GetVersionEx function. - /* Windows version number data. */ - OSVERSIONINFO osvi; - ZeroMemory(&osvi, sizeof(osvi)); - osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); #ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx # pragma warning (push) # pragma warning (disable:4996) #endif - GetVersionEx (&osvi); + GetVersionExW((OSVERSIONINFOW*)&osviex); #ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx # pragma warning (pop) #endif - std::ostringstream windowsVersionString; - windowsVersionString << osvi.dwMajorVersion << "." - << osvi.dwMinorVersion; - windowsVersionString.str(); - mf->AddDefinition("CMAKE_HOST_SYSTEM_VERSION", - windowsVersionString.str().c_str()); - } + std::ostringstream windowsVersionString; + windowsVersionString << osviex.dwMajorVersion << "." + << osviex.dwMinorVersion << "." + << osviex.dwBuildNumber; + windowsVersionString.str(); + mf->AddDefinition("CMAKE_HOST_SYSTEM_VERSION", + windowsVersionString.str().c_str()); #endif // Read the DetermineSystem file std::string systemFile = mf->GetModulesFile("CMakeDetermineSystem.cmake"); @@ -1122,30 +1113,43 @@ void cmGlobalGenerator::ClearEnabledLanguages() return this->CMakeInstance->GetState()->ClearEnabledLanguages(); } +void cmGlobalGenerator::CreateLocalGenerators() +{ + cmDeleteAll(this->LocalGenerators); + this->LocalGenerators.clear(); + this->LocalGenerators.reserve(this->Makefiles.size()); + for (std::vector<cmMakefile*>::const_iterator it = this->Makefiles.begin(); + it != this->Makefiles.end(); ++it) + { + this->LocalGenerators.push_back(this->CreateLocalGenerator(*it)); + } +} + void cmGlobalGenerator::Configure() { this->FirstTimeProgress = 0.0f; this->ClearGeneratorMembers(); - cmMakefile* dirMf = - new cmMakefile(this, this->GetCMakeInstance()->GetCurrentSnapshot()); - this->Makefiles.push_back(dirMf); - cmLocalGenerator *lg = this->CreateLocalGenerator(dirMf); - this->LocalGenerators.push_back(lg); + cmState::Snapshot snapshot = this->CMakeInstance->GetCurrentSnapshot(); - // set the Start directories - dirMf->SetCurrentSourceDirectory + snapshot.GetDirectory().SetCurrentSource (this->CMakeInstance->GetHomeDirectory()); - dirMf->SetCurrentBinaryDirectory + snapshot.GetDirectory().SetCurrentBinary (this->CMakeInstance->GetHomeOutputDirectory()); + cmMakefile* dirMf = new cmMakefile(this, snapshot); + this->Makefiles.push_back(dirMf); + this->BinaryDirectories.insert( this->CMakeInstance->GetHomeOutputDirectory()); // now do it + this->ConfigureDoneCMP0026AndCMP0024 = false; dirMf->Configure(); dirMf->EnforceDirectoryLevelRules(); + this->ConfigureDoneCMP0026AndCMP0024 = true; + // Put a copy of each global target in every directory. cmTargets globalTargets; this->CreateDefaultGlobalTargets(&globalTargets); @@ -1203,9 +1207,29 @@ void cmGlobalGenerator::Configure() void cmGlobalGenerator::CreateGenerationObjects(TargetTypes targetTypes) { - cmDeleteAll(this->GeneratorTargets); - this->GeneratorTargets.clear(); + this->CreateLocalGenerators(); this->CreateGeneratorTargets(targetTypes); + this->ComputeBuildFileGenerators(); +} + +void cmGlobalGenerator::CreateImportedGenerationObjects(cmMakefile* mf, + const std::vector<std::string>& targets, + std::vector<const cmGeneratorTarget*>& exports) +{ + this->CreateGenerationObjects(ImportedOnly); + std::vector<cmMakefile*>::iterator mfit = + std::find(this->Makefiles.begin(), this->Makefiles.end(), mf); + cmLocalGenerator* lg = + this->LocalGenerators[std::distance(this->Makefiles.begin(), mfit)]; + for (std::vector<std::string>::const_iterator it = targets.begin(); + it != targets.end(); ++it) + { + cmGeneratorTarget* gt = lg->FindGeneratorTargetToUse(*it); + if (gt) + { + exports.push_back(gt); + } + } } cmExportBuildFileGenerator* @@ -1243,6 +1267,20 @@ bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const return false; } +void cmGlobalGenerator::ComputeBuildFileGenerators() +{ + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) + { + std::vector<cmExportBuildFileGenerator*> gens = + this->Makefiles[i]->GetExportBuildFileGenerators(); + for (std::vector<cmExportBuildFileGenerator*>::const_iterator it = + gens.begin(); it != gens.end(); ++it) + { + (*it)->Compute(this->LocalGenerators[i]); + } + } +} + bool cmGlobalGenerator::Compute() { // Some generators track files replaced during the Generate. @@ -1268,30 +1306,23 @@ bool cmGlobalGenerator::Compute() #ifdef CMAKE_BUILD_WITH_CMAKE // Iterate through all targets and set up automoc for those which have // the AUTOMOC, AUTOUIC or AUTORCC property set - AutogensType autogens; - this->CreateQtAutoGeneratorsTargets(autogens); + std::vector<cmGeneratorTarget const*> autogenTargets = + this->CreateQtAutoGeneratorsTargets(); #endif unsigned int i; - for (i = 0; i < this->LocalGenerators.size(); ++i) - { - this->LocalGenerators[i]->ComputeObjectMaxPath(); - } - // Add generator specific helper commands for (i = 0; i < this->LocalGenerators.size(); ++i) { this->LocalGenerators[i]->AddHelperCommands(); } - this->InitGeneratorTargets(); - #ifdef CMAKE_BUILD_WITH_CMAKE - for (AutogensType::iterator it = autogens.begin(); it != autogens.end(); - ++it) + for (std::vector<cmGeneratorTarget const*>::iterator it = + autogenTargets.begin(); it != autogenTargets.end(); ++it) { - it->first.SetupAutoGenerateTarget(it->second); + cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(*it); } #endif @@ -1306,12 +1337,7 @@ bool cmGlobalGenerator::Compute() } } - return true; -} - -void cmGlobalGenerator::Generate() -{ - unsigned int i; + this->AddExtraIDETargets(); // Trace the dependencies, after that no custom commands should be added // because their dependencies might not be handled correctly @@ -1331,22 +1357,27 @@ void cmGlobalGenerator::Generate() // Compute the inter-target dependencies. if(!this->ComputeTargetDepends()) { - return; + return false; + } + + for (i = 0; i < this->LocalGenerators.size(); ++i) + { + this->LocalGenerators[i]->ComputeHomeRelativeOutputPath(); } + return true; +} + +void cmGlobalGenerator::Generate() +{ // Create a map from local generator to the complete set of targets // it builds by default. this->InitializeProgressMarks(); this->ProcessEvaluationFiles(); - for (i = 0; i < this->LocalGenerators.size(); ++i) - { - this->LocalGenerators[i]->ComputeHomeRelativeOutputPath(); - } - // Generate project files - for (i = 0; i < this->LocalGenerators.size(); ++i) + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { this->SetCurrentMakefile(this->LocalGenerators[i]->GetMakefile()); this->LocalGenerators[i]->Generate(); @@ -1427,53 +1458,67 @@ bool cmGlobalGenerator::ComputeTargetDepends() } //---------------------------------------------------------------------------- -void cmGlobalGenerator::CreateQtAutoGeneratorsTargets(AutogensType &autogens) +std::vector<const cmGeneratorTarget*> +cmGlobalGenerator::CreateQtAutoGeneratorsTargets() { + std::vector<const cmGeneratorTarget*> autogenTargets; + #ifdef CMAKE_BUILD_WITH_CMAKE for(unsigned int i=0; i < this->LocalGenerators.size(); ++i) { - cmTargets& targets = - this->LocalGenerators[i]->GetMakefile()->GetTargets(); - std::vector<std::string> targetNames; - targetNames.reserve(targets.size()); - for(cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets = + this->LocalGenerators[i]->GetGeneratorTargets(); + std::vector<cmGeneratorTarget*> filteredTargets; + filteredTargets.reserve(targets.size()); + for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ++ti) { - if (ti->second.GetType() == cmTarget::GLOBAL_TARGET) + if ((*ti)->GetType() == cmState::GLOBAL_TARGET) { continue; } - targetNames.push_back(ti->second.GetName()); - } - for(std::vector<std::string>::iterator ti = targetNames.begin(); - ti != targetNames.end(); ++ti) - { - cmTarget& target = *this->LocalGenerators[i] - ->GetMakefile()->FindTarget(*ti, true); - if(target.GetType() == cmTarget::EXECUTABLE || - target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY || - target.GetType() == cmTarget::OBJECT_LIBRARY) + if((*ti)->GetType() != cmState::EXECUTABLE && + (*ti)->GetType() != cmState::STATIC_LIBRARY && + (*ti)->GetType() != cmState::SHARED_LIBRARY && + (*ti)->GetType() != cmState::MODULE_LIBRARY && + (*ti)->GetType() != cmState::OBJECT_LIBRARY) { - if((target.GetPropertyAsBool("AUTOMOC") - || target.GetPropertyAsBool("AUTOUIC") - || target.GetPropertyAsBool("AUTORCC")) - && !target.IsImported()) - { - cmQtAutoGenerators autogen; - if(autogen.InitializeAutogenTarget(this->LocalGenerators[i], - &target)) - { - autogens.push_back(std::make_pair(autogen, &target)); - } - } + continue; + } + if((!(*ti)->GetPropertyAsBool("AUTOMOC") + && !(*ti)->GetPropertyAsBool("AUTOUIC") + && !(*ti)->GetPropertyAsBool("AUTORCC")) + || (*ti)->IsImported()) + { + continue; } + // don't do anything if there is no Qt4 or Qt5Core (which contains moc): + cmMakefile* mf = (*ti)->Target->GetMakefile(); + std::string qtMajorVersion = mf->GetSafeDefinition("QT_VERSION_MAJOR"); + if (qtMajorVersion == "") + { + qtMajorVersion = mf->GetSafeDefinition("Qt5Core_VERSION_MAJOR"); + } + if (qtMajorVersion != "4" && qtMajorVersion != "5") + { + continue; + } + + cmGeneratorTarget* gt = *ti; + + cmQtAutoGeneratorInitializer::InitializeAutogenSources(gt); + filteredTargets.push_back(gt); + } + for(std::vector<cmGeneratorTarget*>::iterator ti = filteredTargets.begin(); + ti != filteredTargets.end(); ++ti) + { + cmQtAutoGeneratorInitializer::InitializeAutogenTarget( + this->LocalGenerators[i], *ti); + autogenTargets.push_back(*ti); } } -#else - (void)autogens; #endif + return autogenTargets; } //---------------------------------------------------------------------------- @@ -1494,14 +1539,14 @@ void cmGlobalGenerator::FinalizeTargetCompileInfo() ti != targets.end(); ++ti) { cmTarget* t = &ti->second; - if (t->GetType() == cmTarget::GLOBAL_TARGET) + if (t->GetType() == cmState::GLOBAL_TARGET) { continue; } t->AppendBuildInterfaceIncludes(); - if (t->GetType() == cmTarget::INTERFACE_LIBRARY) + if (t->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -1536,11 +1581,12 @@ void cmGlobalGenerator::FinalizeTargetCompileInfo() } //---------------------------------------------------------------------------- -void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes, - cmLocalGenerator *lg) +void cmGlobalGenerator::CreateGeneratorTargets( + TargetTypes targetTypes, + cmMakefile *mf, + cmLocalGenerator *lg, + std::map<cmTarget*, cmGeneratorTarget*> const& importedMap) { - cmGeneratorTargetsType generatorTargets; - cmMakefile* mf = lg->GetMakefile(); if (targetTypes == AllTargets) { cmTargets& targets = mf->GetTargets(); @@ -1549,42 +1595,42 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes, { cmTarget* t = &ti->second; cmGeneratorTarget* gt = new cmGeneratorTarget(t, lg); - this->GeneratorTargets[t] = gt; - generatorTargets[t] = gt; + lg->AddGeneratorTarget(gt); } } + std::vector<cmTarget*> itgts = mf->GetImportedTargets(); + for(std::vector<cmTarget*>::const_iterator - j = mf->GetOwnedImportedTargets().begin(); - j != mf->GetOwnedImportedTargets().end(); ++j) + j = itgts.begin(); j != itgts.end(); ++j) { - cmGeneratorTarget* gt = new cmGeneratorTarget(*j, lg); - this->GeneratorTargets[*j] = gt; - generatorTargets[*j] = gt; + lg->AddImportedGeneratorTarget(importedMap.find(*j)->second); } - mf->SetGeneratorTargets(generatorTargets); } //---------------------------------------------------------------------------- -void cmGlobalGenerator::InitGeneratorTargets() +void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes) { - for(cmGeneratorTargetsType::iterator ti = - this->GeneratorTargets.begin(); ti != this->GeneratorTargets.end(); ++ti) + std::map<cmTarget*, cmGeneratorTarget*> importedMap; + for(unsigned int i=0; i < this->Makefiles.size(); ++i) { - if (!ti->second->Target->IsImported()) + cmMakefile* mf = this->Makefiles[i]; + for(std::vector<cmTarget*>::const_iterator + j = mf->GetOwnedImportedTargets().begin(); + j != mf->GetOwnedImportedTargets().end(); ++j) { - this->ComputeTargetObjectDirectory(ti->second); + cmLocalGenerator* lg = this->LocalGenerators[i]; + cmGeneratorTarget* gt = new cmGeneratorTarget(*j, lg); + lg->AddOwnedImportedGeneratorTarget(gt); + importedMap[*j] = gt; } } -} -//---------------------------------------------------------------------------- -void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes) -{ // Construct per-target generator information. for(unsigned int i=0; i < this->LocalGenerators.size(); ++i) { - this->CreateGeneratorTargets(targetTypes, this->LocalGenerators[i]); + this->CreateGeneratorTargets(targetTypes, this->Makefiles[i], + this->LocalGenerators[i], importedMap); } } @@ -1592,9 +1638,6 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes) //---------------------------------------------------------------------------- void cmGlobalGenerator::ClearGeneratorMembers() { - cmDeleteAll(this->GeneratorTargets); - this->GeneratorTargets.clear(); - cmDeleteAll(this->BuildExportSets); this->BuildExportSets.clear(); @@ -1606,8 +1649,6 @@ void cmGlobalGenerator::ClearGeneratorMembers() this->ExportSets.clear(); this->TargetDependencies.clear(); - this->TotalTargets.clear(); - this->ImportedTargets.clear(); this->ProjectMap.clear(); this->RuleHashes.clear(); this->DirectoryContentMap.clear(); @@ -1615,20 +1656,6 @@ void cmGlobalGenerator::ClearGeneratorMembers() } //---------------------------------------------------------------------------- -cmGeneratorTarget* -cmGlobalGenerator::GetGeneratorTarget(cmTarget const* t) const -{ - cmGeneratorTargetsType::const_iterator ti = this->GeneratorTargets.find(t); - if(ti == this->GeneratorTargets.end()) - { - this->CMakeInstance->IssueMessage( - cmake::INTERNAL_ERROR, "Missing cmGeneratorTarget instance!"); - return 0; - } - return ti->second; -} - -//---------------------------------------------------------------------------- void cmGlobalGenerator::ComputeTargetObjectDirectory(cmGeneratorTarget*) const { } @@ -1647,7 +1674,7 @@ void cmGlobalGenerator::CheckTargetProperties() for (cmTargets::iterator l = targets.begin(); l != targets.end(); l++) { - if (l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if (l->second.GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -1964,12 +1991,6 @@ void cmGlobalGenerator::AddMakefile(cmMakefile *mf) this->CMakeInstance->UpdateProgress("Configuring", prog); } -//---------------------------------------------------------------------------- -void cmGlobalGenerator::AddLocalGenerator(cmLocalGenerator *lg) -{ - this->LocalGenerators.push_back(lg); -} - void cmGlobalGenerator::AddInstallComponent(const char* component) { if(component && *component) @@ -2061,8 +2082,8 @@ bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root, bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root, cmGeneratorTarget* target) const { - if(target->GetType() == cmTarget::INTERFACE_LIBRARY - || target->Target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) + if(target->GetType() == cmState::INTERFACE_LIBRARY + || target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) { // This target is excluded from its directory. return true; @@ -2134,7 +2155,7 @@ cmGlobalGenerator::FindLocalGenerator(const std::string& start_dir) const for(std::vector<cmLocalGenerator*>::const_iterator it = this->LocalGenerators.begin(); it != this->LocalGenerators.end(); ++it) { - std::string sd = (*it)->GetMakefile()->GetCurrentSourceDirectory(); + std::string sd = (*it)->GetCurrentSourceDirectory(); if (sd == start_dir) { return *it; @@ -2144,9 +2165,10 @@ cmGlobalGenerator::FindLocalGenerator(const std::string& start_dir) const } //---------------------------------------------------------------------------- -void cmGlobalGenerator::AddAlias(const std::string& name, cmTarget *tgt) +void cmGlobalGenerator::AddAlias(const std::string& name, + std::string const& tgtName) { - this->AliasTargets[name] = tgt; + this->AliasTargets[name] = tgtName; } //---------------------------------------------------------------------------- @@ -2155,6 +2177,79 @@ bool cmGlobalGenerator::IsAlias(const std::string& name) const return this->AliasTargets.find(name) != this->AliasTargets.end(); } +cmTarget* cmGlobalGenerator::FindTargetImpl(std::string const& name) const +{ + for (unsigned int i = 0; i < this->Makefiles.size(); ++i) + { + cmTargets& tgts = this->Makefiles[i]->GetTargets(); + for (cmTargets::iterator it = tgts.begin(); it != tgts.end(); ++it) + { + if (it->second.GetName() == name) + { + return &it->second; + } + } + } + return 0; +} + +cmGeneratorTarget* +cmGlobalGenerator::FindGeneratorTargetImpl(std::string const& name) const +{ + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) + { + std::vector<cmGeneratorTarget*> tgts = + this->LocalGenerators[i]->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin(); + it != tgts.end(); ++it) + { + if ((*it)->GetName() == name) + { + return *it; + } + } + } + return 0; +} + +cmTarget* +cmGlobalGenerator::FindImportedTargetImpl(std::string const& name) const +{ + for (unsigned int i = 0; i < this->Makefiles.size(); ++i) + { + std::vector<cmTarget*> tgts = + this->Makefiles[i]->GetOwnedImportedTargets(); + for (std::vector<cmTarget*>::iterator it = tgts.begin(); + it != tgts.end(); ++it) + { + if ((*it)->GetName() == name && (*it)->IsImportedGloballyVisible()) + { + return *it; + } + } + } + return 0; +} + +cmGeneratorTarget* cmGlobalGenerator::FindImportedGeneratorTargetImpl( + std::string const& name) const +{ + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) + { + std::vector<cmGeneratorTarget*> tgts = + this->LocalGenerators[i]->GetImportedGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin(); + it != tgts.end(); ++it) + { + if ((*it)->IsImportedGloballyVisible() && (*it)->GetName() == name) + { + return *it; + } + } + } + return 0; +} + //---------------------------------------------------------------------------- cmTarget* cmGlobalGenerator::FindTarget(const std::string& name, @@ -2162,23 +2257,28 @@ cmGlobalGenerator::FindTarget(const std::string& name, { if (!excludeAliases) { - TargetMap::const_iterator ai = this->AliasTargets.find(name); + std::map<std::string, std::string>::const_iterator ai = + this->AliasTargets.find(name); if (ai != this->AliasTargets.end()) { - return ai->second; + return this->FindTargetImpl(ai->second); } } - TargetMap::const_iterator i = this->TotalTargets.find ( name ); - if ( i != this->TotalTargets.end() ) + if (cmTarget* tgt = this->FindTargetImpl(name)) { - return i->second; + return tgt; } - i = this->ImportedTargets.find(name); - if ( i != this->ImportedTargets.end() ) + return this->FindImportedTargetImpl(name); +} + +cmGeneratorTarget* +cmGlobalGenerator::FindGeneratorTarget(const std::string& name) const +{ + if (cmGeneratorTarget* tgt = this->FindGeneratorTargetImpl(name)) { - return i->second; + return tgt; } - return 0; + return this->FindImportedGeneratorTargetImpl(name); } //---------------------------------------------------------------------------- @@ -2522,7 +2622,7 @@ cmTarget cmGlobalGenerator::CreateGlobalTarget( { // Package cmTarget target; - target.SetType(cmTarget::GLOBAL_TARGET, name); + target.SetType(cmState::GLOBAL_TARGET, name); target.SetProperty("EXCLUDE_FROM_ALL","TRUE"); std::vector<std::string> no_outputs; @@ -2596,18 +2696,6 @@ cmGlobalGenerator::GetTargetDirectDepends(cmGeneratorTarget const* target) return this->TargetDependencies[target]; } -void cmGlobalGenerator::AddTarget(cmTarget* t) -{ - if(t->IsImported()) - { - this->ImportedTargets[t->GetName()] = t; - } - else - { - this->TotalTargets[t->GetName()] = t; - } -} - bool cmGlobalGenerator::IsReservedTarget(std::string const& name) { // The following is a list of targets reserved @@ -2680,31 +2768,30 @@ void cmGlobalGenerator::GetTargetSets(TargetDependSet& projectTargets, { continue; } - cmMakefile* mf = (*i)->GetMakefile(); // Get the targets in the makefile - cmTargets &tgts = mf->GetTargets(); + std::vector<cmGeneratorTarget*> tgts = (*i)->GetGeneratorTargets(); // loop over all the targets - for (cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - cmTarget* target = &l->second; + cmGeneratorTarget* target = *l; if(this->IsRootOnlyTarget(target) && - target->GetMakefile() != root->GetMakefile()) + target->GetLocalGenerator() != root) { continue; } // put the target in the set of original targets - cmGeneratorTarget* gt = this->GetGeneratorTarget(target); - originalTargets.insert(gt); + originalTargets.insert(target); // Get the set of targets that depend on target - this->AddTargetDepends(gt, projectTargets); + this->AddTargetDepends(target, projectTargets); } } } //---------------------------------------------------------------------------- -bool cmGlobalGenerator::IsRootOnlyTarget(cmTarget* target) const +bool cmGlobalGenerator::IsRootOnlyTarget(cmGeneratorTarget* target) const { - return (target->GetType() == cmTarget::GLOBAL_TARGET || + return (target->GetType() == cmState::GLOBAL_TARGET || target->GetName() == this->GetAllTargetName()); } @@ -2908,29 +2995,31 @@ void cmGlobalGenerator::WriteRuleHashes(std::string const& pfile) //---------------------------------------------------------------------------- void cmGlobalGenerator::WriteSummary() { - cmMakefile* mf = this->LocalGenerators[0]->GetMakefile(); - // Record all target directories in a central location. - std::string fname = mf->GetHomeOutputDirectory(); + std::string fname = this->CMakeInstance->GetHomeOutputDirectory(); fname += cmake::GetCMakeFilesDirectory(); fname += "/TargetDirectories.txt"; cmGeneratedFileStream fout(fname.c_str()); - // Generate summary information files for each target. - for(TargetMap::const_iterator ti = - this->TotalTargets.begin(); ti != this->TotalTargets.end(); ++ti) + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { - if ((ti->second)->GetType() == cmTarget::INTERFACE_LIBRARY) + std::vector<cmGeneratorTarget*> tgts = + this->LocalGenerators[i]->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin(); + it != tgts.end(); ++it) { - continue; + if ((*it)->GetType() == cmState::INTERFACE_LIBRARY) + { + continue; + } + this->WriteSummary(*it); + fout << (*it)->GetSupportDirectory() << "\n"; } - this->WriteSummary(ti->second); - fout << ti->second->GetSupportDirectory() << "\n"; } } //---------------------------------------------------------------------------- -void cmGlobalGenerator::WriteSummary(cmTarget* target) +void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target) { // Place the labels file in a per-target support directory. std::string dir = target->GetSupportDirectory(); @@ -2973,7 +3062,7 @@ void cmGlobalGenerator::WriteSummary(cmTarget* target) fout << "# Source files and their labels\n"; std::vector<cmSourceFile*> sources; std::vector<std::string> configs; - target->GetMakefile()->GetConfigurations(configs); + target->Target->GetMakefile()->GetConfigurations(configs); if (configs.empty()) { configs.push_back(""); @@ -3033,13 +3122,13 @@ std::string cmGlobalGenerator::EscapeJSON(const std::string& s) { //---------------------------------------------------------------------------- void cmGlobalGenerator::SetFilenameTargetDepends(cmSourceFile* sf, - std::set<cmTarget const*> tgts) + std::set<cmGeneratorTarget const*> tgts) { this->FilenameTargetDepends[sf] = tgts; } //---------------------------------------------------------------------------- -std::set<cmTarget const*> const& +std::set<cmGeneratorTarget const*> const& cmGlobalGenerator::GetFilenameTargetDepends(cmSourceFile* sf) const { return this->FilenameTargetDepends[sf]; } diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h index 9fc2d45..bc6e17d 100644 --- a/Source/cmGlobalGenerator.h +++ b/Source/cmGlobalGenerator.h @@ -41,7 +41,6 @@ class cmTarget; class cmInstallTargetGenerator; class cmInstallFilesGenerator; class cmExportBuildFileGenerator; -class cmQtAutoGenerators; /** \class cmGlobalGenerator * \brief Responsible for overseeing the generation process for the entire tree @@ -84,13 +83,17 @@ public: */ virtual void Configure(); - virtual bool Compute(); + bool Compute(); + virtual void AddExtraIDETargets() {} enum TargetTypes { AllTargets, ImportedOnly }; + void CreateImportedGenerationObjects(cmMakefile* mf, + std::vector<std::string> const& targets, + std::vector<cmGeneratorTarget const*>& exports); void CreateGenerationObjects(TargetTypes targetTypes = AllTargets); /** @@ -124,7 +127,7 @@ public: /** * Try to determine system information, get it from another generator */ - virtual void EnableLanguagesFromGenerator(cmGlobalGenerator *gen, + void EnableLanguagesFromGenerator(cmGlobalGenerator *gen, cmMakefile* mf); /** @@ -186,7 +189,6 @@ public: {this->CurrentMakefile = mf;} void AddMakefile(cmMakefile *mf); - void AddLocalGenerator(cmLocalGenerator *lg); ///! Set an generator for an "external makefile based project" void SetExternalMakefileProjectGenerator( @@ -248,7 +250,9 @@ public: cmTarget* FindTarget(const std::string& name, bool excludeAliases = false) const; - void AddAlias(const std::string& name, cmTarget *tgt); + cmGeneratorTarget* FindGeneratorTarget(const std::string& name) const; + + void AddAlias(const std::string& name, const std::string& tgtName); bool IsAlias(const std::string& name) const; /** Determine if a name resolves to a framework on disk or a built target @@ -274,8 +278,6 @@ public: std::set<std::string> const& GetDirectoryContent(std::string const& dir, bool needDisk = true); - void AddTarget(cmTarget* t); - static bool IsReservedTarget(std::string const& name); virtual const char* GetAllTargetName() const { return "ALL_BUILD"; } @@ -301,14 +303,6 @@ public: TargetDependSet const& GetTargetDirectDepends( const cmGeneratorTarget* target); - /** Get per-target generator information. */ - cmGeneratorTarget* GetGeneratorTarget(cmTarget const*) const; - - void AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt) - { - this->GeneratorTargets[t] = gt; - } - const std::map<std::string, std::vector<cmLocalGenerator*> >& GetProjectMap() const {return this->ProjectMap;} @@ -355,14 +349,17 @@ public: void CreateEvaluationSourceFiles(std::string const& config) const; void SetFilenameTargetDepends(cmSourceFile* sf, - std::set<cmTarget const*> tgts); - std::set<cmTarget const*> const& + std::set<const cmGeneratorTarget*> tgts); + const std::set<const cmGeneratorTarget*>& GetFilenameTargetDepends(cmSourceFile* sf) const; #if defined(CMAKE_BUILD_WITH_CMAKE) cmFileLockPool& GetFileLockPool() { return FileLockPool; } #endif + bool GetConfigureDoneCMP0026() const + { return this->ConfigureDoneCMP0026AndCMP0024; } + std::string MakeSilentFlag; protected: typedef std::vector<cmLocalGenerator*> GeneratorVector; @@ -371,7 +368,7 @@ protected: void GetTargetSets(TargetDependSet& projectTargets, TargetDependSet& originalTargets, cmLocalGenerator* root, GeneratorVector const&); - bool IsRootOnlyTarget(cmTarget* target) const; + bool IsRootOnlyTarget(cmGeneratorTarget* target) const; void AddTargetDepends(const cmGeneratorTarget* target, TargetDependSet& projectTargets); void SetLanguageEnabledFlag(const std::string& l, cmMakefile* mf); @@ -384,9 +381,7 @@ protected: virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const; - typedef std::vector<std::pair<cmQtAutoGenerators, - cmTarget const*> > AutogensType; - void CreateQtAutoGeneratorsTargets(AutogensType& autogens); + std::vector<const cmGeneratorTarget*> CreateQtAutoGeneratorsTargets(); std::string SelectMakeProgram(const std::string& makeProgram, const std::string& makeDefault = "") const; @@ -422,19 +417,14 @@ protected: std::map<std::string, cmExportBuildFileGenerator*> BuildExportSets; std::map<std::string, cmExportBuildFileGenerator*> BuildExportExportSets; - // All targets in the entire project. -#if defined(CMAKE_BUILD_WITH_CMAKE) -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP - typedef std::unordered_map<std::string, cmTarget*> TargetMap; -#else - typedef cmsys::hash_map<std::string, cmTarget*> TargetMap; -#endif -#else - typedef std::map<std::string,cmTarget *> TargetMap; -#endif - TargetMap TotalTargets; - TargetMap AliasTargets; - TargetMap ImportedTargets; + std::map<std::string, std::string> AliasTargets; + + cmTarget* FindTargetImpl(std::string const& name) const; + cmTarget* FindImportedTargetImpl(std::string const& name) const; + + cmGeneratorTarget* FindGeneratorTargetImpl(std::string const& name) const; + cmGeneratorTarget* + FindImportedGeneratorTargetImpl(std::string const& name) const; const char* GetPredefinedTargetsFolder(); virtual bool UseFolderProperty(); @@ -459,14 +449,18 @@ private: void WriteRuleHashes(std::string const& pfile); void WriteSummary(); - void WriteSummary(cmTarget* target); + void WriteSummary(cmGeneratorTarget* target); void FinalizeTargetCompileInfo(); virtual void ForceLinkerLanguages(); + void CreateLocalGenerators(); + void CheckCompilerIdCompatibility(cmMakefile* mf, std::string const& lang) const; + void ComputeBuildFileGenerators(); + cmExternalMakefileProjectGenerator* ExtraGenerator; // track files replaced during a Generate @@ -476,11 +470,10 @@ private: typedef std::map<cmGeneratorTarget const*, TargetDependSet> TargetDependMap; TargetDependMap TargetDependencies; - // Per-target generator information. - cmGeneratorTargetsType GeneratorTargets; friend class cmake; - void CreateGeneratorTargets(TargetTypes targetTypes, cmLocalGenerator* lg); - void InitGeneratorTargets(); + void CreateGeneratorTargets(TargetTypes targetTypes, cmMakefile* mf, + cmLocalGenerator* lg, + std::map<cmTarget*, cmGeneratorTarget*> const& importedMap); void CreateGeneratorTargets(TargetTypes targetTypes); void ClearGeneratorMembers(); @@ -505,7 +498,7 @@ private: // track targets to issue CMP0042 warning for. std::set<std::string> CMP0042WarnTargets; - mutable std::map<cmSourceFile*, std::set<cmTarget const*> > + mutable std::map<cmSourceFile*, std::set<cmGeneratorTarget const*> > FilenameTargetDepends; #if defined(CMAKE_BUILD_WITH_CMAKE) @@ -520,6 +513,7 @@ protected: bool ForceUnixPaths; bool ToolSupportsColor; bool InstallTargetEnabled; + bool ConfigureDoneCMP0026AndCMP0024; }; #endif diff --git a/Source/cmGlobalGhsMultiGenerator.cxx b/Source/cmGlobalGhsMultiGenerator.cxx index 6dde1e3..1bcbd26 100644 --- a/Source/cmGlobalGhsMultiGenerator.cxx +++ b/Source/cmGlobalGhsMultiGenerator.cxx @@ -287,8 +287,8 @@ void cmGlobalGhsMultiGenerator::Generate() { cmLocalGhsMultiGenerator *lg = static_cast<cmLocalGhsMultiGenerator *>(this->LocalGenerators[i]); - cmGeneratorTargetsType tgts = lg->GetMakefile()->GetGeneratorTargets(); - this->UpdateBuildFiles(&tgts); + std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets(); + this->UpdateBuildFiles(tgts); } } @@ -481,15 +481,15 @@ cmGlobalGhsMultiGenerator::GetFileNameFromPath(std::string const &path) } void cmGlobalGhsMultiGenerator::UpdateBuildFiles( - cmGeneratorTargetsType *tgts) + std::vector<cmGeneratorTarget*> tgts) { - for (cmGeneratorTargetsType::iterator tgtsI = tgts->begin(); - tgtsI != tgts->end(); ++tgtsI) + for (std::vector<cmGeneratorTarget*>::iterator tgtsI = tgts.begin(); + tgtsI != tgts.end(); ++tgtsI) { - const cmTarget *tgt(tgtsI->first); + const cmGeneratorTarget *tgt = *tgtsI; if (IsTgtForBuild(tgt)) { - char const *rawFolderName = tgtsI->first->GetProperty("FOLDER"); + char const *rawFolderName = tgt->GetProperty("FOLDER"); if (NULL == rawFolderName) { rawFolderName = ""; @@ -509,16 +509,17 @@ void cmGlobalGhsMultiGenerator::UpdateBuildFiles( splitPath.back()); *this->TargetFolderBuildStreams[folderName] << foldNameRelBuildFile << " "; - GhsMultiGpj::WriteGpjTag(cmGhsMultiTargetGenerator::GetGpjTag(tgt), + GhsMultiGpj::WriteGpjTag(cmGhsMultiTargetGenerator::GetGpjTag( + tgt), this->TargetFolderBuildStreams[folderName]); } } } -bool cmGlobalGhsMultiGenerator::IsTgtForBuild(const cmTarget *tgt) +bool cmGlobalGhsMultiGenerator::IsTgtForBuild(const cmGeneratorTarget *tgt) { const std::string config = - tgt->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); + tgt->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); std::vector<cmSourceFile *> tgtSources; tgt->GetSourceFiles(tgtSources, config); bool tgtInBuild = true; diff --git a/Source/cmGlobalGhsMultiGenerator.h b/Source/cmGlobalGhsMultiGenerator.h index 8f88d4f..480cd6a 100644 --- a/Source/cmGlobalGhsMultiGenerator.h +++ b/Source/cmGlobalGhsMultiGenerator.h @@ -110,8 +110,8 @@ private: std::vector<cmsys::String>::const_iterator end, GhsMultiGpj::Types projType); static std::string GetFileNameFromPath(std::string const &path); - void UpdateBuildFiles(cmGeneratorTargetsType *tgts); - bool IsTgtForBuild(const cmTarget *tgt); + void UpdateBuildFiles(std::vector<cmGeneratorTarget*> tgts); + bool IsTgtForBuild(const cmGeneratorTarget *tgt); std::vector<cmGeneratedFileStream *> TargetSubProjects; std::map<std::string, cmGeneratedFileStream *> TargetFolderBuildStreams; diff --git a/Source/cmGlobalKdevelopGenerator.cxx b/Source/cmGlobalKdevelopGenerator.cxx index 138ddbb..018ab24 100644 --- a/Source/cmGlobalKdevelopGenerator.cxx +++ b/Source/cmGlobalKdevelopGenerator.cxx @@ -49,10 +49,9 @@ void cmGlobalKdevelopGenerator::Generate() it!= this->GlobalGenerator->GetProjectMap().end(); ++it) { - cmMakefile* mf = it->second[0]->GetMakefile(); - std::string outputDir=mf->GetCurrentBinaryDirectory(); - std::string projectDir=mf->GetHomeDirectory(); - std::string projectName=mf->GetProjectName(); + std::string outputDir=it->second[0]->GetCurrentBinaryDirectory(); + std::string projectDir=it->second[0]->GetSourceDirectory(); + std::string projectName=it->second[0]->GetProjectName(); std::string cmakeFilePattern("CMakeLists.txt;*.cmake;"); std::string fileToOpen; const std::vector<cmLocalGenerator*>& lgs= it->second; @@ -69,14 +68,14 @@ void cmGlobalKdevelopGenerator::Generate() for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin(); lg!=lgs.end(); lg++) { - cmMakefile* makefile=(*lg)->GetMakefile(); - cmGeneratorTargetsType const& targets = makefile->GetGeneratorTargets(); - for (cmGeneratorTargetsType::const_iterator ti = targets.begin(); - ti != targets.end(); ti++) + std::vector<cmGeneratorTarget*> const& targets = + (*lg)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::const_iterator ti = + targets.begin(); ti != targets.end(); ti++) { - if (ti->second->GetType()==cmTarget::EXECUTABLE) + if ((*ti)->GetType()==cmState::EXECUTABLE) { - executable = ti->second->GetLocation(""); + executable = (*ti)->GetLocation(""); break; } } @@ -106,6 +105,9 @@ bool cmGlobalKdevelopGenerator std::set<std::string> files; std::string tmp; + std::vector<std::string> hdrExts = + this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions(); + for (std::vector<cmLocalGenerator*>::const_iterator it=lgs.begin(); it!=lgs.end(); it++) { @@ -134,12 +136,13 @@ bool cmGlobalKdevelopGenerator } //get all sources - cmTargets& targets=makefile->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets=(*it)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ti++) { std::vector<cmSourceFile*> sources; - ti->second.GetSourceFiles(sources, ti->second.GetMakefile() + cmGeneratorTarget* gt = *ti; + gt->GetSourceFiles(sources, gt->Target->GetMakefile() ->GetSafeDefinition("CMAKE_BUILD_TYPE")); for (std::vector<cmSourceFile*>::const_iterator si=sources.begin(); si!=sources.end(); si++) @@ -160,8 +163,7 @@ bool cmGlobalKdevelopGenerator // check if there's a matching header around for(std::vector<std::string>::const_iterator - ext = makefile->GetHeaderExtensions().begin(); - ext != makefile->GetHeaderExtensions().end(); ++ext) + ext = hdrExts.begin(); ext != hdrExts.end(); ++ext) { std::string hname=headerBasename; hname += "."; diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx index 120bb03..8498e39 100644 --- a/Source/cmGlobalNinjaGenerator.cxx +++ b/Source/cmGlobalNinjaGenerator.cxx @@ -717,13 +717,11 @@ std::string cmGlobalNinjaGenerator::GetEditCacheCommand() const void cmGlobalNinjaGenerator ::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const { - cmTarget* target = gt->Target; - // Compute full path to object file directory for this target. std::string dir; - dir += gt->Makefile->GetCurrentBinaryDirectory(); + dir += gt->LocalGenerator->GetCurrentBinaryDirectory(); dir += "/"; - dir += gt->LocalGenerator->GetTargetDirectory(*target); + dir += gt->LocalGenerator->GetTargetDirectory(gt); dir += "/"; gt->ObjectDirectory = dir; } @@ -818,6 +816,17 @@ void cmGlobalNinjaGenerator::CloseRulesFileStream() } } +std::string cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path) +{ + cmLocalNinjaGenerator *ng = + static_cast<cmLocalNinjaGenerator *>(this->LocalGenerators[0]); + std::string convPath = ng->Convert(path, cmOutputConverter::HOME_OUTPUT); +#ifdef _WIN32 + cmSystemTools::ReplaceString(convPath, "/", "\\"); +#endif + return convPath; +} + void cmGlobalNinjaGenerator::AddCXXCompileCommand( const std::string &commandLine, const std::string &sourceFile) @@ -877,7 +886,7 @@ void cmGlobalNinjaGenerator::WriteDisclaimer(std::ostream& os) << cmVersion::GetMinorVersion() << "\n\n"; } -void cmGlobalNinjaGenerator::AddDependencyToAll(cmTarget* target) +void cmGlobalNinjaGenerator::AddDependencyToAll(cmGeneratorTarget* target) { this->AppendTargetOutputs(target, this->AllDependencies); } @@ -903,12 +912,10 @@ void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies() void cmGlobalNinjaGenerator -::AppendTargetOutputs(cmTarget const* target, cmNinjaDeps& outputs) +::AppendTargetOutputs(cmGeneratorTarget const* target, cmNinjaDeps& outputs) { std::string configName = - target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); - cmLocalNinjaGenerator *ng = - static_cast<cmLocalNinjaGenerator *>(this->LocalGenerators[0]); + target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); // for frameworks, we want the real name, not smple name // frameworks always appear versioned, and the build.ninja @@ -917,20 +924,19 @@ cmGlobalNinjaGenerator bool realname = target->IsFrameworkOnApple(); switch (target->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::SHARED_LIBRARY: - case cmTarget::STATIC_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::EXECUTABLE: + case cmState::SHARED_LIBRARY: + case cmState::STATIC_LIBRARY: + case cmState::MODULE_LIBRARY: { - cmGeneratorTarget *gtgt = this->GetGeneratorTarget(target); - outputs.push_back(ng->ConvertToNinjaPath( - gtgt->GetFullPath(configName, false, realname))); + outputs.push_back(this->ConvertToNinjaPath( + target->GetFullPath(configName, false, realname))); break; } - case cmTarget::OBJECT_LIBRARY: - case cmTarget::UTILITY: { - std::string path = ng->ConvertToNinjaPath( - target->GetMakefile()->GetCurrentBinaryDirectory()); + case cmState::OBJECT_LIBRARY: + case cmState::UTILITY: { + std::string path = this->ConvertToNinjaPath( + target->GetLocalGenerator()->GetCurrentBinaryDirectory()); if (path.empty() || path == ".") outputs.push_back(target->GetName()); else { @@ -941,7 +947,7 @@ cmGlobalNinjaGenerator break; } - case cmTarget::GLOBAL_TARGET: + case cmState::GLOBAL_TARGET: // Always use the target in HOME instead of an unused duplicate in a // subdirectory. outputs.push_back(target->GetName()); @@ -954,30 +960,29 @@ cmGlobalNinjaGenerator void cmGlobalNinjaGenerator -::AppendTargetDepends(cmTarget const* target, cmNinjaDeps& outputs) +::AppendTargetDepends(cmGeneratorTarget const* target, cmNinjaDeps& outputs) { - if (target->GetType() == cmTarget::GLOBAL_TARGET) { + if (target->GetType() == cmState::GLOBAL_TARGET) { // Global targets only depend on other utilities, which may not appear in // the TargetDepends set (e.g. "all"). std::set<std::string> const& utils = target->GetUtilities(); std::copy(utils.begin(), utils.end(), std::back_inserter(outputs)); } else { - cmGeneratorTarget* gt = this->GetGeneratorTarget(target); - cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(gt); + cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(target); for (cmTargetDependSet::const_iterator i = targetDeps.begin(); i != targetDeps.end(); ++i) { - if ((*i)->GetType() == cmTarget::INTERFACE_LIBRARY) + if ((*i)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - this->AppendTargetOutputs((*i)->Target, outputs); + this->AppendTargetOutputs(*i, outputs); } } } void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias, - cmTarget* target) { + cmGeneratorTarget* target) { cmNinjaDeps outputs; this->AppendTargetOutputs(target, outputs); // Mark the target's outputs as ambiguous to ensure that no other target uses @@ -1041,8 +1046,6 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os) //get the list of files that cmake itself has generated as a //product of configuration. - cmLocalNinjaGenerator *ng = - static_cast<cmLocalNinjaGenerator *>(this->LocalGenerators[0]); for (std::vector<cmLocalGenerator *>::const_iterator i = this->LocalGenerators.begin(); i != this->LocalGenerators.end(); ++i) @@ -1054,7 +1057,7 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os) typedef std::vector<std::string>::const_iterator vect_it; for(vect_it j = files.begin(); j != files.end(); ++j) { - knownDependencies.insert( ng->ConvertToNinjaPath( *j ) ); + knownDependencies.insert( this->ConvertToNinjaPath( *j ) ); } //get list files which are implicit dependencies as well and will be phony //for rebuild manifest @@ -1062,7 +1065,7 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os) typedef std::vector<std::string>::const_iterator vect_it; for(vect_it j = lf.begin(); j != lf.end(); ++j) { - knownDependencies.insert( ng->ConvertToNinjaPath( *j ) ); + knownDependencies.insert( this->ConvertToNinjaPath( *j ) ); } std::vector<cmGeneratorExpressionEvaluationFile*> const& ef = (*i)->GetMakefile()->GetEvaluationFiles(); @@ -1074,7 +1077,7 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os) std::vector<std::string> evaluationFiles = (*li)->GetFiles(); for(vect_it j = evaluationFiles.begin(); j != evaluationFiles.end(); ++j) { - knownDependencies.insert( ng->ConvertToNinjaPath( *j ) ); + knownDependencies.insert( this->ConvertToNinjaPath( *j ) ); } } } @@ -1084,7 +1087,7 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os) i != this->TargetAliases.end(); ++i) { - knownDependencies.insert( ng->ConvertToNinjaPath(i->first) ); + knownDependencies.insert( this->ConvertToNinjaPath(i->first) ); } //remove all source files we know will exist. @@ -1093,7 +1096,7 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os) i != this->AssumedSourceDependencies.end(); ++i) { - knownDependencies.insert( ng->ConvertToNinjaPath(i->first) ); + knownDependencies.insert( this->ConvertToNinjaPath(i->first) ); } //now we difference with CombinedCustomCommandExplicitDependencies to find @@ -1191,16 +1194,15 @@ void cmGlobalNinjaGenerator::WriteTargetAll(std::ostream& os) void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os) { cmLocalGenerator *lg = this->LocalGenerators[0]; - cmMakefile* mfRoot = lg->GetMakefile(); std::ostringstream cmd; cmd << lg->ConvertToOutputFormat(cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL) << " -H" - << lg->ConvertToOutputFormat(mfRoot->GetHomeDirectory(), + << lg->ConvertToOutputFormat(lg->GetSourceDirectory(), cmLocalGenerator::SHELL) << " -B" - << lg->ConvertToOutputFormat(mfRoot->GetHomeOutputDirectory(), + << lg->ConvertToOutputFormat(lg->GetBinaryDirectory(), cmLocalGenerator::SHELL); WriteRule(*this->RulesFileStream, "RERUN_CMAKE", @@ -1214,8 +1216,6 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os) /*restat=*/ "", /*generator=*/ true); - cmLocalNinjaGenerator *ng = static_cast<cmLocalNinjaGenerator *>(lg); - cmNinjaDeps implicitDeps; for(std::vector<cmLocalGenerator*>::const_iterator i = this->LocalGenerators.begin(); i != this->LocalGenerators.end(); ++i) @@ -1224,7 +1224,7 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os) for(std::vector<std::string>::const_iterator fi = lf.begin(); fi != lf.end(); ++fi) { - implicitDeps.push_back(ng->ConvertToNinjaPath(*fi)); + implicitDeps.push_back(this->ConvertToNinjaPath(*fi)); } } implicitDeps.push_back("CMakeCache.txt"); diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h index d204a50..7547f16 100644 --- a/Source/cmGlobalNinjaGenerator.h +++ b/Source/cmGlobalNinjaGenerator.h @@ -220,6 +220,19 @@ public: cmGeneratedFileStream* GetRulesFileStream() const { return this->RulesFileStream; } + std::string ConvertToNinjaPath(const std::string& path); + + struct MapToNinjaPathImpl { + cmGlobalNinjaGenerator* GG; + MapToNinjaPathImpl(cmGlobalNinjaGenerator* gg): GG(gg) {} + std::string operator()(std::string const& path) { + return this->GG->ConvertToNinjaPath(path); + } + }; + MapToNinjaPathImpl MapToNinjaPath() { + return MapToNinjaPathImpl(this); + } + void AddCXXCompileCommand(const std::string &commandLine, const std::string &sourceFile); @@ -272,9 +285,11 @@ public: ASD.insert(deps.begin(), deps.end()); } - void AppendTargetOutputs(cmTarget const* target, cmNinjaDeps& outputs); - void AppendTargetDepends(cmTarget const* target, cmNinjaDeps& outputs); - void AddDependencyToAll(cmTarget* target); + void AppendTargetOutputs(cmGeneratorTarget const* target, + cmNinjaDeps& outputs); + void AppendTargetDepends(cmGeneratorTarget const* target, + cmNinjaDeps& outputs); + void AddDependencyToAll(cmGeneratorTarget* target); void AddDependencyToAll(const std::string& input); const std::vector<cmLocalGenerator*>& GetLocalGenerators() const { @@ -286,7 +301,7 @@ public: int GetRuleCmdLength(const std::string& name) { return RuleCmdLength[name]; } - void AddTargetAlias(const std::string& alias, cmTarget* target); + void AddTargetAlias(const std::string& alias, cmGeneratorTarget* target); virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const; @@ -375,7 +390,7 @@ private: /// The mapping from source file to assumed dependencies. std::map<std::string, std::set<std::string> > AssumedSourceDependencies; - typedef std::map<std::string, cmTarget*> TargetAliasMap; + typedef std::map<std::string, cmGeneratorTarget*> TargetAliasMap; TargetAliasMap TargetAliases; }; diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx index cf4fd69..ce7815d 100644 --- a/Source/cmGlobalUnixMakefileGenerator3.cxx +++ b/Source/cmGlobalUnixMakefileGenerator3.cxx @@ -15,8 +15,6 @@ #include "cmMakefile.h" #include "cmake.h" #include "cmGeneratedFileStream.h" -#include "cmSourceFile.h" -#include "cmTarget.h" #include "cmGeneratorTarget.h" #include "cmAlgorithms.h" @@ -114,13 +112,11 @@ void cmGlobalUnixMakefileGenerator3 ::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const { - cmTarget* target = gt->Target; - // Compute full path to object file directory for this target. std::string dir; - dir += gt->Makefile->GetCurrentBinaryDirectory(); + dir += gt->LocalGenerator->GetCurrentBinaryDirectory(); dir += "/"; - dir += gt->LocalGenerator->GetTargetDirectory(*target); + dir += gt->LocalGenerator->GetTargetDirectory(gt); dir += "/"; gt->ObjectDirectory = dir; } @@ -161,9 +157,8 @@ void cmGlobalUnixMakefileGenerator3::Generate() } for(unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { - cmLocalUnixMakefileGenerator3 *lg = - static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); - std::string markFileName = lg->GetMakefile()->GetCurrentBinaryDirectory(); + cmLocalGenerator *lg = this->LocalGenerators[i]; + std::string markFileName = lg->GetCurrentBinaryDirectory(); markFileName += "/"; markFileName += cmake::GetCMakeFilesDirectory(); markFileName += "/progress.marks"; @@ -395,7 +390,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile() { lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); - tmpStr = lg->GetMakefile()->GetCurrentBinaryDirectory(); + tmpStr = lg->GetCurrentBinaryDirectory(); tmpStr += cmake::GetCMakeFilesDirectory(); tmpStr += "/CMakeDirectoryInformation.cmake"; cmakefileStream << " \"" << @@ -425,17 +420,19 @@ void cmGlobalUnixMakefileGenerator3 { lg = static_cast<cmLocalUnixMakefileGenerator3 *>(lGenerators[i]); // for all of out targets - for (cmTargets::iterator l = lg->GetMakefile()->GetTargets().begin(); - l != lg->GetMakefile()->GetTargets().end(); l++) + std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); l++) { - if((l->second.GetType() == cmTarget::EXECUTABLE) || - (l->second.GetType() == cmTarget::STATIC_LIBRARY) || - (l->second.GetType() == cmTarget::SHARED_LIBRARY) || - (l->second.GetType() == cmTarget::MODULE_LIBRARY) || - (l->second.GetType() == cmTarget::OBJECT_LIBRARY) || - (l->second.GetType() == cmTarget::UTILITY)) + if(((*l)->GetType() == cmState::EXECUTABLE) || + ((*l)->GetType() == cmState::STATIC_LIBRARY) || + ((*l)->GetType() == cmState::SHARED_LIBRARY) || + ((*l)->GetType() == cmState::MODULE_LIBRARY) || + ((*l)->GetType() == cmState::OBJECT_LIBRARY) || + ((*l)->GetType() == cmState::UTILITY)) { - std::string tname = lg->GetRelativeTargetDirectory(l->second); + cmGeneratorTarget* gt = *l; + std::string tname = lg->GetRelativeTargetDirectory(gt); tname += "/DependInfo.cmake"; cmSystemTools::ConvertToUnixSlashes(tname); cmakefileStream << " \"" << tname << "\"\n"; @@ -454,37 +451,33 @@ cmGlobalUnixMakefileGenerator3 bool check_relink) { // Get the relative path to the subdirectory from the top. - std::string makeTarget = lg->GetMakefile()->GetCurrentBinaryDirectory(); + std::string makeTarget = lg->GetCurrentBinaryDirectory(); makeTarget += "/"; makeTarget += pass; // The directory-level rule should depend on the target-level rules // for all targets in the directory. std::vector<std::string> depends; - cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator l = targets.begin(); + std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = targets.begin(); l != targets.end(); ++l) { - cmGeneratorTarget* gtarget = l->second; + cmGeneratorTarget* gtarget = *l; int type = gtarget->GetType(); - if((type == cmTarget::EXECUTABLE) || - (type == cmTarget::STATIC_LIBRARY) || - (type == cmTarget::SHARED_LIBRARY) || - (type == cmTarget::MODULE_LIBRARY) || - (type == cmTarget::OBJECT_LIBRARY) || - (type == cmTarget::UTILITY)) + if((type == cmState::EXECUTABLE) || + (type == cmState::STATIC_LIBRARY) || + (type == cmState::SHARED_LIBRARY) || + (type == cmState::MODULE_LIBRARY) || + (type == cmState::OBJECT_LIBRARY) || + (type == cmState::UTILITY)) { - if(gtarget->Target->IsImported()) - { - continue; - } // Add this to the list of depends rules in this directory. if((!check_all || !gtarget->GetPropertyAsBool("EXCLUDE_FROM_ALL")) && (!check_relink || gtarget ->NeedRelinkBeforeInstall(lg->GetConfigName()))) { - std::string tname = lg->GetRelativeTargetDirectory(*gtarget->Target); + std::string tname = lg->GetRelativeTargetDirectory(gtarget); tname += "/"; tname += pass; depends.push_back(tname); @@ -495,7 +488,7 @@ cmGlobalUnixMakefileGenerator3 // The directory-level rule should depend on the directory-level // rules of the subdirectories. std::vector<cmState::Snapshot> children - = lg->GetMakefile()->GetStateSnapshot().GetChildren(); + = lg->GetStateSnapshot().GetChildren(); for(std::vector<cmState::Snapshot>::const_iterator ci = children.begin(); ci != children.end(); ++ci) { @@ -528,13 +521,13 @@ cmGlobalUnixMakefileGenerator3 cmLocalUnixMakefileGenerator3* lg) { // Only subdirectories need these rules. - if(lg->GetMakefile()->IsRootMakefile()) + if(lg->IsRootMakefile()) { return; } // Begin the directory-level rules section. - std::string dir = lg->GetMakefile()->GetCurrentBinaryDirectory(); + std::string dir = lg->GetCurrentBinaryDirectory(); dir = lg->Convert(dir, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::MAKERULE); lg->WriteDivider(ruleFileStream); @@ -578,24 +571,19 @@ void cmGlobalUnixMakefileGenerator3 if (!targetName.empty()) { cmMakefile* mf; - cmLocalUnixMakefileGenerator3 *lg; - if (!this->LocalGenerators.empty()) + if (!this->Makefiles.empty()) { - lg = static_cast<cmLocalUnixMakefileGenerator3 *> - (this->LocalGenerators[0]); - mf = lg->GetMakefile(); + mf = this->Makefiles[0]; } else { cmState::Snapshot snapshot = this->CMakeInstance->GetCurrentSnapshot(); - mf = new cmMakefile(this, snapshot); - lg = static_cast<cmLocalUnixMakefileGenerator3 *> - (this->CreateLocalGenerator(mf)); - // set the Start directories - lg->GetMakefile()->SetCurrentSourceDirectory + snapshot.GetDirectory().SetCurrentSource (this->CMakeInstance->GetHomeDirectory()); - lg->GetMakefile()->SetCurrentBinaryDirectory + snapshot.GetDirectory().SetCurrentBinary (this->CMakeInstance->GetHomeOutputDirectory()); + snapshot.SetDefaultDefinitions(); + mf = new cmMakefile(this, snapshot); } std::string tname = targetName; @@ -603,12 +591,12 @@ void cmGlobalUnixMakefileGenerator3 { tname += "/fast"; } - tname = lg->Convert(tname,cmLocalGenerator::HOME_OUTPUT); + cmOutputConverter conv(mf->GetStateSnapshot()); + tname = conv.Convert(tname,cmOutputConverter::HOME_OUTPUT); cmSystemTools::ConvertToOutputSlashes(tname); makeCommand.push_back(tname); - if (this->LocalGenerators.empty()) + if (this->Makefiles.empty()) { - delete lg; delete mf; } } @@ -633,15 +621,11 @@ cmGlobalUnixMakefileGenerator3 lg = static_cast<cmLocalUnixMakefileGenerator3 *> (this->LocalGenerators[i]); // for each target Generate the rule files for each target. - cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - cmGeneratorTarget* gtarget = t->second; - if(gtarget->Target->IsImported()) - { - continue; - } + cmGeneratorTarget* gtarget = *t; // Don't emit the same rule twice (e.g. two targets with the same // simple name) int type = gtarget->GetType(); @@ -650,12 +634,12 @@ cmGlobalUnixMakefileGenerator3 emitted.insert(name).second && // Handle user targets here. Global targets are handled in // the local generator on a per-directory basis. - ((type == cmTarget::EXECUTABLE) || - (type == cmTarget::STATIC_LIBRARY) || - (type == cmTarget::SHARED_LIBRARY) || - (type == cmTarget::MODULE_LIBRARY) || - (type == cmTarget::OBJECT_LIBRARY) || - (type == cmTarget::UTILITY))) + ((type == cmState::EXECUTABLE) || + (type == cmState::STATIC_LIBRARY) || + (type == cmState::SHARED_LIBRARY) || + (type == cmState::MODULE_LIBRARY) || + (type == cmState::OBJECT_LIBRARY) || + (type == cmState::UTILITY))) { // Add a rule to build the target by name. lg->WriteDivider(ruleFileStream); @@ -678,7 +662,7 @@ cmGlobalUnixMakefileGenerator3 // Add a fast rule to build the target std::string localName = - lg->GetRelativeTargetDirectory(*gtarget->Target); + lg->GetRelativeTargetDirectory(gtarget); std::string makefileName; makefileName = localName; makefileName += "/build.make"; @@ -698,7 +682,7 @@ cmGlobalUnixMakefileGenerator3 if(gtarget ->NeedRelinkBeforeInstall(lg->GetConfigName())) { - makeTargetName = lg->GetRelativeTargetDirectory(*gtarget->Target); + makeTargetName = lg->GetRelativeTargetDirectory(gtarget); makeTargetName += "/preinstall"; localName = name; localName += "/preinstall"; @@ -734,32 +718,28 @@ cmGlobalUnixMakefileGenerator3 depends.push_back("cmake_check_build_system"); // for each target Generate the rule files for each target. - cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - cmGeneratorTarget* gtarget = t->second; - if(gtarget->Target->IsImported()) - { - continue; - } + cmGeneratorTarget* gtarget = *t; int type = gtarget->GetType(); std::string name = gtarget->GetName(); if (!name.empty() - && ( (type == cmTarget::EXECUTABLE) - || (type == cmTarget::STATIC_LIBRARY) - || (type == cmTarget::SHARED_LIBRARY) - || (type == cmTarget::MODULE_LIBRARY) - || (type == cmTarget::OBJECT_LIBRARY) - || (type == cmTarget::UTILITY))) + && ( (type == cmState::EXECUTABLE) + || (type == cmState::STATIC_LIBRARY) + || (type == cmState::SHARED_LIBRARY) + || (type == cmState::MODULE_LIBRARY) + || (type == cmState::OBJECT_LIBRARY) + || (type == cmState::UTILITY))) { std::string makefileName; // Add a rule to build the target by name. - localName = lg->GetRelativeTargetDirectory(*gtarget->Target); + localName = lg->GetRelativeTargetDirectory(gtarget); makefileName = localName; makefileName += "/build.make"; - bool needRequiresStep = this->NeedRequiresStep(*gtarget->Target); + bool needRequiresStep = this->NeedRequiresStep(gtarget); lg->WriteDivider(ruleFileStream); ruleFileStream @@ -790,13 +770,13 @@ cmGlobalUnixMakefileGenerator3 depends.clear(); cmLocalUnixMakefileGenerator3::EchoProgress progress; - progress.Dir = lg->GetMakefile()->GetHomeOutputDirectory(); + progress.Dir = lg->GetBinaryDirectory(); progress.Dir += cmake::GetCMakeFilesDirectory(); { std::ostringstream progressArg; const char* sep = ""; std::vector<unsigned long>& progFiles = - this->ProgressMap[gtarget->Target].Marks; + this->ProgressMap[gtarget].Marks; for (std::vector<unsigned long>::iterator i = progFiles.begin(); i != progFiles.end(); ++i) { @@ -866,7 +846,7 @@ cmGlobalUnixMakefileGenerator3 } depends.clear(); depends.push_back("cmake_check_build_system"); - localName = lg->GetRelativeTargetDirectory(*gtarget->Target); + localName = lg->GetRelativeTargetDirectory(gtarget); localName += "/rule"; lg->WriteMakeRule(ruleFileStream, "Build rule for subdir invocation for target.", @@ -883,7 +863,7 @@ cmGlobalUnixMakefileGenerator3 if(gtarget ->NeedRelinkBeforeInstall(lg->GetConfigName())) { - localName = lg->GetRelativeTargetDirectory(*gtarget->Target); + localName = lg->GetRelativeTargetDirectory(gtarget); localName += "/preinstall"; depends.clear(); commands.clear(); @@ -904,7 +884,7 @@ cmGlobalUnixMakefileGenerator3 } // add the clean rule - localName = lg->GetRelativeTargetDirectory(*gtarget->Target); + localName = lg->GetRelativeTargetDirectory(gtarget); makeTargetName = localName; makeTargetName += "/clean"; depends.clear(); @@ -932,18 +912,16 @@ void cmGlobalUnixMakefileGenerator3::InitializeProgressMarks() lgi != this->LocalGenerators.end(); ++lgi) { cmLocalGenerator* lg = *lgi; - cmMakefile* mf = lg->GetMakefile(); - cmTargets const& targets = mf->GetTargets(); - for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t) + std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin(); + t != targets.end(); ++t) { - cmTarget const& target = t->second; - - cmGeneratorTarget* gt = this->GetGeneratorTarget(&target); + cmGeneratorTarget* gt = *t; cmLocalGenerator* tlg = gt->GetLocalGenerator(); - if(gt->GetType() == cmTarget::INTERFACE_LIBRARY - || gt->Target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) + if(gt->GetType() == cmState::INTERFACE_LIBRARY + || gt->GetPropertyAsBool("EXCLUDE_FROM_ALL")) { continue; } @@ -984,12 +962,12 @@ cmGlobalUnixMakefileGenerator3 size_t count = 0; if(emitted.insert(target).second) { - count = this->ProgressMap[target->Target].Marks.size(); + count = this->ProgressMap[target].Marks.size(); TargetDependSet const& depends = this->GetTargetDirectDepends(target); for(TargetDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { - if ((*di)->GetType() == cmTarget::INTERFACE_LIBRARY) + if ((*di)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -1002,7 +980,7 @@ cmGlobalUnixMakefileGenerator3 //---------------------------------------------------------------------------- size_t cmGlobalUnixMakefileGenerator3 -::CountProgressMarksInAll(cmLocalUnixMakefileGenerator3* lg) +::CountProgressMarksInAll(cmLocalGenerator* lg) { size_t count = 0; std::set<cmGeneratorTarget const*> emitted; @@ -1021,7 +999,7 @@ void cmGlobalUnixMakefileGenerator3::RecordTargetProgress( cmMakefileTargetGenerator* tg) { - TargetProgress& tp = this->ProgressMap[tg->GetTarget()]; + TargetProgress& tp = this->ProgressMap[tg->GetGeneratorTarget()]; tp.NumberOfActions = tg->GetNumberOfProgressActions(); tp.VariableFile = tg->GetProgressFileNameFull(); } @@ -1065,13 +1043,14 @@ cmGlobalUnixMakefileGenerator3 { // Create the target-level dependency. cmGeneratorTarget const* dep = *i; - if (dep->GetType() == cmTarget::INTERFACE_LIBRARY) + if (dep->GetType() == cmState::INTERFACE_LIBRARY) { continue; } cmLocalUnixMakefileGenerator3* lg3 = static_cast<cmLocalUnixMakefileGenerator3*>(dep->GetLocalGenerator()); - std::string tgtName = lg3->GetRelativeTargetDirectory(*(*dep).Target); + std::string tgtName = + lg3->GetRelativeTargetDirectory(const_cast<cmGeneratorTarget*>(dep)); tgtName += "/all"; depends.push_back(tgtName); } @@ -1103,23 +1082,24 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); // for the passed in makefile or if this is the top Makefile wripte out // the targets - if (lg2 == lg || lg->GetMakefile()->IsRootMakefile()) + if (lg2 == lg || lg->IsRootMakefile()) { // for each target Generate the rule files for each target. - cmTargets& targets = lg2->GetMakefile()->GetTargets(); - for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t) + std::vector<cmGeneratorTarget*> targets = lg2->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); + t != targets.end(); ++t) { - cmTarget const& target = t->second; - cmTarget::TargetType type = target.GetType(); - if((type == cmTarget::EXECUTABLE) || - (type == cmTarget::STATIC_LIBRARY) || - (type == cmTarget::SHARED_LIBRARY) || - (type == cmTarget::MODULE_LIBRARY) || - (type == cmTarget::OBJECT_LIBRARY) || - (type == cmTarget::GLOBAL_TARGET) || - (type == cmTarget::UTILITY)) + cmGeneratorTarget* target = *t; + cmState::TargetType type = target->GetType(); + if((type == cmState::EXECUTABLE) || + (type == cmState::STATIC_LIBRARY) || + (type == cmState::SHARED_LIBRARY) || + (type == cmState::MODULE_LIBRARY) || + (type == cmState::OBJECT_LIBRARY) || + (type == cmState::GLOBAL_TARGET) || + (type == cmState::UTILITY)) { - std::string name = target.GetName(); + std::string name = target->GetName(); if(emittedTargets.insert(name).second) { path = "... "; @@ -1146,19 +1126,19 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule bool cmGlobalUnixMakefileGenerator3 -::NeedRequiresStep(cmTarget const& target) +::NeedRequiresStep(const cmGeneratorTarget* target) { std::set<std::string> languages; - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&target); - gtgt->GetLanguages(languages, - target.GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE")); + target->GetLanguages(languages, + target->Target->GetMakefile() + ->GetSafeDefinition("CMAKE_BUILD_TYPE")); for(std::set<std::string>::const_iterator l = languages.begin(); l != languages.end(); ++l) { std::string var = "CMAKE_NEEDS_REQUIRES_STEP_"; var += *l; var += "_FLAG"; - if(target.GetMakefile()->GetDefinition(var)) + if(target->Target->GetMakefile()->GetDefinition(var)) { return true; } diff --git a/Source/cmGlobalUnixMakefileGenerator3.h b/Source/cmGlobalUnixMakefileGenerator3.h index 5f39c79..54fdc0e 100644 --- a/Source/cmGlobalUnixMakefileGenerator3.h +++ b/Source/cmGlobalUnixMakefileGenerator3.h @@ -154,7 +154,7 @@ protected: cmGeneratorTarget* target); // does this generator need a requires step for any of its targets - bool NeedRequiresStep(cmTarget const&); + bool NeedRequiresStep(cmGeneratorTarget const*); // Target name hooks for superclass. const char* GetAllTargetName() const { return "all"; } @@ -192,13 +192,13 @@ protected: std::vector<unsigned long> Marks; void WriteProgressVariables(unsigned long total, unsigned long& current); }; - typedef std::map<cmTarget const*, TargetProgress, - cmStrictTargetComparison> ProgressMapType; + typedef std::map<cmGeneratorTarget const*, TargetProgress, + cmGeneratorTarget::StrictTargetComparison> ProgressMapType; ProgressMapType ProgressMap; size_t CountProgressMarksInTarget(cmGeneratorTarget const* target, std::set<cmGeneratorTarget const*>& emitted); - size_t CountProgressMarksInAll(cmLocalUnixMakefileGenerator3* lg); + size_t CountProgressMarksInAll(cmLocalGenerator* lg); cmGeneratedFileStream *CommandDatabase; private: diff --git a/Source/cmGlobalVisualStudio10Generator.cxx b/Source/cmGlobalVisualStudio10Generator.cxx index 44d632d..e568704 100644 --- a/Source/cmGlobalVisualStudio10Generator.cxx +++ b/Source/cmGlobalVisualStudio10Generator.cxx @@ -176,7 +176,14 @@ cmGlobalVisualStudio10Generator::SetGeneratorToolset(std::string const& ts, //---------------------------------------------------------------------------- bool cmGlobalVisualStudio10Generator::InitializeSystem(cmMakefile* mf) { - if (this->SystemName == "WindowsCE") + if (this->SystemName == "Windows") + { + if (!this->InitializeWindows(mf)) + { + return false; + } + } + else if (this->SystemName == "WindowsCE") { this->SystemIsWindowsCE = true; if (!this->InitializeWindowsCE(mf)) @@ -184,7 +191,7 @@ bool cmGlobalVisualStudio10Generator::InitializeSystem(cmMakefile* mf) return false; } } - else if(this->SystemName == "WindowsPhone") + else if (this->SystemName == "WindowsPhone") { this->SystemIsWindowsPhone = true; if(!this->InitializeWindowsPhone(mf)) @@ -192,7 +199,7 @@ bool cmGlobalVisualStudio10Generator::InitializeSystem(cmMakefile* mf) return false; } } - else if(this->SystemName == "WindowsStore") + else if (this->SystemName == "WindowsStore") { this->SystemIsWindowsStore = true; if(!this->InitializeWindowsStore(mf)) @@ -229,6 +236,12 @@ bool cmGlobalVisualStudio10Generator::InitializeSystem(cmMakefile* mf) } //---------------------------------------------------------------------------- +bool cmGlobalVisualStudio10Generator::InitializeWindows(cmMakefile*) +{ + return true; +} + +//---------------------------------------------------------------------------- bool cmGlobalVisualStudio10Generator::InitializeWindowsCE(cmMakefile* mf) { if (this->DefaultPlatformName != "Win32") @@ -312,23 +325,13 @@ cmLocalGenerator* cmGlobalVisualStudio10Generator::CreateLocalGenerator( return new cmLocalVisualStudio10Generator(this, mf); } -//---------------------------------------------------------------------------- -bool cmGlobalVisualStudio10Generator::Compute() -{ - if (!cmGlobalVisualStudio8Generator::Compute()) - { - return false; - } - this->LongestSource = LongestSourcePath(); - return true; -} - void cmGlobalVisualStudio10Generator::Generate() { + this->LongestSource = LongestSourcePath(); this->cmGlobalVisualStudio8Generator::Generate(); if(this->LongestSource.Length > 0) { - cmMakefile* mf = this->LongestSource.Target->GetMakefile(); + cmLocalGenerator* lg = this->LongestSource.Target->GetLocalGenerator(); std::ostringstream e; e << "The binary and/or source directory paths may be too long to generate " @@ -343,13 +346,13 @@ void cmGlobalVisualStudio10Generator::Generate() " " << this->LongestSource.SourceFile->GetFullPath() << "\n" "This is because some Visual Studio tools would append the relative " "path to the end of the referencing directory path, as in:\n" - " " << mf->GetCurrentBinaryDirectory() << "/" + " " << lg->GetCurrentBinaryDirectory() << "/" << this->LongestSource.SourceRel << "\n" "and then incorrectly complain that the file does not exist because " "the path length is too long for some internal buffer or API. " "To avoid this problem CMake must use a full path for this file " "which then triggers the VS 10 property dialog bug."; - mf->IssueMessage(cmake::WARNING, e.str().c_str()); + lg->IssueMessage(cmake::WARNING, e.str().c_str()); } } @@ -588,9 +591,11 @@ cmGlobalVisualStudio10Generator //---------------------------------------------------------------------------- void cmGlobalVisualStudio10Generator::PathTooLong( - cmTarget* target, cmSourceFile const* sf, std::string const& sfRel) + cmGeneratorTarget *target, cmSourceFile const* sf, + std::string const& sfRel) { - size_t len = (strlen(target->GetMakefile()->GetCurrentBinaryDirectory()) + + size_t len = + (strlen(target->GetLocalGenerator()->GetCurrentBinaryDirectory()) + 1 + sfRel.length()); if(len > this->LongestSource.Length) { diff --git a/Source/cmGlobalVisualStudio10Generator.h b/Source/cmGlobalVisualStudio10Generator.h index 8de7b09..6bf4740 100644 --- a/Source/cmGlobalVisualStudio10Generator.h +++ b/Source/cmGlobalVisualStudio10Generator.h @@ -45,8 +45,6 @@ public: std::vector<std::string> const& makeOptions = std::vector<std::string>() ); - virtual bool Compute(); - ///! create the correct local generator virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile* mf); @@ -74,6 +72,10 @@ public: /** Return the CMAKE_SYSTEM_VERSION. */ std::string const& GetSystemVersion() const { return this->SystemVersion; } + /** Return the Windows version targeted on VS 2015 and above. */ + std::string const& GetWindowsTargetPlatformVersion() const + { return this->WindowsTargetPlatformVersion; } + /** Return true if building for WindowsCE */ bool TargetsWindowsCE() const { return this->SystemIsWindowsCE; } @@ -93,7 +95,7 @@ public: /** Generate an <output>.rule file path for a given command output. */ virtual std::string GenerateRuleFile(std::string const& output) const; - void PathTooLong(cmTarget* target, cmSourceFile const* sf, + void PathTooLong(cmGeneratorTarget* target, cmSourceFile const* sf, std::string const& sfRel); virtual const char* GetToolsVersion() { return "4.0"; } @@ -105,6 +107,7 @@ public: protected: virtual void Generate(); virtual bool InitializeSystem(cmMakefile* mf); + virtual bool InitializeWindows(cmMakefile* mf); virtual bool InitializeWindowsCE(cmMakefile* mf); virtual bool InitializeWindowsPhone(cmMakefile* mf); virtual bool InitializeWindowsStore(cmMakefile* mf); @@ -119,6 +122,7 @@ protected: std::string GeneratorToolset; std::string DefaultPlatformToolset; + std::string WindowsTargetPlatformVersion; std::string SystemName; std::string SystemVersion; std::string NsightTegraVersion; @@ -135,7 +139,7 @@ private: { LongestSourcePath(): Length(0), Target(0), SourceFile(0) {} size_t Length; - cmTarget* Target; + cmGeneratorTarget* Target; cmSourceFile const* SourceFile; std::string SourceRel; }; diff --git a/Source/cmGlobalVisualStudio11Generator.cxx b/Source/cmGlobalVisualStudio11Generator.cxx index 419bf8a..b9b4fff 100644 --- a/Source/cmGlobalVisualStudio11Generator.cxx +++ b/Source/cmGlobalVisualStudio11Generator.cxx @@ -278,10 +278,10 @@ cmGlobalVisualStudio11Generator::GetInstalledWindowsCESDKs() //---------------------------------------------------------------------------- bool -cmGlobalVisualStudio11Generator::NeedsDeploy(cmTarget::TargetType type) const +cmGlobalVisualStudio11Generator::NeedsDeploy(cmState::TargetType type) const { - if((type == cmTarget::EXECUTABLE || - type == cmTarget::SHARED_LIBRARY) && + if((type == cmState::EXECUTABLE || + type == cmState::SHARED_LIBRARY) && (this->SystemIsWindowsPhone || this->SystemIsWindowsStore)) { diff --git a/Source/cmGlobalVisualStudio11Generator.h b/Source/cmGlobalVisualStudio11Generator.h index b50f4c9..f3f6b2b 100644 --- a/Source/cmGlobalVisualStudio11Generator.h +++ b/Source/cmGlobalVisualStudio11Generator.h @@ -34,9 +34,12 @@ protected: virtual bool SelectWindowsPhoneToolset(std::string& toolset) const; virtual bool SelectWindowsStoreToolset(std::string& toolset) const; + // Used to verify that the Desktop toolset for the current generator is + // installed on the machine. + virtual bool IsWindowsDesktopToolsetInstalled() const; + // These aren't virtual because we need to check if the selected version // of the toolset is installed - bool IsWindowsDesktopToolsetInstalled() const; bool IsWindowsPhoneToolsetInstalled() const; bool IsWindowsStoreToolsetInstalled() const; @@ -45,7 +48,7 @@ protected: static std::set<std::string> GetInstalledWindowsCESDKs(); /** Return true if the configuration needs to be deployed */ - virtual bool NeedsDeploy(cmTarget::TargetType type) const; + virtual bool NeedsDeploy(cmState::TargetType type) const; private: class Factory; friend class Factory; diff --git a/Source/cmGlobalVisualStudio12Generator.h b/Source/cmGlobalVisualStudio12Generator.h index bce9e0c..a7939aa 100644 --- a/Source/cmGlobalVisualStudio12Generator.h +++ b/Source/cmGlobalVisualStudio12Generator.h @@ -38,9 +38,12 @@ protected: virtual bool SelectWindowsPhoneToolset(std::string& toolset) const; virtual bool SelectWindowsStoreToolset(std::string& toolset) const; + // Used to verify that the Desktop toolset for the current generator is + // installed on the machine. + virtual bool IsWindowsDesktopToolsetInstalled() const; + // These aren't virtual because we need to check if the selected version // of the toolset is installed - bool IsWindowsDesktopToolsetInstalled() const; bool IsWindowsPhoneToolsetInstalled() const; bool IsWindowsStoreToolsetInstalled() const; virtual const char* GetIDEVersion() { return "12.0"; } diff --git a/Source/cmGlobalVisualStudio14Generator.cxx b/Source/cmGlobalVisualStudio14Generator.cxx index 2cf55d4..41825fb 100644 --- a/Source/cmGlobalVisualStudio14Generator.cxx +++ b/Source/cmGlobalVisualStudio14Generator.cxx @@ -111,6 +111,84 @@ cmGlobalVisualStudio14Generator::MatchesGeneratorName( } //---------------------------------------------------------------------------- +bool cmGlobalVisualStudio14Generator::InitializeWindows(cmMakefile* mf) +{ + if (cmHasLiteralPrefix(this->SystemVersion, "10.0")) + { + return this->SelectWindows10SDK(mf); + } + return true; +} + +//---------------------------------------------------------------------------- +bool cmGlobalVisualStudio14Generator::InitializeWindowsStore(cmMakefile* mf) +{ + std::ostringstream e; + if(!this->SelectWindowsStoreToolset(this->DefaultPlatformToolset)) + { + if(this->DefaultPlatformToolset.empty()) + { + e << this->GetName() << " supports Windows Store '8.0', '8.1' and " + "'10.0', but not '" << this->SystemVersion << + "'. Check CMAKE_SYSTEM_VERSION."; + } + else + { + e << "A Windows Store component with CMake requires both the Windows " + << "Desktop SDK as well as the Windows Store '" << this->SystemVersion + << "' SDK. Please make sure that you have both installed"; + } + mf->IssueMessage(cmake::FATAL_ERROR, e.str()); + return false; + } + if (cmHasLiteralPrefix(this->SystemVersion, "10.0")) + { + return this->SelectWindows10SDK(mf); + } + return true; +} + +//---------------------------------------------------------------------------- +bool cmGlobalVisualStudio14Generator::SelectWindows10SDK(cmMakefile* mf) +{ + // Find the default version of the Windows 10 SDK. + this->WindowsTargetPlatformVersion = this->GetWindows10SDKVersion(); + if (this->WindowsTargetPlatformVersion.empty()) + { + std::ostringstream e; + e << "Could not find an appropriate version of the Windows 10 SDK" + << " installed on this machine"; + mf->IssueMessage(cmake::FATAL_ERROR, e.str()); + return false; + } + mf->AddDefinition("CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION", + this->WindowsTargetPlatformVersion.c_str()); + return true; +} + +//---------------------------------------------------------------------------- +bool +cmGlobalVisualStudio14Generator::SelectWindowsStoreToolset( + std::string& toolset) const +{ + if (cmHasLiteralPrefix(this->SystemVersion, "10.0")) + { + if (this->IsWindowsStoreToolsetInstalled() && + this->IsWindowsDesktopToolsetInstalled()) + { + toolset = "v140"; + return true; + } + else + { + return false; + } + } + return + this->cmGlobalVisualStudio12Generator::SelectWindowsStoreToolset(toolset); +} + +//---------------------------------------------------------------------------- void cmGlobalVisualStudio14Generator::WriteSLNHeader(std::ostream& fout) { // Visual Studio 14 writes .sln format 12.00 @@ -124,3 +202,90 @@ void cmGlobalVisualStudio14Generator::WriteSLNHeader(std::ostream& fout) fout << "# Visual Studio 14\n"; } } + +//---------------------------------------------------------------------------- +bool +cmGlobalVisualStudio14Generator::IsWindowsDesktopToolsetInstalled() const +{ + const char desktop10Key[] = + "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\" + "VisualStudio\\14.0\\VC\\Runtimes"; + + std::vector<std::string> vc14; + return cmSystemTools::GetRegistrySubKeys(desktop10Key, + vc14, cmSystemTools::KeyWOW64_32); +} + +//---------------------------------------------------------------------------- +bool +cmGlobalVisualStudio14Generator::IsWindowsStoreToolsetInstalled() const +{ + const char universal10Key[] = + "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\" + "VisualStudio\\14.0\\Setup\\Build Tools for Windows 10;SrcPath"; + + std::string win10SDK; + return cmSystemTools::ReadRegistryValue(universal10Key, + win10SDK, cmSystemTools::KeyWOW64_32); +} + +//---------------------------------------------------------------------------- +std::string cmGlobalVisualStudio14Generator::GetWindows10SDKVersion() +{ +#if defined(_WIN32) && !defined(__CYGWIN__) + // This logic is taken from the vcvarsqueryregistry.bat file from VS2015 + // Try HKLM and then HKCU. + std::string win10Root; + if (!cmSystemTools::ReadRegistryValue( + "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\" + "Windows Kits\\Installed Roots;KitsRoot10", win10Root, + cmSystemTools::KeyWOW64_32) && + !cmSystemTools::ReadRegistryValue( + "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\" + "Windows Kits\\Installed Roots;KitsRoot10", win10Root, + cmSystemTools::KeyWOW64_32)) + { + return std::string(); + } + + std::vector<std::string> sdks; + std::string path = win10Root + "Include/*"; + // Grab the paths of the different SDKs that are installed + cmSystemTools::GlobDirs(path, sdks); + if (!sdks.empty()) + { + // Only use the filename, which will be the SDK version. + for (std::vector<std::string>::iterator i = sdks.begin(); + i != sdks.end(); ++i) + { + *i = cmSystemTools::GetFilenameName(*i); + } + + // Sort the results to make sure we select the most recent one that + // has a version less or equal to our version of the operating system + std::sort(sdks.begin(), sdks.end(), cmSystemTools::VersionCompareGreater); + + // Select a suitable SDK version. + if (this->SystemVersion == "10.0") + { + // Use the latest Windows 10 SDK since no build version was given. + return sdks.at(0); + } + else + { + // Find the SDK less or equal to our specified version + for (std::vector<std::string>::iterator i = sdks.begin(); + i != sdks.end(); ++i) + { + if (!cmSystemTools::VersionCompareGreater(*i, this->SystemVersion)) + { + // This is the most recent SDK that we can run safely + return *i; + } + } + } + } +#endif + // Return an empty string + return std::string(); +} diff --git a/Source/cmGlobalVisualStudio14Generator.h b/Source/cmGlobalVisualStudio14Generator.h index aa817be..76c15d9 100644 --- a/Source/cmGlobalVisualStudio14Generator.h +++ b/Source/cmGlobalVisualStudio14Generator.h @@ -30,7 +30,23 @@ public: virtual const char* GetToolsVersion() { return "14.0"; } protected: + virtual bool InitializeWindows(cmMakefile* mf); + virtual bool InitializeWindowsStore(cmMakefile* mf); + virtual bool SelectWindowsStoreToolset(std::string& toolset) const; + + // These aren't virtual because we need to check if the selected version + // of the toolset is installed + bool IsWindowsStoreToolsetInstalled() const; + virtual const char* GetIDEVersion() { return "14.0"; } + virtual bool SelectWindows10SDK(cmMakefile* mf); + + // Used to verify that the Desktop toolset for the current generator is + // installed on the machine. + virtual bool IsWindowsDesktopToolsetInstalled() const; + + std::string GetWindows10SDKVersion(); + private: class Factory; }; diff --git a/Source/cmGlobalVisualStudio6Generator.cxx b/Source/cmGlobalVisualStudio6Generator.cxx index df49948..5866c0e 100644 --- a/Source/cmGlobalVisualStudio6Generator.cxx +++ b/Source/cmGlobalVisualStudio6Generator.cxx @@ -217,14 +217,14 @@ void cmGlobalVisualStudio6Generator TargetDependSet projectTargets; TargetDependSet originalTargets; this->GetTargetSets(projectTargets, originalTargets, root, generators); - OrderedTargetDependSet orderedProjectTargets(projectTargets); + OrderedTargetDependSet orderedProjectTargets(projectTargets, "ALL_BUILD"); for(OrderedTargetDependSet::const_iterator tt = orderedProjectTargets.begin(); tt != orderedProjectTargets.end(); ++tt) { - cmTarget const* target = (*tt)->Target; - if(target->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget const* target = *tt; + if(target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -235,14 +235,15 @@ void cmGlobalVisualStudio6Generator std::string project = target->GetName(); std::string location = expath; this->WriteExternalProject(fout, project.c_str(), - location.c_str(), target->GetUtilities()); + location.c_str(), target->GetUtilities()); } else { std::string dspname = GetVS6TargetName(target->GetName()); - std::string dir = target->GetMakefile()->GetCurrentBinaryDirectory(); + std::string dir = + target->GetLocalGenerator()->GetCurrentBinaryDirectory(); dir = root->Convert(dir.c_str(), cmLocalGenerator::START_OUTPUT); - this->WriteProject(fout, dspname.c_str(), dir.c_str(), *target); + this->WriteProject(fout, dspname.c_str(), dir.c_str(), target); } } @@ -260,7 +261,7 @@ void cmGlobalVisualStudio6Generator } std::string fname = root->GetMakefile()->GetCurrentBinaryDirectory(); fname += "/"; - fname += root->GetMakefile()->GetProjectName(); + fname += root->GetProjectName(); fname += ".dsw"; cmsys::ofstream fout(fname.c_str()); if(!fout) @@ -287,9 +288,9 @@ void cmGlobalVisualStudio6Generator::OutputDSWFile() // Note, that dependencies from executables to // the libraries it uses are also done here void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout, - const std::string& dspname, - const char* dir, - cmTarget const& target) + const std::string& dspname, + const char* dir, + const cmGeneratorTarget *target) { fout << "#########################################################" "######################\n\n"; @@ -298,7 +299,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout, fout << "Package=<5>\n{{{\n}}}\n\n"; fout << "Package=<4>\n"; fout << "{{{\n"; - VSDependSet const& depends = this->VSTargetDepends[&target]; + VSDependSet const& depends = this->VSTargetDepends[target]; for(VSDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { @@ -309,7 +310,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout, } fout << "}}}\n\n"; - UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target); + UtilityDependsMap::iterator ui = this->UtilityDepends.find(target); if(ui != this->UtilityDepends.end()) { const char* uname = ui->second.c_str(); @@ -382,12 +383,14 @@ void cmGlobalVisualStudio6Generator::WriteDSWHeader(std::ostream& fout) //---------------------------------------------------------------------------- std::string -cmGlobalVisualStudio6Generator::WriteUtilityDepend(cmTarget const* target) +cmGlobalVisualStudio6Generator::WriteUtilityDepend( + const cmGeneratorTarget *target) { std::string pname = target->GetName(); pname += "_UTILITY"; pname = GetVS6TargetName(pname.c_str()); - std::string fname = target->GetMakefile()->GetCurrentBinaryDirectory(); + std::string fname = + target->GetLocalGenerator()->GetCurrentBinaryDirectory(); fname += "/"; fname += pname; fname += ".dsp"; diff --git a/Source/cmGlobalVisualStudio6Generator.h b/Source/cmGlobalVisualStudio6Generator.h index e9b24ea..993a48f 100644 --- a/Source/cmGlobalVisualStudio6Generator.h +++ b/Source/cmGlobalVisualStudio6Generator.h @@ -15,8 +15,6 @@ #include "cmGlobalVisualStudioGenerator.h" #include "cmGlobalGeneratorFactory.h" -class cmTarget; - /** \class cmGlobalVisualStudio6Generator * \brief Write a Unix makefiles. * @@ -94,12 +92,12 @@ private: void WriteDSWHeader(std::ostream& fout); void WriteProject(std::ostream& fout, const std::string& name, const char* path, - cmTarget const& t); + cmGeneratorTarget const* t); void WriteExternalProject(std::ostream& fout, const std::string& name, const char* path, const std::set<std::string>& dependencies); void WriteDSWFooter(std::ostream& fout); - virtual std::string WriteUtilityDepend(cmTarget const* target); + virtual std::string WriteUtilityDepend(const cmGeneratorTarget *target); std::string MSDevCommand; bool MSDevCommandInitialized; std::string const& GetMSDevCommand(); diff --git a/Source/cmGlobalVisualStudio71Generator.cxx b/Source/cmGlobalVisualStudio71Generator.cxx index 607642c..8227b82 100644 --- a/Source/cmGlobalVisualStudio71Generator.cxx +++ b/Source/cmGlobalVisualStudio71Generator.cxx @@ -94,7 +94,7 @@ void cmGlobalVisualStudio71Generator TargetDependSet projectTargets; TargetDependSet originalTargets; this->GetTargetSets(projectTargets, originalTargets, root, generators); - OrderedTargetDependSet orderedProjectTargets(projectTargets); + OrderedTargetDependSet orderedProjectTargets(projectTargets, "ALL_BUILD"); this->WriteTargetsToSolution(fout, root, orderedProjectTargets); @@ -152,7 +152,7 @@ void cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout, const std::string& dspname, const char* dir, - cmTarget const& t) + cmGeneratorTarget const* t) { // check to see if this is a fortran build const char* ext = ".vcproj"; @@ -163,7 +163,7 @@ cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout, ext = ".vfproj"; project = "Project(\"{6989167D-11E4-40FE-8C1A-2192A86A7E90}\") = \""; } - const char* targetExt = t.GetProperty("GENERATOR_FILE_NAME_EXT"); + const char* targetExt = t->GetProperty("GENERATOR_FILE_NAME_EXT"); if(targetExt) { ext = targetExt; @@ -180,7 +180,7 @@ cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout, fout <<"EndProject\n"; - UtilityDependsMap::iterator ui = this->UtilityDepends.find(&t); + UtilityDependsMap::iterator ui = this->UtilityDepends.find(t); if(ui != this->UtilityDepends.end()) { const char* uname = ui->second.c_str(); @@ -204,9 +204,9 @@ void cmGlobalVisualStudio71Generator ::WriteProjectDepends(std::ostream& fout, const std::string&, - const char*, cmTarget const& target) + const char*, cmGeneratorTarget const* target) { - VSDependSet const& depends = this->VSTargetDepends[&target]; + VSDependSet const& depends = this->VSTargetDepends[target]; for(VSDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { @@ -215,7 +215,7 @@ cmGlobalVisualStudio71Generator if(guid.empty()) { std::string m = "Target: "; - m += target.GetName(); + m += target->GetName(); m += " depends on unknown target: "; m += name; cmSystemTools::Error(m.c_str()); @@ -272,7 +272,7 @@ void cmGlobalVisualStudio71Generator // executables to the libraries it uses are also done here void cmGlobalVisualStudio71Generator ::WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType, + std::ostream& fout, const std::string& name, cmState::TargetType, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, std::string const& platformMapping) diff --git a/Source/cmGlobalVisualStudio71Generator.h b/Source/cmGlobalVisualStudio71Generator.h index fbb9ecc..5035fda 100644 --- a/Source/cmGlobalVisualStudio71Generator.h +++ b/Source/cmGlobalVisualStudio71Generator.h @@ -59,12 +59,12 @@ protected: std::ostream& fout, std::vector<std::string> const& configs); virtual void WriteProject(std::ostream& fout, const std::string& name, const char* path, - cmTarget const& t); + const cmGeneratorTarget *t); virtual void WriteProjectDepends(std::ostream& fout, const std::string& name, const char* path, - cmTarget const& t); + cmGeneratorTarget const* t); virtual void WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType type, + std::ostream& fout, const std::string& name, cmState::TargetType type, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, const std::string& platformMapping = ""); diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx index 0175062..f5848ab 100644 --- a/Source/cmGlobalVisualStudio7Generator.cxx +++ b/Source/cmGlobalVisualStudio7Generator.cxx @@ -362,10 +362,10 @@ void cmGlobalVisualStudio7Generator { return; } - this->CurrentProject = root->GetMakefile()->GetProjectName(); - std::string fname = root->GetMakefile()->GetCurrentBinaryDirectory(); + this->CurrentProject = root->GetProjectName(); + std::string fname = root->GetCurrentBinaryDirectory(); fname += "/"; - fname += root->GetMakefile()->GetProjectName(); + fname += root->GetProjectName(); fname += ".sln"; cmGeneratedFileStream fout(fname.c_str()); fout.SetCopyIfDifferent(true); @@ -401,8 +401,8 @@ void cmGlobalVisualStudio7Generator::WriteTargetConfigurations( for(OrderedTargetDependSet::const_iterator tt = projectTargets.begin(); tt != projectTargets.end(); ++tt) { - cmTarget const* target = (*tt)->Target; - if(target->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget const* target = *tt; + if(target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -441,8 +441,8 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution( for(OrderedTargetDependSet::const_iterator tt = projectTargets.begin(); tt != projectTargets.end(); ++tt) { - cmTarget const* target = (*tt)->Target; - if(target->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget const* target = *tt; + if(target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -468,8 +468,8 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution( target->GetProperty("GENERATOR_FILE_NAME"); if(vcprojName) { - cmMakefile* tmf = target->GetMakefile(); - std::string dir = tmf->GetCurrentBinaryDirectory(); + cmLocalGenerator* lg = target->GetLocalGenerator(); + std::string dir = lg->GetCurrentBinaryDirectory(); dir = root->Convert(dir.c_str(), cmLocalGenerator::START_OUTPUT); if(dir == ".") @@ -477,7 +477,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution( dir = ""; // msbuild cannot handle ".\" prefix } this->WriteProject(fout, vcprojName, dir.c_str(), - *target); + target); written = true; } } @@ -533,19 +533,19 @@ void cmGlobalVisualStudio7Generator::WriteTargetDepends( for(OrderedTargetDependSet::const_iterator tt = projectTargets.begin(); tt != projectTargets.end(); ++tt) { - cmTarget const* target = (*tt)->Target; - if(target->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget const* target = *tt; + if(target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - cmMakefile* mf = target->GetMakefile(); const char *vcprojName = target->GetProperty("GENERATOR_FILE_NAME"); if (vcprojName) { - std::string dir = mf->GetCurrentSourceDirectory(); + std::string dir = target->GetLocalGenerator() + ->GetCurrentSourceDirectory(); this->WriteProjectDepends(fout, vcprojName, - dir.c_str(), *target); + dir.c_str(), target); } } } @@ -568,7 +568,7 @@ void cmGlobalVisualStudio7Generator TargetDependSet projectTargets; TargetDependSet originalTargets; this->GetTargetSets(projectTargets, originalTargets, root, generators); - OrderedTargetDependSet orderedProjectTargets(projectTargets); + OrderedTargetDependSet orderedProjectTargets(projectTargets, "ALL_BUILD"); this->WriteTargetsToSolution(fout, root, orderedProjectTargets); @@ -685,7 +685,8 @@ cmGlobalVisualStudio7Generator::ConvertToSolutionPath(const char* path) // the libraries it uses are also done here void cmGlobalVisualStudio7Generator::WriteProject(std::ostream& fout, const std::string& dspname, - const char* dir, cmTarget const& target) + const char* dir, + cmGeneratorTarget const* target) { // check to see if this is a fortran build const char* ext = ".vcproj"; @@ -703,7 +704,7 @@ void cmGlobalVisualStudio7Generator::WriteProject(std::ostream& fout, << dspname << ext << "\", \"{" << this->GetGUID(dspname) << "}\"\nEndProject\n"; - UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target); + UtilityDependsMap::iterator ui = this->UtilityDepends.find(target); if(ui != this->UtilityDepends.end()) { const char* uname = ui->second.c_str(); @@ -725,11 +726,11 @@ void cmGlobalVisualStudio7Generator ::WriteProjectDepends(std::ostream& fout, const std::string& dspname, - const char*, cmTarget const& target) + const char*, cmGeneratorTarget const* target) { int depcount = 0; std::string dspguid = this->GetGUID(dspname); - VSDependSet const& depends = this->VSTargetDepends[&target]; + VSDependSet const& depends = this->VSTargetDepends[target]; for(VSDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { @@ -738,7 +739,7 @@ cmGlobalVisualStudio7Generator if(guid.empty()) { std::string m = "Target: "; - m += target.GetName(); + m += target->GetName(); m += " depends on unknown target: "; m += name; cmSystemTools::Error(m.c_str()); @@ -747,7 +748,7 @@ cmGlobalVisualStudio7Generator depcount++; } - UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target); + UtilityDependsMap::iterator ui = this->UtilityDepends.find(target); if(ui != this->UtilityDepends.end()) { const char* uname = ui->second.c_str(); @@ -760,7 +761,7 @@ cmGlobalVisualStudio7Generator // executables to the libraries it uses are also done here void cmGlobalVisualStudio7Generator ::WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType, + std::ostream& fout, const std::string& name, cmState::TargetType, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, const std::string& platformMapping) @@ -887,13 +888,14 @@ void cmGlobalVisualStudio7Generator::WriteSLNHeader(std::ostream& fout) //---------------------------------------------------------------------------- std::string -cmGlobalVisualStudio7Generator::WriteUtilityDepend(cmTarget const* target) +cmGlobalVisualStudio7Generator::WriteUtilityDepend( + cmGeneratorTarget const* target) { std::vector<std::string> configs; - target->GetMakefile()->GetConfigurations(configs); + target->Target->GetMakefile()->GetConfigurations(configs); std::string pname = target->GetName(); pname += "_UTILITY"; - std::string fname = target->GetMakefile()->GetCurrentBinaryDirectory(); + std::string fname = target->GetLocalGenerator()->GetCurrentBinaryDirectory(); fname += "/"; fname += pname; fname += ".vcproj"; @@ -994,13 +996,14 @@ cmGlobalVisualStudio7Generator std::set<std::string> cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild( std::vector<std::string> const& configs, - OrderedTargetDependSet const& projectTargets, cmTarget const* target) + OrderedTargetDependSet const& projectTargets, + cmGeneratorTarget const* target) { std::set<std::string> activeConfigs; // if it is a utilitiy target then only make it part of the // default build if another target depends on it int type = target->GetType(); - if (type == cmTarget::GLOBAL_TARGET) + if (type == cmState::GLOBAL_TARGET) { // check if INSTALL target is part of default build if(target->GetName() == "INSTALL") @@ -1009,12 +1012,13 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild( for(std::vector<std::string>::const_iterator i = configs.begin(); i != configs.end(); ++i) { - const char* propertyValue = target->GetMakefile() + const char* propertyValue = target->Target->GetMakefile() ->GetDefinition("CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD"); cmGeneratorExpression ge; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(propertyValue); - if(cmSystemTools::IsOn(cge->Evaluate(target->GetMakefile(), *i))) + if(cmSystemTools::IsOn(cge->Evaluate(target->GetLocalGenerator(), + *i))) { activeConfigs.insert(*i); } @@ -1022,17 +1026,16 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild( } return activeConfigs; } - if(type == cmTarget::UTILITY && !this->IsDependedOn(projectTargets, target)) + if(type == cmState::UTILITY && !this->IsDependedOn(projectTargets, target)) { return activeConfigs; } - cmGeneratorTarget* gt = this->GetGeneratorTarget(target); // inspect EXCLUDE_FROM_DEFAULT_BUILD[_<CONFIG>] properties for(std::vector<std::string>::const_iterator i = configs.begin(); i != configs.end(); ++i) { const char* propertyValue = - gt->GetFeature("EXCLUDE_FROM_DEFAULT_BUILD", i->c_str()); + target->GetFeature("EXCLUDE_FROM_DEFAULT_BUILD", i->c_str()); if(cmSystemTools::IsOff(propertyValue)) { activeConfigs.insert(*i); @@ -1044,9 +1047,8 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild( bool cmGlobalVisualStudio7Generator ::IsDependedOn(OrderedTargetDependSet const& projectTargets, - cmTarget const* targetIn) + cmGeneratorTarget const* gtIn) { - cmGeneratorTarget* gtIn = this->GetGeneratorTarget(targetIn); for (OrderedTargetDependSet::const_iterator l = projectTargets.begin(); l != projectTargets.end(); ++l) { diff --git a/Source/cmGlobalVisualStudio7Generator.h b/Source/cmGlobalVisualStudio7Generator.h index 35575d1..fe6db2e 100644 --- a/Source/cmGlobalVisualStudio7Generator.h +++ b/Source/cmGlobalVisualStudio7Generator.h @@ -94,7 +94,8 @@ public: /** Return true if the target project file should have the option LinkLibraryDependencies and link to .sln dependencies. */ - virtual bool NeedLinkLibraryDependencies(cmTarget&) { return false; } + virtual bool NeedLinkLibraryDependencies(cmGeneratorTarget*) + { return false; } const char* GetIntelProjectVersion(); @@ -123,12 +124,12 @@ protected: std::vector<cmLocalGenerator*>& generators); virtual void WriteProject(std::ostream& fout, const std::string& name, const char* path, - cmTarget const& t); + const cmGeneratorTarget *t); virtual void WriteProjectDepends(std::ostream& fout, const std::string& name, const char* path, - cmTarget const&t); + cmGeneratorTarget const* t); virtual void WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType type, + std::ostream& fout, const std::string& name, cmState::TargetType type, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, const std::string& platformMapping = ""); @@ -136,7 +137,7 @@ protected: cmLocalGenerator* root); virtual void WriteSLNFooter(std::ostream& fout); virtual void WriteSLNHeader(std::ostream& fout); - virtual std::string WriteUtilityDepend(cmTarget const* target); + virtual std::string WriteUtilityDepend(const cmGeneratorTarget *target); virtual void WriteTargetsToSolution( std::ostream& fout, @@ -162,9 +163,9 @@ protected: std::set<std::string> IsPartOfDefaultBuild(std::vector<std::string> const& configs, OrderedTargetDependSet const& projectTargets, - cmTarget const* target); + cmGeneratorTarget const* target); bool IsDependedOn(OrderedTargetDependSet const& projectTargets, - cmTarget const* target); + cmGeneratorTarget const* target); std::map<std::string, std::string> GUIDMap; virtual void WriteFolders(std::ostream& fout); diff --git a/Source/cmGlobalVisualStudio8Generator.cxx b/Source/cmGlobalVisualStudio8Generator.cxx index 28f0425..5e239b8 100644 --- a/Source/cmGlobalVisualStudio8Generator.cxx +++ b/Source/cmGlobalVisualStudio8Generator.cxx @@ -256,7 +256,7 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget() noCommandLines); cmGeneratorTarget* gt = new cmGeneratorTarget(tgt, lg); - mf->AddGeneratorTarget(tgt, gt); + lg->AddGeneratorTarget(gt); // Organize in the "predefined targets" folder: // @@ -312,10 +312,10 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget() cmCustomCommandLine commandLine; commandLine.push_back(cmSystemTools::GetCMakeCommand()); std::string argH = "-H"; - argH += mf->GetHomeDirectory(); + argH += lg->GetSourceDirectory(); commandLine.push_back(argH); std::string argB = "-B"; - argB += mf->GetHomeOutputDirectory(); + argB += lg->GetBinaryDirectory(); commandLine.push_back(argB); commandLine.push_back("--check-stamp-list"); commandLine.push_back(stampList.c_str()); @@ -336,7 +336,7 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget() no_main_dependency, commandLines, "Checking Build System", no_working_directory, true)) { - tgt->AddSource(file->GetFullPath()); + gt->AddSource(file->GetFullPath()); } else { @@ -348,27 +348,26 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget() } //---------------------------------------------------------------------------- -bool cmGlobalVisualStudio8Generator::Compute() +void cmGlobalVisualStudio8Generator::AddExtraIDETargets() { - if (!cmGlobalVisualStudio7Generator::Compute()) - { - return false; - } - + cmGlobalVisualStudio7Generator::AddExtraIDETargets(); if(this->AddCheckTarget()) { - // All targets depend on the build-system check target. - for(TargetMap::const_iterator - ti = this->TotalTargets.begin(); - ti != this->TotalTargets.end(); ++ti) + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { - if(ti->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET) + std::vector<cmGeneratorTarget*> tgts = + this->LocalGenerators[i]->GetGeneratorTargets(); + // All targets depend on the build-system check target. + for(std::vector<cmGeneratorTarget*>::iterator ti = tgts.begin(); + ti != tgts.end(); ++ti) { - ti->second->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET); + if((*ti)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET) + { + (*ti)->Target->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET); + } } } } - return true; } //---------------------------------------------------------------------------- @@ -391,7 +390,7 @@ cmGlobalVisualStudio8Generator void cmGlobalVisualStudio8Generator ::WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType type, + std::ostream& fout, const std::string& name, cmState::TargetType type, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, std::string const& platformMapping) @@ -428,10 +427,10 @@ cmGlobalVisualStudio8Generator //---------------------------------------------------------------------------- bool -cmGlobalVisualStudio8Generator::NeedsDeploy(cmTarget::TargetType type) const +cmGlobalVisualStudio8Generator::NeedsDeploy(cmState::TargetType type) const { - bool needsDeploy = (type == cmTarget::EXECUTABLE || - type == cmTarget::SHARED_LIBRARY); + bool needsDeploy = (type == cmState::EXECUTABLE || + type == cmState::SHARED_LIBRARY); return this->TargetsWindowsCE() && needsDeploy; } @@ -445,15 +444,15 @@ bool cmGlobalVisualStudio8Generator::ComputeTargetDepends() //---------------------------------------------------------------------------- void cmGlobalVisualStudio8Generator::WriteProjectDepends( - std::ostream& fout, const std::string&, const char*, cmTarget const& t) + std::ostream& fout, const std::string&, const char*, + cmGeneratorTarget const* gt) { - cmGeneratorTarget* gt = this->GetGeneratorTarget(&t); TargetDependSet const& unordered = this->GetTargetDirectDepends(gt); - OrderedTargetDependSet depends(unordered); + OrderedTargetDependSet depends(unordered, std::string()); for(OrderedTargetDependSet::const_iterator i = depends.begin(); i != depends.end(); ++i) { - if((*i)->GetType() == cmTarget::INTERFACE_LIBRARY) + if((*i)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -464,16 +463,17 @@ void cmGlobalVisualStudio8Generator::WriteProjectDepends( //---------------------------------------------------------------------------- bool cmGlobalVisualStudio8Generator::NeedLinkLibraryDependencies( - cmTarget& target) + cmGeneratorTarget *target) { // Look for utility dependencies that magically link. for(std::set<std::string>::const_iterator ui = - target.GetUtilities().begin(); - ui != target.GetUtilities().end(); ++ui) + target->GetUtilities().begin(); + ui != target->GetUtilities().end(); ++ui) { - if(cmTarget* depTarget = this->FindTarget(ui->c_str())) + if(cmGeneratorTarget* depTarget = + target->GetLocalGenerator()->FindGeneratorTargetToUse(ui->c_str())) { - if(depTarget->GetType() != cmTarget::INTERFACE_LIBRARY + if(depTarget->GetType() != cmState::INTERFACE_LIBRARY && depTarget->GetProperty("EXTERNAL_MSPROJECT")) { // This utility dependency names an external .vcproj target. diff --git a/Source/cmGlobalVisualStudio8Generator.h b/Source/cmGlobalVisualStudio8Generator.h index 1c61103..b3093cc 100644 --- a/Source/cmGlobalVisualStudio8Generator.h +++ b/Source/cmGlobalVisualStudio8Generator.h @@ -60,14 +60,14 @@ public: /** Return true if the target project file should have the option LinkLibraryDependencies and link to .sln dependencies. */ - virtual bool NeedLinkLibraryDependencies(cmTarget& target); + virtual bool NeedLinkLibraryDependencies(cmGeneratorTarget* target); /** Return true if building for Windows CE */ virtual bool TargetsWindowsCE() const { return !this->WindowsCEVersion.empty(); } protected: - virtual bool Compute(); + virtual void AddExtraIDETargets(); virtual const char* GetIDEVersion() { return "8.0"; } virtual std::string FindDevEnvCommand(); @@ -77,21 +77,22 @@ protected: bool AddCheckTarget(); /** Return true if the configuration needs to be deployed */ - virtual bool NeedsDeploy(cmTarget::TargetType type) const; + virtual bool NeedsDeploy(cmState::TargetType type) const; static cmIDEFlagTable const* GetExtraFlagTableVS8(); virtual void WriteSLNHeader(std::ostream& fout); virtual void WriteSolutionConfigurations( std::ostream& fout, std::vector<std::string> const& configs); virtual void WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType type, + std::ostream& fout, const std::string& name, cmState::TargetType type, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, const std::string& platformMapping = ""); virtual bool ComputeTargetDepends(); virtual void WriteProjectDepends(std::ostream& fout, const std::string& name, - const char* path, cmTarget const& t); + const char* path, + const cmGeneratorTarget *t); std::string Name; std::string WindowsCEVersion; diff --git a/Source/cmGlobalVisualStudioGenerator.cxx b/Source/cmGlobalVisualStudioGenerator.cxx index 2bf04b4..6a1aa29 100644 --- a/Source/cmGlobalVisualStudioGenerator.cxx +++ b/Source/cmGlobalVisualStudioGenerator.cxx @@ -64,13 +64,8 @@ std::string cmGlobalVisualStudioGenerator::GetRegistryBase( } //---------------------------------------------------------------------------- -bool cmGlobalVisualStudioGenerator::Compute() +void cmGlobalVisualStudioGenerator::AddExtraIDETargets() { - if (!cmGlobalGenerator::Compute()) - { - return false; - } - // Add a special target that depends on ALL projects for easy build // of one configuration only. const char* no_working_dir = 0; @@ -92,7 +87,7 @@ bool cmGlobalVisualStudioGenerator::Compute() "Build all projects"); cmGeneratorTarget* gt = new cmGeneratorTarget(allBuild, gen[0]); - allBuild->GetMakefile()->AddGeneratorTarget(allBuild, gt); + gen[0]->AddGeneratorTarget(gt); #if 0 // Can't activate this code because we want ALL_BUILD @@ -112,19 +107,20 @@ bool cmGlobalVisualStudioGenerator::Compute() for(std::vector<cmLocalGenerator*>::iterator i = gen.begin(); i != gen.end(); ++i) { - cmGeneratorTargetsType targets = - (*i)->GetMakefile()->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = + (*i)->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - if (t->second->GetType() == cmTarget::GLOBAL_TARGET - || t->first->IsImported()) + cmGeneratorTarget* tgt = *t; + if (tgt->GetType() == cmState::GLOBAL_TARGET + || tgt->IsImported()) { continue; } - if(!this->IsExcluded(gen[0], t->second)) + if(!this->IsExcluded(gen[0], tgt)) { - allBuild->AddUtility(t->second->GetName()); + allBuild->AddUtility(tgt->GetName()); } } } @@ -144,16 +140,15 @@ bool cmGlobalVisualStudioGenerator::Compute() static_cast<cmLocalVisualStudioGenerator*>(*lgi); lg->AddCMakeListsRules(); } - return true; } //---------------------------------------------------------------------------- void cmGlobalVisualStudioGenerator ::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const { - std::string dir = gt->Makefile->GetCurrentBinaryDirectory(); + std::string dir = gt->LocalGenerator->GetCurrentBinaryDirectory(); dir += "/"; - std::string tgtDir = gt->LocalGenerator->GetTargetDirectory(*gt->Target); + std::string tgtDir = gt->LocalGenerator->GetTargetDirectory(gt); if(!tgtDir.empty()) { dir += tgtDir; @@ -192,7 +187,7 @@ void cmGlobalVisualStudioGenerator::ConfigureCMakeVisualStudioMacros() cmMakefile* mf = this->LocalGenerators[0]->GetMakefile(); std::string dir = this->GetUserMacrosDirectory(); - if (mf != 0 && dir != "") + if (dir != "") { std::string src = mf->GetRequiredDefinition("CMAKE_ROOT"); src += "/Templates/" CMAKE_VSMACROS_FILENAME; @@ -233,13 +228,12 @@ cmGlobalVisualStudioGenerator std::string dir = this->GetUserMacrosDirectory(); // Only really try to call the macro if: - // - mf is non-NULL // - there is a UserMacrosDirectory // - the CMake vsmacros file exists // - the CMake vsmacros file is registered // - there were .sln/.vcproj files changed during generation // - if (mf != 0 && dir != "") + if (dir != "") { std::string macrosFile = dir + "/CMakeMacros/" CMAKE_VSMACROS_FILENAME; std::string nextSubkeyName; @@ -257,7 +251,7 @@ cmGlobalVisualStudioGenerator { topLevelSlnName = mf->GetCurrentBinaryDirectory(); topLevelSlnName += "/"; - topLevelSlnName += mf->GetProjectName(); + topLevelSlnName += this->LocalGenerators[0]->GetProjectName(); topLevelSlnName += ".sln"; } @@ -308,19 +302,20 @@ std::string cmGlobalVisualStudioGenerator::GetUserMacrosRegKeyBase() } //---------------------------------------------------------------------------- -void cmGlobalVisualStudioGenerator::FillLinkClosure(cmTarget const* target, - TargetSet& linked) +void cmGlobalVisualStudioGenerator::FillLinkClosure( + const cmGeneratorTarget *target, + TargetSet& linked) { if(linked.insert(target).second) { - cmGeneratorTarget* gt = this->GetGeneratorTarget(target); - TargetDependSet const& depends = this->GetTargetDirectDepends(gt); + TargetDependSet const& depends = + this->GetTargetDirectDepends(target); for(TargetDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { if(di->IsLink()) { - this->FillLinkClosure((*di)->Target, linked); + this->FillLinkClosure(*di, linked); } } } @@ -328,7 +323,7 @@ void cmGlobalVisualStudioGenerator::FillLinkClosure(cmTarget const* target, //---------------------------------------------------------------------------- cmGlobalVisualStudioGenerator::TargetSet const& -cmGlobalVisualStudioGenerator::GetTargetLinkClosure(cmTarget* target) +cmGlobalVisualStudioGenerator::GetTargetLinkClosure(cmGeneratorTarget* target) { TargetSetMap::iterator i = this->TargetLinkClosure.find(target); if(i == this->TargetLinkClosure.end()) @@ -342,25 +337,25 @@ cmGlobalVisualStudioGenerator::GetTargetLinkClosure(cmTarget* target) //---------------------------------------------------------------------------- void cmGlobalVisualStudioGenerator::FollowLinkDepends( - cmTarget const* target, std::set<cmTarget const*>& linked) + const cmGeneratorTarget *target, + std::set<const cmGeneratorTarget *> &linked) { - if(target->GetType() == cmTarget::INTERFACE_LIBRARY) + if(target->GetType() == cmState::INTERFACE_LIBRARY) { return; } if(linked.insert(target).second && - target->GetType() == cmTarget::STATIC_LIBRARY) + target->GetType() == cmState::STATIC_LIBRARY) { // Static library targets do not list their link dependencies so // we must follow them transitively now. - cmGeneratorTarget* gt = this->GetGeneratorTarget(target); - TargetDependSet const& depends = this->GetTargetDirectDepends(gt); + TargetDependSet const& depends = this->GetTargetDirectDepends(target); for(TargetDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { if(di->IsLink()) { - this->FollowLinkDepends((*di)->Target, linked); + this->FollowLinkDepends(*di, linked); } } } @@ -380,11 +375,11 @@ bool cmGlobalVisualStudioGenerator::ComputeTargetDepends() for(std::vector<cmLocalGenerator*>::iterator i = gen.begin(); i != gen.end(); ++i) { - cmTargets& targets = (*i)->GetMakefile()->GetTargets(); - for(cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets = (*i)->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ++ti) { - this->ComputeVSTargetDepends(ti->second); + this->ComputeVSTargetDepends(*ti); } } } @@ -392,19 +387,20 @@ bool cmGlobalVisualStudioGenerator::ComputeTargetDepends() } //---------------------------------------------------------------------------- -static bool VSLinkable(cmTarget const* t) +static bool VSLinkable(cmGeneratorTarget const* t) { - return t->IsLinkable() || t->GetType() == cmTarget::OBJECT_LIBRARY; + return t->IsLinkable() || t->GetType() == cmState::OBJECT_LIBRARY; } //---------------------------------------------------------------------------- -void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(cmTarget& target) +void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends( + cmGeneratorTarget* target) { - if(this->VSTargetDepends.find(&target) != this->VSTargetDepends.end()) + if(this->VSTargetDepends.find(target) != this->VSTargetDepends.end()) { return; } - VSDependSet& vsTargetDepend = this->VSTargetDepends[&target]; + VSDependSet& vsTargetDepend = this->VSTargetDepends[target]; // VS <= 7.1 has two behaviors that affect solution dependencies. // // (1) Solution-level dependencies between a linkable target and a @@ -424,19 +420,18 @@ void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(cmTarget& target) // leaving them out for the static library itself but following them // transitively for other targets. - bool allowLinkable = (target.GetType() != cmTarget::STATIC_LIBRARY && - target.GetType() != cmTarget::SHARED_LIBRARY && - target.GetType() != cmTarget::MODULE_LIBRARY && - target.GetType() != cmTarget::EXECUTABLE); + bool allowLinkable = (target->GetType() != cmState::STATIC_LIBRARY && + target->GetType() != cmState::SHARED_LIBRARY && + target->GetType() != cmState::MODULE_LIBRARY && + target->GetType() != cmState::EXECUTABLE); - cmGeneratorTarget* gt = this->GetGeneratorTarget(&target); - TargetDependSet const& depends = this->GetTargetDirectDepends(gt); + TargetDependSet const& depends = this->GetTargetDirectDepends(target); // Collect implicit link dependencies (target_link_libraries). // Static libraries cannot depend on their link implementation // due to behavior (2), but they do not really need to. - std::set<cmTarget const*> linkDepends; - if(target.GetType() != cmTarget::STATIC_LIBRARY) + std::set<cmGeneratorTarget const*> linkDepends; + if(target->GetType() != cmState::STATIC_LIBRARY) { for(TargetDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) @@ -444,54 +439,54 @@ void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(cmTarget& target) cmTargetDepend dep = *di; if(dep.IsLink()) { - this->FollowLinkDepends(dep->Target, linkDepends); + this->FollowLinkDepends(*di, linkDepends); } } } // Collect explicit util dependencies (add_dependencies). - std::set<cmTarget const*> utilDepends; + std::set<cmGeneratorTarget const*> utilDepends; for(TargetDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { cmTargetDepend dep = *di; if(dep.IsUtil()) { - this->FollowLinkDepends(dep->Target, utilDepends); + this->FollowLinkDepends(*di, utilDepends); } } // Collect all targets linked by this target so we can avoid // intermediate targets below. TargetSet linked; - if(target.GetType() != cmTarget::STATIC_LIBRARY) + if(target->GetType() != cmState::STATIC_LIBRARY) { - linked = this->GetTargetLinkClosure(&target); + linked = this->GetTargetLinkClosure(target); } // Emit link dependencies. - for(std::set<cmTarget const*>::iterator di = linkDepends.begin(); + for(std::set<cmGeneratorTarget const*>::iterator di = linkDepends.begin(); di != linkDepends.end(); ++di) { - cmTarget const* dep = *di; + cmGeneratorTarget const* dep = *di; vsTargetDepend.insert(dep->GetName()); } // Emit util dependencies. Possibly use intermediate targets. - for(std::set<cmTarget const*>::iterator di = utilDepends.begin(); + for(std::set<cmGeneratorTarget const*>::iterator di = utilDepends.begin(); di != utilDepends.end(); ++di) { - cmTarget const* dep = *di; - if(allowLinkable || !VSLinkable(dep) || linked.count(dep)) + cmGeneratorTarget const* dgt = *di; + if(allowLinkable || !VSLinkable(dgt) || linked.count(dgt)) { // Direct dependency allowed. - vsTargetDepend.insert(dep->GetName()); + vsTargetDepend.insert(dgt->GetName()); } else { // Direct dependency on linkable target not allowed. // Use an intermediate utility target. - vsTargetDepend.insert(this->GetUtilityDepend(dep)); + vsTargetDepend.insert(this->GetUtilityDepend(dgt)); } } } @@ -511,7 +506,8 @@ void cmGlobalVisualStudioGenerator::FindMakeProgram(cmMakefile* mf) //---------------------------------------------------------------------------- std::string -cmGlobalVisualStudioGenerator::GetUtilityDepend(cmTarget const* target) +cmGlobalVisualStudioGenerator::GetUtilityDepend( + cmGeneratorTarget const* target) { UtilityDependsMap::iterator i = this->UtilityDepends.find(target); if(i == this->UtilityDepends.end()) @@ -834,10 +830,8 @@ void RegisterVisualStudioMacros(const std::string& macrosFile, } } bool -cmGlobalVisualStudioGenerator::TargetIsFortranOnly(cmTarget const& target) +cmGlobalVisualStudioGenerator::TargetIsFortranOnly(cmGeneratorTarget const* gt) { - cmGeneratorTarget* gt = this->GetGeneratorTarget(&target); - // check to see if this is a fortran build std::set<std::string> languages; { @@ -864,35 +858,39 @@ bool cmGlobalVisualStudioGenerator::TargetCompare ::operator()(cmGeneratorTarget const* l, cmGeneratorTarget const* r) const { - // Make sure ALL_BUILD is first so it is the default active project. - if(r->GetName() == "ALL_BUILD") + // Make sure a given named target is ordered first, + // e.g. to set ALL_BUILD as the default active project. + // When the empty string is named this is a no-op. + if (r->GetName() == this->First) { return false; } - if(l->GetName() == "ALL_BUILD") + if (l->GetName() == this->First) { return true; } - return strcmp(l->GetName().c_str(), r->GetName().c_str()) < 0; + return l->GetName() < r->GetName(); } //---------------------------------------------------------------------------- cmGlobalVisualStudioGenerator::OrderedTargetDependSet -::OrderedTargetDependSet(TargetDependSet const& targets) +::OrderedTargetDependSet(TargetDependSet const& targets, + std::string const& first): + derived(TargetCompare(first)) { this->insert(targets.begin(), targets.end()); } //---------------------------------------------------------------------------- cmGlobalVisualStudioGenerator::OrderedTargetDependSet -::OrderedTargetDependSet(TargetSet const& targets) +::OrderedTargetDependSet(TargetSet const& targets, + std::string const& first): + derived(TargetCompare(first)) { for (TargetSet::const_iterator it = targets.begin(); it != targets.end(); ++it) { - cmGeneratorTarget* gt = - (*it)->GetMakefile()->GetGlobalGenerator()->GetGeneratorTarget(*it); - this->insert(gt); + this->insert(*it); } } diff --git a/Source/cmGlobalVisualStudioGenerator.h b/Source/cmGlobalVisualStudioGenerator.h index 64440ad..f827f26 100644 --- a/Source/cmGlobalVisualStudioGenerator.h +++ b/Source/cmGlobalVisualStudioGenerator.h @@ -73,7 +73,7 @@ public: const char* vsSolutionFile = 0); // return true if target is fortran only - bool TargetIsFortranOnly(cmTarget const& t); + bool TargetIsFortranOnly(const cmGeneratorTarget *gt); /** Get the top-level registry key for this VS version. */ std::string GetRegistryBase(); @@ -88,9 +88,12 @@ public: /** Return true if building for Windows CE */ virtual bool TargetsWindowsCE() const { return false; } - class TargetSet: public std::set<cmTarget const*> {}; - struct TargetCompare + class TargetSet: public std::set<cmGeneratorTarget const*> {}; + class TargetCompare { + std::string First; + public: + TargetCompare(std::string const& first): First(first) {} bool operator()(cmGeneratorTarget const* l, cmGeneratorTarget const* r) const; }; @@ -108,7 +111,7 @@ public: cmGeneratorTarget*, std::vector<cmCustomCommand>& commands, std::string const& configName); protected: - virtual bool Compute(); + virtual void AddExtraIDETargets(); // Does this VS version link targets to each other if there are // dependencies in the SLN file? This was done for VS versions @@ -119,15 +122,16 @@ protected: virtual bool ComputeTargetDepends(); class VSDependSet: public std::set<std::string> {}; - class VSDependMap: public std::map<cmTarget const*, VSDependSet> {}; + class VSDependMap: public std::map<cmGeneratorTarget const*, VSDependSet> {}; VSDependMap VSTargetDepends; - void ComputeVSTargetDepends(cmTarget&); - - bool CheckTargetLinks(cmTarget& target, const std::string& name); - std::string GetUtilityForTarget(cmTarget& target, const std::string&); - virtual std::string WriteUtilityDepend(cmTarget const*) = 0; - std::string GetUtilityDepend(cmTarget const* target); - typedef std::map<cmTarget const*, std::string> UtilityDependsMap; + void ComputeVSTargetDepends(cmGeneratorTarget *); + + bool CheckTargetLinks(cmGeneratorTarget& target, const std::string& name); + std::string GetUtilityForTarget(cmGeneratorTarget& target, + const std::string&); + virtual std::string WriteUtilityDepend(cmGeneratorTarget const*) = 0; + std::string GetUtilityDepend(const cmGeneratorTarget *target); + typedef std::map<cmGeneratorTarget const*, std::string> UtilityDependsMap; UtilityDependsMap UtilityDepends; protected: @@ -138,24 +142,28 @@ private: void PrintCompilerAdvice(std::ostream&, std::string const&, const char*) const {} - void FollowLinkDepends(cmTarget const* target, - std::set<cmTarget const*>& linked); + void FollowLinkDepends(cmGeneratorTarget const* target, + std::set<cmGeneratorTarget const*>& linked); - class TargetSetMap: public std::map<cmTarget*, TargetSet> {}; + class TargetSetMap: public std::map<cmGeneratorTarget*, TargetSet> {}; TargetSetMap TargetLinkClosure; - void FillLinkClosure(cmTarget const* target, TargetSet& linked); - TargetSet const& GetTargetLinkClosure(cmTarget* target); + void FillLinkClosure(const cmGeneratorTarget *target, + TargetSet& linked); + TargetSet const& GetTargetLinkClosure(cmGeneratorTarget* target); }; class cmGlobalVisualStudioGenerator::OrderedTargetDependSet: public std::multiset<cmTargetDepend, cmGlobalVisualStudioGenerator::TargetCompare> { + typedef std::multiset<cmTargetDepend, + cmGlobalVisualStudioGenerator::TargetCompare> + derived; public: typedef cmGlobalGenerator::TargetDependSet TargetDependSet; typedef cmGlobalVisualStudioGenerator::TargetSet TargetSet; - OrderedTargetDependSet(TargetDependSet const&); - OrderedTargetDependSet(TargetSet const&); + OrderedTargetDependSet(TargetDependSet const&, std::string const& first); + OrderedTargetDependSet(TargetSet const&, std::string const& first); }; #endif diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx index 33babec..da8c814 100644 --- a/Source/cmGlobalXCodeGenerator.cxx +++ b/Source/cmGlobalXCodeGenerator.cxx @@ -376,14 +376,8 @@ cmGlobalXCodeGenerator::CreateLocalGenerator(cmMakefile* mf) return new cmLocalXCodeGenerator(this, mf); } -//---------------------------------------------------------------------------- -bool cmGlobalXCodeGenerator::Compute() +void cmGlobalXCodeGenerator::AddExtraIDETargets() { - if (!cmGlobalGenerator::Compute()) - { - return false; - } - std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it; // make sure extra targets are added before calling // the parent generate which will call trace depends @@ -394,7 +388,6 @@ bool cmGlobalXCodeGenerator::Compute() // add ALL_BUILD, INSTALL, etc this->AddExtraTargets(root, it->second); } - return true; } void cmGlobalXCodeGenerator::Generate() @@ -417,15 +410,17 @@ void cmGlobalXCodeGenerator::Generate() //---------------------------------------------------------------------------- void cmGlobalXCodeGenerator::SetGenerationRoot(cmLocalGenerator* root) { - this->CurrentProject = root->GetMakefile()->GetProjectName(); + this->CurrentProject = root->GetProjectName(); this->SetCurrentLocalGenerator(root); - cmSystemTools::SplitPath(this->CurrentMakefile->GetCurrentSourceDirectory(), - this->ProjectSourceDirectoryComponents); - cmSystemTools::SplitPath(this->CurrentMakefile->GetCurrentBinaryDirectory(), - this->ProjectOutputDirectoryComponents); + cmSystemTools::SplitPath( + this->CurrentLocalGenerator->GetCurrentSourceDirectory(), + this->ProjectSourceDirectoryComponents); + cmSystemTools::SplitPath( + this->CurrentLocalGenerator->GetCurrentBinaryDirectory(), + this->ProjectOutputDirectoryComponents); this->CurrentXCodeHackMakefile = - root->GetMakefile()->GetCurrentBinaryDirectory(); + root->GetCurrentBinaryDirectory(); this->CurrentXCodeHackMakefile += "/CMakeScripts"; cmSystemTools::MakeDirectory(this->CurrentXCodeHackMakefile.c_str()); this->CurrentXCodeHackMakefile += "/XCODE_DEPEND_HELPER.make"; @@ -464,16 +459,16 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, "echo", "Build all projects"); cmGeneratorTarget* allBuildGt = new cmGeneratorTarget(allbuild, root); - mf->AddGeneratorTarget(allbuild, allBuildGt); + root->AddGeneratorTarget(allBuildGt); // Refer to the main build configuration file for easy editing. - std::string listfile = mf->GetCurrentSourceDirectory(); + std::string listfile = root->GetCurrentSourceDirectory(); listfile += "/"; listfile += "CMakeLists.txt"; - allbuild->AddSourceCMP0049(listfile.c_str()); + allBuildGt->AddSource(listfile.c_str()); // Add XCODE depend helper - std::string dir = mf->GetCurrentBinaryDirectory(); + std::string dir = root->GetCurrentBinaryDirectory(); cmCustomCommandLine makeHelper; if(this->XcodeVersion < 50) { @@ -499,7 +494,7 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, "make", "-f", file.c_str()); cmGeneratorTarget* checkGt = new cmGeneratorTarget(check, root); - mf->AddGeneratorTarget(check, checkGt); + root->AddGeneratorTarget(checkGt); } // now make the allbuild depend on all the non-utility targets @@ -513,19 +508,22 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, continue; } - cmTargets& tgts = lg->GetMakefile()->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++) + std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); l++) { - cmTarget& target = l->second; + cmGeneratorTarget* target = *l; - if (target.GetType() == cmTarget::GLOBAL_TARGET) + if (target->GetType() == cmState::GLOBAL_TARGET) { continue; } - if (regenerate && (l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET)) + std::string targetName = target->GetName(); + + if (regenerate && (targetName != CMAKE_CHECK_BUILD_SYSTEM_TARGET)) { - target.AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET); + target->Target->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET); } // make all exe, shared libs and modules @@ -533,19 +531,19 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, // this will make sure that when the next target is built // things are up-to-date if(!makeHelper.empty() && - (target.GetType() == cmTarget::EXECUTABLE || + (target->GetType() == cmState::EXECUTABLE || // Nope - no post-build for OBJECT_LIRBRARY -// target.GetType() == cmTarget::OBJECT_LIBRARY || - target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY)) +// target->GetType() == cmState::OBJECT_LIBRARY || + target->GetType() == cmState::STATIC_LIBRARY || + target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY)) { makeHelper[makeHelper.size()-1] = // fill placeholder - this->PostBuildMakeTarget(target.GetName(), "$(CONFIGURATION)"); + this->PostBuildMakeTarget(target->GetName(), "$(CONFIGURATION)"); cmCustomCommandLines commandLines; commandLines.push_back(makeHelper); std::vector<std::string> no_byproducts; - lg->GetMakefile()->AddCustomCommandToTarget(target.GetName(), + lg->GetMakefile()->AddCustomCommandToTarget(target->GetName(), no_byproducts, no_depends, commandLines, @@ -554,17 +552,17 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, dir.c_str()); } - if(target.GetType() != cmTarget::INTERFACE_LIBRARY - && !target.GetPropertyAsBool("EXCLUDE_FROM_ALL")) + if(target->GetType() != cmState::INTERFACE_LIBRARY + && !target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) { - allbuild->AddUtility(target.GetName()); + allbuild->AddUtility(target->GetName()); } // Refer to the build configuration file for easy editing. - listfile = lg->GetMakefile()->GetCurrentSourceDirectory(); + listfile = lg->GetCurrentSourceDirectory(); listfile += "/"; listfile += "CMakeLists.txt"; - target.AddSourceCMP0049(listfile.c_str()); + target->AddSource(listfile.c_str()); } } } @@ -573,7 +571,6 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, void cmGlobalXCodeGenerator::CreateReRunCMakeFile( cmLocalGenerator* root, std::vector<cmLocalGenerator*> const& gens) { - cmMakefile* mf = root->GetMakefile(); std::vector<std::string> lfiles; for(std::vector<cmLocalGenerator*>::const_iterator gi = gens.begin(); gi != gens.end(); ++gi) @@ -587,7 +584,7 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile( std::vector<std::string>::iterator new_end = std::unique(lfiles.begin(), lfiles.end()); lfiles.erase(new_end, lfiles.end()); - this->CurrentReRunCMakeMakefile = mf->GetCurrentBinaryDirectory(); + this->CurrentReRunCMakeMakefile = root->GetCurrentBinaryDirectory(); this->CurrentReRunCMakeMakefile += "/CMakeScripts"; cmSystemTools::MakeDirectory(this->CurrentReRunCMakeMakefile.c_str()); this->CurrentReRunCMakeMakefile += "/ReRunCMake.make"; @@ -595,7 +592,7 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile( (this->CurrentReRunCMakeMakefile.c_str()); makefileStream.SetCopyIfDifferent(true); makefileStream << "# Generated by CMake, DO NOT EDIT\n"; - std::string checkCache = mf->GetHomeOutputDirectory(); + std::string checkCache = root->GetBinaryDirectory(); checkCache += "/"; checkCache += cmake::GetCMakeFilesDirectoryPostSlash(); checkCache += "cmake.check_cache"; @@ -609,9 +606,9 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile( makefileStream << "\n\t" << this->ConvertToRelativeForMake(cmSystemTools::GetCMakeCommand().c_str()) << " -H" << this->ConvertToRelativeForMake( - mf->GetHomeDirectory()) + root->GetSourceDirectory()) << " -B" << this->ConvertToRelativeForMake( - mf->GetHomeOutputDirectory()) << "\n"; + root->GetBinaryDirectory()) << "\n"; } //---------------------------------------------------------------------------- @@ -712,9 +709,9 @@ cmXCodeObject* cmGlobalXCodeGenerator //---------------------------------------------------------------------------- std::string -GetGroupMapKeyFromPath(cmTarget& cmtarget, const std::string& fullpath) +GetGroupMapKeyFromPath(cmGeneratorTarget* target, const std::string& fullpath) { - std::string key(cmtarget.GetName()); + std::string key(target->GetName()); key += "-"; key += fullpath; return key; @@ -722,16 +719,16 @@ GetGroupMapKeyFromPath(cmTarget& cmtarget, const std::string& fullpath) //---------------------------------------------------------------------------- std::string -GetGroupMapKey(cmTarget& cmtarget, cmSourceFile* sf) +GetGroupMapKey(cmGeneratorTarget* target, cmSourceFile* sf) { - return GetGroupMapKeyFromPath(cmtarget, sf->GetFullPath()); + return GetGroupMapKeyFromPath(target, sf->GetFullPath()); } //---------------------------------------------------------------------------- cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath( const std::string &fullpath, - cmTarget& cmtarget, + cmGeneratorTarget* target, const std::string &lang, cmSourceFile* sf) { @@ -739,7 +736,7 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath( // fileRef object for any given full path. // cmXCodeObject* fileRef = - this->CreateXCodeFileReferenceFromPath(fullpath, cmtarget, lang, sf); + this->CreateXCodeFileReferenceFromPath(fullpath, target, lang, sf); cmXCodeObject* buildFile = this->CreateObject(cmXCodeObject::PBXBuildFile); buildFile->SetComment(fileRef->GetComment()); @@ -752,7 +749,7 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath( cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg, cmSourceFile* sf, - cmTarget& cmtarget) + cmGeneratorTarget* gtgt) { // Add flags from target and source file properties. std::string flags; @@ -782,7 +779,7 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg, this->CurrentLocalGenerator->GetSourceFileLanguage(*sf); cmXCodeObject* buildFile = - this->CreateXCodeSourceFileFromPath(sf->GetFullPath(), cmtarget, lang, sf); + this->CreateXCodeSourceFileFromPath(sf->GetFullPath(), gtgt, lang, sf); cmXCodeObject* fileRef = buildFile->GetObject("fileRef")->GetObject(); cmXCodeObject* settings = @@ -791,14 +788,15 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg, // Is this a resource file in this target? Add it to the resources group... // + cmGeneratorTarget::SourceFileFlags tsFlags = - this->GetGeneratorTarget(&cmtarget)->GetTargetSourceFileFlags(sf); + gtgt->GetTargetSourceFileFlags(sf); bool isResource = tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource; // Is this a "private" or "public" framework header file? // Set the ATTRIBUTES attribute appropriately... // - if(cmtarget.IsFrameworkOnApple()) + if(gtgt->IsFrameworkOnApple()) { if(tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader) { @@ -925,11 +923,11 @@ GetSourcecodeValueFromFileExtension(const std::string& _ext, cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath( const std::string &fullpath, - cmTarget& cmtarget, + cmGeneratorTarget* target, const std::string &lang, cmSourceFile* sf) { - std::string key = GetGroupMapKeyFromPath(cmtarget, fullpath); + std::string key = GetGroupMapKeyFromPath(target, fullpath); cmXCodeObject* fileRef = this->FileRefs[key]; if(!fileRef) { @@ -1006,13 +1004,13 @@ cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath( //---------------------------------------------------------------------------- cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeFileReference(cmSourceFile* sf, - cmTarget& cmtarget) + cmGeneratorTarget* target) { std::string lang = this->CurrentLocalGenerator->GetSourceFileLanguage(*sf); return this->CreateXCodeFileReferenceFromPath( - sf->GetFullPath(), cmtarget, lang, sf); + sf->GetFullPath(), target, lang, sf); } //---------------------------------------------------------------------------- @@ -1038,7 +1036,7 @@ void cmGlobalXCodeGenerator::SetCurrentLocalGenerator(cmLocalGenerator* gen) this->CurrentLocalGenerator = gen; this->CurrentMakefile = gen->GetMakefile(); std::string outdir = - cmSystemTools::CollapseFullPath(this->CurrentMakefile-> + cmSystemTools::CollapseFullPath(this->CurrentLocalGenerator-> GetCurrentBinaryDirectory()); cmSystemTools::SplitPath(outdir.c_str(), this->CurrentOutputDirectoryComponents); @@ -1085,34 +1083,38 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, targets) { this->SetCurrentLocalGenerator(gen); - cmTargets &tgts = this->CurrentMakefile->GetTargets(); - typedef std::map<std::string, cmTarget*, cmCompareTargets> cmSortedTargets; + std::vector<cmGeneratorTarget*> tgts = + this->CurrentLocalGenerator->GetGeneratorTargets(); + typedef std::map<std::string, cmGeneratorTarget*, cmCompareTargets> + cmSortedTargets; cmSortedTargets sortedTargets; - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++) + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); l++) { - sortedTargets[l->first] = &l->second; + sortedTargets[(*l)->GetName()] = *l; } for(cmSortedTargets::iterator l = sortedTargets.begin(); l != sortedTargets.end(); l++) { - cmTarget& cmtarget = *l->second; - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget); + cmGeneratorTarget* gtgt = l->second; + + std::string targetName = gtgt->GetName(); // make sure ALL_BUILD, INSTALL, etc are only done once - if(this->SpecialTargetEmitted(l->first.c_str())) + if(this->SpecialTargetEmitted(targetName.c_str())) { continue; } - if(cmtarget.GetType() == cmTarget::INTERFACE_LIBRARY) + if(gtgt->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - if(cmtarget.GetType() == cmTarget::UTILITY || - cmtarget.GetType() == cmTarget::GLOBAL_TARGET) + if(gtgt->GetType() == cmState::UTILITY || + gtgt->GetType() == cmState::GLOBAL_TARGET) { - cmXCodeObject* t = this->CreateUtilityTarget(cmtarget); + cmXCodeObject* t = this->CreateUtilityTarget(gtgt); if (!t) { return false; @@ -1140,7 +1142,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, { cmXCodeObject* xsf = this->CreateXCodeSourceFile(this->CurrentLocalGenerator, - *i, cmtarget); + *i, gtgt); cmXCodeObject* fr = xsf->GetObject("fileRef"); cmXCodeObject* filetype = fr->GetObject()->GetObject("explicitFileType"); @@ -1191,15 +1193,15 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, { std::string obj = *oi; cmXCodeObject* xsf = - this->CreateXCodeSourceFileFromPath(obj, cmtarget, "", 0); + this->CreateXCodeSourceFileFromPath(obj, gtgt, "", 0); externalObjFiles.push_back(xsf); } } // some build phases only apply to bundles and/or frameworks - bool isFrameworkTarget = cmtarget.IsFrameworkOnApple(); - bool isBundleTarget = cmtarget.GetPropertyAsBool("MACOSX_BUNDLE"); - bool isCFBundleTarget = cmtarget.IsCFBundleOnApple(); + bool isFrameworkTarget = gtgt->IsFrameworkOnApple(); + bool isBundleTarget = gtgt->GetPropertyAsBool("MACOSX_BUNDLE"); + bool isCFBundleTarget = gtgt->IsCFBundleOnApple(); cmXCodeObject* buildFiles = 0; @@ -1293,7 +1295,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, copyFilesBuildPhase->AddAttribute("dstSubfolderSpec", this->CreateString("6")); std::ostringstream ostr; - if (cmtarget.IsFrameworkOnApple()) + if (gtgt->IsFrameworkOnApple()) { // dstPath in frameworks is relative to Versions/<version> ostr << mit->first; @@ -1314,7 +1316,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, { cmXCodeObject* xsf = this->CreateXCodeSourceFile(this->CurrentLocalGenerator, - *sfIt, cmtarget); + *sfIt, gtgt); buildFiles->AddObject(xsf); } contentBuildPhases.push_back(copyFilesBuildPhase); @@ -1348,9 +1350,9 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, this->CreateCustomCommands(buildPhases, sourceBuildPhase, headerBuildPhase, resourceBuildPhase, contentBuildPhases, - frameworkBuildPhase, cmtarget); + frameworkBuildPhase, gtgt); - targets.push_back(this->CreateXCodeTarget(cmtarget, buildPhases)); + targets.push_back(this->CreateXCodeTarget(gtgt, buildPhases)); } return true; } @@ -1358,26 +1360,31 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, //---------------------------------------------------------------------------- void cmGlobalXCodeGenerator::ForceLinkerLanguages() { - // This makes sure all targets link using the proper language. - for(TargetMap::const_iterator - ti = this->TotalTargets.begin(); ti != this->TotalTargets.end(); ++ti) + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { - this->ForceLinkerLanguage(*ti->second); + std::vector<cmGeneratorTarget*> tgts = + this->LocalGenerators[i]->GetGeneratorTargets(); + // All targets depend on the build-system check target. + for(std::vector<cmGeneratorTarget*>::const_iterator ti = tgts.begin(); + ti != tgts.end(); ++ti) + { + // This makes sure all targets link using the proper language. + this->ForceLinkerLanguage(*ti); + } } } //---------------------------------------------------------------------------- -void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmTarget& cmtarget) +void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmGeneratorTarget* gtgt) { // This matters only for targets that link. - if(cmtarget.GetType() != cmTarget::EXECUTABLE && - cmtarget.GetType() != cmTarget::SHARED_LIBRARY && - cmtarget.GetType() != cmTarget::MODULE_LIBRARY) + if(gtgt->GetType() != cmState::EXECUTABLE && + gtgt->GetType() != cmState::SHARED_LIBRARY && + gtgt->GetType() != cmState::MODULE_LIBRARY) { return; } - cmGeneratorTarget *gtgt = this->GetGeneratorTarget(&cmtarget); std::string llang = gtgt->GetLinkerLanguage("NOCONFIG"); if(llang.empty()) { return; } @@ -1393,11 +1400,11 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmTarget& cmtarget) // Add an empty source file to the target that compiles with the // linker language. This should convince Xcode to choose the proper // language. - cmMakefile* mf = cmtarget.GetMakefile(); - std::string fname = mf->GetCurrentBinaryDirectory(); + cmMakefile* mf = gtgt->Target->GetMakefile(); + std::string fname = gtgt->GetLocalGenerator()->GetCurrentBinaryDirectory(); fname += cmake::GetCMakeFilesDirectory(); fname += "/"; - fname += cmtarget.GetName(); + fname += gtgt->GetName(); fname += "-CMakeForceLinker"; fname += "."; fname += cmSystemTools::LowerCase(llang); @@ -1408,7 +1415,7 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmTarget& cmtarget) if(cmSourceFile* sf = mf->GetOrCreateSource(fname.c_str())) { sf->SetProperty("LANGUAGE", llang.c_str()); - cmtarget.AddSource(fname); + gtgt->AddSource(fname); } } @@ -1416,7 +1423,7 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmTarget& cmtarget) bool cmGlobalXCodeGenerator::IsHeaderFile(cmSourceFile* sf) { const std::vector<std::string>& hdrExts = - this->CurrentMakefile->GetHeaderExtensions(); + this->CMakeInstance->GetHeaderExtensions(); return (std::find(hdrExts.begin(), hdrExts.end(), sf->GetExtension()) != hdrExts.end()); } @@ -1425,7 +1432,7 @@ bool cmGlobalXCodeGenerator::IsHeaderFile(cmSourceFile* sf) cmXCodeObject* cmGlobalXCodeGenerator::CreateBuildPhase(const char* name, const char* name2, - cmTarget& cmtarget, + cmGeneratorTarget* target, const std::vector<cmCustomCommand>& commands) { @@ -1445,7 +1452,7 @@ cmGlobalXCodeGenerator::CreateBuildPhase(const char* name, this->CreateString("0")); buildPhase->AddAttribute("shellPath", this->CreateString("/bin/sh")); - this->AddCommandsToBuildPhase(buildPhase, cmtarget, commands, + this->AddCommandsToBuildPhase(buildPhase, target, commands, name2); return buildPhase; } @@ -1462,17 +1469,17 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases, contentBuildPhases, cmXCodeObject* frameworkBuildPhase, - cmTarget& cmtarget) + cmGeneratorTarget* gtgt) { std::vector<cmCustomCommand> const & prebuild - = cmtarget.GetPreBuildCommands(); + = gtgt->GetPreBuildCommands(); std::vector<cmCustomCommand> const & prelink - = cmtarget.GetPreLinkCommands(); + = gtgt->GetPreLinkCommands(); std::vector<cmCustomCommand> postbuild - = cmtarget.GetPostBuildCommands(); + = gtgt->GetPostBuildCommands(); - if(cmtarget.GetType() == cmTarget::SHARED_LIBRARY && - !cmtarget.IsFrameworkOnApple()) + if(gtgt->GetType() == cmState::SHARED_LIBRARY && + !gtgt->IsFrameworkOnApple()) { cmCustomCommandLines cmd; cmd.resize(1); @@ -1480,13 +1487,13 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases, cmd[0].push_back("-E"); cmd[0].push_back("cmake_symlink_library"); std::string str_file = "$<TARGET_FILE:"; - str_file += cmtarget.GetName(); + str_file += gtgt->GetName(); str_file += ">"; std::string str_so_file = "$<TARGET_SONAME_FILE:"; - str_so_file += cmtarget.GetName(); + str_so_file += gtgt->GetName(); str_so_file += ">"; std::string str_link_file = "$<TARGET_LINKER_FILE:"; - str_link_file += cmtarget.GetName(); + str_link_file += gtgt->GetName(); str_link_file += ">"; cmd[0].push_back(str_file); cmd[0].push_back(str_so_file); @@ -1504,7 +1511,6 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases, } std::vector<cmSourceFile*> classes; - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget); if (!gtgt->GetConfigCommonSourceFiles(classes)) { return; @@ -1523,19 +1529,19 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases, cmXCodeObject* cmakeRulesBuildPhase = this->CreateBuildPhase("CMake Rules", "cmakeRulesBuildPhase", - cmtarget, commands); + gtgt, commands); // create prebuild phase cmXCodeObject* preBuildPhase = this->CreateBuildPhase("CMake PreBuild Rules", "preBuildCommands", - cmtarget, prebuild); + gtgt, prebuild); // create prelink phase cmXCodeObject* preLinkPhase = this->CreateBuildPhase("CMake PreLink Rules", "preLinkCommands", - cmtarget, prelink); + gtgt, prelink); // create postbuild phase cmXCodeObject* postBuildPhase = this->CreateBuildPhase("CMake PostBuild Rules", "postBuildPhase", - cmtarget, postbuild); + gtgt, postbuild); // The order here is the order they will be built in. // The order "headers, resources, sources" mimics a native project generated @@ -1616,19 +1622,52 @@ std::string cmGlobalXCodeGenerator::ExtractFlag(const char* flag, } //---------------------------------------------------------------------------- +// This function removes each matching occurrence of the expression and +// returns the last one (i.e., the dominant flag in GCC) +std::string cmGlobalXCodeGenerator::ExtractFlagRegex(const char* exp, + int matchIndex, + std::string& flags) +{ + std::string retFlag; + + cmsys::RegularExpression regex(exp); + assert(regex.is_valid()); + if(!regex.is_valid()) + { + return retFlag; + } + + std::string::size_type offset = 0; + + while(regex.find(flags.c_str() + offset)) + { + const std::string::size_type startPos = offset + regex.start(matchIndex); + const std::string::size_type endPos = offset + regex.end(matchIndex); + const std::string::size_type size = endPos - startPos; + + offset = startPos + 1; + + retFlag.assign(flags, startPos, size); + flags.replace(startPos, size, size, ' '); + } + + return retFlag; +} + +//---------------------------------------------------------------------------- void cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase, - cmTarget& target, + cmGeneratorTarget* target, std::vector<cmCustomCommand> const & commands, const char* name) { - std::string dir = this->CurrentMakefile->GetCurrentBinaryDirectory(); + std::string dir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory(); dir += "/CMakeScripts"; cmSystemTools::MakeDirectory(dir.c_str()); std::string makefile = dir; makefile += "/"; - makefile += target.GetName(); + makefile += target->GetName(); makefile += "_"; makefile += name; makefile += ".make"; @@ -1644,7 +1683,7 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase, currentConfig->c_str()); } - std::string cdir = this->CurrentMakefile->GetCurrentBinaryDirectory(); + std::string cdir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory(); cdir = this->ConvertToRelativeForXCode(cdir.c_str()); std::string makecmd = "make -C "; makecmd += cdir; @@ -1662,7 +1701,7 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase, //---------------------------------------------------------------------------- void cmGlobalXCodeGenerator ::CreateCustomRulesMakefile(const char* makefileBasename, - cmTarget& target, + cmGeneratorTarget* target, std::vector<cmCustomCommand> const & commands, const std::string& configName) @@ -1679,7 +1718,7 @@ void cmGlobalXCodeGenerator } makefileStream.SetCopyIfDifferent(true); makefileStream << "# Generated by CMake, DO NOT EDIT\n"; - makefileStream << "# Custom rules for " << target.GetName() << "\n"; + makefileStream << "# Custom rules for " << target->GetName() << "\n"; // disable the implicit rules makefileStream << ".SUFFIXES: " << "\n"; @@ -1708,7 +1747,7 @@ void cmGlobalXCodeGenerator { std::ostringstream str; str << "_buildpart_" << count++ ; - tname[&ccg.GetCC()] = std::string(target.GetName()) + str.str(); + tname[&ccg.GetCC()] = std::string(target->GetName()) + str.str(); makefileStream << "\\\n\t" << tname[&ccg.GetCC()]; } } @@ -1786,26 +1825,25 @@ void cmGlobalXCodeGenerator } //---------------------------------------------------------------------------- -void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, +void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt, cmXCodeObject* buildSettings, const std::string& configName) { - if(target.GetType() == cmTarget::INTERFACE_LIBRARY) + if(gtgt->GetType() == cmState::INTERFACE_LIBRARY) { return; } std::string defFlags; - bool shared = ((target.GetType() == cmTarget::SHARED_LIBRARY) || - (target.GetType() == cmTarget::MODULE_LIBRARY)); - bool binary = ((target.GetType() == cmTarget::OBJECT_LIBRARY) || - (target.GetType() == cmTarget::STATIC_LIBRARY) || - (target.GetType() == cmTarget::EXECUTABLE) || + bool shared = ((gtgt->GetType() == cmState::SHARED_LIBRARY) || + (gtgt->GetType() == cmState::MODULE_LIBRARY)); + bool binary = ((gtgt->GetType() == cmState::OBJECT_LIBRARY) || + (gtgt->GetType() == cmState::STATIC_LIBRARY) || + (gtgt->GetType() == cmState::EXECUTABLE) || shared); // Compute the compilation flags for each language. std::set<std::string> languages; - cmGeneratorTarget *gtgt = this->GetGeneratorTarget(&target); gtgt->GetLanguages(languages, configName); std::map<std::string, std::string> cflags; for (std::set<std::string>::iterator li = languages.begin(); @@ -1818,14 +1856,14 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, this->CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName); // Add shared-library flags if needed. - this->CurrentLocalGenerator->AddCMP0018Flags(flags, &target, + this->CurrentLocalGenerator->AddCMP0018Flags(flags, gtgt, lang, configName); - this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, &target, + this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, gtgt, lang); this->CurrentLocalGenerator-> - AddCompileOptions(flags, &target, lang, configName); + AddCompileOptions(flags, gtgt, lang, configName); } std::string llang = gtgt->GetLinkerLanguage(configName); @@ -1833,7 +1871,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, { cmSystemTools::Error ("CMake can not determine linker language for target: ", - target.GetName().c_str()); + gtgt->GetName().c_str()); return; } @@ -1849,7 +1887,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, this->AppendDefines(ppDefs, "CMAKE_INTDIR=\"$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)\""); } - if(const char* exportMacro = target.GetExportMacro()) + if(const char* exportMacro = gtgt->GetExportMacro()) { // Add the export symbol definition for shared library objects. this->AppendDefines(ppDefs, exportMacro); @@ -1862,15 +1900,15 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, std::string extraLinkOptionsVar; std::string extraLinkOptions; - if(target.GetType() == cmTarget::EXECUTABLE) + if(gtgt->GetType() == cmState::EXECUTABLE) { extraLinkOptionsVar = "CMAKE_EXE_LINKER_FLAGS"; } - else if(target.GetType() == cmTarget::SHARED_LIBRARY) + else if(gtgt->GetType() == cmState::SHARED_LIBRARY) { extraLinkOptionsVar = "CMAKE_SHARED_LINKER_FLAGS"; } - else if(target.GetType() == cmTarget::MODULE_LIBRARY) + else if(gtgt->GetType() == cmState::MODULE_LIBRARY) { extraLinkOptionsVar = "CMAKE_MODULE_LINKER_FLAGS"; } @@ -1882,17 +1920,17 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, configName); } - if(target.GetType() == cmTarget::OBJECT_LIBRARY || - target.GetType() == cmTarget::STATIC_LIBRARY) + if(gtgt->GetType() == cmState::OBJECT_LIBRARY || + gtgt->GetType() == cmState::STATIC_LIBRARY) { this->CurrentLocalGenerator ->GetStaticLibraryFlags(extraLinkOptions, cmSystemTools::UpperCase(configName), - &target); + gtgt); } else { - const char* targetLinkFlags = target.GetProperty("LINK_FLAGS"); + const char* targetLinkFlags = gtgt->GetProperty("LINK_FLAGS"); if(targetLinkFlags) { this->CurrentLocalGenerator-> @@ -1902,7 +1940,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, { std::string linkFlagsVar = "LINK_FLAGS_"; linkFlagsVar += cmSystemTools::UpperCase(configName); - if(const char* linkFlags = target.GetProperty(linkFlagsVar.c_str())) + if(const char* linkFlags = gtgt->GetProperty(linkFlagsVar.c_str())) { this->CurrentLocalGenerator-> AppendFlags(extraLinkOptions, linkFlags); @@ -1945,9 +1983,9 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, std::string pnsuffix; gtgt->GetFullNameComponents(pnprefix, pnbase, pnsuffix, configName); - const char* version = target.GetProperty("VERSION"); - const char* soversion = target.GetProperty("SOVERSION"); - if(!gtgt->HasSOName(configName) || target.IsFrameworkOnApple()) + const char* version = gtgt->GetProperty("VERSION"); + const char* soversion = gtgt->GetProperty("SOVERSION"); + if(!gtgt->HasSOName(configName) || gtgt->IsFrameworkOnApple()) { version = 0; soversion = 0; @@ -1972,17 +2010,17 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, } // Set attributes to specify the proper name for the target. - std::string pndir = this->CurrentMakefile->GetCurrentBinaryDirectory(); - if(target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY || - target.GetType() == cmTarget::EXECUTABLE) + std::string pndir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory(); + if(gtgt->GetType() == cmState::STATIC_LIBRARY || + gtgt->GetType() == cmState::SHARED_LIBRARY || + gtgt->GetType() == cmState::MODULE_LIBRARY || + gtgt->GetType() == cmState::EXECUTABLE) { if(this->XcodeVersion >= 21) { - if(!target.UsesDefaultOutputDir(configName, false)) + if(!gtgt->UsesDefaultOutputDir(configName, false)) { - std::string pncdir = target.GetDirectory(configName); + std::string pncdir = gtgt->GetDirectory(configName); buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR", this->CreateString(pncdir.c_str())); } @@ -1991,10 +2029,10 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, { buildSettings->AddAttribute("OBJROOT", this->CreateString(pndir.c_str())); - pndir = target.GetDirectory(configName); + pndir = gtgt->GetDirectory(configName); } - if(target.IsFrameworkOnApple() || target.IsCFBundleOnApple()) + if(gtgt->IsFrameworkOnApple() || gtgt->IsCFBundleOnApple()) { pnprefix = ""; } @@ -2004,16 +2042,16 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, buildSettings->AddAttribute("EXECUTABLE_SUFFIX", this->CreateString(pnsuffix.c_str())); } - else if(target.GetType() == cmTarget::OBJECT_LIBRARY) + else if(gtgt->GetType() == cmState::OBJECT_LIBRARY) { pnprefix = "lib"; - pnbase = target.GetName(); + pnbase = gtgt->GetName(); pnsuffix = ".a"; if(this->XcodeVersion >= 21) { std::string pncdir = this->GetObjectsNormalDirectory( - this->CurrentProject, configName, &target); + this->CurrentProject, configName, gtgt); buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR", this->CreateString(pncdir.c_str())); } @@ -2022,7 +2060,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, buildSettings->AddAttribute("OBJROOT", this->CreateString(pndir.c_str())); pndir = this->GetObjectsNormalDirectory( - this->CurrentProject, configName, &target); + this->CurrentProject, configName, gtgt); } } @@ -2033,21 +2071,21 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, this->CreateString(pndir.c_str())); // Handle settings for each target type. - switch(target.GetType()) + switch(gtgt->GetType()) { - case cmTarget::OBJECT_LIBRARY: - case cmTarget::STATIC_LIBRARY: + case cmState::OBJECT_LIBRARY: + case cmState::STATIC_LIBRARY: { buildSettings->AddAttribute("LIBRARY_STYLE", this->CreateString("STATIC")); break; } - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: { buildSettings->AddAttribute("LIBRARY_STYLE", this->CreateString("BUNDLE")); - if (target.IsCFBundleOnApple()) + if (gtgt->IsCFBundleOnApple()) { // It turns out that a BUNDLE is basically the same // in many ways as an application bundle, as far as @@ -2060,13 +2098,13 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, extraLinkOptions += " "; extraLinkOptions += createFlags; } - std::string plist = this->ComputeInfoPListLocation(target); + std::string plist = this->ComputeInfoPListLocation(gtgt); // Xcode will create the final version of Info.plist at build time, // so let it replace the cfbundle name. This avoids creating // a per-configuration Info.plist file. The cfbundle plist // is very similar to the application bundle plist this->CurrentLocalGenerator - ->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)", + ->GenerateAppleInfoPList(gtgt, "$(EXECUTABLE_NAME)", plist.c_str()); std::string path = this->ConvertToRelativeForXCode(plist.c_str()); @@ -2102,20 +2140,20 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, } break; } - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: { - if(target.GetPropertyAsBool("FRAMEWORK")) + if(gtgt->GetPropertyAsBool("FRAMEWORK")) { - std::string fw_version = target.GetFrameworkVersion(); + std::string fw_version = gtgt->GetFrameworkVersion(); buildSettings->AddAttribute("FRAMEWORK_VERSION", this->CreateString(fw_version.c_str())); - std::string plist = this->ComputeInfoPListLocation(target); + std::string plist = this->ComputeInfoPListLocation(gtgt); // Xcode will create the final version of Info.plist at build time, // so let it replace the framework name. This avoids creating // a per-configuration Info.plist file. this->CurrentLocalGenerator - ->GenerateFrameworkInfoPList(&target, "$(EXECUTABLE_NAME)", + ->GenerateFrameworkInfoPList(gtgt, "$(EXECUTABLE_NAME)", plist.c_str()); std::string path = this->ConvertToRelativeForXCode(plist.c_str()); @@ -2139,7 +2177,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, this->CreateString("DYNAMIC")); break; } - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: { // Add the flags to create an executable. std::string createFlags = @@ -2151,14 +2189,14 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, } // Handle bundles and normal executables separately. - if(target.GetPropertyAsBool("MACOSX_BUNDLE")) + if(gtgt->GetPropertyAsBool("MACOSX_BUNDLE")) { - std::string plist = this->ComputeInfoPListLocation(target); + std::string plist = this->ComputeInfoPListLocation(gtgt); // Xcode will create the final version of Info.plist at build time, // so let it replace the executable name. This avoids creating // a per-configuration Info.plist file. this->CurrentLocalGenerator - ->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)", + ->GenerateAppleInfoPList(gtgt, "$(EXECUTABLE_NAME)", plist.c_str()); std::string path = this->ConvertToRelativeForXCode(plist.c_str()); @@ -2231,9 +2269,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, bool same_gflags = true; std::map<std::string, std::string> gflags; std::string const* last_gflag = 0; - char optLevel[2]; - optLevel[0] = '0'; - optLevel[1] = 0; + std::string optLevel = "0"; // Minimal map of flags to build settings. for (std::set<std::string>::iterator li = languages.begin(); @@ -2241,14 +2277,15 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, { std::string& flags = cflags[*li]; std::string& gflag = gflags[*li]; - std::string oflag = this->ExtractFlag("-O", flags); - if(oflag.size() == 3) + std::string oflag = + this->ExtractFlagRegex("(^| )(-Ofast|-Os|-O[0-9]*)( |$)", 2, flags); + if(oflag.size() == 2) { - optLevel[0] = oflag[2]; + optLevel = "1"; } - if(oflag.size() == 2) + else if(oflag.size() > 2) { - optLevel[0] = '1'; + optLevel = oflag.substr(2); } gflag = this->ExtractFlag("-g", flags); // put back gdwarf-2 if used since there is no way @@ -2316,7 +2353,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, // Add Fortran source format attribute if property is set. const char* format = 0; - const char* tgtfmt = target.GetProperty("Fortran_FORMAT"); + const char* tgtfmt = gtgt->GetProperty("Fortran_FORMAT"); switch(this->CurrentLocalGenerator->GetFortranFormat(tgtfmt)) { case cmLocalGenerator::FortranFormatFixed: format = "fixed"; break; @@ -2331,7 +2368,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, // Create the INSTALL_PATH attribute. std::string install_name_dir; - if(target.GetType() == cmTarget::SHARED_LIBRARY) + if(gtgt->GetType() == cmState::SHARED_LIBRARY) { // Get the install_name directory for the build tree. install_name_dir = gtgt->GetInstallNameDirForBuildTree(configName); @@ -2393,7 +2430,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, } } - buildSettings->AddAttribute(this->GetTargetLinkFlagsVar(target), + buildSettings->AddAttribute(this->GetTargetLinkFlagsVar(gtgt), this->CreateString(extraLinkOptions.c_str())); buildSettings->AddAttribute("OTHER_REZFLAGS", this->CreateString("")); @@ -2419,14 +2456,14 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, } // Runtime version information. - if(target.GetType() == cmTarget::SHARED_LIBRARY) + if(gtgt->GetType() == cmState::SHARED_LIBRARY) { int major; int minor; int patch; // VERSION -> current_version - target.GetTargetVersion(false, major, minor, patch); + gtgt->GetTargetVersion(false, major, minor, patch); std::ostringstream v; // Xcode always wants at least 1.0.0 or nothing @@ -2438,7 +2475,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, this->CreateString(v.str().c_str())); // SOVERSION -> compatibility_version - target.GetTargetVersion(true, major, minor, patch); + gtgt->GetTargetVersion(true, major, minor, patch); std::ostringstream vso; // Xcode always wants at least 1.0.0 or nothing @@ -2452,13 +2489,13 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, // put this last so it can override existing settings // Convert "XCODE_ATTRIBUTE_*" properties directly. { - cmPropertyMap const& props = target.GetProperties(); - for(cmPropertyMap::const_iterator i = props.begin(); + std::vector<std::string> const& props = gtgt->GetPropertyKeys(); + for(std::vector<std::string>::const_iterator i = props.begin(); i != props.end(); ++i) { - if(i->first.find("XCODE_ATTRIBUTE_") == 0) + if(i->find("XCODE_ATTRIBUTE_") == 0) { - std::string attribute = i->first.substr(16); + std::string attribute = i->substr(16); // Handle [variant=<config>] condition explicitly here. std::string::size_type beginVariant = attribute.find("[variant="); @@ -2489,8 +2526,8 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, if (!attribute.empty()) { cmGeneratorExpression ge; - std::string processed = ge.Parse(i->second.GetValue()) - ->Evaluate(this->CurrentMakefile, configName); + std::string processed = ge.Parse(gtgt->GetProperty(*i)) + ->Evaluate(this->CurrentLocalGenerator, configName); buildSettings->AddAttribute(attribute.c_str(), this->CreateString(processed)); } @@ -2501,7 +2538,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, //---------------------------------------------------------------------------- cmXCodeObject* -cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget) +cmGlobalXCodeGenerator::CreateUtilityTarget(cmGeneratorTarget* gtgt) { cmXCodeObject* shellBuildPhase = this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase); @@ -2525,16 +2562,16 @@ cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget) cmXCodeObject* target = this->CreateObject(cmXCodeObject::PBXAggregateTarget); - target->SetComment(cmtarget.GetName().c_str()); + target->SetComment(gtgt->GetName().c_str()); cmXCodeObject* buildPhases = this->CreateObject(cmXCodeObject::OBJECT_LIST); std::vector<cmXCodeObject*> emptyContentVector; this->CreateCustomCommands(buildPhases, 0, 0, 0, emptyContentVector, 0, - cmtarget); + gtgt); target->AddAttribute("buildPhases", buildPhases); if(this->XcodeVersion > 20) { - this->AddConfigurations(target, cmtarget); + this->AddConfigurations(target, gtgt); } else { @@ -2542,22 +2579,21 @@ cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget) this->CurrentMakefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); cmXCodeObject* buildSettings = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP); - this->CreateBuildSettings(cmtarget, buildSettings, theConfig); + this->CreateBuildSettings(gtgt, buildSettings, theConfig); target->AddAttribute("buildSettings", buildSettings); } cmXCodeObject* dependencies = this->CreateObject(cmXCodeObject::OBJECT_LIST); target->AddAttribute("dependencies", dependencies); - target->AddAttribute("name", this->CreateString(cmtarget.GetName())); - target->AddAttribute("productName",this->CreateString(cmtarget.GetName())); - target->SetTarget(&cmtarget); - this->XCodeObjectMap[&cmtarget] = target; + target->AddAttribute("name", this->CreateString(gtgt->GetName())); + target->AddAttribute("productName",this->CreateString(gtgt->GetName())); + target->SetTarget(gtgt); + this->XCodeObjectMap[gtgt] = target; // Add source files without build rules for editing convenience. - if(cmtarget.GetType() == cmTarget::UTILITY) + if(gtgt->GetType() == cmState::UTILITY) { std::vector<cmSourceFile*> sources; - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget); if (!gtgt->GetConfigCommonSourceFiles(sources)) { return 0; @@ -2568,20 +2604,20 @@ cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget) { if(!(*i)->GetPropertyAsBool("GENERATED")) { - this->CreateXCodeFileReference(*i, cmtarget); + this->CreateXCodeFileReference(*i, gtgt); } } } target->SetId(this->GetOrCreateId( - cmtarget.GetName(), target->GetId()).c_str()); + gtgt->GetName(), target->GetId()).c_str()); return target; } //---------------------------------------------------------------------------- std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target, - cmTarget& cmtarget) + cmGeneratorTarget* gtgt) { std::string configTypes = this->CurrentMakefile->GetRequiredDefinition("CMAKE_CONFIGURATION_TYPES"); @@ -2597,7 +2633,7 @@ std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target, std::string comment = "Build configuration list for "; comment += cmXCodeObject::PBXTypeNames[target->GetIsA()]; comment += " \""; - comment += cmtarget.GetName(); + comment += gtgt->GetName(); comment += "\""; configlist->SetComment(comment.c_str()); target->AddAttribute("buildConfigurationList", @@ -2609,7 +2645,7 @@ std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target, buildConfigurations->AddObject(config); cmXCodeObject* buildSettings = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP); - this->CreateBuildSettings(cmtarget, buildSettings, + this->CreateBuildSettings(gtgt, buildSettings, configVector[i].c_str()); config->AddAttribute("name", this->CreateString(configVector[i].c_str())); config->SetComment(configVector[i].c_str()); @@ -2627,12 +2663,12 @@ std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target, } //---------------------------------------------------------------------------- -const char* -cmGlobalXCodeGenerator::GetTargetLinkFlagsVar(cmTarget const& cmtarget) const +const char* cmGlobalXCodeGenerator::GetTargetLinkFlagsVar( + cmGeneratorTarget const* target) const { if(this->XcodeVersion >= 60 && - (cmtarget.GetType() == cmTarget::STATIC_LIBRARY || - cmtarget.GetType() == cmTarget::OBJECT_LIBRARY)) + (target->GetType() == cmState::STATIC_LIBRARY || + target->GetType() == cmState::OBJECT_LIBRARY)) { return "OTHER_LIBTOOLFLAGS"; } @@ -2643,25 +2679,26 @@ cmGlobalXCodeGenerator::GetTargetLinkFlagsVar(cmTarget const& cmtarget) const } //---------------------------------------------------------------------------- -const char* cmGlobalXCodeGenerator::GetTargetFileType(cmTarget& cmtarget) +const char* cmGlobalXCodeGenerator::GetTargetFileType( + cmGeneratorTarget* target) { - switch(cmtarget.GetType()) + switch(target->GetType()) { - case cmTarget::OBJECT_LIBRARY: - case cmTarget::STATIC_LIBRARY: + case cmState::OBJECT_LIBRARY: + case cmState::STATIC_LIBRARY: return "archive.ar"; - case cmTarget::MODULE_LIBRARY: - if (cmtarget.IsXCTestOnApple()) + case cmState::MODULE_LIBRARY: + if (target->IsXCTestOnApple()) return "wrapper.cfbundle"; - else if (cmtarget.IsCFBundleOnApple()) + else if (target->IsCFBundleOnApple()) return "wrapper.plug-in"; else return ((this->XcodeVersion >= 22)? "compiled.mach-o.executable" : "compiled.mach-o.dylib"); - case cmTarget::SHARED_LIBRARY: - return (cmtarget.GetPropertyAsBool("FRAMEWORK")? + case cmState::SHARED_LIBRARY: + return (target->GetPropertyAsBool("FRAMEWORK")? "wrapper.framework" : "compiled.mach-o.dylib"); - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return "compiled.mach-o.executable"; default: break; } @@ -2669,28 +2706,29 @@ const char* cmGlobalXCodeGenerator::GetTargetFileType(cmTarget& cmtarget) } //---------------------------------------------------------------------------- -const char* cmGlobalXCodeGenerator::GetTargetProductType(cmTarget& cmtarget) +const char* cmGlobalXCodeGenerator::GetTargetProductType( + cmGeneratorTarget* target) { - switch(cmtarget.GetType()) + switch(target->GetType()) { - case cmTarget::OBJECT_LIBRARY: - case cmTarget::STATIC_LIBRARY: + case cmState::OBJECT_LIBRARY: + case cmState::STATIC_LIBRARY: return "com.apple.product-type.library.static"; - case cmTarget::MODULE_LIBRARY: - if (cmtarget.IsXCTestOnApple()) + case cmState::MODULE_LIBRARY: + if (target->IsXCTestOnApple()) return "com.apple.product-type.bundle.unit-test"; - else if (cmtarget.IsCFBundleOnApple()) + else if (target->IsCFBundleOnApple()) return "com.apple.product-type.bundle"; else return ((this->XcodeVersion >= 22)? "com.apple.product-type.tool" : "com.apple.product-type.library.dynamic"); - case cmTarget::SHARED_LIBRARY: - return (cmtarget.GetPropertyAsBool("FRAMEWORK")? + case cmState::SHARED_LIBRARY: + return (target->GetPropertyAsBool("FRAMEWORK")? "com.apple.product-type.framework" : "com.apple.product-type.library.dynamic"); - case cmTarget::EXECUTABLE: - return (cmtarget.GetPropertyAsBool("MACOSX_BUNDLE")? + case cmState::EXECUTABLE: + return (target->GetPropertyAsBool("MACOSX_BUNDLE")? "com.apple.product-type.application" : "com.apple.product-type.tool"); default: break; @@ -2700,10 +2738,10 @@ const char* cmGlobalXCodeGenerator::GetTargetProductType(cmTarget& cmtarget) //---------------------------------------------------------------------------- cmXCodeObject* -cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget, +cmGlobalXCodeGenerator::CreateXCodeTarget(cmGeneratorTarget* gtgt, cmXCodeObject* buildPhases) { - if(cmtarget.GetType() == cmTarget::INTERFACE_LIBRARY) + if(gtgt->GetType() == cmState::INTERFACE_LIBRARY) { return 0; } @@ -2715,67 +2753,67 @@ cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget, std::string defConfig; if(this->XcodeVersion > 20) { - defConfig = this->AddConfigurations(target, cmtarget); + defConfig = this->AddConfigurations(target, gtgt); } else { cmXCodeObject* buildSettings = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP); defConfig = this->CurrentMakefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); - this->CreateBuildSettings(cmtarget, buildSettings, defConfig.c_str()); + this->CreateBuildSettings(gtgt, buildSettings, defConfig.c_str()); target->AddAttribute("buildSettings", buildSettings); } cmXCodeObject* dependencies = this->CreateObject(cmXCodeObject::OBJECT_LIST); target->AddAttribute("dependencies", dependencies); - target->AddAttribute("name", this->CreateString(cmtarget.GetName())); - target->AddAttribute("productName",this->CreateString(cmtarget.GetName())); + target->AddAttribute("name", this->CreateString(gtgt->GetName())); + target->AddAttribute("productName",this->CreateString(gtgt->GetName())); cmXCodeObject* fileRef = this->CreateObject(cmXCodeObject::PBXFileReference); - if(const char* fileType = this->GetTargetFileType(cmtarget)) + if(const char* fileType = this->GetTargetFileType(gtgt)) { fileRef->AddAttribute("explicitFileType", this->CreateString(fileType)); } std::string fullName; - if(cmtarget.GetType() == cmTarget::OBJECT_LIBRARY) + if(gtgt->GetType() == cmState::OBJECT_LIBRARY) { fullName = "lib"; - fullName += cmtarget.GetName(); + fullName += gtgt->GetName(); fullName += ".a"; } else { - cmGeneratorTarget *gtgt = this->GetGeneratorTarget(&cmtarget); fullName = gtgt->GetFullName(defConfig.c_str()); } fileRef->AddAttribute("path", this->CreateString(fullName.c_str())); fileRef->AddAttribute("refType", this->CreateString("0")); fileRef->AddAttribute("sourceTree", this->CreateString("BUILT_PRODUCTS_DIR")); - fileRef->SetComment(cmtarget.GetName().c_str()); + fileRef->SetComment(gtgt->GetName().c_str()); target->AddAttribute("productReference", this->CreateObjectReference(fileRef)); - if(const char* productType = this->GetTargetProductType(cmtarget)) + if(const char* productType = this->GetTargetProductType(gtgt)) { target->AddAttribute("productType", this->CreateString(productType)); } - target->SetTarget(&cmtarget); - this->XCodeObjectMap[&cmtarget] = target; + target->SetTarget(gtgt); + this->XCodeObjectMap[gtgt] = target; target->SetId(this->GetOrCreateId( - cmtarget.GetName(), target->GetId()).c_str()); + gtgt->GetName(), target->GetId()).c_str()); return target; } //---------------------------------------------------------------------------- -cmXCodeObject* cmGlobalXCodeGenerator::FindXCodeTarget(cmTarget const* t) +cmXCodeObject* +cmGlobalXCodeGenerator::FindXCodeTarget(cmGeneratorTarget const* t) { if(!t) { return 0; } - std::map<cmTarget const*, cmXCodeObject*>::const_iterator const i = + std::map<cmGeneratorTarget const*, cmXCodeObject*>::const_iterator const i = this->XCodeObjectMap.find(t); if (i == this->XCodeObjectMap.end()) { @@ -2912,23 +2950,22 @@ void cmGlobalXCodeGenerator void cmGlobalXCodeGenerator ::AddDependAndLinkInformation(cmXCodeObject* target) { - cmTarget* cmtarget = target->GetTarget(); - if(cmtarget->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget* gt = target->GetTarget(); + if(!gt) { + cmSystemTools::Error("Error no target on xobject\n"); return; } - if(!cmtarget) + if(gt->GetType() == cmState::INTERFACE_LIBRARY) { - cmSystemTools::Error("Error no target on xobject\n"); return; } // Add dependencies on other CMake targets. - cmGeneratorTarget* gt = this->GetGeneratorTarget(cmtarget); TargetDependSet const& deps = this->GetTargetDirectDepends(gt); for(TargetDependSet::const_iterator i = deps.begin(); i != deps.end(); ++i) { - if(cmXCodeObject* dptarget = this->FindXCodeTarget((*i)->Target)) + if(cmXCodeObject* dptarget = this->FindXCodeTarget(*i)) { this->AddDependTarget(target, dptarget); } @@ -2948,7 +2985,7 @@ void cmGlobalXCodeGenerator std::string linkObjs; const char* sep = ""; std::vector<std::string> objs; - this->GetGeneratorTarget(cmtarget)->UseObjectLibraries(objs, ""); + gt->UseObjectLibraries(objs, ""); for(std::vector<std::string>::const_iterator oi = objs.begin(); oi != objs.end(); ++oi) { @@ -2957,20 +2994,19 @@ void cmGlobalXCodeGenerator linkObjs += this->XCodeEscapePath(oi->c_str()); } this->AppendBuildSettingAttribute( - target, this->GetTargetLinkFlagsVar(*cmtarget), + target, this->GetTargetLinkFlagsVar(gt), linkObjs.c_str(), configName); } // Skip link information for object libraries. - if(cmtarget->GetType() == cmTarget::OBJECT_LIBRARY || - cmtarget->GetType() == cmTarget::STATIC_LIBRARY) + if(gt->GetType() == cmState::OBJECT_LIBRARY || + gt->GetType() == cmState::STATIC_LIBRARY) { continue; } // Compute the link library and directory information. - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(cmtarget); - cmComputeLinkInformation* pcli = gtgt->GetLinkInformation(configName); + cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName); if(!pcli) { continue; @@ -3028,7 +3064,7 @@ void cmGlobalXCodeGenerator linkLibs += this->XCodeEscapePath(li->Value.c_str()); } else if (!li->Target - || li->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + || li->Target->GetType() != cmState::INTERFACE_LIBRARY) { linkLibs += li->Value; } @@ -3038,7 +3074,7 @@ void cmGlobalXCodeGenerator } } this->AppendBuildSettingAttribute( - target, this->GetTargetLinkFlagsVar(*cmtarget), + target, this->GetTargetLinkFlagsVar(gt), linkLibs.c_str(), configName); } } @@ -3058,35 +3094,35 @@ bool cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root, } cmMakefile* mf = (*i)->GetMakefile(); std::vector<cmSourceGroup> sourceGroups = mf->GetSourceGroups(); - cmTargets &tgts = mf->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++) + std::vector<cmGeneratorTarget*> tgts = (*i)->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); l++) { - cmTarget& cmtarget = l->second; + cmGeneratorTarget* gtgt = *l; // Same skipping logic here as in CreateXCodeTargets so that we do not // end up with (empty anyhow) ALL_BUILD and XCODE_DEPEND_HELPER source // groups: // - if(cmtarget.GetType() == cmTarget::GLOBAL_TARGET) + if(gtgt->GetType() == cmState::GLOBAL_TARGET) { continue; } - if(cmtarget.GetType() == cmTarget::INTERFACE_LIBRARY) + if(gtgt->GetType() == cmState::INTERFACE_LIBRARY) { continue; } // add the soon to be generated Info.plist file as a source for a // MACOSX_BUNDLE file - if(cmtarget.GetPropertyAsBool("MACOSX_BUNDLE")) + if(gtgt->GetPropertyAsBool("MACOSX_BUNDLE")) { - std::string plist = this->ComputeInfoPListLocation(cmtarget); + std::string plist = this->ComputeInfoPListLocation(gtgt); mf->GetOrCreateSource(plist, true); - cmtarget.AddSource(plist); + gtgt->AddSource(plist); } std::vector<cmSourceFile*> classes; - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget); if (!gtgt->GetConfigCommonSourceFiles(classes)) { return false; @@ -3101,14 +3137,14 @@ bool cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root, cmSourceGroup* sourceGroup = mf->FindSourceGroup(source.c_str(), sourceGroups); cmXCodeObject* pbxgroup = - this->CreateOrGetPBXGroup(cmtarget, sourceGroup); - std::string key = GetGroupMapKey(cmtarget, sf); + this->CreateOrGetPBXGroup(gtgt, sourceGroup); + std::string key = GetGroupMapKey(gtgt, sf); this->GroupMap[key] = pbxgroup; } // Put OBJECT_LIBRARY objects in proper groups: std::vector<std::string> objs; - this->GetGeneratorTarget(&cmtarget)->UseObjectLibraries(objs, ""); + gtgt->UseObjectLibraries(objs, ""); for(std::vector<std::string>::const_iterator oi = objs.begin(); oi != objs.end(); ++oi) { @@ -3116,8 +3152,8 @@ bool cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root, cmSourceGroup* sourceGroup = mf->FindSourceGroup(source.c_str(), sourceGroups); cmXCodeObject* pbxgroup = - this->CreateOrGetPBXGroup(cmtarget, sourceGroup); - std::string key = GetGroupMapKeyFromPath(cmtarget, source); + this->CreateOrGetPBXGroup(gtgt, sourceGroup); + std::string key = GetGroupMapKeyFromPath(gtgt, source); this->GroupMap[key] = pbxgroup; } } @@ -3148,16 +3184,16 @@ cmXCodeObject *cmGlobalXCodeGenerator //---------------------------------------------------------------------------- cmXCodeObject* cmGlobalXCodeGenerator -::CreateOrGetPBXGroup(cmTarget& cmtarget, cmSourceGroup* sg) +::CreateOrGetPBXGroup(cmGeneratorTarget* gtgt, cmSourceGroup* sg) { std::string s; std::string target; - const char *targetFolder= cmtarget.GetProperty("FOLDER"); + const char *targetFolder= gtgt->GetProperty("FOLDER"); if(targetFolder) { target = targetFolder; target += "/"; } - target += cmtarget.GetName(); + target += gtgt->GetName(); s = target + "/"; s += sg->GetFullName(); std::map<std::string, cmXCodeObject* >::iterator it = @@ -3346,7 +3382,7 @@ bool cmGlobalXCodeGenerator this->RootObject->SetComment("Project object"); std::string project_id = "PROJECT_"; - project_id += root->GetMakefile()->GetProjectName(); + project_id += root->GetProjectName(); this->RootObject->SetId(this->GetOrCreateId( project_id.c_str(), this->RootObject->GetId()).c_str()); @@ -3376,7 +3412,7 @@ bool cmGlobalXCodeGenerator // Point Xcode at the top of the source tree. { std::string pdir = - this->RelativeToBinary(root->GetMakefile()->GetCurrentSourceDirectory()); + this->RelativeToBinary(root->GetCurrentSourceDirectory()); this->RootObject->AddAttribute("projectDirPath", this->CreateString(pdir.c_str())); this->RootObject->AddAttribute("projectRoot", this->CreateString("")); @@ -3488,7 +3524,7 @@ bool cmGlobalXCodeGenerator } } - std::string symroot = root->GetMakefile()->GetCurrentBinaryDirectory(); + std::string symroot = root->GetCurrentBinaryDirectory(); symroot += "/build"; buildSettings->AddAttribute("SYMROOT", this->CreateString(symroot.c_str())); @@ -3547,10 +3583,10 @@ std::string cmGlobalXCodeGenerator::GetObjectsNormalDirectory( const std::string &projName, const std::string &configName, - const cmTarget *t) const + const cmGeneratorTarget *t) const { std::string dir = - t->GetMakefile()->GetCurrentBinaryDirectory(); + t->GetLocalGenerator()->GetCurrentBinaryDirectory(); dir += "/"; dir += projName; dir += ".build/"; @@ -3624,24 +3660,23 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget( i != targets.end(); ++i) { cmXCodeObject* target = *i; - cmTarget* t =target->GetTarget(); - cmGeneratorTarget *gt = this->GetGeneratorTarget(t); + cmGeneratorTarget* gt =target->GetTarget(); - if(t->GetType() == cmTarget::EXECUTABLE || + if(gt->GetType() == cmState::EXECUTABLE || // Nope - no post-build for OBJECT_LIRBRARY -// t->GetType() == cmTarget::OBJECT_LIBRARY || - t->GetType() == cmTarget::STATIC_LIBRARY || - t->GetType() == cmTarget::SHARED_LIBRARY || - t->GetType() == cmTarget::MODULE_LIBRARY) +// gt->GetType() == cmState::OBJECT_LIBRARY || + gt->GetType() == cmState::STATIC_LIBRARY || + gt->GetType() == cmState::SHARED_LIBRARY || + gt->GetType() == cmState::MODULE_LIBRARY) { // Declare an entry point for the target post-build phase. - makefileStream << this->PostBuildMakeTarget(t->GetName(), *ct) + makefileStream << this->PostBuildMakeTarget(gt->GetName(), *ct) << ":\n"; } - if(t->GetType() == cmTarget::EXECUTABLE || - t->GetType() == cmTarget::SHARED_LIBRARY || - t->GetType() == cmTarget::MODULE_LIBRARY) + if(gt->GetType() == cmState::EXECUTABLE || + gt->GetType() == cmState::SHARED_LIBRARY || + gt->GetType() == cmState::MODULE_LIBRARY) { std::string tfull = gt->GetFullPath(configName); std::string trel = this->ConvertToRelativeForMake(tfull.c_str()); @@ -3686,7 +3721,7 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget( if(this->Architectures.size() > 1) { std::string universal = this->GetObjectsNormalDirectory( - this->CurrentProject, configName, t); + this->CurrentProject, configName, gt); for( std::vector<std::string>::iterator arch = this->Architectures.begin(); arch != this->Architectures.end(); ++arch) @@ -3731,9 +3766,9 @@ cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root, { return; } - std::string xcodeDir = root->GetMakefile()->GetCurrentBinaryDirectory(); + std::string xcodeDir = root->GetCurrentBinaryDirectory(); xcodeDir += "/"; - xcodeDir += root->GetMakefile()->GetProjectName(); + xcodeDir += root->GetProjectName(); xcodeDir += ".xcode"; if(this->XcodeVersion > 20) { @@ -3753,7 +3788,7 @@ cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root, // Since this call may have created new cache entries, save the cache: // root->GetMakefile()->GetCMakeInstance()->SaveCache( - root->GetMakefile()->GetHomeOutputDirectory()); + root->GetBinaryDirectory()); } //---------------------------------------------------------------------------- @@ -4029,12 +4064,13 @@ void cmGlobalXCodeGenerator::AppendFlag(std::string& flags, //---------------------------------------------------------------------------- std::string -cmGlobalXCodeGenerator::ComputeInfoPListLocation(cmTarget& target) +cmGlobalXCodeGenerator::ComputeInfoPListLocation(cmGeneratorTarget* target) { - std::string plist = target.GetMakefile()->GetCurrentBinaryDirectory(); + std::string plist = + target->GetLocalGenerator()->GetCurrentBinaryDirectory(); plist += cmake::GetCMakeFilesDirectory(); plist += "/"; - plist += target.GetName(); + plist += target->GetName(); plist += ".dir/Info.plist"; return plist; } @@ -4060,7 +4096,7 @@ void cmGlobalXCodeGenerator { std::string configName = this->GetCMakeCFGIntDir(); std::string dir = this->GetObjectsNormalDirectory( - "$(PROJECT_NAME)", configName, gt->Target); + "$(PROJECT_NAME)", configName, gt); if(this->XcodeVersion >= 21) { dir += "$(CURRENT_ARCH)/"; diff --git a/Source/cmGlobalXCodeGenerator.h b/Source/cmGlobalXCodeGenerator.h index 102c036..c8a39df 100644 --- a/Source/cmGlobalXCodeGenerator.h +++ b/Source/cmGlobalXCodeGenerator.h @@ -16,7 +16,6 @@ #include "cmXCodeObject.h" #include "cmCustomCommand.h" class cmGlobalGeneratorFactory; -class cmTarget; class cmSourceFile; class cmSourceGroup; @@ -87,10 +86,10 @@ public: virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf); void AppendFlag(std::string& flags, std::string const& flag); protected: - virtual bool Compute(); + virtual void AddExtraIDETargets(); virtual void Generate(); private: - cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget, + cmXCodeObject* CreateOrGetPBXGroup(cmGeneratorTarget* gtgt, cmSourceGroup* sg); cmXCodeObject* CreatePBXGroup(cmXCodeObject *parent, std::string name); @@ -108,22 +107,22 @@ private: cmXCodeObject* resourceBuildPhase, std::vector<cmXCodeObject*> contentBuildPhases, cmXCodeObject* frameworkBuildPhase, - cmTarget& cmtarget); + cmGeneratorTarget *gtgt); - std::string ComputeInfoPListLocation(cmTarget& target); + std::string ComputeInfoPListLocation(cmGeneratorTarget *target); void AddCommandsToBuildPhase(cmXCodeObject* buildphase, - cmTarget& target, + cmGeneratorTarget *target, std::vector<cmCustomCommand> const & commands, const char* commandFileName); void CreateCustomRulesMakefile(const char* makefileBasename, - cmTarget& target, + cmGeneratorTarget* target, std::vector<cmCustomCommand> const & commands, const std::string& configName); - cmXCodeObject* FindXCodeTarget(cmTarget const*); + cmXCodeObject* FindXCodeTarget(const cmGeneratorTarget *); std::string GetOrCreateId(const std::string& name, const std::string& id); // create cmXCodeObject from these functions so that memory can be managed @@ -132,25 +131,28 @@ private: cmXCodeObject* CreateObject(cmXCodeObject::Type type); cmXCodeObject* CreateString(const std::string& s); cmXCodeObject* CreateObjectReference(cmXCodeObject*); - cmXCodeObject* CreateXCodeTarget(cmTarget& target, + cmXCodeObject* CreateXCodeTarget(cmGeneratorTarget *gtgt, cmXCodeObject* buildPhases); void ForceLinkerLanguages(); - void ForceLinkerLanguage(cmTarget& cmtarget); - const char* GetTargetLinkFlagsVar(cmTarget const& cmtarget) const; - const char* GetTargetFileType(cmTarget& cmtarget); - const char* GetTargetProductType(cmTarget& cmtarget); - std::string AddConfigurations(cmXCodeObject* target, cmTarget& cmtarget); + void ForceLinkerLanguage(cmGeneratorTarget* gtgt); + const char* GetTargetLinkFlagsVar(const cmGeneratorTarget *target) const; + const char* GetTargetFileType(cmGeneratorTarget* target); + const char* GetTargetProductType(cmGeneratorTarget* target); + std::string AddConfigurations(cmXCodeObject* target, + cmGeneratorTarget *gtgt); void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr, const char* value); void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr, const char* value, const std::string& configName); - cmXCodeObject* CreateUtilityTarget(cmTarget& target); + cmXCodeObject* CreateUtilityTarget(cmGeneratorTarget *gtgt); void AddDependAndLinkInformation(cmXCodeObject* target); - void CreateBuildSettings(cmTarget& target, + void CreateBuildSettings(cmGeneratorTarget *gtgt, cmXCodeObject* buildSettings, const std::string& buildType); std::string ExtractFlag(const char* flag, std::string& flags); + std::string ExtractFlagRegex(const char* exp, int matchIndex, + std::string& flags); void SortXCodeObjects(); // delete all objects in the this->XCodeObjects vector. void ClearXCodeObjects(); @@ -161,18 +163,18 @@ private: void WriteXCodePBXProj(std::ostream& fout, cmLocalGenerator* root, std::vector<cmLocalGenerator*>& generators); cmXCodeObject* CreateXCodeFileReferenceFromPath(const std::string &fullpath, - cmTarget& cmtarget, + cmGeneratorTarget *target, const std::string &lang, cmSourceFile* sf); cmXCodeObject* CreateXCodeSourceFileFromPath(const std::string &fullpath, - cmTarget& cmtarget, + cmGeneratorTarget *target, const std::string &lang, cmSourceFile* sf); cmXCodeObject* CreateXCodeFileReference(cmSourceFile* sf, - cmTarget& cmtarget); + cmGeneratorTarget *target); cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen, cmSourceFile* sf, - cmTarget& cmtarget); + cmGeneratorTarget *gtgt); bool CreateXCodeTargets(cmLocalGenerator* gen, std::vector<cmXCodeObject*>&); bool IsHeaderFile(cmSourceFile*); @@ -185,7 +187,7 @@ private: std::vector<cmLocalGenerator*>& gens); cmXCodeObject* CreateBuildPhase(const char* name, const char* name2, - cmTarget& cmtarget, + cmGeneratorTarget *target, const std::vector<cmCustomCommand>&); void CreateReRunCMakeFile(cmLocalGenerator* root, std::vector<cmLocalGenerator*> const& gens); @@ -224,10 +226,9 @@ private: void PrintCompilerAdvice(std::ostream&, std::string const&, const char*) const {} - std::string GetObjectsNormalDirectory( - const std::string &projName, + std::string GetObjectsNormalDirectory(const std::string &projName, const std::string &configName, - const cmTarget *t) const; + const cmGeneratorTarget *t) const; void addObject(cmXCodeObject *obj); std::string PostBuildMakeTarget(std::string const& tName, @@ -249,7 +250,7 @@ private: std::map<std::string, cmXCodeObject* > GroupNameMap; std::map<std::string, cmXCodeObject* > TargetGroup; std::map<std::string, cmXCodeObject* > FileRefs; - std::map<cmTarget const*, cmXCodeObject* > XCodeObjectMap; + std::map<cmGeneratorTarget const*, cmXCodeObject* > XCodeObjectMap; std::vector<std::string> Architectures; std::string GeneratorToolset; }; diff --git a/Source/cmGraphVizWriter.cxx b/Source/cmGraphVizWriter.cxx index 2023697..a63b6e3 100644 --- a/Source/cmGraphVizWriter.cxx +++ b/Source/cmGraphVizWriter.cxx @@ -17,7 +17,7 @@ -static const char* getShapeForTarget(const cmTarget* target) +static const char* getShapeForTarget(const cmGeneratorTarget* target) { if (!target) { @@ -26,13 +26,13 @@ static const char* getShapeForTarget(const cmTarget* target) switch ( target->GetType() ) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return "house"; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: return "diamond"; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return "polygon"; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: return "octagon"; default: break; @@ -67,6 +67,7 @@ void cmGraphVizWriter::ReadSettings(const char* settingsFileName, cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator ggi(&cm); cmsys::auto_ptr<cmMakefile> mf( new cmMakefile(&ggi, cm.GetCurrentSnapshot())); @@ -162,7 +163,7 @@ void cmGraphVizWriter::WriteTargetDependersFiles(const char* fileName) this->CollectTargetsAndLibs(); - for(std::map<std::string, const cmTarget*>::const_iterator ptrIt = + for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt = this->TargetPtrs.begin(); ptrIt != this->TargetPtrs.end(); ++ptrIt) @@ -213,7 +214,7 @@ void cmGraphVizWriter::WritePerTargetFiles(const char* fileName) this->CollectTargetsAndLibs(); - for(std::map<std::string, const cmTarget*>::const_iterator ptrIt = + for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt = this->TargetPtrs.begin(); ptrIt != this->TargetPtrs.end(); ++ptrIt) @@ -267,7 +268,7 @@ void cmGraphVizWriter::WriteGlobalFile(const char* fileName) std::set<std::string> insertedConnections; std::set<std::string> insertedNodes; - for(std::map<std::string, const cmTarget*>::const_iterator ptrIt = + for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt = this->TargetPtrs.begin(); ptrIt != this->TargetPtrs.end(); ++ptrIt) @@ -307,8 +308,8 @@ void cmGraphVizWriter::WriteConnections(const std::string& targetName, std::set<std::string>& insertedConnections, cmGeneratedFileStream& str) const { - std::map<std::string, const cmTarget* >::const_iterator targetPtrIt = - this->TargetPtrs.find(targetName); + std::map<std::string, const cmGeneratorTarget* >::const_iterator targetPtrIt + = this->TargetPtrs.find(targetName); if (targetPtrIt == this->TargetPtrs.end()) // not found at all { @@ -326,7 +327,7 @@ void cmGraphVizWriter::WriteConnections(const std::string& targetName, std::string myNodeName = this->TargetNamesNodes.find(targetName)->second; const cmTarget::LinkLibraryVectorType* ll = - &(targetPtrIt->second->GetOriginalLinkLibraries()); + &(targetPtrIt->second->Target->GetOriginalLinkLibraries()); for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin(); llit != ll->end(); @@ -366,8 +367,8 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName, std::set<std::string>& insertedConnections, cmGeneratedFileStream& str) const { - std::map<std::string, const cmTarget* >::const_iterator targetPtrIt = - this->TargetPtrs.find(targetName); + std::map<std::string, const cmGeneratorTarget* >::const_iterator targetPtrIt + = this->TargetPtrs.find(targetName); if (targetPtrIt == this->TargetPtrs.end()) // not found at all { @@ -385,8 +386,8 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName, std::string myNodeName = this->TargetNamesNodes.find(targetName)->second; // now search who links against me - for(std::map<std::string, const cmTarget*>::const_iterator dependerIt = - this->TargetPtrs.begin(); + for(std::map<std::string, const cmGeneratorTarget*>::const_iterator + dependerIt = this->TargetPtrs.begin(); dependerIt != this->TargetPtrs.end(); ++dependerIt) { @@ -403,7 +404,7 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName, // Now we have a target, check whether it links against targetName. // If so, draw a connection, and then continue with dependers on that one. const cmTarget::LinkLibraryVectorType* ll = - &(dependerIt->second->GetOriginalLinkLibraries()); + &(dependerIt->second->Target->GetOriginalLinkLibraries()); for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin(); llit != ll->end(); @@ -447,7 +448,7 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName, void cmGraphVizWriter::WriteNode(const std::string& targetName, - const cmTarget* target, + const cmGeneratorTarget* target, std::set<std::string>& insertedNodes, cmGeneratedFileStream& str) const { @@ -487,12 +488,11 @@ int cmGraphVizWriter::CollectAllTargets() lit != this->LocalGenerators.end(); ++ lit ) { - const cmTargets* targets = &((*lit)->GetMakefile()->GetTargets()); - for ( cmTargets::const_iterator tit = targets->begin(); - tit != targets->end(); - ++ tit ) + std::vector<cmGeneratorTarget*> targets = (*lit)->GetGeneratorTargets(); + for ( std::vector<cmGeneratorTarget*>::const_iterator it = + targets.begin(); it != targets.end(); ++it ) { - const char* realTargetName = tit->first.c_str(); + const char* realTargetName = (*it)->GetName().c_str(); if(this->IgnoreThisTarget(realTargetName)) { // Skip ignored targets @@ -502,7 +502,7 @@ int cmGraphVizWriter::CollectAllTargets() std::ostringstream ostr; ostr << this->GraphNodePrefix << cnt++; this->TargetNamesNodes[realTargetName] = ostr.str(); - this->TargetPtrs[realTargetName] = &tit->second; + this->TargetPtrs[realTargetName] = *it; } } @@ -518,19 +518,18 @@ int cmGraphVizWriter::CollectAllExternalLibs(int cnt) lit != this->LocalGenerators.end(); ++ lit ) { - const cmTargets* targets = &((*lit)->GetMakefile()->GetTargets()); - for ( cmTargets::const_iterator tit = targets->begin(); - tit != targets->end(); - ++ tit ) + std::vector<cmGeneratorTarget*> targets = (*lit)->GetGeneratorTargets(); + for ( std::vector<cmGeneratorTarget*>::const_iterator it = + targets.begin(); it != targets.end(); ++it ) { - const char* realTargetName = tit->first.c_str(); + const char* realTargetName = (*it)->GetName().c_str(); if (this->IgnoreThisTarget(realTargetName)) { // Skip ignored targets continue; } const cmTarget::LinkLibraryVectorType* ll = - &(tit->second.GetOriginalLinkLibraries()); + &((*it)->Target->GetOriginalLinkLibraries()); for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin(); llit != ll->end(); ++ llit ) @@ -542,8 +541,8 @@ int cmGraphVizWriter::CollectAllExternalLibs(int cnt) continue; } - std::map<std::string, const cmTarget*>::const_iterator tarIt = - this->TargetPtrs.find(libName); + std::map<std::string, const cmGeneratorTarget*>::const_iterator tarIt + = this->TargetPtrs.find(libName); if ( tarIt == this->TargetPtrs.end() ) { std::ostringstream ostr; @@ -581,18 +580,18 @@ bool cmGraphVizWriter::IgnoreThisTarget(const std::string& name) } -bool cmGraphVizWriter::GenerateForTargetType(cmTarget::TargetType targetType) +bool cmGraphVizWriter::GenerateForTargetType(cmState::TargetType targetType) const { switch (targetType) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return this->GenerateForExecutables; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: return this->GenerateForStaticLibs; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return this->GenerateForSharedLibs; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: return this->GenerateForModuleLibs; default: break; diff --git a/Source/cmGraphVizWriter.h b/Source/cmGraphVizWriter.h index 64de684..90d31d3 100644 --- a/Source/cmGraphVizWriter.h +++ b/Source/cmGraphVizWriter.h @@ -14,9 +14,9 @@ #include "cmStandardIncludes.h" #include "cmLocalGenerator.h" #include "cmGeneratedFileStream.h" -#include "cmTarget.h" #include <cmsys/RegularExpression.hxx> +class cmGeneratorTarget; /** This class implements writing files for graphviz (dot) for graphs * representing the dependencies between the targets in the project. */ @@ -54,7 +54,8 @@ protected: std::set<std::string>& insertedConnections, cmGeneratedFileStream& str) const; - void WriteNode(const std::string& targetName, const cmTarget* target, + void WriteNode(const std::string& targetName, + const cmGeneratorTarget* target, std::set<std::string>& insertedNodes, cmGeneratedFileStream& str) const; @@ -62,7 +63,7 @@ protected: bool IgnoreThisTarget(const std::string& name); - bool GenerateForTargetType(cmTarget::TargetType targetType) const; + bool GenerateForTargetType(cmState::TargetType targetType) const; std::string GraphType; std::string GraphName; @@ -73,7 +74,7 @@ protected: const std::vector<cmLocalGenerator*>& LocalGenerators; - std::map<std::string, const cmTarget*> TargetPtrs; + std::map<std::string, const cmGeneratorTarget*> TargetPtrs; // maps from the actual target names to node names in dot: std::map<std::string, std::string> TargetNamesNodes; diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx index 20448c1..5964ef1 100644 --- a/Source/cmIfCommand.cxx +++ b/Source/cmIfCommand.cxx @@ -11,6 +11,7 @@ ============================================================================*/ #include "cmIfCommand.h" #include "cmStringCommand.h" +#include "cmOutputConverter.h" #include "cmConditionEvaluator.h" @@ -106,7 +107,14 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmake::MessageType messType; - cmConditionEvaluator conditionEvaluator(mf); + cmListFileContext conditionContext = + cmConditionEvaluator::GetConditionContext( + &mf, this->Functions[c], + this->GetStartingContext().FilePath); + + cmConditionEvaluator conditionEvaluator( + mf, conditionContext, + mf.GetBacktrace(this->Functions[c])); bool isTrue = conditionEvaluator.IsTrue( expandedArguments, errorString, messType); @@ -195,7 +203,16 @@ bool cmIfCommand cmake::MessageType status; - cmConditionEvaluator conditionEvaluator(*(this->Makefile)); + cmListFileContext execContext = this->Makefile->GetExecutionContext(); + + cmCommandContext commandContext; + commandContext.Line = execContext.Line; + commandContext.Name = execContext.Name; + + cmConditionEvaluator conditionEvaluator( + *(this->Makefile), cmConditionEvaluator::GetConditionContext( + this->Makefile, commandContext, execContext.FilePath), + this->Makefile->GetBacktrace()); bool isTrue = conditionEvaluator.IsTrue( expandedArguments, errorString, status); diff --git a/Source/cmIncludeExternalMSProjectCommand.cxx b/Source/cmIncludeExternalMSProjectCommand.cxx index 1e7258a..c64d128 100644 --- a/Source/cmIncludeExternalMSProjectCommand.cxx +++ b/Source/cmIncludeExternalMSProjectCommand.cxx @@ -77,7 +77,7 @@ bool cmIncludeExternalMSProjectCommand } // Create a target instance for this utility. - cmTarget* target=this->Makefile->AddNewTarget(cmTarget::UTILITY, + cmTarget* target=this->Makefile->AddNewTarget(cmState::UTILITY, utility_name.c_str()); target->SetProperty("GENERATOR_FILE_NAME", utility_name.c_str()); diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx index 333c2ff..6b06fce 100644 --- a/Source/cmInstallCommand.cxx +++ b/Source/cmInstallCommand.cxx @@ -383,12 +383,12 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) if(cmTarget* target=this->Makefile->FindTarget(*targetIt)) { // Found the target. Check its type. - if(target->GetType() != cmTarget::EXECUTABLE && - target->GetType() != cmTarget::STATIC_LIBRARY && - target->GetType() != cmTarget::SHARED_LIBRARY && - target->GetType() != cmTarget::MODULE_LIBRARY && - target->GetType() != cmTarget::OBJECT_LIBRARY && - target->GetType() != cmTarget::INTERFACE_LIBRARY) + if(target->GetType() != cmState::EXECUTABLE && + target->GetType() != cmState::STATIC_LIBRARY && + target->GetType() != cmState::SHARED_LIBRARY && + target->GetType() != cmState::MODULE_LIBRARY && + target->GetType() != cmState::OBJECT_LIBRARY && + target->GetType() != cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "TARGETS given target \"" << (*targetIt) @@ -396,7 +396,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) this->SetError(e.str()); return false; } - else if(target->GetType() == cmTarget::OBJECT_LIBRARY) + else if(target->GetType() == cmState::OBJECT_LIBRARY) { std::ostringstream e; e << "TARGETS given OBJECT library \"" << (*targetIt) @@ -449,7 +449,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) switch(target.GetType()) { - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: { // Shared libraries are handled differently on DLL and non-DLL // platforms. All windows platforms are DLL platforms including @@ -532,7 +532,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) } } break; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: { // Static libraries use ARCHIVE properties. if (!archiveArgs.GetDestination().empty()) @@ -550,7 +550,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) } } break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: { // Modules use LIBRARY properties. if (!libraryArgs.GetDestination().empty()) @@ -571,7 +571,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) } } break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: { if(target.IsAppBundleOnApple()) { @@ -635,7 +635,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) } } break; - case cmTarget::INTERFACE_LIBRARY: + case cmState::INTERFACE_LIBRARY: // Nothing to do. An INTERFACE_LIBRARY can be installed, but the // only effect of that is to make it exportable. It installs no // other files itself. @@ -654,7 +654,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) bool createInstallGeneratorsForTargetFileSets = true; if(target.IsFrameworkOnApple() - || target.GetType() == cmTarget::INTERFACE_LIBRARY) + || target.GetType() == cmState::INTERFACE_LIBRARY) { createInstallGeneratorsForTargetFileSets = false; } @@ -773,7 +773,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) if(!exports.GetString().empty() && !namelinkOnly) { cmTargetExport *te = new cmTargetExport; - te->Target = ⌖ + te->TargetName = target.GetName(); te->ArchiveGenerator = archiveGenerator; te->BundleGenerator = bundleGenerator; te->FrameworkGenerator = frameworkGenerator; @@ -1379,16 +1379,17 @@ bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args) tei != exportSet->GetTargetExports()->end(); ++tei) { cmTargetExport const* te = *tei; + cmTarget* tgt = this->Makefile->FindTarget(te->TargetName); const bool newCMP0022Behavior = - te->Target->GetPolicyStatusCMP0022() != cmPolicies::WARN - && te->Target->GetPolicyStatusCMP0022() != cmPolicies::OLD; + tgt->GetPolicyStatusCMP0022() != cmPolicies::WARN + && tgt->GetPolicyStatusCMP0022() != cmPolicies::OLD; if(!newCMP0022Behavior) { std::ostringstream e; e << "INSTALL(EXPORT) given keyword \"" << "EXPORT_LINK_INTERFACE_LIBRARIES" << "\", but target \"" - << te->Target->GetName() + << te->TargetName << "\" does not have policy CMP0022 set to NEW."; this->SetError(e.str()); return false; diff --git a/Source/cmInstallDirectoryGenerator.cxx b/Source/cmInstallDirectoryGenerator.cxx index 7593380..ea27f61 100644 --- a/Source/cmInstallDirectoryGenerator.cxx +++ b/Source/cmInstallDirectoryGenerator.cxx @@ -11,7 +11,8 @@ ============================================================================*/ #include "cmInstallDirectoryGenerator.h" -#include "cmTarget.h" +#include "cmGeneratorExpression.h" +#include "cmLocalGenerator.h" //---------------------------------------------------------------------------- cmInstallDirectoryGenerator @@ -25,10 +26,16 @@ cmInstallDirectoryGenerator const char* literal_args, bool optional): cmInstallGenerator(dest, configurations, component, message), + LocalGenerator(0), Directories(dirs), FilePermissions(file_permissions), DirPermissions(dir_permissions), LiteralArguments(literal_args), Optional(optional) { + // We need per-config actions if destination have generator expressions. + if(cmGeneratorExpression::Find(Destination) != std::string::npos) + { + this->ActionsPerConfig = true; + } } //---------------------------------------------------------------------------- @@ -37,15 +44,43 @@ cmInstallDirectoryGenerator { } +void cmInstallDirectoryGenerator::Compute(cmLocalGenerator* lg) +{ + LocalGenerator = lg; +} + //---------------------------------------------------------------------------- void cmInstallDirectoryGenerator::GenerateScriptActions(std::ostream& os, Indent const& indent) { + if(this->ActionsPerConfig) + { + this->cmInstallGenerator::GenerateScriptActions(os, indent); + } + else + { + this->AddDirectoryInstallRule(os, "", indent); + } +} + +void cmInstallDirectoryGenerator::GenerateScriptForConfig( + std::ostream& os, + const std::string& config, + Indent const& indent) +{ + this->AddDirectoryInstallRule(os, config, indent); +} + +void cmInstallDirectoryGenerator::AddDirectoryInstallRule( + std::ostream& os, + const std::string& config, + Indent const& indent) +{ // Write code to install the directories. const char* no_rename = 0; this->AddInstallRule(os, - this->Destination, + this->GetDestination(config), cmInstallType_DIRECTORY, this->Directories, this->Optional, @@ -54,3 +89,12 @@ cmInstallDirectoryGenerator::GenerateScriptActions(std::ostream& os, no_rename, this->LiteralArguments.c_str(), indent); } + +//---------------------------------------------------------------------------- +std::string +cmInstallDirectoryGenerator::GetDestination(std::string const& config) const +{ + cmGeneratorExpression ge; + return ge.Parse(this->Destination) + ->Evaluate(this->LocalGenerator, config); +} diff --git a/Source/cmInstallDirectoryGenerator.h b/Source/cmInstallDirectoryGenerator.h index 165ab91..04107e1 100644 --- a/Source/cmInstallDirectoryGenerator.h +++ b/Source/cmInstallDirectoryGenerator.h @@ -31,8 +31,19 @@ public: bool optional = false); virtual ~cmInstallDirectoryGenerator(); + void Compute(cmLocalGenerator* lg); + + std::string GetDestination(std::string const& config) const; + protected: virtual void GenerateScriptActions(std::ostream& os, Indent const& indent); + virtual void GenerateScriptForConfig(std::ostream& os, + const std::string& config, + Indent const& indent); + void AddDirectoryInstallRule(std::ostream& os, + const std::string& config, + Indent const& indent); + cmLocalGenerator* LocalGenerator; std::vector<std::string> Directories; std::string FilePermissions; std::string DirPermissions; diff --git a/Source/cmInstallExportGenerator.cxx b/Source/cmInstallExportGenerator.cxx index 97b9405..9570ba3 100644 --- a/Source/cmInstallExportGenerator.cxx +++ b/Source/cmInstallExportGenerator.cxx @@ -56,6 +56,7 @@ cmInstallExportGenerator::~cmInstallExportGenerator() void cmInstallExportGenerator::Compute(cmLocalGenerator* lg) { this->LocalGenerator = lg; + this->ExportSet->Compute(lg); } //---------------------------------------------------------------------------- @@ -64,7 +65,7 @@ void cmInstallExportGenerator::ComputeTempDir() // Choose a temporary directory in which to generate the import // files to be installed. this->TempDir = - this->LocalGenerator->GetMakefile()->GetCurrentBinaryDirectory(); + this->LocalGenerator->GetCurrentBinaryDirectory(); this->TempDir += cmake::GetCMakeFilesDirectory(); this->TempDir += "/Export"; if(this->Destination.empty()) diff --git a/Source/cmInstallFilesCommand.h b/Source/cmInstallFilesCommand.h index 4551ab1..8062d11 100644 --- a/Source/cmInstallFilesCommand.h +++ b/Source/cmInstallFilesCommand.h @@ -52,12 +52,6 @@ public: virtual void FinalPass(); virtual bool HasFinalPass() const { return !this->IsFilesForm; } - /** This command is kept for compatibility with older CMake versions. */ - virtual bool IsDiscouraged() const - { - return true; - } - cmTypeMacro(cmInstallFilesCommand, cmCommand); protected: diff --git a/Source/cmInstallFilesGenerator.cxx b/Source/cmInstallFilesGenerator.cxx index c18b174..383031b 100644 --- a/Source/cmInstallFilesGenerator.cxx +++ b/Source/cmInstallFilesGenerator.cxx @@ -34,6 +34,12 @@ cmInstallFilesGenerator Programs(programs), Optional(optional) { + // We need per-config actions if the destination has generator expressions. + if(cmGeneratorExpression::Find(Destination) != std::string::npos) + { + this->ActionsPerConfig = true; + } + // We need per-config actions if any files have generator expressions. for(std::vector<std::string>::const_iterator i = files.begin(); !this->ActionsPerConfig && i != files.end(); ++i) @@ -57,14 +63,25 @@ void cmInstallFilesGenerator::Compute(cmLocalGenerator* lg) } //---------------------------------------------------------------------------- +std::string +cmInstallFilesGenerator::GetDestination(std::string const& config) const +{ + cmGeneratorExpression ge; + return ge.Parse(this->Destination) + ->Evaluate(this->LocalGenerator, config); +} + +//---------------------------------------------------------------------------- void cmInstallFilesGenerator::AddFilesInstallRule( - std::ostream& os, Indent const& indent, + std::ostream& os, + const std::string config, + Indent const& indent, std::vector<std::string> const& files) { // Write code to install the files. const char* no_dir_permissions = 0; this->AddInstallRule(os, - this->Destination, + this->GetDestination(config), (this->Programs ? cmInstallType_PROGRAMS : cmInstallType_FILES), @@ -84,7 +101,7 @@ void cmInstallFilesGenerator::GenerateScriptActions(std::ostream& os, } else { - this->AddFilesInstallRule(os, indent, this->Files); + this->AddFilesInstallRule(os, "", indent, this->Files); } } @@ -100,7 +117,7 @@ void cmInstallFilesGenerator::GenerateScriptForConfig(std::ostream& os, { cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*i); cmSystemTools::ExpandListArgument(cge->Evaluate( - this->LocalGenerator->GetMakefile(), config), files); + this->LocalGenerator, config), files); } - this->AddFilesInstallRule(os, indent, files); + this->AddFilesInstallRule(os, config, indent, files); } diff --git a/Source/cmInstallFilesGenerator.h b/Source/cmInstallFilesGenerator.h index 00b3a79..bfe4039 100644 --- a/Source/cmInstallFilesGenerator.h +++ b/Source/cmInstallFilesGenerator.h @@ -32,12 +32,16 @@ public: void Compute(cmLocalGenerator* lg); + std::string GetDestination(std::string const& config) const; + protected: virtual void GenerateScriptActions(std::ostream& os, Indent const& indent); virtual void GenerateScriptForConfig(std::ostream& os, const std::string& config, Indent const& indent); - void AddFilesInstallRule(std::ostream& os, Indent const& indent, + void AddFilesInstallRule(std::ostream& os, + const std::string config, + Indent const& indent, std::vector<std::string> const& files); cmLocalGenerator* LocalGenerator; diff --git a/Source/cmInstallProgramsCommand.h b/Source/cmInstallProgramsCommand.h index 90c7ba3..524debf 100644 --- a/Source/cmInstallProgramsCommand.h +++ b/Source/cmInstallProgramsCommand.h @@ -53,12 +53,6 @@ public: virtual bool HasFinalPass() const { return true; } - /** This command is kept for compatibility with older CMake versions. */ - virtual bool IsDiscouraged() const - { - return true; - } - cmTypeMacro(cmInstallProgramsCommand, cmCommand); protected: diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx index 30cf175..59d06f6 100644 --- a/Source/cmInstallTargetGenerator.cxx +++ b/Source/cmInstallTargetGenerator.cxx @@ -76,14 +76,14 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, if(this->Target->NeedRelinkBeforeInstall(config)) { fromDirConfig = - this->Target->Target->GetMakefile()->GetCurrentBinaryDirectory(); + this->Target->GetLocalGenerator()->GetCurrentBinaryDirectory(); fromDirConfig += cmake::GetCMakeFilesDirectory(); fromDirConfig += "/CMakeRelink.dir/"; } else { fromDirConfig = - this->Target->Target->GetDirectory(config, this->ImportLibrary); + this->Target->GetDirectory(config, this->ImportLibrary); fromDirConfig += "/"; } std::string toDir = @@ -94,29 +94,28 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, std::vector<std::string> filesFrom; std::vector<std::string> filesTo; std::string literal_args; - cmTarget::TargetType targetType = - static_cast<cmTarget::TargetType>(this->Target->GetType()); + cmState::TargetType targetType = this->Target->GetType(); cmInstallType type = cmInstallType(); switch(targetType) { - case cmTarget::EXECUTABLE: type = cmInstallType_EXECUTABLE; break; - case cmTarget::STATIC_LIBRARY: type = cmInstallType_STATIC_LIBRARY; break; - case cmTarget::SHARED_LIBRARY: type = cmInstallType_SHARED_LIBRARY; break; - case cmTarget::MODULE_LIBRARY: type = cmInstallType_MODULE_LIBRARY; break; - case cmTarget::INTERFACE_LIBRARY: + case cmState::EXECUTABLE: type = cmInstallType_EXECUTABLE; break; + case cmState::STATIC_LIBRARY: type = cmInstallType_STATIC_LIBRARY; break; + case cmState::SHARED_LIBRARY: type = cmInstallType_SHARED_LIBRARY; break; + case cmState::MODULE_LIBRARY: type = cmInstallType_MODULE_LIBRARY; break; + case cmState::INTERFACE_LIBRARY: // Not reachable. We never create a cmInstallTargetGenerator for // an INTERFACE_LIBRARY. assert(0 && "INTERFACE_LIBRARY targets have no installable outputs."); break; - case cmTarget::OBJECT_LIBRARY: - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: - case cmTarget::UNKNOWN_LIBRARY: - this->Target->Target->GetMakefile()->IssueMessage(cmake::INTERNAL_ERROR, + case cmState::OBJECT_LIBRARY: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: + case cmState::UNKNOWN_LIBRARY: + this->Target->GetLocalGenerator()->IssueMessage(cmake::INTERNAL_ERROR, "cmInstallTargetGenerator created with non-installable target."); return; } - if(targetType == cmTarget::EXECUTABLE) + if(targetType == cmState::EXECUTABLE) { // There is a bug in cmInstallCommand if this fails. assert(this->NamelinkMode == NamelinkModeNone); @@ -135,7 +134,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, filesFrom.push_back(from1); filesTo.push_back(to1); std::string targetNameImportLib; - if(this->Target->Target->GetImplibGNUtoMS(targetNameImport, + if(this->Target->GetImplibGNUtoMS(targetNameImport, targetNameImportLib)) { filesFrom.push_back(fromDirConfig + targetNameImportLib); @@ -151,7 +150,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, std::string to1 = toDir + targetName; // Handle OSX Bundles. - if(this->Target->Target->IsAppBundleOnApple()) + if(this->Target->IsAppBundleOnApple()) { // Install the whole app bundle directory. type = cmInstallType_DIRECTORY; @@ -199,7 +198,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, filesFrom.push_back(from1); filesTo.push_back(to1); std::string targetNameImportLib; - if(this->Target->Target->GetImplibGNUtoMS(targetNameImport, + if(this->Target->GetImplibGNUtoMS(targetNameImport, targetNameImportLib)) { filesFrom.push_back(fromDirConfig + targetNameImportLib); @@ -209,7 +208,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, // An import library looks like a static library. type = cmInstallType_STATIC_LIBRARY; } - else if(this->Target->Target->IsFrameworkOnApple()) + else if(this->Target->IsFrameworkOnApple()) { // There is a bug in cmInstallCommand if this fails. assert(this->NamelinkMode == NamelinkModeNone); @@ -227,7 +226,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, filesFrom.push_back(from1); filesTo.push_back(to1); } - else if(this->Target->Target->IsCFBundleOnApple()) + else if(this->Target->IsCFBundleOnApple()) { // Install the whole app bundle directory. type = cmInstallType_DIRECTORY; @@ -351,7 +350,7 @@ cmInstallTargetGenerator::GetDestination(std::string const& config) const { cmGeneratorExpression ge; return ge.Parse(this->Destination) - ->Evaluate(this->Target->Target->GetMakefile(), config); + ->Evaluate(this->Target->GetLocalGenerator(), config); } //---------------------------------------------------------------------------- @@ -360,28 +359,25 @@ cmInstallTargetGenerator::GetInstallFilename(const std::string& config) const { NameType nameType = this->ImportLibrary? NameImplib : NameNormal; return - cmInstallTargetGenerator::GetInstallFilename(this->Target->Target, config, + cmInstallTargetGenerator::GetInstallFilename(this->Target, config, nameType); } //---------------------------------------------------------------------------- std::string -cmInstallTargetGenerator::GetInstallFilename(cmTarget const* target, +cmInstallTargetGenerator::GetInstallFilename(cmGeneratorTarget const* target, const std::string& config, NameType nameType) { std::string fname; // Compute the name of the library. - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - if(target->GetType() == cmTarget::EXECUTABLE) + if(target->GetType() == cmState::EXECUTABLE) { std::string targetName; std::string targetNameReal; std::string targetNameImport; std::string targetNamePDB; - gtgt->GetExecutableNames(targetName, targetNameReal, + target->GetExecutableNames(targetName, targetNameReal, targetNameImport, targetNamePDB, config); if(nameType == NameImplib) @@ -411,7 +407,7 @@ cmInstallTargetGenerator::GetInstallFilename(cmTarget const* target, std::string targetNameReal; std::string targetNameImport; std::string targetNamePDB; - gtgt->GetLibraryNames(targetName, targetNameSO, targetNameReal, + target->GetLibraryNames(targetName, targetNameSO, targetNameReal, targetNameImport, targetNamePDB, config); if(nameType == NameImplib) { @@ -444,8 +440,7 @@ cmInstallTargetGenerator::GetInstallFilename(cmTarget const* target, void cmInstallTargetGenerator::Compute(cmLocalGenerator* lg) { - this->Target = lg->GetGlobalGenerator()->GetGeneratorTarget( - lg->GetMakefile()->FindTarget(this->TargetName)); + this->Target = lg->FindGeneratorTarget(this->TargetName); } //---------------------------------------------------------------------------- @@ -542,9 +537,9 @@ cmInstallTargetGenerator std::string const& toDestDirPath) { if(this->ImportLibrary || - !(this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY || - this->Target->GetType() == cmTarget::EXECUTABLE)) + !(this->Target->GetType() == cmState::SHARED_LIBRARY || + this->Target->GetType() == cmState::MODULE_LIBRARY || + this->Target->GetType() == cmState::EXECUTABLE)) { return; } @@ -563,12 +558,12 @@ cmInstallTargetGenerator std::map<std::string, std::string> install_name_remap; if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config)) { - std::set<cmTarget const*> const& sharedLibs + std::set<cmGeneratorTarget const*> const& sharedLibs = cli->GetSharedLibrariesLinked(); - for(std::set<cmTarget const*>::const_iterator j = sharedLibs.begin(); - j != sharedLibs.end(); ++j) + for(std::set<cmGeneratorTarget const*>::const_iterator j + = sharedLibs.begin(); j != sharedLibs.end(); ++j) { - cmTarget const* tgt = *j; + cmGeneratorTarget const* tgt = *j; // The install_name of an imported target does not change. if(tgt->IsImported()) @@ -576,14 +571,11 @@ cmInstallTargetGenerator continue; } - cmGeneratorTarget *gtgt = tgt->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(tgt); // If the build tree and install tree use different path // components of the install_name field then we need to create a // mapping to be applied after installation. - std::string for_build = gtgt->GetInstallNameDirForBuildTree(config); - std::string for_install = gtgt->GetInstallNameDirForInstallTree(); + std::string for_build = tgt->GetInstallNameDirForBuildTree(config); + std::string for_install = tgt->GetInstallNameDirForInstallTree(); if(for_build != for_install) { // The directory portions differ. Append the filename to @@ -605,14 +597,14 @@ cmInstallTargetGenerator // Edit the install_name of the target itself if necessary. std::string new_id; - if(this->Target->GetType() == cmTarget::SHARED_LIBRARY) + if(this->Target->GetType() == cmState::SHARED_LIBRARY) { std::string for_build = this->Target->GetInstallNameDirForBuildTree(config); std::string for_install = this->Target->GetInstallNameDirForInstallTree(); - if(this->Target->Target->IsFrameworkOnApple() && for_install.empty()) + if(this->Target->IsFrameworkOnApple() && for_install.empty()) { // Frameworks seem to have an id corresponding to their own full // path. @@ -626,7 +618,7 @@ cmInstallTargetGenerator { // Prepare to refer to the install-tree install_name. new_id = for_install; - new_id += this->GetInstallFilename(this->Target->Target, config, NameSO); + new_id += this->GetInstallFilename(this->Target, config, NameSO); } } @@ -816,14 +808,14 @@ cmInstallTargetGenerator::AddStripRule(std::ostream& os, // don't strip static and import libraries, because it removes the only // symbol table they have so you can't link to them anymore - if(this->Target->GetType()==cmTarget::STATIC_LIBRARY || this->ImportLibrary) + if(this->Target->GetType()==cmState::STATIC_LIBRARY || this->ImportLibrary) { return; } // Don't handle OSX Bundles. if(this->Target->Target->GetMakefile()->IsOn("APPLE") && - this->Target->Target->GetPropertyAsBool("MACOSX_BUNDLE")) + this->Target->GetPropertyAsBool("MACOSX_BUNDLE")) { return; } @@ -847,7 +839,7 @@ cmInstallTargetGenerator::AddRanlibRule(std::ostream& os, const std::string& toDestDirPath) { // Static libraries need ranlib on this platform. - if(this->Target->GetType() != cmTarget::STATIC_LIBRARY) + if(this->Target->GetType() != cmState::STATIC_LIBRARY) { return; } diff --git a/Source/cmInstallTargetGenerator.h b/Source/cmInstallTargetGenerator.h index a8f4a75..ec89c05 100644 --- a/Source/cmInstallTargetGenerator.h +++ b/Source/cmInstallTargetGenerator.h @@ -14,7 +14,6 @@ #include "cmInstallGenerator.h" -class cmTarget; class cmGeneratorTarget; /** \class cmInstallTargetGenerator @@ -54,7 +53,7 @@ public: NameReal }; - static std::string GetInstallFilename(cmTarget const* target, + static std::string GetInstallFilename(const cmGeneratorTarget* target, const std::string& config, NameType nameType = NameNormal); diff --git a/Source/cmInstallTargetsCommand.h b/Source/cmInstallTargetsCommand.h index e6cbe6e..05160eb 100644 --- a/Source/cmInstallTargetsCommand.h +++ b/Source/cmInstallTargetsCommand.h @@ -44,12 +44,6 @@ public: */ virtual std::string GetName() const { return "install_targets";} - /** This command is kept for compatibility with older CMake versions. */ - virtual bool IsDiscouraged() const - { - return true; - } - cmTypeMacro(cmInstallTargetsCommand, cmCommand); }; diff --git a/Source/cmLinkItem.h b/Source/cmLinkItem.h index 10dd465..b603bcc 100644 --- a/Source/cmLinkItem.h +++ b/Source/cmLinkItem.h @@ -14,8 +14,9 @@ #define cmLinkItem_h #include "cmListFileCache.h" +#include "cmSystemTools.h" -class cmTarget; +class cmGeneratorTarget; // Basic information about each link item. class cmLinkItem: public std::string @@ -24,9 +25,9 @@ class cmLinkItem: public std::string public: cmLinkItem(): std_string(), Target(0) {} cmLinkItem(const std_string& n, - cmTarget const* t): std_string(n), Target(t) {} + cmGeneratorTarget const* t): std_string(n), Target(t) {} cmLinkItem(cmLinkItem const& r): std_string(r), Target(r.Target) {} - cmTarget const* Target; + cmGeneratorTarget const* Target; }; class cmLinkImplItem: public cmLinkItem @@ -34,7 +35,7 @@ class cmLinkImplItem: public cmLinkItem public: cmLinkImplItem(): cmLinkItem(), Backtrace(), FromGenex(false) {} cmLinkImplItem(std::string const& n, - cmTarget const* t, + cmGeneratorTarget const* t, cmListFileBacktrace const& bt, bool fromGenex): cmLinkItem(n, t), Backtrace(bt), FromGenex(fromGenex) {} @@ -97,7 +98,7 @@ struct cmOptionalLinkInterface: public cmLinkInterface }; struct cmHeadToLinkInterfaceMap: - public std::map<cmTarget const*, cmOptionalLinkInterface> + public std::map<cmGeneratorTarget const*, cmOptionalLinkInterface> { }; @@ -118,4 +119,27 @@ struct cmOptionalLinkImplementation: public cmLinkImplementation bool HadHeadSensitiveCondition; }; +/** Compute the link type to use for the given configuration. */ +inline cmTargetLinkLibraryType +CMP0003_ComputeLinkType(const std::string& config, + std::vector<std::string> const& debugConfigs) +{ + // No configuration is always optimized. + if(config.empty()) + { + return OPTIMIZED_LibraryType; + } + + // Check if any entry in the list matches this configuration. + std::string configUpper = cmSystemTools::UpperCase(config); + if (std::find(debugConfigs.begin(), debugConfigs.end(), configUpper) != + debugConfigs.end()) + { + return DEBUG_LibraryType; + } + // The current configuration is not a debug configuration. + return OPTIMIZED_LibraryType; +} + + #endif diff --git a/Source/cmLinkLibrariesCommand.cxx b/Source/cmLinkLibrariesCommand.cxx index 996b538..eb3bfce 100644 --- a/Source/cmLinkLibrariesCommand.cxx +++ b/Source/cmLinkLibrariesCommand.cxx @@ -34,7 +34,7 @@ bool cmLinkLibrariesCommand return false; } this->Makefile->AddLinkLibrary(*i, - cmTarget::DEBUG); + DEBUG_LibraryType); } else if (*i == "optimized") { @@ -46,7 +46,7 @@ bool cmLinkLibrariesCommand return false; } this->Makefile->AddLinkLibrary(*i, - cmTarget::OPTIMIZED); + OPTIMIZED_LibraryType); } else { diff --git a/Source/cmLinkLibrariesCommand.h b/Source/cmLinkLibrariesCommand.h index c572439..1ddefc4 100644 --- a/Source/cmLinkLibrariesCommand.h +++ b/Source/cmLinkLibrariesCommand.h @@ -44,12 +44,6 @@ public: */ virtual std::string GetName() const { return "link_libraries";} - /** This command is kept for compatibility with older CMake versions. */ - virtual bool IsDiscouraged() const - { - return true; - } - cmTypeMacro(cmLinkLibrariesCommand, cmCommand); }; diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx index bff2986..5050229 100644 --- a/Source/cmListFileCache.cxx +++ b/Source/cmListFileCache.cxx @@ -12,7 +12,7 @@ #include "cmListFileCache.h" #include "cmListFileLexer.h" -#include "cmLocalGenerator.h" +#include "cmOutputConverter.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmVersion.h" diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h index 0afd7f5..5f1a310 100644 --- a/Source/cmListFileCache.h +++ b/Source/cmListFileCache.h @@ -111,13 +111,4 @@ struct cmListFile std::vector<cmListFileFunction> Functions; }; -struct cmValueWithOrigin { - cmValueWithOrigin(const std::string &value, - const cmListFileBacktrace &bt) - : Value(value), Backtrace(bt) - {} - std::string Value; - cmListFileBacktrace Backtrace; -}; - #endif diff --git a/Source/cmLoadCommandCommand.h b/Source/cmLoadCommandCommand.h index 4581269..445e167 100644 --- a/Source/cmLoadCommandCommand.h +++ b/Source/cmLoadCommandCommand.h @@ -21,7 +21,6 @@ public: virtual bool InitialPass(std::vector<std::string> const& args, cmExecutionStatus &status); virtual std::string GetName() const {return "load_command";} - virtual bool IsDiscouraged() const { return true; } cmTypeMacro(cmLoadCommandCommand, cmCommand); }; diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index b360c22..d92cbea 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -51,13 +51,19 @@ cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg, this->Makefile = makefile; + this->AliasTargets = makefile->GetAliasTargets(); + this->EmitUniversalBinaryFlags = true; this->BackwardsCompatibility = 0; this->BackwardsCompatibilityFinal = false; + + this->ComputeObjectMaxPath(); } cmLocalGenerator::~cmLocalGenerator() { + cmDeleteAll(this->GeneratorTargets); + cmDeleteAll(this->OwnedImportedGeneratorTargets); } void cmLocalGenerator::IssueMessage(cmake::MessageType t, @@ -130,16 +136,15 @@ void cmLocalGenerator::TraceDependencies() this->GlobalGenerator->CreateEvaluationSourceFiles(*ci); } // Generate the rule files for each target. - cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - if (t->second->Target->IsImported() - || t->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - t->second->TraceDependencies(); + (*t)->TraceDependencies(); } } @@ -446,6 +451,63 @@ void cmLocalGenerator::GenerateInstallRules() } } + +void cmLocalGenerator::AddGeneratorTarget(cmGeneratorTarget* gt) +{ + this->GeneratorTargets.push_back(gt); +} + +void cmLocalGenerator::AddImportedGeneratorTarget(cmGeneratorTarget* gt) +{ + this->ImportedGeneratorTargets.push_back(gt); +} + +void cmLocalGenerator::AddOwnedImportedGeneratorTarget(cmGeneratorTarget* gt) +{ + this->OwnedImportedGeneratorTargets.push_back(gt); +} + +struct NamedGeneratorTargetFinder +{ + NamedGeneratorTargetFinder(std::string const& name) + : Name(name) + { + + } + + bool operator()(cmGeneratorTarget* tgt) + { + return tgt->GetName() == this->Name; + } +private: + std::string Name; +}; + +cmGeneratorTarget* cmLocalGenerator::FindGeneratorTarget( + const std::string& name) const +{ + std::map<std::string, std::string>::const_iterator i = + this->AliasTargets.find(name); + if (i != this->AliasTargets.end()) + { + std::vector<cmGeneratorTarget*>::const_iterator ai = + std::find_if(this->GeneratorTargets.begin(), + this->GeneratorTargets.end(), + NamedGeneratorTargetFinder(i->second)); + return *ai; + } + std::vector<cmGeneratorTarget*>::const_iterator ti = + std::find_if(this->GeneratorTargets.begin(), + this->GeneratorTargets.end(), + NamedGeneratorTargetFinder(name)); + if ( ti != this->GeneratorTargets.end() ) + { + return *ti; + } + + return 0; +} + //---------------------------------------------------------------------------- void cmLocalGenerator::ComputeTargetManifest() { @@ -458,16 +520,12 @@ void cmLocalGenerator::ComputeTargetManifest() } // Add our targets to the manifest for each configuration. - cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - cmGeneratorTarget& target = *t->second; - if (target.Target->GetType() == cmTarget::INTERFACE_LIBRARY) - { - continue; - } - if (target.Target->IsImported()) + cmGeneratorTarget* target = *t; + if (target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -475,11 +533,16 @@ void cmLocalGenerator::ComputeTargetManifest() ci != configNames.end(); ++ci) { const char* config = ci->c_str(); - target.ComputeTargetManifest(config); + target->ComputeTargetManifest(config); } } } +bool cmLocalGenerator::IsRootMakefile() const +{ + return !this->StateSnapshot.GetBuildsystemDirectoryParent().IsValid(); +} + cmState* cmLocalGenerator::GetState() const { return this->GlobalGenerator->GetCMakeInstance()->GetState(); @@ -487,7 +550,7 @@ cmState* cmLocalGenerator::GetState() const cmState::Snapshot cmLocalGenerator::GetStateSnapshot() const { - return this->StateSnapshot; + return this->Makefile->GetStateSnapshot(); } // List of variables that are replaced when @@ -525,6 +588,13 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable, return replaceValues.LinkFlags; } } + if(replaceValues.Manifests) + { + if(variable == "MANIFESTS") + { + return replaceValues.Manifests; + } + } if(replaceValues.Flags) { if(variable == "FLAGS") @@ -744,7 +814,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable, } if(variable == "TARGET_TYPE") { - return cmTarget::GetTargetTypeName(replaceValues.CMTarget->GetType()); + return cmState::GetTargetTypeName(replaceValues.CMTarget->GetType()); } } if(replaceValues.Output) @@ -904,7 +974,7 @@ cmLocalGenerator::ExpandRuleVariables(std::string& s, } //---------------------------------------------------------------------------- -const char* cmLocalGenerator::GetRuleLauncher(cmTarget* target, +const char* cmLocalGenerator::GetRuleLauncher(cmGeneratorTarget* target, const std::string& prop) { if(target) @@ -918,7 +988,8 @@ const char* cmLocalGenerator::GetRuleLauncher(cmTarget* target, } //---------------------------------------------------------------------------- -void cmLocalGenerator::InsertRuleLauncher(std::string& s, cmTarget* target, +void cmLocalGenerator::InsertRuleLauncher(std::string& s, + cmGeneratorTarget* target, const std::string& prop) { if(const char* val = this->GetRuleLauncher(target, prop)) @@ -1071,27 +1142,23 @@ std::string cmLocalGenerator::GetIncludeFlags( //---------------------------------------------------------------------------- void cmLocalGenerator::AddCompileDefinitions(std::set<std::string>& defines, - cmTarget const* target, + cmGeneratorTarget const* target, const std::string& config, const std::string& lang) { std::vector<std::string> targetDefines; - cmGeneratorTarget* gtgt = this->GlobalGenerator->GetGeneratorTarget(target); - gtgt->GetCompileDefinitions(targetDefines, config, lang); + target->GetCompileDefinitions(targetDefines, config, lang); this->AppendDefines(defines, targetDefines); } //---------------------------------------------------------------------------- void cmLocalGenerator::AddCompileOptions( - std::string& flags, cmTarget* target, + std::string& flags, cmGeneratorTarget* target, const std::string& lang, const std::string& config ) { std::string langFlagRegexVar = std::string("CMAKE_")+lang+"_FLAG_REGEX"; - cmGeneratorTarget* gtgt = - this->GlobalGenerator->GetGeneratorTarget(target); - if(const char* langFlagRegexStr = this->Makefile->GetDefinition(langFlagRegexVar)) { @@ -1102,7 +1169,7 @@ void cmLocalGenerator::AddCompileOptions( { cmSystemTools::ParseWindowsCommandLine(targetFlags, opts); } - gtgt->GetCompileOptions(opts, config, lang); + target->GetCompileOptions(opts, config, lang); for(std::vector<std::string>::const_iterator i = opts.begin(); i != opts.end(); ++i) { @@ -1123,7 +1190,7 @@ void cmLocalGenerator::AddCompileOptions( this->AppendFlags(flags, targetFlags); } std::vector<std::string> opts; - gtgt->GetCompileOptions(opts, config, lang); + target->GetCompileOptions(opts, config, lang); for(std::vector<std::string>::const_iterator i = opts.begin(); i != opts.end(); ++i) { @@ -1132,11 +1199,11 @@ void cmLocalGenerator::AddCompileOptions( } } std::vector<std::string> features; - gtgt->GetCompileFeatures(features, config); + target->GetCompileFeatures(features, config); for(std::vector<std::string>::const_iterator it = features.begin(); it != features.end(); ++it) { - if (!this->Makefile->AddRequiredTargetFeature(target, *it)) + if (!this->Makefile->AddRequiredTargetFeature(target->Target, *it)) { return; } @@ -1171,7 +1238,7 @@ void cmLocalGenerator::AddCompileOptions( //---------------------------------------------------------------------------- void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs, - cmGeneratorTarget* target, + cmGeneratorTarget const* target, const std::string& lang, const std::string& config, bool stripImplicitInclDirs @@ -1298,7 +1365,7 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs, void cmLocalGenerator::GetStaticLibraryFlags(std::string& flags, std::string const& config, - cmTarget* target) + cmGeneratorTarget* target) { this->AppendFlags(flags, this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS")); @@ -1331,12 +1398,12 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs, switch(target->GetType()) { - case cmTarget::STATIC_LIBRARY: - this->GetStaticLibraryFlags(linkFlags, buildType, target->Target); + case cmState::STATIC_LIBRARY: + this->GetStaticLibraryFlags(linkFlags, buildType, target); break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: libraryLinkVariable = "CMAKE_MODULE_LINKER_FLAGS"; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: { linkFlags = this->Makefile->GetSafeDefinition(libraryLinkVariable); linkFlags += " "; @@ -1388,7 +1455,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs, *target, false, false, useWatcomQuote); } break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: { linkFlags += this->Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS"); @@ -1405,7 +1472,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs, { cmSystemTools::Error ("CMake can not determine linker language for target: ", - target->Target->GetName().c_str()); + target->GetName().c_str()); return; } this->AddLanguageFlags(flags, linkLanguage, buildType); @@ -1431,7 +1498,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs, this->Makefile->GetSafeDefinition("CMAKE_CREATE_CONSOLE_EXE"); linkFlags += " "; } - if (target->Target->IsExecutableWithExports()) + if (target->IsExecutableWithExports()) { std::string exportFlagVar = "CMAKE_EXE_EXPORTS_"; exportFlagVar += linkLanguage; @@ -1533,13 +1600,49 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries, this->Makefile->GetSafeDefinition("CMAKE_LIBRARY_PATH_TERMINATOR"); // Flags to link an executable to shared libraries. - std::string linkFlagsVar = "CMAKE_SHARED_LIBRARY_LINK_"; - linkFlagsVar += linkLanguage; - linkFlagsVar += "_FLAGS"; - if( tgt.GetType() == cmTarget::EXECUTABLE ) + if (tgt.GetType() == cmState::EXECUTABLE && + this->StateSnapshot.GetState()-> + GetGlobalPropertyAsBool("TARGET_SUPPORTS_SHARED_LIBS")) { - linkLibs = this->Makefile->GetSafeDefinition(linkFlagsVar); - linkLibs += " "; + bool add_shlib_flags = false; + switch(tgt.GetPolicyStatusCMP0065()) + { + case cmPolicies::WARN: + if(!tgt.GetPropertyAsBool("ENABLE_EXPORTS") && + this->Makefile->PolicyOptionalWarningEnabled( + "CMAKE_POLICY_WARNING_CMP0065")) + { + std::ostringstream w; + w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0065) << "\n" + "For compatibility with older versions of CMake, " + "additional flags may be added to export symbols on all " + "executables regardless of thier ENABLE_EXPORTS property."; + this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str()); + } + case cmPolicies::OLD: + // OLD behavior is to always add the flags + add_shlib_flags = true; + break; + case cmPolicies::REQUIRED_IF_USED: + case cmPolicies::REQUIRED_ALWAYS: + this->Makefile->IssueMessage( + cmake::FATAL_ERROR, + cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0065) + ); + case cmPolicies::NEW: + // NEW behavior is to only add the flags if ENABLE_EXPORTS is on + add_shlib_flags = tgt.GetPropertyAsBool("ENABLE_EXPORTS"); + break; + } + + if(add_shlib_flags) + { + std::string linkFlagsVar = "CMAKE_SHARED_LIBRARY_LINK_"; + linkFlagsVar += linkLanguage; + linkFlagsVar += "_FLAGS"; + linkLibs = this->Makefile->GetSafeDefinition(linkFlagsVar); + linkLibs += " "; + } } // Append the framework search path flags. @@ -1579,7 +1682,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries, ItemVector const& items = cli.GetItems(); for(ItemVector::const_iterator li = items.begin(); li != items.end(); ++li) { - if(li->Target && li->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if(li->Target && li->Target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -1722,6 +1825,27 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags, } //---------------------------------------------------------------------------- +cmGeneratorTarget* +cmLocalGenerator::FindGeneratorTargetToUse(const std::string& name) const +{ + std::vector<cmGeneratorTarget*>::const_iterator + imported = std::find_if(this->ImportedGeneratorTargets.begin(), + this->ImportedGeneratorTargets.end(), + NamedGeneratorTargetFinder(name)); + if(imported != this->ImportedGeneratorTargets.end()) + { + return *imported; + } + + if(cmGeneratorTarget* t = this->FindGeneratorTarget(name)) + { + return t; + } + + return this->GetGlobalGenerator()->FindGeneratorTarget(name); +} + +//---------------------------------------------------------------------------- bool cmLocalGenerator::GetRealDependency(const std::string& inName, const std::string& config, std::string& dep) @@ -1747,15 +1871,15 @@ bool cmLocalGenerator::GetRealDependency(const std::string& inName, // Look for a CMake target with the given name. if(cmGeneratorTarget* target = - this->Makefile->FindGeneratorTargetToUse(name)) + this->FindGeneratorTargetToUse(name)) { // make sure it is not just a coincidence that the target name // found is part of the inName if(cmSystemTools::FileIsFullPath(inName.c_str())) { std::string tLocation; - if(target->GetType() >= cmTarget::EXECUTABLE && - target->GetType() <= cmTarget::MODULE_LIBRARY) + if(target->GetType() >= cmState::EXECUTABLE && + target->GetType() <= cmState::MODULE_LIBRARY) { tLocation = target->GetLocation(config); tLocation = cmSystemTools::GetFilenamePath(tLocation); @@ -1775,23 +1899,23 @@ bool cmLocalGenerator::GetRealDependency(const std::string& inName, } switch (target->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::UNKNOWN_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::UNKNOWN_LIBRARY: dep = target->GetLocation(config); return true; - case cmTarget::OBJECT_LIBRARY: + case cmState::OBJECT_LIBRARY: // An object library has no single file on which to depend. // This was listed to get the target-level dependency. return false; - case cmTarget::INTERFACE_LIBRARY: + case cmState::INTERFACE_LIBRARY: // An interface library has no file on which to depend. // This was listed to get the target-level dependency. return false; - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: // A utility target has no file on which to depend. This was listed // only to get the target-level dependency. return false; @@ -1841,7 +1965,8 @@ void cmLocalGenerator::AddSharedFlags(std::string& flags, //---------------------------------------------------------------------------- void cmLocalGenerator:: -AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, +AddCompilerRequirementFlag(std::string &flags, + cmGeneratorTarget const* target, const std::string& lang) { if (lang.empty()) @@ -1879,7 +2004,8 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, "CMAKE_" + lang + standardProp + "_" + type + "_COMPILE_OPTION"; - const char *opt = target->GetMakefile()->GetDefinition(option_flag); + const char *opt = target->Target->GetMakefile() + ->GetDefinition(option_flag); if (!opt) { std::ostringstream e; @@ -1944,7 +2070,7 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, + "_" + type + "_COMPILE_OPTION"; const char *opt = - target->GetMakefile()->GetRequiredDefinition(option_flag); + target->Target->GetMakefile()->GetRequiredDefinition(option_flag); this->AppendFlagEscape(flags, opt); return; } @@ -1955,7 +2081,8 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, "CMAKE_" + lang + *stdIt + "_" + type + "_COMPILE_OPTION"; - if (const char *opt = target->GetMakefile()->GetDefinition(option_flag)) + if (const char *opt = target->Target + ->GetMakefile()->GetDefinition(option_flag)) { this->AppendFlagEscape(flags, opt); return; @@ -1964,7 +2091,7 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, } static void AddVisibilityCompileOption(std::string &flags, - cmTarget const* target, + cmGeneratorTarget const* target, cmLocalGenerator *lg, const std::string& lang, std::string* warnCMP0063) @@ -2004,7 +2131,7 @@ static void AddVisibilityCompileOption(std::string &flags, } static void AddInlineVisibilityCompileOption(std::string &flags, - cmTarget const* target, + cmGeneratorTarget const* target, cmLocalGenerator *lg, std::string* warnCMP0063) { @@ -2031,7 +2158,7 @@ static void AddInlineVisibilityCompileOption(std::string &flags, //---------------------------------------------------------------------------- void cmLocalGenerator -::AddVisibilityPresetFlags(std::string &flags, cmTarget const* target, +::AddVisibilityPresetFlags(std::string &flags, cmGeneratorTarget const* target, const std::string& lang) { if (lang.empty()) @@ -2041,8 +2168,8 @@ void cmLocalGenerator std::string warnCMP0063; std::string *pWarnCMP0063 = 0; - if (target->GetType() != cmTarget::SHARED_LIBRARY && - target->GetType() != cmTarget::MODULE_LIBRARY && + if (target->GetType() != cmState::SHARED_LIBRARY && + target->GetType() != cmState::MODULE_LIBRARY && !target->IsExecutableWithExports()) { switch (target->GetPolicyStatusCMP0063()) @@ -2071,25 +2198,26 @@ void cmLocalGenerator w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0063) << "\n" "Target \"" << target->GetName() << "\" of " - "type \"" << cmTarget::GetTargetTypeName(target->GetType()) << "\" " + "type \"" << cmState::GetTargetTypeName(target->GetType()) << "\" " "has the following visibility properties set for " << lang << ":\n" << warnCMP0063 << "For compatibility CMake is not honoring them for this target."; - target->GetMakefile()->GetCMakeInstance() - ->IssueMessage(cmake::AUTHOR_WARNING, w.str(), target->GetBacktrace()); + target->GetLocalGenerator()->GetCMakeInstance() + ->IssueMessage(cmake::AUTHOR_WARNING, w.str(), + target->GetBacktrace()); } } //---------------------------------------------------------------------------- void cmLocalGenerator::AddCMP0018Flags(std::string &flags, - cmTarget const* target, + cmGeneratorTarget const* target, std::string const& lang, const std::string& config) { int targetType = target->GetType(); - bool shared = ((targetType == cmTarget::SHARED_LIBRARY) || - (targetType == cmTarget::MODULE_LIBRARY)); + bool shared = ((targetType == cmState::SHARED_LIBRARY) || + (targetType == cmState::MODULE_LIBRARY)); if (this->GetShouldUseOldFlags(shared, lang)) { @@ -2097,7 +2225,7 @@ void cmLocalGenerator::AddCMP0018Flags(std::string &flags, } else { - if (target->GetType() == cmTarget::OBJECT_LIBRARY) + if (target->GetType() == cmState::OBJECT_LIBRARY) { if (target->GetPropertyAsBool("POSITION_INDEPENDENT_CODE")) { @@ -2106,9 +2234,7 @@ void cmLocalGenerator::AddCMP0018Flags(std::string &flags, return; } - cmGeneratorTarget* gtgt = - this->GlobalGenerator->GetGeneratorTarget(target); - if (gtgt->GetLinkInterfaceDependentBoolProperty( + if (target->GetLinkInterfaceDependentBoolProperty( "POSITION_INDEPENDENT_CODE", config)) { @@ -2137,7 +2263,7 @@ bool cmLocalGenerator::GetShouldUseOldFlags(bool shared, if (flags && flags != originalFlags) { - switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0018)) + switch (this->GetPolicyStatus(cmPolicies::CMP0018)) { case cmPolicies::WARN: { @@ -2171,7 +2297,7 @@ void cmLocalGenerator::AddPositionIndependentFlags(std::string& flags, { const char* picFlags = 0; - if(targetType == cmTarget::EXECUTABLE) + if(targetType == cmState::EXECUTABLE) { std::string flagsVar = "CMAKE_"; flagsVar += lang; @@ -2386,6 +2512,11 @@ const char* cmLocalGenerator::GetFeature(const std::string& feature, return 0; } +std::string cmLocalGenerator::GetProjectName() const +{ + return this->StateSnapshot.GetProjectName(); +} + //---------------------------------------------------------------------------- std::string cmLocalGenerator::ConstructComment(cmCustomCommandGenerator const& ccg, @@ -2441,28 +2572,29 @@ cmLocalGenerator { // Convert the old-style install specification from each target to // an install generator and run it. - cmTargets& tgts = this->Makefile->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if (l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if ((*l)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } // Include the user-specified pre-install script for this target. - if(const char* preinstall = l->second.GetProperty("PRE_INSTALL_SCRIPT")) + if(const char* preinstall = (*l)->GetProperty("PRE_INSTALL_SCRIPT")) { cmInstallScriptGenerator g(preinstall, false, 0); g.Generate(os, config, configurationTypes); } // Install this target if a destination is given. - if(l->second.GetInstallPath() != "") + if((*l)->Target->GetInstallPath() != "") { // Compute the full install destination. Note that converting // to unix slashes also removes any trailing slash. // We also skip over the leading slash given by the user. - std::string destination = l->second.GetInstallPath().substr(1); + std::string destination = (*l)->Target->GetInstallPath().substr(1); cmSystemTools::ConvertToUnixSlashes(destination); if(destination.empty()) { @@ -2470,37 +2602,37 @@ cmLocalGenerator } // Generate the proper install generator for this target type. - switch(l->second.GetType()) + switch((*l)->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::MODULE_LIBRARY: { // Use a target install generator. cmInstallTargetGeneratorLocal - g(this, l->first, destination.c_str(), false); + g(this, (*l)->GetName(), destination.c_str(), false); g.Generate(os, config, configurationTypes); } break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: { #if defined(_WIN32) || defined(__CYGWIN__) // Special code to handle DLL. Install the import library // to the normal destination and the DLL to the runtime // destination. cmInstallTargetGeneratorLocal - g1(this, l->first, destination.c_str(), true); + g1(this, (*l)->GetName(), destination.c_str(), true); g1.Generate(os, config, configurationTypes); // We also skip over the leading slash given by the user. - destination = l->second.GetRuntimeInstallPath().substr(1); + destination = (*l)->Target->GetRuntimeInstallPath().substr(1); cmSystemTools::ConvertToUnixSlashes(destination); cmInstallTargetGeneratorLocal - g2(this, l->first, destination.c_str(), false); + g2(this, (*l)->GetName(), destination.c_str(), false); g2.Generate(os, config, configurationTypes); #else // Use a target install generator. cmInstallTargetGeneratorLocal - g(this, l->first, destination.c_str(), false); + g(this, (*l)->GetName(), destination.c_str(), false); g.Generate(os, config, configurationTypes); #endif } @@ -2511,7 +2643,7 @@ cmLocalGenerator } // Include the user-specified post-install script for this target. - if(const char* postinstall = l->second.GetProperty("POST_INSTALL_SCRIPT")) + if(const char* postinstall = (*l)->GetProperty("POST_INSTALL_SCRIPT")) { cmInstallScriptGenerator g(postinstall, false, 0); g.Generate(os, config, configurationTypes); @@ -2813,9 +2945,34 @@ cmLocalGenerator return source.GetLanguage(); } +cmake* cmLocalGenerator::GetCMakeInstance() const +{ + return this->GlobalGenerator->GetCMakeInstance(); +} + +const char* cmLocalGenerator::GetSourceDirectory() const +{ + return this->GetCMakeInstance()->GetHomeDirectory(); +} + +const char* cmLocalGenerator::GetBinaryDirectory() const +{ + return this->GetCMakeInstance()->GetHomeOutputDirectory(); +} + +const char* cmLocalGenerator::GetCurrentBinaryDirectory() const +{ + return this->StateSnapshot.GetDirectory().GetCurrentBinary(); +} + +const char* cmLocalGenerator::GetCurrentSourceDirectory() const +{ + return this->StateSnapshot.GetDirectory().GetCurrentSource(); +} + //---------------------------------------------------------------------------- std::string -cmLocalGenerator::GetTargetDirectory(cmTarget const&) const +cmLocalGenerator::GetTargetDirectory(const cmGeneratorTarget*) const { cmSystemTools::Error("GetTargetDirectory" " called on cmLocalGenerator"); @@ -2843,7 +3000,7 @@ cmIML_INT_uint64_t cmLocalGenerator::GetBackwardsCompatibility() } } this->BackwardsCompatibility = CMake_VERSION_ENCODE(major, minor, patch); - this->BackwardsCompatibilityFinal = this->Makefile->IsConfigured(); + this->BackwardsCompatibilityFinal = true; } return this->BackwardsCompatibility; @@ -2854,7 +3011,7 @@ bool cmLocalGenerator::NeedBackwardsCompatibility_2_4() { // Check the policy to decide whether to pay attention to this // variable. - switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0001)) + switch(this->GetPolicyStatus(cmPolicies::CMP0001)) { case cmPolicies::WARN: // WARN is just OLD without warning because user code does not @@ -2881,6 +3038,12 @@ bool cmLocalGenerator::NeedBackwardsCompatibility_2_4() actual_compat <= CMake_VERSION_ENCODE(2, 4, 255)); } +cmPolicies::PolicyStatus +cmLocalGenerator::GetPolicyStatus(cmPolicies::PolicyID id) const +{ + return this->Makefile->GetPolicyStatus(id); +} + //---------------------------------------------------------------------------- bool cmLocalGenerator::CheckDefinition(std::string const& define) const { @@ -2919,7 +3082,7 @@ bool cmLocalGenerator::CheckDefinition(std::string const& define) const } //---------------------------------------------------------------------------- -static void cmLGInfoProp(cmMakefile* mf, cmTarget* target, +static void cmLGInfoProp(cmMakefile* mf, cmGeneratorTarget* target, const std::string& prop) { if(const char* val = target->GetProperty(prop)) @@ -2929,7 +3092,7 @@ static void cmLGInfoProp(cmMakefile* mf, cmTarget* target, } //---------------------------------------------------------------------------- -void cmLocalGenerator::GenerateAppleInfoPList(cmTarget* target, +void cmLocalGenerator::GenerateAppleInfoPList(cmGeneratorTarget* target, const std::string& targetName, const char* fname) { @@ -2973,7 +3136,7 @@ void cmLocalGenerator::GenerateAppleInfoPList(cmTarget* target, } //---------------------------------------------------------------------------- -void cmLocalGenerator::GenerateFrameworkInfoPList(cmTarget* target, +void cmLocalGenerator::GenerateFrameworkInfoPList(cmGeneratorTarget* target, const std::string& targetName, const char* fname) { diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index b051e5d..e2f5519 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -20,7 +20,6 @@ class cmMakefile; class cmGlobalGenerator; class cmGeneratorTarget; -class cmTarget; class cmTargetManifest; class cmSourceFile; class cmCustomCommand; @@ -68,6 +67,8 @@ public: */ void ComputeTargetManifest(); + bool IsRootMakefile() const; + ///! Get the makefile for this generator cmMakefile *GetMakefile() { return this->Makefile; } @@ -91,13 +92,15 @@ public: void AddLanguageFlags(std::string& flags, const std::string& lang, const std::string& config); - void AddCMP0018Flags(std::string &flags, cmTarget const* target, + void AddCMP0018Flags(std::string &flags, cmGeneratorTarget const* target, std::string const& lang, const std::string& config); - void AddVisibilityPresetFlags(std::string &flags, cmTarget const* target, + void AddVisibilityPresetFlags(std::string &flags, + cmGeneratorTarget const* target, const std::string& lang); void AddConfigVariableFlags(std::string& flags, const std::string& var, const std::string& config); - void AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, + void AddCompilerRequirementFlag(std::string &flags, + cmGeneratorTarget const* target, const std::string& lang); ///! Append flags to a string. virtual void AppendFlags(std::string& flags, const std::string& newFlags); @@ -112,6 +115,23 @@ public: bool forResponseFile = false, const std::string& config = ""); + const std::vector<cmGeneratorTarget*> &GetGeneratorTargets() const + { + return this->GeneratorTargets; + } + + const std::vector<cmGeneratorTarget*> &GetImportedGeneratorTargets() const + { + return this->ImportedGeneratorTargets; + } + + void AddGeneratorTarget(cmGeneratorTarget* gt); + void AddImportedGeneratorTarget(cmGeneratorTarget* gt); + void AddOwnedImportedGeneratorTarget(cmGeneratorTarget* gt); + + cmGeneratorTarget* FindGeneratorTarget(const std::string& name) const; + cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const; + /** * Encode a list of preprocessor definitions for the compiler * command line. @@ -171,23 +191,25 @@ public: /** Get the include flags for the current makefile and language. */ void GetIncludeDirectories(std::vector<std::string>& dirs, - cmGeneratorTarget* target, + cmGeneratorTarget const* target, const std::string& lang = "C", const std::string& config = "", bool stripImplicitInclDirs = true) const; - void AddCompileOptions(std::string& flags, cmTarget* target, + void AddCompileOptions(std::string& flags, cmGeneratorTarget* target, const std::string& lang, const std::string& config); void AddCompileDefinitions(std::set<std::string>& defines, - cmTarget const* target, + cmGeneratorTarget const* target, const std::string& config, const std::string& lang); + std::string GetProjectName() const; + /** Compute the language used to compile the given source file. */ std::string GetSourceFileLanguage(const cmSourceFile& source); // Fill the vector with the target names for the object files, // preprocessed files and assembly files. - virtual void GetIndividualFileTargets(std::vector<std::string>&) {} + void GetIndividualFileTargets(std::vector<std::string>&) {} // Create a struct to hold the varibles passed into // ExpandRuleVariables @@ -197,7 +219,7 @@ public: { memset(this, 0, sizeof(*this)); } - cmTarget* CMTarget; + cmGeneratorTarget* CMTarget; const char* TargetPDB; const char* TargetCompilePDB; const char* TargetVersionMajor; @@ -219,6 +241,7 @@ public: const char* TargetSOName; const char* TargetInstallNameDir; const char* LinkFlags; + const char* Manifests; const char* LanguageCompileFlags; const char* Defines; const char* Includes; @@ -231,7 +254,8 @@ public: * Get the relative path from the generator output directory to a * per-target support directory. */ - virtual std::string GetTargetDirectory(cmTarget const& target) const; + virtual std::string + GetTargetDirectory(cmGeneratorTarget const* target) const; /** * Get the level of backwards compatibility requested by the project @@ -250,16 +274,27 @@ public: */ bool NeedBackwardsCompatibility_2_4(); + cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id) const; + + cmake* GetCMakeInstance() const; + + const char* GetSourceDirectory() const; + const char* GetBinaryDirectory() const; + + const char* GetCurrentBinaryDirectory() const; + const char* GetCurrentSourceDirectory() const; + /** * Generate a Mac OS X application bundle Info.plist file. */ - void GenerateAppleInfoPList(cmTarget* target, const std::string& targetName, + void GenerateAppleInfoPList(cmGeneratorTarget* target, + const std::string& targetName, const char* fname); /** * Generate a Mac OS X framework Info.plist file. */ - void GenerateFrameworkInfoPList(cmTarget* target, + void GenerateFrameworkInfoPList(cmGeneratorTarget* target, const std::string& targetName, const char* fname); /** Construct a comment for a custom command. */ @@ -273,7 +308,7 @@ public: /** Fill out the static linker flags for the given target. */ void GetStaticLibraryFlags(std::string& flags, std::string const& config, - cmTarget* target); + cmGeneratorTarget* target); /** Fill out these strings for the given target. Libraries to link, * flags, and linkflags. */ @@ -299,7 +334,6 @@ public: void CreateEvaluationFileOutputs(const std::string& config); void ProcessEvaluationFiles(std::vector<std::string>& generatedFiles); - void ComputeObjectMaxPath(); protected: ///! put all the libraries for a target on into the given stream void OutputLinkLibraries(std::string& linkLibraries, @@ -317,8 +351,9 @@ protected: std::string ExpandRuleVariable(std::string const& variable, const RuleVariables& replaceValues); - const char* GetRuleLauncher(cmTarget* target, const std::string& prop); - void InsertRuleLauncher(std::string& s, cmTarget* target, + const char* GetRuleLauncher(cmGeneratorTarget* target, + const std::string& prop); + void InsertRuleLauncher(std::string& s, cmGeneratorTarget* target, const std::string& prop); // Handle old-style install rules stored in the targets. @@ -343,7 +378,11 @@ protected: std::string::size_type ObjectPathMax; std::set<std::string> ObjectMaxPathViolations; - std::set<cmTarget const*> WarnCMP0063; + std::set<cmGeneratorTarget const*> WarnCMP0063; + std::vector<cmGeneratorTarget*> GeneratorTargets; + std::vector<cmGeneratorTarget*> ImportedGeneratorTargets; + std::vector<cmGeneratorTarget*> OwnedImportedGeneratorTargets; + std::map<std::string, std::string> AliasTargets; bool EmitUniversalBinaryFlags; @@ -359,6 +398,8 @@ private: bool GetShouldUseOldFlags(bool shared, const std::string &lang) const; void AddPositionIndependentFlags(std::string& flags, std::string const& l, int targetType); + + void ComputeObjectMaxPath(); }; #endif diff --git a/Source/cmLocalGhsMultiGenerator.cxx b/Source/cmLocalGhsMultiGenerator.cxx index bac989f..a77a75e 100644 --- a/Source/cmLocalGhsMultiGenerator.cxx +++ b/Source/cmLocalGhsMultiGenerator.cxx @@ -26,17 +26,16 @@ cmLocalGhsMultiGenerator::~cmLocalGhsMultiGenerator() {} void cmLocalGhsMultiGenerator::Generate() { - cmGeneratorTargetsType tgts = this->GetMakefile()->GetGeneratorTargets(); + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); - for (cmGeneratorTargetsType::iterator l = tgts.begin(); l != tgts.end(); - ++l) + for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if (l->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY - || l->second->Target->IsImported()) + if ((*l)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - cmGhsMultiTargetGenerator tg(l->second); + cmGhsMultiTargetGenerator tg(*l); tg.Generate(); } } diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx index 7525bf2..ecaa269 100644 --- a/Source/cmLocalNinjaGenerator.cxx +++ b/Source/cmLocalNinjaGenerator.cxx @@ -42,7 +42,7 @@ void cmLocalNinjaGenerator::Generate() // Compute the path to use when referencing the current output // directory from the top output directory. this->HomeRelativeOutputPath = - this->Convert(this->Makefile->GetCurrentBinaryDirectory(), HOME_OUTPUT); + this->Convert(this->GetCurrentBinaryDirectory(), HOME_OUTPUT); if(this->HomeRelativeOutputPath == ".") { this->HomeRelativeOutputPath = ""; @@ -56,7 +56,7 @@ void cmLocalNinjaGenerator::Generate() #endif // We do that only once for the top CMakeLists.txt file. - if(this->Makefile->IsRootMakefile()) + if(this->IsRootMakefile()) { this->WriteBuildFileTop(); @@ -73,24 +73,23 @@ void cmLocalNinjaGenerator::Generate() } } - cmGeneratorTargetsType targets = this->GetMakefile()->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - if (t->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY - || t->second->Target->IsImported()) + if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(t->second); + cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(*t); if(tg) { tg->Generate(); // Add the target to "all" if required. if (!this->GetGlobalNinjaGenerator()->IsExcluded( this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0], - t->second)) - this->GetGlobalNinjaGenerator()->AddDependencyToAll(t->second->Target); + *t)) + this->GetGlobalNinjaGenerator()->AddDependencyToAll(*t); delete tg; } } @@ -100,10 +99,10 @@ void cmLocalNinjaGenerator::Generate() // TODO: Picked up from cmLocalUnixMakefileGenerator3. Refactor it. std::string cmLocalNinjaGenerator -::GetTargetDirectory(cmTarget const& target) const +::GetTargetDirectory(cmGeneratorTarget const* target) const { std::string dir = cmake::GetCMakeFilesDirectoryPostSlash(); - dir += target.GetName(); + dir += target->GetName(); #if defined(__VMS) dir += "_dir"; #else @@ -183,7 +182,7 @@ void cmLocalNinjaGenerator::WriteProjectHeader(std::ostream& os) { cmGlobalNinjaGenerator::WriteDivider(os); os - << "# Project: " << this->GetMakefile()->GetProjectName() << std::endl + << "# Project: " << this->GetProjectName() << std::endl << "# Configuration: " << this->ConfigName << std::endl ; cmGlobalNinjaGenerator::WriteDivider(os); @@ -278,31 +277,22 @@ void cmLocalNinjaGenerator::WriteProcessedMakefile(std::ostream& os) << "# Write statements declared in CMakeLists.txt:" << std::endl << "# " << this->Makefile->GetDefinition("CMAKE_CURRENT_LIST_FILE") << std::endl; - if(this->Makefile->IsRootMakefile()) + if(this->IsRootMakefile()) os << "# Which is the root file." << std::endl; cmGlobalNinjaGenerator::WriteDivider(os); os << std::endl; } -std::string cmLocalNinjaGenerator::ConvertToNinjaPath(const std::string& path) -{ - std::string convPath = this->Convert(path, cmLocalGenerator::HOME_OUTPUT); -#ifdef _WIN32 - cmSystemTools::ReplaceString(convPath, "/", "\\"); -#endif - return convPath; -} - void cmLocalNinjaGenerator -::AppendTargetOutputs(cmTarget* target, cmNinjaDeps& outputs) +::AppendTargetOutputs(cmGeneratorTarget* target, cmNinjaDeps& outputs) { this->GetGlobalNinjaGenerator()->AppendTargetOutputs(target, outputs); } void cmLocalNinjaGenerator -::AppendTargetDepends(cmTarget* target, cmNinjaDeps& outputs) +::AppendTargetDepends(cmGeneratorTarget* target, cmNinjaDeps& outputs) { this->GetGlobalNinjaGenerator()->AppendTargetDepends(target, outputs); } @@ -316,7 +306,8 @@ void cmLocalNinjaGenerator::AppendCustomCommandDeps( i != deps.end(); ++i) { std::string dep; if (this->GetRealDependency(*i, this->GetConfigName(), dep)) - ninjaDeps.push_back(ConvertToNinjaPath(dep)); + ninjaDeps.push_back( + this->GetGlobalNinjaGenerator()->ConvertToNinjaPath(dep)); } } @@ -371,7 +362,7 @@ void cmLocalNinjaGenerator::AppendCustomCommandLines( if (ccg.GetNumberOfCommands() > 0) { std::string wd = ccg.GetWorkingDirectory(); if (wd.empty()) - wd = this->GetMakefile()->GetCurrentBinaryDirectory(); + wd = this->GetCurrentBinaryDirectory(); std::ostringstream cdCmd; #ifdef _WIN32 @@ -413,9 +404,11 @@ cmLocalNinjaGenerator::WriteCustomCommandBuildStatement( at us. How to know which ExternalProject step actually provides it? #endif std::transform(outputs.begin(), outputs.end(), - ninjaOutputs.begin(), MapToNinjaPath()); + ninjaOutputs.begin(), + this->GetGlobalNinjaGenerator()->MapToNinjaPath()); std::transform(byproducts.begin(), byproducts.end(), - ninjaOutputs.begin() + outputs.size(), MapToNinjaPath()); + ninjaOutputs.begin() + outputs.size(), + this->GetGlobalNinjaGenerator()->MapToNinjaPath()); this->AppendCustomCommandDeps(ccg, ninjaDeps); for (cmNinjaDeps::iterator i = ninjaOutputs.begin(); i != ninjaOutputs.end(); @@ -448,7 +441,7 @@ cmLocalNinjaGenerator::WriteCustomCommandBuildStatement( } void cmLocalNinjaGenerator::AddCustomCommandTarget(cmCustomCommand const* cc, - cmTarget* target) + cmGeneratorTarget* target) { this->CustomCommandTargets[cc].insert(target); } @@ -466,7 +459,7 @@ void cmLocalNinjaGenerator::WriteCustomCommandBuildStatements() // // FIXME: This won't work in certain obscure scenarios involving indirect // dependencies. - std::set<cmTarget*>::iterator j = i->second.begin(); + std::set<cmGeneratorTarget*>::iterator j = i->second.begin(); assert(j != i->second.end()); std::vector<std::string> ccTargetDeps; this->AppendTargetDepends(*j, ccTargetDeps); diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h index 8d3d49c..b6987ef 100644 --- a/Source/cmLocalNinjaGenerator.h +++ b/Source/cmLocalNinjaGenerator.h @@ -37,7 +37,8 @@ public: virtual void Generate(); - virtual std::string GetTargetDirectory(cmTarget const& target) const; + virtual + std::string GetTargetDirectory(cmGeneratorTarget const* target) const; const cmGlobalNinjaGenerator* GetGlobalNinjaGenerator() const; cmGlobalNinjaGenerator* GetGlobalNinjaGenerator(); @@ -50,21 +51,6 @@ public: std::string GetHomeRelativeOutputPath() const { return this->HomeRelativeOutputPath; } - std::string ConvertToNinjaPath(const std::string& path); - - struct map_to_ninja_path { - cmLocalNinjaGenerator *LocalGenerator; - map_to_ninja_path(cmLocalNinjaGenerator *LocalGen) - : LocalGenerator(LocalGen) {} - std::string operator()(const std::string &path) { - return LocalGenerator->ConvertToNinjaPath(path); - } - }; - - map_to_ninja_path MapToNinjaPath() { - return map_to_ninja_path(this); - } - void ExpandRuleVariables(std::string& string, const RuleVariables& replaceValues) { cmLocalGenerator::ExpandRuleVariables(string, replaceValues); @@ -72,10 +58,11 @@ public: std::string BuildCommandLine(const std::vector<std::string> &cmdLines); - void AppendTargetOutputs(cmTarget* target, cmNinjaDeps& outputs); - void AppendTargetDepends(cmTarget* target, cmNinjaDeps& outputs); + void AppendTargetOutputs(cmGeneratorTarget* target, cmNinjaDeps& outputs); + void AppendTargetDepends(cmGeneratorTarget* target, cmNinjaDeps& outputs); - void AddCustomCommandTarget(cmCustomCommand const* cc, cmTarget* target); + void AddCustomCommandTarget(cmCustomCommand const* cc, + cmGeneratorTarget* target); void AppendCustomCommandLines(cmCustomCommandGenerator const& ccg, std::vector<std::string> &cmdLines); void AppendCustomCommandDeps(cmCustomCommandGenerator const& ccg, @@ -116,7 +103,7 @@ private: std::string HomeRelativeOutputPath; - typedef std::map<cmCustomCommand const*, std::set<cmTarget*> > + typedef std::map<cmCustomCommand const*, std::set<cmGeneratorTarget*> > CustomCommandTargetMap; CustomCommandTargetMap CustomCommandTargets; }; diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx index b131a63..62fea3d 100644 --- a/Source/cmLocalUnixMakefileGenerator3.cxx +++ b/Source/cmLocalUnixMakefileGenerator3.cxx @@ -113,19 +113,18 @@ void cmLocalUnixMakefileGenerator3::Generate() this->Makefile->IsOn("CMAKE_SKIP_ASSEMBLY_SOURCE_RULES"); // Generate the rule files for each target. - cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); cmGlobalUnixMakefileGenerator3* gg = static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - if (t->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY - || t->second->Target->IsImported()) + if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } cmsys::auto_ptr<cmMakefileTargetGenerator> tg( - cmMakefileTargetGenerator::New(t->second)); + cmMakefileTargetGenerator::New(*t)); if (tg.get()) { tg->WriteRuleFiles(); @@ -145,7 +144,7 @@ void cmLocalUnixMakefileGenerator3::ComputeHomeRelativeOutputPath() // Compute the path to use when referencing the current output // directory from the top output directory. this->HomeRelativeOutputPath = - this->Convert(this->Makefile->GetCurrentBinaryDirectory(), HOME_OUTPUT); + this->Convert(this->GetCurrentBinaryDirectory(), HOME_OUTPUT); if(this->HomeRelativeOutputPath == ".") { this->HomeRelativeOutputPath = ""; @@ -174,13 +173,12 @@ void cmLocalUnixMakefileGenerator3::ComputeObjectFilenames( void cmLocalUnixMakefileGenerator3:: GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles) { - std::set<std::string> emitted; - cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ++ti) { - cmGeneratorTarget* gt = ti->second; - if (gt->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget* gt = *ti; + if (gt->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -189,9 +187,9 @@ GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles) ->GetSafeDefinition("CMAKE_BUILD_TYPE")); // Compute full path to object file directory for this target. std::string dir; - dir += gt->Makefile->GetCurrentBinaryDirectory(); + dir += gt->LocalGenerator->GetCurrentBinaryDirectory(); dir += "/"; - dir += this->GetTargetDirectory(*gt->Target); + dir += this->GetTargetDirectory(gt); dir += "/"; // Compute the name of each object file. for(std::vector<cmSourceFile const*>::iterator @@ -209,7 +207,7 @@ GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles) } LocalObjectInfo& info = localObjectFiles[objectName]; info.HasSourceExtension = hasSourceExtension; - info.push_back(LocalObjectEntry(gt->Target, sf->GetLanguage())); + info.push_back(LocalObjectEntry(gt, sf->GetLanguage())); } } } @@ -255,7 +253,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile() return; } // always write the top makefile - if (!this->GetMakefile()->IsRootMakefile()) + if (!this->IsRootMakefile()) { ruleFileStream.SetCopyIfDifferent(true); } @@ -266,7 +264,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile() // only write local targets unless at the top Keep track of targets already // listed. std::set<std::string> emittedTargets; - if (!this->GetMakefile()->IsRootMakefile()) + if (!this->IsRootMakefile()) { // write our targets, and while doing it collect up the object // file rules @@ -389,7 +387,7 @@ cmLocalUnixMakefileGenerator3 t != info.end(); ++t) { std::string tgtMakefileName = - this->GetRelativeTargetDirectory(*(t->Target)); + this->GetRelativeTargetDirectory(t->Target); std::string targetName = tgtMakefileName; tgtMakefileName += "/build.make"; targetName += "/"; @@ -399,7 +397,7 @@ cmLocalUnixMakefileGenerator3 ); } this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); // Write the rule to the makefile. @@ -418,27 +416,22 @@ void cmLocalUnixMakefileGenerator3 // for each target we just provide a rule to cd up to the top and do a make // on the target - cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); std::string localName; - for(cmGeneratorTargetsType::iterator t = targets.begin(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - if((t->second->GetType() == cmTarget::EXECUTABLE) || - (t->second->GetType() == cmTarget::STATIC_LIBRARY) || - (t->second->GetType() == cmTarget::SHARED_LIBRARY) || - (t->second->GetType() == cmTarget::MODULE_LIBRARY) || - (t->second->GetType() == cmTarget::OBJECT_LIBRARY) || - (t->second->GetType() == cmTarget::UTILITY)) + if(((*t)->GetType() == cmState::EXECUTABLE) || + ((*t)->GetType() == cmState::STATIC_LIBRARY) || + ((*t)->GetType() == cmState::SHARED_LIBRARY) || + ((*t)->GetType() == cmState::MODULE_LIBRARY) || + ((*t)->GetType() == cmState::OBJECT_LIBRARY) || + ((*t)->GetType() == cmState::UTILITY)) { - if (t->second->Target->IsImported()) - { - continue; - } - - emitted.insert(t->second->GetName()); + emitted.insert((*t)->GetName()); // for subdirs add a rule to build this specific target by name. - localName = this->GetRelativeTargetDirectory(*t->second->Target); + localName = this->GetRelativeTargetDirectory(*t); localName += "/rule"; commands.clear(); depends.clear(); @@ -449,54 +442,54 @@ void cmLocalUnixMakefileGenerator3 commands.push_back(this->GetRecursiveMakeCall (makefile2.c_str(),localName)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "Convenience name for target.", localName, depends, commands, true); // Add a target with the canonical name (no prefix, suffix or path). - if(localName != t->second->GetName()) + if(localName != (*t)->GetName()) { commands.clear(); depends.push_back(localName); this->WriteMakeRule(ruleFileStream, "Convenience name for target.", - t->second->GetName(), depends, commands, true); + (*t)->GetName(), depends, commands, true); } // Add a fast rule to build the target std::string makefileName = - this->GetRelativeTargetDirectory(*t->second->Target); + this->GetRelativeTargetDirectory(*t); makefileName += "/build.make"; // make sure the makefile name is suitable for a makefile std::string makeTargetName = - this->GetRelativeTargetDirectory(*t->second->Target); + this->GetRelativeTargetDirectory(*t); makeTargetName += "/build"; - localName = t->second->GetName(); + localName = (*t)->GetName(); localName += "/fast"; depends.clear(); commands.clear(); commands.push_back(this->GetRecursiveMakeCall (makefileName.c_str(), makeTargetName)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "fast build rule for target.", localName, depends, commands, true); // Add a local name for the rule to relink the target before // installation. - if(t->second->NeedRelinkBeforeInstall(this->ConfigName)) + if((*t)->NeedRelinkBeforeInstall(this->ConfigName)) { - makeTargetName = this->GetRelativeTargetDirectory(*t->second->Target); + makeTargetName = this->GetRelativeTargetDirectory(*t); makeTargetName += "/preinstall"; - localName = t->second->GetName(); + localName = (*t)->GetName(); localName += "/preinstall"; depends.clear(); commands.clear(); commands.push_back(this->GetRecursiveMakeCall (makefile2.c_str(), makeTargetName)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "Manual pre-install relink rule for target.", @@ -509,7 +502,7 @@ void cmLocalUnixMakefileGenerator3 //---------------------------------------------------------------------------- void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile() { - std::string infoFileName = this->Makefile->GetCurrentBinaryDirectory(); + std::string infoFileName = this->GetCurrentBinaryDirectory(); infoFileName += cmake::GetCMakeFilesDirectory(); infoFileName += "/CMakeDirectoryInformation.cmake"; @@ -573,7 +566,7 @@ std::string cmLocalUnixMakefileGenerator3 ::ConvertToFullPath(const std::string& localPath) { - std::string dir = this->Makefile->GetCurrentBinaryDirectory(); + std::string dir = this->GetCurrentBinaryDirectory(); dir += "/"; dir += localPath; return dir; @@ -750,13 +743,13 @@ cmLocalUnixMakefileGenerator3 makefileStream << "# The top-level source directory on which CMake was run.\n" << "CMAKE_SOURCE_DIR = " - << this->Convert(this->Makefile->GetHomeDirectory(), FULL, SHELL) + << this->Convert(this->GetSourceDirectory(), FULL, SHELL) << "\n" << "\n"; makefileStream << "# The top-level build directory on which CMake was run.\n" << "CMAKE_BINARY_DIR = " - << this->Convert(this->Makefile->GetHomeOutputDirectory(), FULL, SHELL) + << this->Convert(this->GetBinaryDirectory(), FULL, SHELL) << "\n" << "\n"; } @@ -886,10 +879,10 @@ void cmLocalUnixMakefileGenerator3 std::vector<std::string> no_depends; std::vector<std::string> commands; commands.push_back(runRule); - if(!this->GetMakefile()->IsRootMakefile()) + if(!this->IsRootMakefile()) { this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); } this->WriteMakeRule(makefileStream, @@ -933,7 +926,7 @@ cmLocalUnixMakefileGenerator3 //---------------------------------------------------------------------------- std::string cmLocalUnixMakefileGenerator3 -::GetRelativeTargetDirectory(cmTarget const& target) +::GetRelativeTargetDirectory(cmGeneratorTarget* target) { std::string dir = this->HomeRelativeOutputPath; dir += this->GetTargetDirectory(target); @@ -1034,7 +1027,7 @@ void cmLocalUnixMakefileGenerator3 ::AppendCustomCommands(std::vector<std::string>& commands, const std::vector<cmCustomCommand>& ccs, - cmTarget* target, + cmGeneratorTarget* target, cmLocalGenerator::RelativeRoot relative) { for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin(); @@ -1050,7 +1043,7 @@ void cmLocalUnixMakefileGenerator3 ::AppendCustomCommand(std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg, - cmTarget* target, + cmGeneratorTarget* target, bool echo_comment, cmLocalGenerator::RelativeRoot relative, std::ostream* content) @@ -1070,7 +1063,7 @@ cmLocalUnixMakefileGenerator3 } // if the command specified a working directory use it. - std::string dir = this->Makefile->GetCurrentBinaryDirectory(); + std::string dir = this->GetCurrentBinaryDirectory(); std::string workingDir = ccg.GetWorkingDirectory(); if(!workingDir.empty()) { @@ -1181,7 +1174,7 @@ cmLocalUnixMakefileGenerator3 std::string cmLocalUnixMakefileGenerator3::MakeLauncher( cmCustomCommandGenerator const& ccg, - cmTarget* target, RelativeRoot relative) + cmGeneratorTarget* target, RelativeRoot relative) { // Short-circuit if there is no launcher. const char* prop = "RULE_LAUNCH_CUSTOM"; @@ -1218,9 +1211,9 @@ void cmLocalUnixMakefileGenerator3 ::AppendCleanCommand(std::vector<std::string>& commands, const std::vector<std::string>& files, - cmTarget& target, const char* filename) + cmGeneratorTarget* target, const char* filename) { - std::string cleanfile = this->Makefile->GetCurrentBinaryDirectory(); + std::string cleanfile = this->GetCurrentBinaryDirectory(); cleanfile += "/"; cleanfile += this->GetTargetDirectory(target); cleanfile += "/cmake_clean"; @@ -1256,9 +1249,7 @@ cmLocalUnixMakefileGenerator3 { // Get the set of source languages in the target. std::set<std::string> languages; - cmGeneratorTarget *gtgt = - this->GlobalGenerator->GetGeneratorTarget(&target); - gtgt->GetLanguages(languages, + target->GetLanguages(languages, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); fout << "\n" << "# Per-language clean rules from dependency scanning.\n" @@ -1501,7 +1492,7 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo, // If the directory information is newer than depend.internal, include dirs // may have changed. In this case discard all old dependencies. bool needRescanDirInfo = false; - std::string dirInfoFile = this->Makefile->GetCurrentBinaryDirectory(); + std::string dirInfoFile = this->GetCurrentBinaryDirectory(); dirInfoFile += cmake::GetCMakeFilesDirectory(); dirInfoFile += "/CMakeDirectoryInformation.cmake"; { @@ -1575,7 +1566,7 @@ cmLocalUnixMakefileGenerator3 // Read the directory information file. cmMakefile* mf = this->Makefile; bool haveDirectoryInfo = false; - std::string dirInfoFile = this->Makefile->GetCurrentBinaryDirectory(); + std::string dirInfoFile = this->GetCurrentBinaryDirectory(); dirInfoFile += cmake::GetCMakeFilesDirectory(); dirInfoFile += "/CMakeDirectoryInformation.cmake"; if(mf->ReadListFile(dirInfoFile.c_str()) && @@ -1770,40 +1761,43 @@ void cmLocalUnixMakefileGenerator3 ruleFileStream << "# Targets provided globally by CMake.\n" << "\n"; - cmTargets* targets = &(this->Makefile->GetTargets()); - cmTargets::iterator glIt; - for ( glIt = targets->begin(); glIt != targets->end(); ++ glIt ) + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + std::vector<cmGeneratorTarget*>::iterator glIt; + for ( glIt = targets.begin(); glIt != targets.end(); ++ glIt ) { - if ( glIt->second.GetType() == cmTarget::GLOBAL_TARGET ) + if ( (*glIt)->GetType() == cmState::GLOBAL_TARGET ) { - std::string targetString = "Special rule for the target " + glIt->first; + std::string targetString = "Special rule for the target " + + (*glIt)->GetName(); std::vector<std::string> commands; std::vector<std::string> depends; - const char* text = glIt->second.GetProperty("EchoString"); + const char* text = (*glIt)->GetProperty("EchoString"); if ( !text ) { text = "Running external command ..."; } - depends.insert(depends.end(), glIt->second.GetUtilities().begin(), - glIt->second.GetUtilities().end()); + depends.insert(depends.end(), (*glIt)->GetUtilities().begin(), + (*glIt)->GetUtilities().end()); this->AppendEcho(commands, text, cmLocalUnixMakefileGenerator3::EchoGlobal); + cmGeneratorTarget* gt = *glIt; + // Global targets store their rules in pre- and post-build commands. this->AppendCustomDepends(depends, - glIt->second.GetPreBuildCommands()); + gt->GetPreBuildCommands()); this->AppendCustomDepends(depends, - glIt->second.GetPostBuildCommands()); + gt->GetPostBuildCommands()); this->AppendCustomCommands(commands, - glIt->second.GetPreBuildCommands(), - &glIt->second, + gt->GetPreBuildCommands(), + gt, cmLocalGenerator::START_OUTPUT); this->AppendCustomCommands(commands, - glIt->second.GetPostBuildCommands(), - &glIt->second, + gt->GetPostBuildCommands(), + gt, cmLocalGenerator::START_OUTPUT); - std::string targetName = glIt->second.GetName(); + std::string targetName = gt->GetName(); this->WriteMakeRule(ruleFileStream, targetString.c_str(), targetName, depends, commands, true); @@ -1833,12 +1827,12 @@ void cmLocalUnixMakefileGenerator3 std::vector<std::string> commands; // Write the all rule. - std::string recursiveTarget = this->Makefile->GetCurrentBinaryDirectory(); + std::string recursiveTarget = this->GetCurrentBinaryDirectory(); recursiveTarget += "/all"; depends.push_back("cmake_check_build_system"); - std::string progressDir = this->Makefile->GetHomeOutputDirectory(); + std::string progressDir = this->GetBinaryDirectory(); progressDir += cmake::GetCMakeFilesDirectory(); { std::ostringstream progCmd; @@ -1862,7 +1856,7 @@ void cmLocalUnixMakefileGenerator3 commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); { std::ostringstream progCmd; @@ -1877,14 +1871,14 @@ void cmLocalUnixMakefileGenerator3 depends, commands, true); // Write the clean rule. - recursiveTarget = this->Makefile->GetCurrentBinaryDirectory(); + recursiveTarget = this->GetCurrentBinaryDirectory(); recursiveTarget += "/clean"; commands.clear(); depends.clear(); commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "The main clean target", "clean", depends, commands, true); @@ -1895,7 +1889,7 @@ void cmLocalUnixMakefileGenerator3 depends, commands, true); // Write the preinstall rule. - recursiveTarget = this->Makefile->GetCurrentBinaryDirectory(); + recursiveTarget = this->GetCurrentBinaryDirectory(); recursiveTarget += "/preinstall"; commands.clear(); depends.clear(); @@ -1914,7 +1908,7 @@ void cmLocalUnixMakefileGenerator3 commands.push_back (this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.", "preinstall", depends, commands, true); @@ -1935,7 +1929,7 @@ void cmLocalUnixMakefileGenerator3 runRule += " 1"; commands.push_back(runRule); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "clear depends", "depend", @@ -1978,7 +1972,8 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf, void cmLocalUnixMakefileGenerator3 -::WriteDependLanguageInfo(std::ostream& cmakefileStream, cmTarget &target) +::WriteDependLanguageInfo(std::ostream& cmakefileStream, + cmGeneratorTarget* target) { ImplicitDependLanguageMap const& implicitLangs = this->GetImplicitDepends(target); @@ -2032,7 +2027,7 @@ void cmLocalUnixMakefileGenerator3 // Build a list of preprocessor definitions for the target. std::set<std::string> defines; - this->AddCompileDefinitions(defines, &target, + this->AddCompileDefinitions(defines, target, this->ConfigName, l->first); if(!defines.empty()) { @@ -2058,12 +2053,10 @@ void cmLocalUnixMakefileGenerator3 << "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n"; std::vector<std::string> includes; - cmGeneratorTarget* gt = this->GetGlobalGenerator() - ->GetGeneratorTarget(&target); const std::string& config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); - this->GetIncludeDirectories(includes, gt, + this->GetIncludeDirectories(includes, target, l->first, config); for(std::vector<std::string>::iterator i = includes.begin(); i != includes.end(); ++i) @@ -2086,7 +2079,7 @@ void cmLocalUnixMakefileGenerator3 cmSystemTools::ExpandListArgument(xform, transformRules); } if(const char* xform = - target.GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) + target->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) { cmSystemTools::ExpandListArgument(xform, transformRules); } @@ -2284,10 +2277,10 @@ cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p, //---------------------------------------------------------------------------- std::string cmLocalUnixMakefileGenerator3 -::GetTargetDirectory(cmTarget const& target) const +::GetTargetDirectory(cmGeneratorTarget const* target) const { std::string dir = cmake::GetCMakeFilesDirectoryPostSlash(); - dir += target.GetName(); + dir += target->GetName(); #if defined(__VMS) dir += "_dir"; #else @@ -2298,19 +2291,20 @@ cmLocalUnixMakefileGenerator3 //---------------------------------------------------------------------------- cmLocalUnixMakefileGenerator3::ImplicitDependLanguageMap const& -cmLocalUnixMakefileGenerator3::GetImplicitDepends(cmTarget const& tgt) +cmLocalUnixMakefileGenerator3::GetImplicitDepends( + const cmGeneratorTarget* tgt) { - return this->ImplicitDepends[tgt.GetName()]; + return this->ImplicitDepends[tgt->GetName()]; } //---------------------------------------------------------------------------- void -cmLocalUnixMakefileGenerator3::AddImplicitDepends(cmTarget const& tgt, +cmLocalUnixMakefileGenerator3::AddImplicitDepends(const cmGeneratorTarget* tgt, const std::string& lang, const char* obj, const char* src) { - this->ImplicitDepends[tgt.GetName()][lang][obj].push_back(src); + this->ImplicitDepends[tgt->GetName()][lang][obj].push_back(src); } //---------------------------------------------------------------------------- diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h index 98f15e6..8f69311 100644 --- a/Source/cmLocalUnixMakefileGenerator3.h +++ b/Source/cmLocalUnixMakefileGenerator3.h @@ -19,10 +19,8 @@ class cmCustomCommand; class cmCustomCommandGenerator; -class cmDependInformation; class cmDepends; class cmMakefileTargetGenerator; -class cmTarget; class cmSourceFile; /** \class cmLocalUnixMakefileGenerator3 @@ -106,7 +104,8 @@ public: /** Get whether the makefile is to have color. */ bool GetColorMakefile() const { return this->ColorMakefile; } - virtual std::string GetTargetDirectory(cmTarget const& target) const; + virtual + std::string GetTargetDirectory(cmGeneratorTarget const* target) const; // create a command that cds to the start dir then runs the commands void CreateCDCommand(std::vector<std::string>& commands, @@ -131,7 +130,7 @@ public: void WriteSpecialTargetsTop(std::ostream& makefileStream); void WriteSpecialTargetsBottom(std::ostream& makefileStream); - std::string GetRelativeTargetDirectory(cmTarget const& target); + std::string GetRelativeTargetDirectory(cmGeneratorTarget* target); // File pairs for implicit dependency scanning. The key of the map // is the depender and the value is the explicit dependee. @@ -141,9 +140,11 @@ public: public std::map<std::string, ImplicitDependFileMap> {}; struct ImplicitDependTargetMap: public std::map<std::string, ImplicitDependLanguageMap> {}; - ImplicitDependLanguageMap const& GetImplicitDepends(cmTarget const& tgt); + ImplicitDependLanguageMap const& + GetImplicitDepends(cmGeneratorTarget const* tgt); - void AddImplicitDepends(cmTarget const& tgt, const std::string& lang, + void AddImplicitDepends(cmGeneratorTarget const* tgt, + const std::string& lang, const char* obj, const char* src); // write the target rules for the local Makefile into the stream @@ -181,7 +182,8 @@ protected: // write the depend info - void WriteDependLanguageInfo(std::ostream& cmakefileStream, cmTarget &tgt); + void WriteDependLanguageInfo(std::ostream& cmakefileStream, + cmGeneratorTarget *tgt); // write the local help rule void WriteHelpRule(std::ostream& ruleFileStream); @@ -196,12 +198,12 @@ protected: const std::string& helpTarget); void WriteTargetDependRule(std::ostream& ruleFileStream, - cmTarget& target); + cmGeneratorTarget* target); void WriteTargetCleanRule(std::ostream& ruleFileStream, - cmTarget& target, + cmGeneratorTarget* target, const std::vector<std::string>& files); void WriteTargetRequiresRule(std::ostream& ruleFileStream, - cmTarget& target, + cmGeneratorTarget* target, const std::vector<std::string>& objects); void AppendRuleDepend(std::vector<std::string>& depends, @@ -214,19 +216,19 @@ protected: cmCustomCommandGenerator const& cc); void AppendCustomCommands(std::vector<std::string>& commands, const std::vector<cmCustomCommand>& ccs, - cmTarget* target, + cmGeneratorTarget* target, cmLocalGenerator::RelativeRoot relative = cmLocalGenerator::HOME_OUTPUT); void AppendCustomCommand(std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg, - cmTarget* target, + cmGeneratorTarget* target, bool echo_comment=false, cmLocalGenerator::RelativeRoot relative = cmLocalGenerator::HOME_OUTPUT, std::ostream* content = 0); void AppendCleanCommand(std::vector<std::string>& commands, const std::vector<std::string>& files, - cmTarget& target, const char* filename =0); + cmGeneratorTarget* target, const char* filename =0); // Helper methods for dependeny updates. bool ScanDependencies(const char* targetDir, @@ -236,7 +238,7 @@ protected: private: std::string ConvertShellCommand(std::string const& cmd, RelativeRoot root); std::string MakeLauncher(cmCustomCommandGenerator const& ccg, - cmTarget* target, RelativeRoot relative); + cmGeneratorTarget* target, RelativeRoot relative); virtual void ComputeObjectFilenames( std::map<cmSourceFile const*, std::string>& mapping, @@ -254,10 +256,10 @@ private: struct LocalObjectEntry { - cmTarget* Target; + cmGeneratorTarget* Target; std::string Language; LocalObjectEntry(): Target(0), Language() {} - LocalObjectEntry(cmTarget* t, const std::string& lang): + LocalObjectEntry(cmGeneratorTarget* t, const std::string& lang): Target(t), Language(lang) {} }; struct LocalObjectInfo: public std::vector<LocalObjectEntry> diff --git a/Source/cmLocalVisualStudio10Generator.cxx b/Source/cmLocalVisualStudio10Generator.cxx index b043b00..d0784ad 100644 --- a/Source/cmLocalVisualStudio10Generator.cxx +++ b/Source/cmLocalVisualStudio10Generator.cxx @@ -10,7 +10,6 @@ See the License for more information. ============================================================================*/ #include "cmLocalVisualStudio10Generator.h" -#include "cmTarget.h" #include "cmMakefile.h" #include "cmVisualStudio10TargetGenerator.h" #include "cmGlobalVisualStudio10Generator.h" @@ -74,22 +73,23 @@ cmLocalVisualStudio10Generator::~cmLocalVisualStudio10Generator() void cmLocalVisualStudio10Generator::Generate() { - cmTargets &tgts = this->Makefile->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if(l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if((*l)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } if(static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator) - ->TargetIsFortranOnly(l->second)) + ->TargetIsFortranOnly(*l)) { - this->CreateSingleVCProj(l->first.c_str(),l->second); + this->CreateSingleVCProj((*l)->GetName().c_str(), *l); } else { cmVisualStudio10TargetGenerator tg( - &l->second, static_cast<cmGlobalVisualStudio10Generator*>( + *l, static_cast<cmGlobalVisualStudio10Generator*>( this->GetGlobalGenerator())); tg.Generate(); } diff --git a/Source/cmLocalVisualStudio6Generator.cxx b/Source/cmLocalVisualStudio6Generator.cxx index cc94cd4..cdacb9e 100644 --- a/Source/cmLocalVisualStudio6Generator.cxx +++ b/Source/cmLocalVisualStudio6Generator.cxx @@ -82,12 +82,12 @@ private: void cmLocalVisualStudio6Generator::AddCMakeListsRules() { - cmTargets &tgts = this->Makefile->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); - l != tgts.end(); l++) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if (l->second.GetType() == cmTarget::INTERFACE_LIBRARY - || l->second.GetType() == cmTarget::GLOBAL_TARGET) + if ((*l)->GetType() == cmState::INTERFACE_LIBRARY + || (*l)->GetType() == cmState::GLOBAL_TARGET) { continue; } @@ -98,7 +98,7 @@ void cmLocalVisualStudio6Generator::AddCMakeListsRules() this->Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION"); if (!cmSystemTools::IsOn(suppRegenRule)) { - this->AddDSPBuildRule(l->second); + this->AddDSPBuildRule(*l); } } } @@ -111,67 +111,69 @@ void cmLocalVisualStudio6Generator::Generate() void cmLocalVisualStudio6Generator::OutputDSPFile() { // If not an in source build, then create the output directory - if(strcmp(this->Makefile->GetCurrentBinaryDirectory(), - this->Makefile->GetHomeDirectory()) != 0) + if(strcmp(this->GetCurrentBinaryDirectory(), + this->GetSourceDirectory()) != 0) { if(!cmSystemTools::MakeDirectory - (this->Makefile->GetCurrentBinaryDirectory())) + (this->GetCurrentBinaryDirectory())) { cmSystemTools::Error("Error creating directory ", - this->Makefile->GetCurrentBinaryDirectory()); + this->GetCurrentBinaryDirectory()); } } // Create the DSP or set of DSP's for libraries and executables - cmTargets &tgts = this->Makefile->GetTargets(); - - // build any targets - for(cmTargets::iterator l = tgts.begin(); - l != tgts.end(); l++) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - switch(l->second.GetType()) + switch((*l)->GetType()) { - case cmTarget::STATIC_LIBRARY: - case cmTarget::OBJECT_LIBRARY: - this->SetBuildType(STATIC_LIBRARY, l->first.c_str(), l->second); + case cmState::STATIC_LIBRARY: + case cmState::OBJECT_LIBRARY: + this->SetBuildType(STATIC_LIBRARY, + (*l)->GetName().c_str(), *l); break; - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - this->SetBuildType(DLL, l->first.c_str(), l->second); + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + this->SetBuildType(DLL, + (*l)->GetName().c_str(), *l); break; - case cmTarget::EXECUTABLE: - this->SetBuildType(EXECUTABLE,l->first.c_str(), l->second); + case cmState::EXECUTABLE: + this->SetBuildType(EXECUTABLE, + (*l)->GetName().c_str(), *l); break; - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: - this->SetBuildType(UTILITY, l->first.c_str(), l->second); + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: + this->SetBuildType(UTILITY, + (*l)->GetName().c_str(), *l); break; - case cmTarget::INTERFACE_LIBRARY: + case cmState::INTERFACE_LIBRARY: continue; default: - cmSystemTools::Error("Bad target type: ", l->first.c_str()); + cmSystemTools::Error("Bad target type: ", (*l)->GetName().c_str()); break; } // INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace // so don't build a projectfile for it const char* path = - l->second.GetProperty("EXTERNAL_MSPROJECT"); + (*l)->GetProperty("EXTERNAL_MSPROJECT"); if(!path) { // check to see if the dsp is going into a sub-directory - std::string::size_type pos = l->first.rfind('/'); + std::string::size_type pos = (*l)->GetName().rfind('/'); if(pos != std::string::npos) { - std::string dir = this->Makefile->GetCurrentBinaryDirectory(); + std::string dir = this->GetCurrentBinaryDirectory(); dir += "/"; - dir += l->first.substr(0, pos); + dir += (*l)->GetName().substr(0, pos); if(!cmSystemTools::MakeDirectory(dir.c_str())) { cmSystemTools::Error("Error creating directory: ", dir.c_str()); } } - this->CreateSingleDSP(l->first.c_str(),l->second); + this->CreateSingleDSP((*l)->GetName().c_str(), *l); } } } @@ -182,14 +184,14 @@ void cmLocalVisualStudio6Generator::OutputDSPFile() extern std::string GetVS6TargetName(const std::string& targetName); void cmLocalVisualStudio6Generator::CreateSingleDSP(const std::string& lname, - cmTarget &target) + cmGeneratorTarget* target) { // add to the list of projects std::string pname = GetVS6TargetName(lname); // create the dsp.cmake file std::string fname; - fname = this->Makefile->GetCurrentBinaryDirectory(); + fname = this->GetCurrentBinaryDirectory(); fname += "/"; fname += pname; fname += ".dsp"; @@ -209,13 +211,13 @@ void cmLocalVisualStudio6Generator::CreateSingleDSP(const std::string& lname, } -void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt) +void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmGeneratorTarget *tgt) { - std::string dspname = GetVS6TargetName(tgt.GetName()); + std::string dspname = GetVS6TargetName(tgt->GetName()); dspname += ".dsp.cmake"; cmCustomCommandLine commandLine; commandLine.push_back(cmSystemTools::GetCMakeCommand()); - std::string makefileIn = this->Makefile->GetCurrentSourceDirectory(); + std::string makefileIn = this->GetCurrentSourceDirectory(); makefileIn += "/"; makefileIn += "CMakeLists.txt"; if(!cmSystemTools::FileExists(makefileIn.c_str())) @@ -226,10 +228,10 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt) comment += makefileIn; std::string args; args = "-H"; - args += this->Makefile->GetHomeDirectory(); + args += this->GetSourceDirectory(); commandLine.push_back(args); args = "-B"; - args += this->Makefile->GetHomeOutputDirectory(); + args += this->GetBinaryDirectory(); commandLine.push_back(args); std::vector<std::string> const& listFiles = this->Makefile->GetListFiles(); @@ -243,7 +245,7 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt) no_working_directory, true); if(this->Makefile->GetSource(makefileIn.c_str())) { - tgt.AddSource(makefileIn); + tgt->AddSource(makefileIn); } else { @@ -254,7 +256,7 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt) void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, const std::string& libName, - cmTarget &target) + cmGeneratorTarget *target) { // For utility targets need custom command since pre- and post- // build does not do anything in Visual Studio 6. In order for the @@ -262,23 +264,23 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, // special care for dependencies. The first rule must depend on all // the dependencies of all the rules. The later rules must each // depend only on the previous rule. - if ((target.GetType() == cmTarget::UTILITY || - target.GetType() == cmTarget::GLOBAL_TARGET) && - (!target.GetPreBuildCommands().empty() || - !target.GetPostBuildCommands().empty())) + if ((target->GetType() == cmState::UTILITY || + target->GetType() == cmState::GLOBAL_TARGET) && + (!target->GetPreBuildCommands().empty() || + !target->GetPostBuildCommands().empty())) { // Accumulate the dependencies of all the commands. std::vector<std::string> depends; for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetPreBuildCommands().begin(); - cr != target.GetPreBuildCommands().end(); ++cr) + target->GetPreBuildCommands().begin(); + cr != target->GetPreBuildCommands().end(); ++cr) { depends.insert(depends.end(), cr->GetDepends().begin(), cr->GetDepends().end()); } for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetPostBuildCommands().begin(); - cr != target.GetPostBuildCommands().end(); ++cr) + target->GetPostBuildCommands().begin(); + cr != target->GetPostBuildCommands().end(); ++cr) { depends.insert(depends.end(), cr->GetDepends().begin(), cr->GetDepends().end()); @@ -287,14 +289,14 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, // Add the pre- and post-build commands in order. int count = 1; for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetPreBuildCommands().begin(); - cr != target.GetPreBuildCommands().end(); ++cr) + target->GetPreBuildCommands().begin(); + cr != target->GetPreBuildCommands().end(); ++cr) { this->AddUtilityCommandHack(target, count++, depends, *cr); } for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetPostBuildCommands().begin(); - cr != target.GetPostBuildCommands().end(); ++cr) + target->GetPostBuildCommands().begin(); + cr != target->GetPostBuildCommands().end(); ++cr) { this->AddUtilityCommandHack(target, count++, depends, *cr); } @@ -303,12 +305,9 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, // We may be modifying the source groups temporarily, so make a copy. std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups(); - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); - // get the classes from the source lists then add them to the groups std::vector<cmSourceFile*> classes; - if (!gt->GetConfigCommonSourceFiles(classes)) + if (!target->GetConfigCommonSourceFiles(classes)) { return; } @@ -372,11 +371,9 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, } void cmLocalVisualStudio6Generator -::WriteGroup(const cmSourceGroup *sg, cmTarget& target, +::WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target, std::ostream &fout, const std::string& libName) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); const std::vector<const cmSourceFile *> &sourceFiles = sg->GetSourceFiles(); // If the group is empty, don't write it at all. @@ -408,9 +405,10 @@ void cmLocalVisualStudio6Generator std::string compileFlags; std::vector<std::string> depends; std::string objectNameDir; - if(gt->HasExplicitObjectName(*sf)) + if(target->HasExplicitObjectName(*sf)) { - objectNameDir = cmSystemTools::GetFilenamePath(gt->GetObjectName(*sf)); + objectNameDir = + cmSystemTools::GetFilenamePath(target->GetObjectName(*sf)); } // Add per-source file flags. @@ -481,8 +479,8 @@ void cmLocalVisualStudio6Generator cmSystemTools::ExpandListArgument(dependsValue, depends); } if (GetVS6TargetName(source) != libName || - target.GetType() == cmTarget::UTILITY || - target.GetType() == cmTarget::GLOBAL_TARGET) + target->GetType() == cmState::UTILITY || + target->GetType() == cmState::GLOBAL_TARGET) { fout << "# Begin Source File\n\n"; @@ -572,15 +570,15 @@ void cmLocalVisualStudio6Generator void cmLocalVisualStudio6Generator -::AddUtilityCommandHack(cmTarget& target, int count, +::AddUtilityCommandHack(cmGeneratorTarget *target, int count, std::vector<std::string>& depends, const cmCustomCommand& origCommand) { // Create a fake output that forces the rule to run. - char* output = new char[(strlen(this->Makefile->GetCurrentBinaryDirectory()) - + target.GetName().size() + 30)]; - sprintf(output,"%s/%s_force_%i", this->Makefile->GetCurrentBinaryDirectory(), - target.GetName().c_str(), count); + char* output = new char[(strlen(this->GetCurrentBinaryDirectory()) + + target->GetName().size() + 30)]; + sprintf(output,"%s/%s_force_%i", this->GetCurrentBinaryDirectory(), + target->GetName().c_str(), count); const char* comment = origCommand.GetComment(); if(!comment && origCommand.GetOutputs().empty()) { @@ -595,7 +593,7 @@ cmLocalVisualStudio6Generator origCommand.GetCommandLines(), comment, origCommand.GetWorkingDirectory().c_str())) { - target.AddSource(outsf->GetFullPath()); + target->AddSource(outsf->GetFullPath()); } // Replace the dependencies with the output of this rule so that the @@ -711,7 +709,7 @@ void cmLocalVisualStudio6Generator::WriteDSPEndGroup(std::ostream& fout) void cmLocalVisualStudio6Generator::SetBuildType(BuildType b, const std::string& libName, - cmTarget& target) + cmGeneratorTarget *target) { std::string root= this->Makefile->GetRequiredDefinition("CMAKE_ROOT"); const char *def= @@ -743,7 +741,7 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b, this->DSPFooterTemplate += "/DLLFooter.dsptemplate"; break; case EXECUTABLE: - if ( target.GetPropertyAsBool("WIN32_EXECUTABLE") ) + if ( target->GetPropertyAsBool("WIN32_EXECUTABLE") ) { this->DSPHeaderTemplate = root; this->DSPHeaderTemplate += "/EXEWinHeader.dsptemplate"; @@ -795,15 +793,16 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b, //---------------------------------------------------------------------------- cmsys::auto_ptr<cmCustomCommand> -cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmTarget& target, +cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmGeneratorTarget* target, const std::string& config) { cmsys::auto_ptr<cmCustomCommand> pcc; // VS6 forgets to create the output directory for archives if it // differs from the intermediate directory. - if(target.GetType() != cmTarget::STATIC_LIBRARY) { return pcc; } - std::string outDir = target.GetDirectory(config, false); + if(target->GetType() != cmState::STATIC_LIBRARY) { return pcc; } + + std::string outDir = target->GetDirectory(config, false); // Add a pre-link event to create the directory. cmCustomCommandLine command; @@ -825,11 +824,11 @@ cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmTarget& target, // look for custom rules on a target and collect them together std::string -cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target, +cmLocalVisualStudio6Generator::CreateTargetRules(cmGeneratorTarget *target, const std::string& configName, const std::string& /* libName */) { - if (target.GetType() >= cmTarget::UTILITY ) + if (target->GetType() >= cmState::UTILITY ) { return ""; } @@ -839,8 +838,8 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target, // Write the pre-build and pre-link together (VS6 does not support both). event.Start("PreLink"); - event.Write(target.GetPreBuildCommands()); - event.Write(target.GetPreLinkCommands()); + event.Write(target->GetPreBuildCommands()); + event.Write(target->GetPreLinkCommands()); cmsys::auto_ptr<cmCustomCommand> pcc( this->MaybeCreateImplibDir(target, configName, false)); if(pcc.get()) @@ -856,7 +855,7 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target, // Write the post-build rules. event.Start("PostBuild"); - event.Write(target.GetPostBuildCommands()); + event.Write(target->GetPostBuildCommands()); event.Finish(); customRuleCode += "# End Special Build Tool\n"; @@ -875,7 +874,8 @@ inline std::string removeQuotes(const std::string& s) std::string -cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target, +cmLocalVisualStudio6Generator::GetTargetIncludeOptions( + cmGeneratorTarget *target, const std::string& config) { std::string includeOptions; @@ -886,12 +886,10 @@ cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target, unsigned int maxIncludeLength = 3000; bool useShortPath = false; - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); for(int j=0; j < 2; ++j) { std::vector<std::string> includes; - this->GetIncludeDirectories(includes, gt, "C", config); + this->GetIncludeDirectories(includes, target, "C", config); std::vector<std::string>::iterator i; for(i = includes.begin(); i != includes.end(); ++i) @@ -939,11 +937,11 @@ cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target, void cmLocalVisualStudio6Generator ::WriteDSPHeader(std::ostream& fout, - const std::string& libName, cmTarget &target, + const std::string& libName, cmGeneratorTarget* target, std::vector<cmSourceGroup> &) { - bool targetBuilds = (target.GetType() >= cmTarget::EXECUTABLE && - target.GetType() <= cmTarget::MODULE_LIBRARY); + bool targetBuilds = (target->GetType() >= cmState::EXECUTABLE && + target->GetType() <= cmState::MODULE_LIBRARY); #ifdef CM_USE_OLD_VS6 // Lookup the library and executable output directories. std::string libPath; @@ -1053,7 +1051,8 @@ void cmLocalVisualStudio6Generator } } std::vector<std::string>::const_iterator i; - const std::vector<std::string>& libdirs = target.GetLinkDirectories(); + const std::vector<std::string>& libdirs = + target->GetLinkDirectories(); for(i = libdirs.begin(); i != libdirs.end(); ++i) { std::string path = *i; @@ -1095,33 +1094,32 @@ void cmLocalVisualStudio6Generator } // find link libraries const cmTarget::LinkLibraryVectorType& libs = - target.GetLinkLibrariesForVS6(); + target->Target->GetLinkLibrariesForVS6(); cmTarget::LinkLibraryVectorType::const_iterator j; for(j = libs.begin(); j != libs.end(); ++j) { // add libraries to executables and dlls (but never include // a library in a library, bad recursion) // NEVER LINK STATIC LIBRARIES TO OTHER STATIC LIBRARIES - if ((target.GetType() != cmTarget::SHARED_LIBRARY - && target.GetType() != cmTarget::STATIC_LIBRARY - && target.GetType() != cmTarget::MODULE_LIBRARY) || - (target.GetType()==cmTarget::SHARED_LIBRARY + if ((target->GetType() != cmState::SHARED_LIBRARY + && target->GetType() != cmState::STATIC_LIBRARY + && target->GetType() != cmState::MODULE_LIBRARY) || + (target->GetType()==cmState::SHARED_LIBRARY && libName != GetVS6TargetName(j->first)) || - (target.GetType()==cmTarget::MODULE_LIBRARY + (target->GetType()==cmState::MODULE_LIBRARY && libName != GetVS6TargetName(j->first))) { // Compute the proper name to use to link this library. std::string lib; std::string libDebug; - cmTarget* tgt = this->GlobalGenerator->FindTarget(j->first.c_str()); + cmGeneratorTarget* tgt = + this->GlobalGenerator->FindGeneratorTarget(j->first.c_str()); if(tgt) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(tgt); lib = cmSystemTools::GetFilenameWithoutExtension - (gt->GetFullName().c_str()); + (tgt->GetFullName().c_str()); libDebug = cmSystemTools::GetFilenameWithoutExtension - (gt->GetFullName("Debug").c_str()); + (tgt->GetFullName("Debug").c_str()); lib += ".lib"; libDebug += ".lib"; } @@ -1139,7 +1137,7 @@ void cmLocalVisualStudio6Generator libDebug = this->ConvertToOutputFormat(libDebug.c_str(), SHELL); - if (j->second == cmTarget::GENERAL) + if (j->second == GENERAL_LibraryType) { libOptions += " "; libOptions += lib; @@ -1150,7 +1148,7 @@ void cmLocalVisualStudio6Generator libMultiLineOptionsForDebug += libDebug; libMultiLineOptionsForDebug += "\n"; } - if (j->second == cmTarget::DEBUG) + if (j->second == DEBUG_LibraryType) { libDebugOptions += " "; libDebugOptions += lib; @@ -1159,7 +1157,7 @@ void cmLocalVisualStudio6Generator libMultiLineDebugOptions += libDebug; libMultiLineDebugOptions += "\n"; } - if (j->second == cmTarget::OPTIMIZED) + if (j->second == OPTIMIZED_LibraryType) { libOptimizedOptions += " "; libOptimizedOptions += lib; @@ -1189,7 +1187,7 @@ void cmLocalVisualStudio6Generator std::string extraLinkOptionsRelease; std::string extraLinkOptionsMinSizeRel; std::string extraLinkOptionsRelWithDebInfo; - if(target.GetType() == cmTarget::EXECUTABLE) + if(target->GetType() == cmState::EXECUTABLE) { extraLinkOptions = this->Makefile-> GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS"); @@ -1202,7 +1200,7 @@ void cmLocalVisualStudio6Generator extraLinkOptionsRelWithDebInfo = this->Makefile-> GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO"); } - if(target.GetType() == cmTarget::SHARED_LIBRARY) + if(target->GetType() == cmState::SHARED_LIBRARY) { extraLinkOptions = this->Makefile-> GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS"); @@ -1215,7 +1213,7 @@ void cmLocalVisualStudio6Generator extraLinkOptionsRelWithDebInfo = this->Makefile-> GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO"); } - if(target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::MODULE_LIBRARY) { extraLinkOptions = this->Makefile-> GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS"); @@ -1230,63 +1228,61 @@ void cmLocalVisualStudio6Generator } // Get extra linker options for this target. - if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS")) + if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS")) { extraLinkOptions += " "; extraLinkOptions += targetLinkFlags; } - if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_DEBUG")) + if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS_DEBUG")) { extraLinkOptionsDebug += " "; extraLinkOptionsDebug += targetLinkFlags; } - if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_RELEASE")) + if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS_RELEASE")) { extraLinkOptionsRelease += " "; extraLinkOptionsRelease += targetLinkFlags; } - if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_MINSIZEREL")) + if(const char* targetLinkFlags = + target->GetProperty("LINK_FLAGS_MINSIZEREL")) { extraLinkOptionsMinSizeRel += " "; extraLinkOptionsMinSizeRel += targetLinkFlags; } if(const char* targetLinkFlags = - target.GetProperty("LINK_FLAGS_RELWITHDEBINFO")) + target->GetProperty("LINK_FLAGS_RELWITHDEBINFO")) { extraLinkOptionsRelWithDebInfo += " "; extraLinkOptionsRelWithDebInfo += targetLinkFlags; } - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); - // Get standard libraries for this language. if(targetBuilds) { // Get the language to use for linking. std::vector<std::string> configs; - target.GetMakefile()->GetConfigurations(configs); + target->Target->GetMakefile()->GetConfigurations(configs); std::vector<std::string>::const_iterator it = configs.begin(); - const std::string& linkLanguage = gt->GetLinkerLanguage(*it); + const std::string& linkLanguage = target->GetLinkerLanguage(*it); for ( ; it != configs.end(); ++it) { - const std::string& configLinkLanguage = gt->GetLinkerLanguage(*it); + const std::string& configLinkLanguage = target->GetLinkerLanguage(*it); if (configLinkLanguage != linkLanguage) { cmSystemTools::Error ("Linker language must not vary by configuration for target: ", - target.GetName().c_str()); + target->GetName().c_str()); } } if(linkLanguage.empty()) { cmSystemTools::Error ("CMake can not determine linker language for target: ", - target.GetName().c_str()); + target->GetName().c_str()); return; } @@ -1307,13 +1303,13 @@ void cmLocalVisualStudio6Generator // Compute version number information. std::string targetVersionFlag; - if(target.GetType() == cmTarget::EXECUTABLE || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::EXECUTABLE || + target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY) { int major; int minor; - target.GetTargetVersion(major, minor); + target->GetTargetVersion(major, minor); std::ostringstream targetVersionStream; targetVersionStream << "/version:" << major << "." << minor; targetVersionFlag = targetVersionStream.str(); @@ -1326,20 +1322,20 @@ void cmLocalVisualStudio6Generator std::string outputNameRelease = outputName; std::string outputNameMinSizeRel = outputName; std::string outputNameRelWithDebInfo = outputName; - if(target.GetType() == cmTarget::EXECUTABLE || - target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::EXECUTABLE || + target->GetType() == cmState::STATIC_LIBRARY || + target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY) { - outputName = gt->GetFullName(); - outputNameDebug = gt->GetFullName("Debug"); - outputNameRelease = gt->GetFullName("Release"); - outputNameMinSizeRel = gt->GetFullName("MinSizeRel"); - outputNameRelWithDebInfo = gt->GetFullName("RelWithDebInfo"); + outputName = target->GetFullName(); + outputNameDebug = target->GetFullName("Debug"); + outputNameRelease = target->GetFullName("Release"); + outputNameMinSizeRel = target->GetFullName("MinSizeRel"); + outputNameRelWithDebInfo = target->GetFullName("RelWithDebInfo"); } - else if(target.GetType() == cmTarget::OBJECT_LIBRARY) + else if(target->GetType() == cmState::OBJECT_LIBRARY) { - outputName = target.GetName(); + outputName = target->GetName(); outputName += ".lib"; outputNameDebug = outputName; outputNameRelease = outputName; @@ -1353,30 +1349,30 @@ void cmLocalVisualStudio6Generator std::string outputDirRelease; std::string outputDirMinSizeRel; std::string outputDirRelWithDebInfo; - if(target.GetType() == cmTarget::EXECUTABLE || - target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::EXECUTABLE || + target->GetType() == cmState::STATIC_LIBRARY || + target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY) { #ifdef CM_USE_OLD_VS6 outputDirOld = removeQuotes(this->ConvertToOutputFormat - (target.GetDirectory().c_str(), SHELL)); + (target->GetDirectory().c_str(), SHELL)); #endif outputDirDebug = removeQuotes(this->ConvertToOutputFormat( - target.GetDirectory("Debug").c_str(), SHELL)); + target->GetDirectory("Debug").c_str(), SHELL)); outputDirRelease = removeQuotes(this->ConvertToOutputFormat( - target.GetDirectory("Release").c_str(), SHELL)); + target->GetDirectory("Release").c_str(), SHELL)); outputDirMinSizeRel = removeQuotes(this->ConvertToOutputFormat( - target.GetDirectory("MinSizeRel").c_str(), SHELL)); + target->GetDirectory("MinSizeRel").c_str(), SHELL)); outputDirRelWithDebInfo = removeQuotes(this->ConvertToOutputFormat( - target.GetDirectory("RelWithDebInfo").c_str(), SHELL)); + target->GetDirectory("RelWithDebInfo").c_str(), SHELL)); } - else if(target.GetType() == cmTarget::OBJECT_LIBRARY) + else if(target->GetType() == cmState::OBJECT_LIBRARY) { std::string outputDir = cmake::GetCMakeFilesDirectoryPostSlash(); outputDirDebug = outputDir + "Debug"; @@ -1390,9 +1386,9 @@ void cmLocalVisualStudio6Generator std::string optionsRelease; std::string optionsMinSizeRel; std::string optionsRelWithDebInfo; - if(target.GetType() == cmTarget::EXECUTABLE || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::EXECUTABLE || + target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY) { extraLinkOptionsDebug = extraLinkOptions + " " + extraLinkOptionsDebug; @@ -1418,24 +1414,24 @@ void cmLocalVisualStudio6Generator std::string targetImplibFlagRelease; std::string targetImplibFlagMinSizeRel; std::string targetImplibFlagRelWithDebInfo; - if(target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY || - target.GetType() == cmTarget::EXECUTABLE) + if(target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY || + target->GetType() == cmState::EXECUTABLE) { - std::string fullPathImpDebug = target.GetDirectory("Debug", true); - std::string fullPathImpRelease = target.GetDirectory("Release", true); + std::string fullPathImpDebug = target->GetDirectory("Debug", true); + std::string fullPathImpRelease = target->GetDirectory("Release", true); std::string fullPathImpMinSizeRel = - target.GetDirectory("MinSizeRel", true); + target->GetDirectory("MinSizeRel", true); std::string fullPathImpRelWithDebInfo = - target.GetDirectory("RelWithDebInfo", true); + target->GetDirectory("RelWithDebInfo", true); fullPathImpDebug += "/"; fullPathImpRelease += "/"; fullPathImpMinSizeRel += "/"; fullPathImpRelWithDebInfo += "/"; - fullPathImpDebug += gt->GetFullName("Debug", true); - fullPathImpRelease += gt->GetFullName("Release", true); - fullPathImpMinSizeRel += gt->GetFullName("MinSizeRel", true); - fullPathImpRelWithDebInfo += gt->GetFullName("RelWithDebInfo", true); + fullPathImpDebug += target->GetFullName("Debug", true); + fullPathImpRelease += target->GetFullName("Release", true); + fullPathImpMinSizeRel += target->GetFullName("MinSizeRel", true); + fullPathImpRelWithDebInfo += target->GetFullName("RelWithDebInfo", true); targetImplibFlagDebug = "/implib:"; targetImplibFlagRelease = "/implib:"; @@ -1488,7 +1484,7 @@ void cmLocalVisualStudio6Generator std::string staticLibOptionsRelease; std::string staticLibOptionsMinSizeRel; std::string staticLibOptionsRelWithDebInfo; - if(target.GetType() == cmTarget::STATIC_LIBRARY ) + if(target->GetType() == cmState::STATIC_LIBRARY ) { const char *libflagsGlobal = this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS"); @@ -1507,7 +1503,7 @@ void cmLocalVisualStudio6Generator this->AppendFlags(staticLibOptionsRelWithDebInfo, this->Makefile-> GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO")); - const char *libflags = target.GetProperty("STATIC_LIBRARY_FLAGS"); + const char *libflags = target->GetProperty("STATIC_LIBRARY_FLAGS"); this->AppendFlags(staticLibOptions, libflags); this->AppendFlags(staticLibOptionsDebug, libflags); this->AppendFlags(staticLibOptionsRelease, libflags); @@ -1515,13 +1511,13 @@ void cmLocalVisualStudio6Generator this->AppendFlags(staticLibOptionsRelWithDebInfo, libflags); this->AppendFlags(staticLibOptionsDebug, - target.GetProperty("STATIC_LIBRARY_FLAGS_DEBUG")); + target->GetProperty("STATIC_LIBRARY_FLAGS_DEBUG")); this->AppendFlags(staticLibOptionsRelease, - target.GetProperty("STATIC_LIBRARY_FLAGS_RELEASE")); + target->GetProperty("STATIC_LIBRARY_FLAGS_RELEASE")); this->AppendFlags(staticLibOptionsMinSizeRel, - target.GetProperty("STATIC_LIBRARY_FLAGS_MINSIZEREL")); + target->GetProperty("STATIC_LIBRARY_FLAGS_MINSIZEREL")); this->AppendFlags(staticLibOptionsRelWithDebInfo, - target.GetProperty("STATIC_LIBRARY_FLAGS_RELWITHDEBINFO")); + target->GetProperty("STATIC_LIBRARY_FLAGS_RELWITHDEBINFO")); std::string objects; this->OutputObjects(target, "LIB", objects); @@ -1537,7 +1533,7 @@ void cmLocalVisualStudio6Generator // Add the export symbol definition for shared library objects. std::string exportSymbol; - if(const char* exportMacro = target.GetExportMacro()) + if(const char* exportMacro = target->GetExportMacro()) { exportSymbol = exportMacro; } @@ -1561,8 +1557,8 @@ void cmLocalVisualStudio6Generator libnameExports.c_str()); cmSystemTools::ReplaceString(line, "CMAKE_MFC_FLAG", mfcFlag); - if(target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::OBJECT_LIBRARY) + if(target->GetType() == cmState::STATIC_LIBRARY || + target->GetType() == cmState::OBJECT_LIBRARY) { cmSystemTools::ReplaceString(line, "CM_STATIC_LIB_ARGS_DEBUG", staticLibOptionsDebug.c_str()); @@ -1668,7 +1664,7 @@ void cmLocalVisualStudio6Generator (exePath.c_str(), SHELL)).c_str()); #endif - if(targetBuilds || target.GetType() == cmTarget::OBJECT_LIBRARY) + if(targetBuilds || target->GetType() == cmState::OBJECT_LIBRARY) { cmSystemTools::ReplaceString(line, "OUTPUT_DIRECTORY_DEBUG", outputDirDebug.c_str()); @@ -1692,8 +1688,8 @@ void cmLocalVisualStudio6Generator = this->Makefile->GetDefinition("CMAKE_DEBUG_POSTFIX"); cmSystemTools::ReplaceString(line, "DEBUG_POSTFIX", debugPostfix?debugPostfix:""); - if(target.GetType() >= cmTarget::EXECUTABLE && - target.GetType() <= cmTarget::OBJECT_LIBRARY) + if(target->GetType() >= cmState::EXECUTABLE && + target->GetType() <= cmState::OBJECT_LIBRARY) { // store flags for each configuration std::string flags = " "; @@ -1702,24 +1698,24 @@ void cmLocalVisualStudio6Generator std::string flagsDebug = " "; std::string flagsRelWithDebInfo = " "; std::vector<std::string> configs; - target.GetMakefile()->GetConfigurations(configs); + target->Target->GetMakefile()->GetConfigurations(configs); std::vector<std::string>::const_iterator it = configs.begin(); - const std::string& linkLanguage = gt->GetLinkerLanguage(*it); + const std::string& linkLanguage = target->GetLinkerLanguage(*it); for ( ; it != configs.end(); ++it) { - const std::string& configLinkLanguage = gt->GetLinkerLanguage(*it); + const std::string& configLinkLanguage = target->GetLinkerLanguage(*it); if (configLinkLanguage != linkLanguage) { cmSystemTools::Error ("Linker language must not vary by configuration for target: ", - target.GetName().c_str()); + target->GetName().c_str()); } } if(linkLanguage.empty()) { cmSystemTools::Error ("CMake can not determine linker language for target: ", - target.GetName().c_str()); + target->GetName().c_str()); return; } // if CXX is on and the target contains cxx code then add the cxx flags @@ -1744,12 +1740,12 @@ void cmLocalVisualStudio6Generator flagsRelWithDebInfo = this->Makefile->GetSafeDefinition(flagVar.c_str()); flagsRelWithDebInfo += " -DCMAKE_INTDIR=\\\"RelWithDebInfo\\\" "; - this->AddCompileOptions(flags, &target, linkLanguage, ""); - this->AddCompileOptions(flagsDebug, &target, linkLanguage, "Debug"); - this->AddCompileOptions(flagsRelease, &target, linkLanguage, "Release"); - this->AddCompileOptions(flagsMinSizeRel, &target, linkLanguage, + this->AddCompileOptions(flags, target, linkLanguage, ""); + this->AddCompileOptions(flagsDebug, target, linkLanguage, "Debug"); + this->AddCompileOptions(flagsRelease, target, linkLanguage, "Release"); + this->AddCompileOptions(flagsMinSizeRel, target, linkLanguage, "MinSizeRel"); - this->AddCompileOptions(flagsRelWithDebInfo, &target, linkLanguage, + this->AddCompileOptions(flagsRelWithDebInfo, target, linkLanguage, "RelWithDebInfo"); // if _UNICODE and _SBCS are not found, then add -D_MBCS @@ -1769,14 +1765,14 @@ void cmLocalVisualStudio6Generator std::set<std::string> minsizeDefinesSet; std::set<std::string> debugrelDefinesSet; - this->AddCompileDefinitions(definesSet, &target, "", linkLanguage); - this->AddCompileDefinitions(debugDefinesSet, &target, + this->AddCompileDefinitions(definesSet, target, "", linkLanguage); + this->AddCompileDefinitions(debugDefinesSet, target, "DEBUG", linkLanguage); - this->AddCompileDefinitions(releaseDefinesSet, &target, + this->AddCompileDefinitions(releaseDefinesSet, target, "RELEASE", linkLanguage); - this->AddCompileDefinitions(minsizeDefinesSet, &target, + this->AddCompileDefinitions(minsizeDefinesSet, target, "MINSIZEREL", linkLanguage); - this->AddCompileDefinitions(debugrelDefinesSet, &target, + this->AddCompileDefinitions(debugrelDefinesSet, target, "RELWITHDEBINFO", linkLanguage); std::string defines = " "; @@ -1844,15 +1840,13 @@ void cmLocalVisualStudio6Generator::WriteDSPFooter(std::ostream& fout) //---------------------------------------------------------------------------- void cmLocalVisualStudio6Generator -::ComputeLinkOptions(cmTarget& target, +::ComputeLinkOptions(cmGeneratorTarget *target, const std::string& configName, const std::string extraOptions, std::string& options) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); // Compute the link information for this configuration. - cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName); + cmComputeLinkInformation* pcli = target->GetLinkInformation(configName); if(!pcli) { return; @@ -1893,7 +1887,7 @@ void cmLocalVisualStudio6Generator this->ConvertToOutputFormat(l->Value.c_str(), SHELL); } else if (!l->Target - || l->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + || l->Target->GetType() != cmState::INTERFACE_LIBRARY) { options += l->Value; } @@ -1911,15 +1905,13 @@ void cmLocalVisualStudio6Generator //---------------------------------------------------------------------------- void cmLocalVisualStudio6Generator -::OutputObjects(cmTarget& target, const char* tool, +::OutputObjects(cmGeneratorTarget* target, const char* tool, std::string& options) { // VS 6 does not support per-config source locations so we // list object library content on the link line instead. - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); std::vector<std::string> objs; - gt->UseObjectLibraries(objs, ""); + target->UseObjectLibraries(objs, ""); for(std::vector<std::string>::const_iterator oi = objs.begin(); oi != objs.end(); ++oi) { @@ -1933,7 +1925,7 @@ void cmLocalVisualStudio6Generator std::string cmLocalVisualStudio6Generator -::GetTargetDirectory(cmTarget const&) const +::GetTargetDirectory(cmGeneratorTarget const*) const { // No per-target directory for this generator (yet). return ""; @@ -1942,7 +1934,7 @@ cmLocalVisualStudio6Generator //---------------------------------------------------------------------------- std::string cmLocalVisualStudio6Generator -::ComputeLongestObjectDirectory(cmTarget&) const +::ComputeLongestObjectDirectory(cmGeneratorTarget const*) const { // Compute the maximum length configuration name. std::string config_max; @@ -1962,7 +1954,7 @@ cmLocalVisualStudio6Generator // files directory for any configuration. This is used to construct // object file names that do not produce paths that are too long. std::string dir_max; - dir_max += this->Makefile->GetCurrentBinaryDirectory(); + dir_max += this->GetCurrentBinaryDirectory(); dir_max += "/"; dir_max += config_max; dir_max += "/"; diff --git a/Source/cmLocalVisualStudio6Generator.h b/Source/cmLocalVisualStudio6Generator.h index 828d252..dab32a5 100644 --- a/Source/cmLocalVisualStudio6Generator.h +++ b/Source/cmLocalVisualStudio6Generator.h @@ -14,7 +14,6 @@ #include "cmLocalVisualStudioGenerator.h" -class cmTarget; class cmSourceFile; class cmSourceGroup; class cmCustomCommand; @@ -47,49 +46,52 @@ public: /** * Specify the type of the build: static, dll, or executable. */ - void SetBuildType(BuildType, const std::string& libName, cmTarget&); + void SetBuildType(BuildType, const std::string& libName, cmGeneratorTarget*); - virtual std::string GetTargetDirectory(cmTarget const& target) const; - virtual std::string ComputeLongestObjectDirectory(cmTarget&) const; + virtual + std::string GetTargetDirectory(cmGeneratorTarget const* target) const; + virtual std::string + ComputeLongestObjectDirectory(cmGeneratorTarget const*) const; private: std::string DSPHeaderTemplate; std::string DSPFooterTemplate; - void CreateSingleDSP(const std::string& lname, cmTarget &tgt); + void CreateSingleDSP(const std::string& lname, cmGeneratorTarget* tgt); void WriteDSPFile(std::ostream& fout, const std::string& libName, - cmTarget &tgt); + cmGeneratorTarget* tgt); void WriteDSPBeginGroup(std::ostream& fout, const char* group, const char* filter); void WriteDSPEndGroup(std::ostream& fout); void WriteDSPHeader(std::ostream& fout, const std::string& libName, - cmTarget &tgt, std::vector<cmSourceGroup> &sgs); + cmGeneratorTarget* tgt, std::vector<cmSourceGroup> &sgs); void WriteDSPFooter(std::ostream& fout); - void AddDSPBuildRule(cmTarget& tgt); + void AddDSPBuildRule(cmGeneratorTarget* tgt); void WriteCustomRule(std::ostream& fout, const char* source, const cmCustomCommand& command, const char* flags); - void AddUtilityCommandHack(cmTarget& target, int count, + void AddUtilityCommandHack(cmGeneratorTarget* target, int count, std::vector<std::string>& depends, const cmCustomCommand& origCommand); - void WriteGroup(const cmSourceGroup *sg, cmTarget& target, + void WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target, std::ostream &fout, const std::string& libName); class EventWriter; friend class EventWriter; cmsys::auto_ptr<cmCustomCommand> - MaybeCreateOutputDir(cmTarget& target, const std::string& config); - std::string CreateTargetRules(cmTarget &target, + MaybeCreateOutputDir(cmGeneratorTarget *target, const std::string& config); + std::string CreateTargetRules(cmGeneratorTarget* target, const std::string& configName, const std::string& libName); - void ComputeLinkOptions(cmTarget& target, const std::string& configName, + void ComputeLinkOptions(cmGeneratorTarget* target, + const std::string& configName, const std::string extraOptions, std::string& options); - void OutputObjects(cmTarget& target, const char* tool, + void OutputObjects(cmGeneratorTarget* target, const char* tool, std::string& options); - std::string GetTargetIncludeOptions(cmTarget &target, + std::string GetTargetIncludeOptions(cmGeneratorTarget* target, const std::string& config); std::vector<std::string> Configurations; diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx index cf67251..ae6a24e 100644 --- a/Source/cmLocalVisualStudio7Generator.cxx +++ b/Source/cmLocalVisualStudio7Generator.cxx @@ -34,7 +34,8 @@ public: LocalGenerator(e) {} typedef cmComputeLinkInformation::ItemVector ItemVector; void OutputLibraries(std::ostream& fout, ItemVector const& libs); - void OutputObjects(std::ostream& fout, cmTarget* t, const char* isep = 0); + void OutputObjects(std::ostream& fout, cmGeneratorTarget* t, + const char* isep = 0); private: cmLocalVisualStudio7Generator* LocalGenerator; }; @@ -67,19 +68,19 @@ cmLocalVisualStudio7Generator::~cmLocalVisualStudio7Generator() void cmLocalVisualStudio7Generator::AddHelperCommands() { // Now create GUIDs for targets - cmTargets &tgts = this->Makefile->GetTargets(); - - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if(l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if((*l)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - const char* path = l->second.GetProperty("EXTERNAL_MSPROJECT"); + const char* path = (*l)->GetProperty("EXTERNAL_MSPROJECT"); if(path) { this->ReadAndStoreExternalGUID( - l->second.GetName().c_str(), path); + (*l)->GetName().c_str(), path); } } @@ -95,7 +96,6 @@ void cmLocalVisualStudio7Generator::Generate() void cmLocalVisualStudio7Generator::AddCMakeListsRules() { - cmTargets &tgts = this->Makefile->GetTargets(); // Create the regeneration custom rule. if(!this->Makefile->IsOn("CMAKE_SUPPRESS_REGENERATION")) { @@ -104,15 +104,17 @@ void cmLocalVisualStudio7Generator::AddCMakeListsRules() if(cmSourceFile* sf = this->CreateVCProjBuildRule()) { // Add the rule to targets that need it. - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if (l->second.GetType() == cmTarget::GLOBAL_TARGET) + if ((*l)->GetType() == cmState::GLOBAL_TARGET) { continue; } - if(l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET) + if((*l)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET) { - l->second.AddSource(sf->GetFullPath()); + (*l)->AddSource(sf->GetFullPath()); } } } @@ -124,12 +126,11 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets() // Visual Studio .NET 2003 Service Pack 1 will not run post-build // commands for targets in which no sources are built. Add dummy // rules to force these targets to build. - cmTargets &tgts = this->Makefile->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); l != tgts.end(); l++) { - cmTarget& tgt = l->second; - if(tgt.GetType() == cmTarget::GLOBAL_TARGET) + if((*l)->GetType() == cmState::GLOBAL_TARGET) { std::vector<std::string> no_depends; cmCustomCommandLine force_command; @@ -138,17 +139,17 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets() cmCustomCommandLines force_commands; force_commands.push_back(force_command); std::string no_main_dependency = ""; - std::string force = this->Makefile->GetCurrentBinaryDirectory(); + std::string force = this->GetCurrentBinaryDirectory(); force += cmake::GetCMakeFilesDirectory(); force += "/"; - force += tgt.GetName(); + force += (*l)->GetName(); force += "_force"; if(cmSourceFile* file = this->Makefile->AddCustomCommandToOutput( force.c_str(), no_depends, no_main_dependency, force_commands, " ", 0, true)) { - tgt.AddSource(file->GetFullPath()); + (*l)->AddSource(file->GetFullPath()); } } } @@ -160,33 +161,33 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets() void cmLocalVisualStudio7Generator::WriteProjectFiles() { // If not an in source build, then create the output directory - if(strcmp(this->Makefile->GetCurrentBinaryDirectory(), - this->Makefile->GetHomeDirectory()) != 0) + if(strcmp(this->GetCurrentBinaryDirectory(), + this->GetSourceDirectory()) != 0) { if(!cmSystemTools::MakeDirectory - (this->Makefile->GetCurrentBinaryDirectory())) + (this->GetCurrentBinaryDirectory())) { cmSystemTools::Error("Error creating directory ", - this->Makefile->GetCurrentBinaryDirectory()); + this->GetCurrentBinaryDirectory()); } } // Get the set of targets in this directory. - cmTargets &tgts = this->Makefile->GetTargets(); + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); // Create the project file for each target. - for(cmTargets::iterator l = tgts.begin(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); l != tgts.end(); l++) { - if(l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if((*l)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } // INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace // so don't build a projectfile for it - if(!l->second.GetProperty("EXTERNAL_MSPROJECT")) + if(!(*l)->GetProperty("EXTERNAL_MSPROJECT")) { - this->CreateSingleVCProj(l->first.c_str(),l->second); + this->CreateSingleVCProj((*l)->GetName().c_str(), *l); } } } @@ -196,7 +197,7 @@ void cmLocalVisualStudio7Generator::WriteStampFiles() { // Touch a timestamp file used to determine when the project file is // out of date. - std::string stampName = this->Makefile->GetCurrentBinaryDirectory(); + std::string stampName = this->GetCurrentBinaryDirectory(); stampName += cmake::GetCMakeFilesDirectory(); cmSystemTools::MakeDirectory(stampName.c_str()); stampName += "/"; @@ -224,7 +225,7 @@ void cmLocalVisualStudio7Generator::WriteStampFiles() //---------------------------------------------------------------------------- void cmLocalVisualStudio7Generator -::CreateSingleVCProj(const std::string& lname, cmTarget &target) +::CreateSingleVCProj(const std::string& lname, cmGeneratorTarget *target) { cmGlobalVisualStudioGenerator* gg = static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator); @@ -240,10 +241,10 @@ void cmLocalVisualStudio7Generator } // add to the list of projects - target.SetProperty("GENERATOR_FILE_NAME",lname.c_str()); + target->Target->SetProperty("GENERATOR_FILE_NAME",lname.c_str()); // create the dsp.cmake file std::string fname; - fname = this->Makefile->GetCurrentBinaryDirectory(); + fname = this->GetCurrentBinaryDirectory(); fname += "/"; fname += lname; if(this->FortranProject) @@ -272,13 +273,13 @@ void cmLocalVisualStudio7Generator //---------------------------------------------------------------------------- cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule() { - std::string stampName = this->Makefile->GetCurrentBinaryDirectory(); + std::string stampName = this->GetCurrentBinaryDirectory(); stampName += "/"; stampName += cmake::GetCMakeFilesDirectoryPostSlash(); stampName += "generate.stamp"; cmCustomCommandLine commandLine; commandLine.push_back(cmSystemTools::GetCMakeCommand()); - std::string makefileIn = this->Makefile->GetCurrentSourceDirectory(); + std::string makefileIn = this->GetCurrentSourceDirectory(); makefileIn += "/"; makefileIn += "CMakeLists.txt"; makefileIn = cmSystemTools::CollapseFullPath(makefileIn.c_str()); @@ -290,10 +291,10 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule() comment += makefileIn; std::string args; args = "-H"; - args += this->Makefile->GetHomeDirectory(); + args += this->GetSourceDirectory(); commandLine.push_back(args); args = "-B"; - args += this->Makefile->GetHomeOutputDirectory(); + args += this->GetBinaryDirectory(); commandLine.push_back(args); commandLine.push_back("--check-stamp-file"); std::string stampFilename = this->Convert(stampName.c_str(), FULL, @@ -323,8 +324,9 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule() } void cmLocalVisualStudio7Generator::WriteConfigurations( - std::ostream& fout, std::vector<std::string> const& configs, - const std::string& libName, cmTarget &target + std::ostream& fout, + std::vector<std::string> const& configs, + const std::string& libName, cmGeneratorTarget *target ) { fout << "\t<Configurations>\n"; @@ -642,7 +644,7 @@ private: void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, const std::string& configName, const std::string& libName, - cmTarget &target) + cmGeneratorTarget *target) { const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG"); if(!mfcFlag) @@ -663,27 +665,24 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, const char* projectType = 0; bool targetBuilds = true; - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); - - switch(target.GetType()) + switch(target->GetType()) { - case cmTarget::OBJECT_LIBRARY: + case cmState::OBJECT_LIBRARY: targetBuilds = false; // no manifest tool for object library - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: projectType = "typeStaticLibrary"; configType = "4"; break; - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: projectType = "typeDynamicLibrary"; configType = "2"; break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: configType = "1"; break; - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: configType = "10"; default: targetBuilds = false; @@ -698,12 +697,12 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, { const std::string& linkLanguage = (this->FortranProject? std::string("Fortran"): - gt->GetLinkerLanguage(configName)); + target->GetLinkerLanguage(configName)); if(linkLanguage.empty()) { cmSystemTools::Error ("CMake can not determine linker language for target: ", - target.GetName().c_str()); + target->GetName().c_str()); return; } if(linkLanguage == "C" || linkLanguage == "CXX" @@ -729,12 +728,12 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, } // Add the target-specific flags. - this->AddCompileOptions(flags, &target, linkLanguage, configName); + this->AddCompileOptions(flags, target, linkLanguage, configName); } if(this->FortranProject) { - switch(this->GetFortranFormat(target.GetProperty("Fortran_FORMAT"))) + switch(this->GetFortranFormat(target->GetProperty("Fortran_FORMAT"))) { case FortranFormatFixed: flags += " -fixed"; break; case FortranFormatFree: flags += " -free"; break; @@ -761,7 +760,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, targetOptions.Parse(defineFlags.c_str()); targetOptions.ParseFinish(); std::vector<std::string> targetDefines; - gt->GetCompileDefinitions(targetDefines, configName, "CXX"); + target->GetCompileDefinitions(targetDefines, configName, "CXX"); targetOptions.AddDefines(targetDefines); targetOptions.SetVerboseMakefile( this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE")); @@ -773,7 +772,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, targetOptions.AddDefine(configDefine); // Add the export symbol definition for shared library objects. - if(const char* exportMacro = target.GetExportMacro()) + if(const char* exportMacro = target->GetExportMacro()) { targetOptions.AddDefine(exportMacro); } @@ -784,11 +783,11 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, intermediateDir += "/"; intermediateDir += configName; - if (target.GetType() < cmTarget::UTILITY) + if (target->GetType() < cmState::UTILITY) { std::string const& outDir = - target.GetType() == cmTarget::OBJECT_LIBRARY? - intermediateDir : target.GetDirectory(configName); + target->GetType() == cmState::OBJECT_LIBRARY? + intermediateDir : target->GetDirectory(configName); fout << "\t\t\tOutputDirectory=\"" << this->ConvertToXMLOutputPathSingle(outDir.c_str()) << "\"\n"; } @@ -803,7 +802,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, if (this->FortranProject) { // Intel Fortran >= 15.0 uses TargetName property. - std::string targetNameFull = gt->GetFullName(configName); + std::string targetNameFull = target->GetFullName(configName); std::string targetName = cmSystemTools::GetFilenameWithoutLastExtension(targetNameFull); std::string targetExt = @@ -838,7 +837,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, if(this->FortranProject) { const char* target_mod_dir = - target.GetProperty("Fortran_MODULE_DIRECTORY"); + target->GetProperty("Fortran_MODULE_DIRECTORY"); std::string modDir; if(target_mod_dir) { @@ -857,7 +856,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, targetOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n"); fout << "\t\t\t\tAdditionalIncludeDirectories=\""; std::vector<std::string> includes; - this->GetIncludeDirectories(includes, gt, "C", configName); + this->GetIncludeDirectories(includes, target, "C", configName); std::vector<std::string>::iterator i = includes.begin(); for(;i != includes.end(); ++i) { @@ -878,10 +877,10 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, targetOptions.OutputFlagMap(fout, "\t\t\t\t"); targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n", "CXX"); fout << "\t\t\t\tObjectFile=\"$(IntDir)\\\"\n"; - if(target.GetType() <= cmTarget::OBJECT_LIBRARY) + if(target->GetType() <= cmState::OBJECT_LIBRARY) { // Specify the compiler program database file if configured. - std::string pdb = gt->GetCompilePDBPath(configName); + std::string pdb = target->GetCompilePDBPath(configName); if(!pdb.empty()) { fout << "\t\t\t\tProgramDataBaseFileName=\"" @@ -972,25 +971,43 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, fout << "\t\t\t\tProxyFileName=\"$(InputName)_p.c\"/>\n"; // end of <Tool Name=VCMIDLTool - // Check if we need the FAT32 workaround. + // Add manifest tool settings. if(targetBuilds && this->GetVersion() >= cmGlobalVisualStudioGenerator::VS8) { + const char* manifestTool = "VCManifestTool"; + if (this->FortranProject) + { + manifestTool = "VFManifestTool"; + } + fout << + "\t\t\t<Tool\n" + "\t\t\t\tName=\"" << manifestTool << "\""; + + std::vector<cmSourceFile const*> manifest_srcs; + target->GetManifests(manifest_srcs, configName); + if (!manifest_srcs.empty()) + { + fout << "\n\t\t\t\tAdditionalManifestFiles=\""; + for (std::vector<cmSourceFile const*>::const_iterator + mi = manifest_srcs.begin(); mi != manifest_srcs.end(); ++mi) + { + std::string m = (*mi)->GetFullPath(); + fout << this->ConvertToXMLOutputPath(m.c_str()) << ";"; + } + fout << "\""; + } + + // Check if we need the FAT32 workaround. // Check the filesystem type where the target will be written. - if(cmLVS6G_IsFAT(target.GetDirectory(configName).c_str())) + if (cmLVS6G_IsFAT(target->GetDirectory(configName).c_str())) { // Add a flag telling the manifest tool to use a workaround // for FAT32 file systems, which can cause an empty manifest // to be embedded into the resulting executable. See CMake // bug #2617. - const char* manifestTool = "VCManifestTool"; - if(this->FortranProject) - { - manifestTool = "VFManifestTool"; - } - fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << manifestTool << "\"\n" - << "\t\t\t\tUseFAT32Workaround=\"true\"\n" - << "\t\t\t/>\n"; + fout << "\n\t\t\t\tUseFAT32Workaround=\"true\""; } + fout << "/>\n"; } this->OutputTargetRules(fout, configName, target, libName); @@ -1016,28 +1033,28 @@ cmLocalVisualStudio7Generator } void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, - const std::string& configName, cmTarget &target, + const std::string& configName, cmGeneratorTarget* target, const Options& targetOptions) { cmGlobalVisualStudio7Generator* gg = static_cast<cmGlobalVisualStudio7Generator*>(this->GlobalGenerator); std::string temp; std::string extraLinkOptions; - if(target.GetType() == cmTarget::EXECUTABLE) + if(target->GetType() == cmState::EXECUTABLE) { extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS") + std::string(" ") + GetBuildTypeLinkerFlags("CMAKE_EXE_LINKER_FLAGS", configName); } - if(target.GetType() == cmTarget::SHARED_LIBRARY) + if(target->GetType() == cmState::SHARED_LIBRARY) { extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS") + std::string(" ") + GetBuildTypeLinkerFlags("CMAKE_SHARED_LINKER_FLAGS", configName); } - if(target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::MODULE_LIBRARY) { extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS") @@ -1045,7 +1062,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, + GetBuildTypeLinkerFlags("CMAKE_MODULE_LINKER_FLAGS", configName); } - const char* targetLinkFlags = target.GetProperty("LINK_FLAGS"); + const char* targetLinkFlags = target->GetProperty("LINK_FLAGS"); if(targetLinkFlags) { extraLinkOptions += " "; @@ -1054,7 +1071,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, std::string configTypeUpper = cmSystemTools::UpperCase(configName); std::string linkFlagsConfig = "LINK_FLAGS_"; linkFlagsConfig += configTypeUpper; - targetLinkFlags = target.GetProperty(linkFlagsConfig.c_str()); + targetLinkFlags = target->GetProperty(linkFlagsConfig.c_str()); if(targetLinkFlags) { extraLinkOptions += " "; @@ -1074,28 +1091,26 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, this->ConvertToOutputFormat(this->ModuleDefinitionFile, SHELL); linkOptions.AddFlag("ModuleDefinitionFile", defFile.c_str()); } - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); - if (target.GetType() == cmTarget::SHARED_LIBRARY && + if (target->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if (target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if (target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { linkOptions.AddFlag("ModuleDefinitionFile", "$(IntDir)/exportall.def"); } } - switch(target.GetType()) + switch(target->GetType()) { - case cmTarget::UNKNOWN_LIBRARY: + case cmState::UNKNOWN_LIBRARY: break; - case cmTarget::OBJECT_LIBRARY: + case cmState::OBJECT_LIBRARY: { std::string libpath = this->GetTargetDirectory(target); libpath += "/"; libpath += configName; libpath += "/"; - libpath += target.GetName(); + libpath += target->GetName(); libpath += ".lib"; const char* tool = this->FortranProject? "VFLibrarianTool":"VCLibrarianTool"; @@ -1105,10 +1120,10 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, << this->ConvertToXMLOutputPathSingle(libpath.c_str()) << "\"/>\n"; break; } - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: { - std::string targetNameFull = gt->GetFullName(configName); - std::string libpath = target.GetDirectory(configName); + std::string targetNameFull = target->GetFullName(configName); + std::string libpath = target->GetDirectory(configName); libpath += "/"; libpath += targetNameFull; const char* tool = "VCLibrarianTool"; @@ -1123,14 +1138,14 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, || this->FortranProject) { std::ostringstream libdeps; - this->Internal->OutputObjects(libdeps, &target); + this->Internal->OutputObjects(libdeps, target); if(!libdeps.str().empty()) { fout << "\t\t\t\tAdditionalDependencies=\"" << libdeps.str() << "\"\n"; } } std::string libflags; - this->GetStaticLibraryFlags(libflags, configTypeUpper, &target); + this->GetStaticLibraryFlags(libflags, configTypeUpper, target); if(!libflags.empty()) { fout << "\t\t\t\tAdditionalOptions=\"" << libflags << "\"\n"; @@ -1139,19 +1154,19 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, << this->ConvertToXMLOutputPathSingle(libpath.c_str()) << "\"/>\n"; break; } - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: { std::string targetName; std::string targetNameSO; std::string targetNameFull; std::string targetNameImport; std::string targetNamePDB; - gt->GetLibraryNames(targetName, targetNameSO, targetNameFull, + target->GetLibraryNames(targetName, targetNameSO, targetNameFull, targetNameImport, targetNamePDB, configName); // Compute the link library and directory information. - cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName); + cmComputeLinkInformation* pcli = target->GetLinkInformation(configName); if(!pcli) { return; @@ -1183,12 +1198,12 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8 || this->FortranProject) { - this->Internal->OutputObjects(fout, &target, " "); + this->Internal->OutputObjects(fout, target, " "); } fout << " "; this->Internal->OutputLibraries(fout, cli.GetItems()); fout << "\"\n"; - temp = target.GetDirectory(configName); + temp = target->GetDirectory(configName); temp += "/"; temp += targetNameFull; fout << "\t\t\t\tOutputFile=\"" @@ -1198,7 +1213,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, fout << "\t\t\t\tAdditionalLibraryDirectories=\""; this->OutputLibraryDirectories(fout, cli.GetDirectories()); fout << "\"\n"; - temp = target.GetPDBDirectory(configName); + temp = target->GetPDBDirectory(configName); temp += "/"; temp += targetNamePDB; fout << "\t\t\t\tProgramDatabaseFile=\"" << @@ -1226,7 +1241,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, { fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"\n"; } - temp = target.GetDirectory(configName, true); + temp = target->GetDirectory(configName, true); temp += "/"; temp += targetNameImport; fout << "\t\t\t\tImportLibrary=\"" @@ -1238,17 +1253,17 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, fout << "/>\n"; } break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: { std::string targetName; std::string targetNameFull; std::string targetNameImport; std::string targetNamePDB; - gt->GetExecutableNames(targetName, targetNameFull, + target->GetExecutableNames(targetName, targetNameFull, targetNameImport, targetNamePDB, configName); // Compute the link library and directory information. - cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName); + cmComputeLinkInformation* pcli = target->GetLinkInformation(configName); if(!pcli) { return; @@ -1256,7 +1271,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, cmComputeLinkInformation& cli = *pcli; std::string linkLanguage = cli.GetLinkLanguage(); - bool isWin32Executable = target.GetPropertyAsBool("WIN32_EXECUTABLE"); + bool isWin32Executable = target->GetPropertyAsBool("WIN32_EXECUTABLE"); // Compute the variable name to lookup standard libraries for this // language. @@ -1282,12 +1297,12 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8 || this->FortranProject) { - this->Internal->OutputObjects(fout, &target, " "); + this->Internal->OutputObjects(fout, target, " "); } fout << " "; this->Internal->OutputLibraries(fout, cli.GetItems()); fout << "\"\n"; - temp = target.GetDirectory(configName); + temp = target->GetDirectory(configName); temp += "/"; temp += targetNameFull; fout << "\t\t\t\tOutputFile=\"" @@ -1298,7 +1313,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, this->OutputLibraryDirectories(fout, cli.GetDirectories()); fout << "\"\n"; std::string path = this->ConvertToXMLOutputPathSingle( - target.GetPDBDirectory(configName).c_str()); + target->GetPDBDirectory(configName).c_str()); fout << "\t\t\t\tProgramDatabaseFile=\"" << path << "/" << targetNamePDB << "\"\n"; @@ -1345,16 +1360,16 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, { fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\""; } - temp = target.GetDirectory(configName, true); + temp = target->GetDirectory(configName, true); temp += "/"; temp += targetNameImport; fout << "\t\t\t\tImportLibrary=\"" << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"/>\n"; break; } - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: - case cmTarget::INTERFACE_LIBRARY: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: + case cmState::INTERFACE_LIBRARY: break; } } @@ -1362,11 +1377,11 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, //---------------------------------------------------------------------------- void cmLocalVisualStudio7Generator -::WriteTargetVersionAttribute(std::ostream& fout, cmTarget& target) +::WriteTargetVersionAttribute(std::ostream& fout, cmGeneratorTarget* gt) { int major; int minor; - target.GetTargetVersion(major, minor); + gt->GetTargetVersion(major, minor); fout << "\t\t\t\tVersion=\"" << major << "." << minor << "\"\n"; } @@ -1386,7 +1401,7 @@ cmLocalVisualStudio7GeneratorInternals fout << lg->ConvertToXMLOutputPath(rel.c_str()) << " "; } else if (!l->Target - || l->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + || l->Target->GetType() != cmState::INTERFACE_LIBRARY) { fout << l->Value << " "; } @@ -1396,13 +1411,11 @@ cmLocalVisualStudio7GeneratorInternals //---------------------------------------------------------------------------- void cmLocalVisualStudio7GeneratorInternals -::OutputObjects(std::ostream& fout, cmTarget* t, const char* isep) +::OutputObjects(std::ostream& fout, cmGeneratorTarget* gt, const char* isep) { // VS < 8 does not support per-config source locations so we // list object library content on the link line instead. cmLocalVisualStudio7Generator* lg = this->LocalGenerator; - cmGeneratorTarget* gt = - lg->GetGlobalGenerator()->GetGeneratorTarget(t); std::vector<std::string> objs; gt->UseObjectLibraries(objs, ""); const char* sep = isep? isep : ""; @@ -1459,7 +1472,7 @@ cmLocalVisualStudio7Generator void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, const std::string& libName, - cmTarget &target) + cmGeneratorTarget* target) { std::vector<std::string> configs; this->Makefile->GetConfigurations(configs); @@ -1467,13 +1480,10 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, // We may be modifying the source groups temporarily, so make a copy. std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups(); - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); - // get the classes from the source lists then add them to the groups this->ModuleDefinitionFile = ""; std::vector<cmSourceFile*> classes; - if (!gt->GetConfigCommonSourceFiles(classes)) + if (!target->GetConfigCommonSourceFiles(classes)) { return; } @@ -1516,7 +1526,7 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, // VS >= 8 support per-config source locations so we // list object library content as external objects. std::vector<std::string> objs; - gt->UseObjectLibraries(objs, ""); + target->UseObjectLibraries(objs, ""); if(!objs.empty()) { // TODO: Separate sub-filter for each object library used? @@ -1551,7 +1561,7 @@ class cmLocalVisualStudio7GeneratorFCInfo { public: cmLocalVisualStudio7GeneratorFCInfo(cmLocalVisualStudio7Generator* lg, - cmTarget& target, + cmGeneratorTarget* target, cmSourceFile const& sf, std::vector<std::string> const& configs); std::map<std::string, cmLVS7GFileConfig> FileConfigMap; @@ -1559,12 +1569,10 @@ public: cmLocalVisualStudio7GeneratorFCInfo ::cmLocalVisualStudio7GeneratorFCInfo(cmLocalVisualStudio7Generator* lg, - cmTarget& target, + cmGeneratorTarget* gt, cmSourceFile const& sf, std::vector<std::string> const& configs) { - cmGeneratorTarget* gt = - lg->GetGlobalGenerator()->GetGeneratorTarget(&target); std::string objectName; if(gt->HasExplicitObjectName(&sf)) { @@ -1681,10 +1689,10 @@ cmLocalVisualStudio7GeneratorFCInfo //---------------------------------------------------------------------------- std::string cmLocalVisualStudio7Generator -::ComputeLongestObjectDirectory(cmTarget& target) const +::ComputeLongestObjectDirectory(cmGeneratorTarget const* target) const { std::vector<std::string> configs; - target.GetMakefile()->GetConfigurations(configs); + target->Target->GetMakefile()->GetConfigurations(configs); // Compute the maximum length configuration name. std::string config_max; @@ -1701,7 +1709,7 @@ cmLocalVisualStudio7Generator // files directory for any configuration. This is used to construct // object file names that do not produce paths that are too long. std::string dir_max; - dir_max += this->Makefile->GetCurrentBinaryDirectory(); + dir_max += this->GetCurrentBinaryDirectory(); dir_max += "/"; dir_max += this->GetTargetDirectory(target); dir_max += "/"; @@ -1711,7 +1719,7 @@ cmLocalVisualStudio7Generator } bool cmLocalVisualStudio7Generator -::WriteGroup(const cmSourceGroup *sg, cmTarget& target, +::WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target, std::ostream &fout, const std::string& libName, std::vector<std::string> const& configs) { @@ -1746,15 +1754,14 @@ bool cmLocalVisualStudio7Generator } // Loop through each source in the source group. - std::string objectName; for(std::vector<const cmSourceFile *>::const_iterator sf = sourceFiles.begin(); sf != sourceFiles.end(); ++sf) { std::string source = (*sf)->GetFullPath(); FCInfo fcinfo(this, target, *(*sf), configs); - if (source != libName || target.GetType() == cmTarget::UTILITY || - target.GetType() == cmTarget::GLOBAL_TARGET ) + if (source != libName || target->GetType() == cmState::UTILITY || + target->GetType() == cmState::GLOBAL_TARGET ) { fout << "\t\t\t<File\n"; std::string d = this->ConvertToXMLOutputPathSingle(source.c_str()); @@ -2001,10 +2008,10 @@ void cmLocalVisualStudio7Generator::WriteVCProjEndGroup(std::ostream& fout) void cmLocalVisualStudio7Generator ::OutputTargetRules(std::ostream& fout, const std::string& configName, - cmTarget &target, + cmGeneratorTarget *target, const std::string& /*libName*/) { - if (target.GetType() > cmTarget::GLOBAL_TARGET) + if (target->GetType() > cmState::GLOBAL_TARGET) { return; } @@ -2014,36 +2021,35 @@ void cmLocalVisualStudio7Generator const char* tool = this->FortranProject? "VFPreBuildEventTool":"VCPreBuildEventTool"; event.Start(tool); - event.Write(target.GetPreBuildCommands()); + event.Write(target->GetPreBuildCommands()); event.Finish(); // Add pre-link event. tool = this->FortranProject? "VFPreLinkEventTool":"VCPreLinkEventTool"; event.Start(tool); bool addedPrelink = false; - if (target.GetType() == cmTarget::SHARED_LIBRARY && + if (target->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if (target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if (target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { addedPrelink = true; std::vector<cmCustomCommand> commands = - target.GetPreLinkCommands(); + target->GetPreLinkCommands(); cmGlobalVisualStudioGenerator* gg = static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator); - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); gg->AddSymbolExportCommand( - gt, commands, configName); + target, commands, configName); event.Write(commands); } } if (!addedPrelink) { - event.Write(target.GetPreLinkCommands()); + event.Write(target->GetPreLinkCommands()); } cmsys::auto_ptr<cmCustomCommand> pcc( - this->MaybeCreateImplibDir(target, configName, this->FortranProject)); + this->MaybeCreateImplibDir(target, + configName, this->FortranProject)); if(pcc.get()) { event.Write(*pcc); @@ -2053,18 +2059,18 @@ void cmLocalVisualStudio7Generator // Add post-build event. tool = this->FortranProject? "VFPostBuildEventTool":"VCPostBuildEventTool"; event.Start(tool); - event.Write(target.GetPostBuildCommands()); + event.Write(target->GetPostBuildCommands()); event.Finish(); } void cmLocalVisualStudio7Generator::WriteProjectSCC(std::ostream& fout, - cmTarget& target) + cmGeneratorTarget* target) { // if we have all the required Source code control tags // then add that to the project - const char* vsProjectname = target.GetProperty("VS_SCC_PROJECTNAME"); - const char* vsLocalpath = target.GetProperty("VS_SCC_LOCALPATH"); - const char* vsProvider = target.GetProperty("VS_SCC_PROVIDER"); + const char* vsProjectname = target->GetProperty("VS_SCC_PROJECTNAME"); + const char* vsLocalpath = target->GetProperty("VS_SCC_LOCALPATH"); + const char* vsProvider = target->GetProperty("VS_SCC_PROVIDER"); if(vsProvider && vsLocalpath && vsProjectname) { @@ -2072,7 +2078,7 @@ void cmLocalVisualStudio7Generator::WriteProjectSCC(std::ostream& fout, << "\tSccLocalPath=\"" << vsLocalpath << "\"\n" << "\tSccProvider=\"" << vsProvider << "\"\n"; - const char* vsAuxPath = target.GetProperty("VS_SCC_AUXPATH"); + const char* vsAuxPath = target->GetProperty("VS_SCC_AUXPATH"); if(vsAuxPath) { fout << "\tSccAuxPath=\"" << vsAuxPath << "\"\n"; @@ -2084,7 +2090,7 @@ void cmLocalVisualStudio7Generator ::WriteProjectStartFortran(std::ostream& fout, const std::string& libName, - cmTarget & target) + cmGeneratorTarget *target) { cmGlobalVisualStudio7Generator* gg = @@ -2094,38 +2100,38 @@ cmLocalVisualStudio7Generator << "<VisualStudioProject\n" << "\tProjectCreator=\"Intel Fortran\"\n" << "\tVersion=\"" << gg->GetIntelProjectVersion() << "\"\n"; - const char* keyword = target.GetProperty("VS_KEYWORD"); + const char* keyword = target->GetProperty("VS_KEYWORD"); if(!keyword) { keyword = "Console Application"; } const char* projectType = 0; - switch(target.GetType()) + switch(target->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: projectType = "typeStaticLibrary"; if(keyword) { keyword = "Static Library"; } break; - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: projectType = "typeDynamicLibrary"; if(!keyword) { keyword = "Dll"; } break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: if(!keyword) { keyword = "Console Application"; } projectType = 0; break; - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: default: break; } @@ -2145,7 +2151,7 @@ cmLocalVisualStudio7Generator void cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout, const std::string& libName, - cmTarget & target, + cmGeneratorTarget *target, std::vector<cmSourceGroup> &) { if(this->FortranProject) @@ -2169,12 +2175,12 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout, { fout << "\tVersion=\"" << (gg->GetVersion()/10) << ".00\"\n"; } - const char* projLabel = target.GetProperty("PROJECT_LABEL"); + const char* projLabel = target->GetProperty("PROJECT_LABEL"); if(!projLabel) { projLabel = libName.c_str(); } - const char* keyword = target.GetProperty("VS_KEYWORD"); + const char* keyword = target->GetProperty("VS_KEYWORD"); if(!keyword) { keyword = "Win32Proj"; @@ -2186,7 +2192,7 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout, } this->WriteProjectSCC(fout, target); if(const char* targetFrameworkVersion = - target.GetProperty("VS_DOTNET_TARGET_FRAMEWORK_VERSION")) + target->GetProperty("VS_DOTNET_TARGET_FRAMEWORK_VERSION")) { fout << "\tTargetFrameworkVersion=\"" << targetFrameworkVersion << "\"\n"; } @@ -2207,22 +2213,24 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout, } -void cmLocalVisualStudio7Generator::WriteVCProjFooter(std::ostream& fout, - cmTarget &target) +void cmLocalVisualStudio7Generator::WriteVCProjFooter( + std::ostream& fout, + cmGeneratorTarget *target) { fout << "\t<Globals>\n"; - cmPropertyMap const& props = target.GetProperties(); - for(cmPropertyMap::const_iterator i = props.begin(); i != props.end(); ++i) + std::vector<std::string> const& props = target->GetPropertyKeys(); + for(std::vector<std::string>::const_iterator i = props.begin(); + i != props.end(); ++i) { - if(i->first.find("VS_GLOBAL_") == 0) + if(i->find("VS_GLOBAL_") == 0) { - std::string name = i->first.substr(10); + std::string name = i->substr(10); if(name != "") { fout << "\t\t<Global\n" << "\t\t\tName=\"" << name << "\"\n" - << "\t\t\tValue=\"" << i->second.GetValue() << "\"\n" + << "\t\t\tValue=\"" << target->GetProperty(*i) << "\"\n" << "\t\t/>\n"; } } @@ -2347,10 +2355,10 @@ void cmLocalVisualStudio7Generator::ReadAndStoreExternalGUID( //---------------------------------------------------------------------------- std::string cmLocalVisualStudio7Generator -::GetTargetDirectory(cmTarget const& target) const +::GetTargetDirectory(cmGeneratorTarget const* target) const { std::string dir; - dir += target.GetName(); + dir += target->GetName(); dir += ".dir"; return dir; } diff --git a/Source/cmLocalVisualStudio7Generator.h b/Source/cmLocalVisualStudio7Generator.h index bc05a06..7bb9cc6 100644 --- a/Source/cmLocalVisualStudio7Generator.h +++ b/Source/cmLocalVisualStudio7Generator.h @@ -15,7 +15,6 @@ #include "cmLocalVisualStudioGenerator.h" #include "cmVisualStudioGeneratorOptions.h" -class cmTarget; class cmSourceFile; class cmCustomCommand; class cmSourceGroup; @@ -53,16 +52,19 @@ public: */ void SetBuildType(BuildType,const std::string& name); - virtual std::string GetTargetDirectory(cmTarget const&) const; + virtual + std::string GetTargetDirectory(cmGeneratorTarget const* target) const; cmSourceFile* CreateVCProjBuildRule(); void WriteStampFiles(); - virtual std::string ComputeLongestObjectDirectory(cmTarget&) const; + virtual std::string + ComputeLongestObjectDirectory(cmGeneratorTarget const*) const; virtual void ReadAndStoreExternalGUID(const std::string& name, const char* path); virtual void AddCMakeListsRules(); protected: - void CreateSingleVCProj(const std::string& lname, cmTarget &tgt); + void CreateSingleVCProj(const std::string& lname, + cmGeneratorTarget *tgt); private: typedef cmVisualStudioGeneratorOptions Options; typedef cmLocalVisualStudio7GeneratorFCInfo FCInfo; @@ -71,30 +73,33 @@ private: void FixGlobalTargets(); void WriteProjectFiles(); void WriteVCProjHeader(std::ostream& fout, const std::string& libName, - cmTarget &tgt, std::vector<cmSourceGroup> &sgs); - void WriteVCProjFooter(std::ostream& fout, cmTarget &target); + cmGeneratorTarget* tgt, + std::vector<cmSourceGroup> &sgs); + void WriteVCProjFooter(std::ostream& fout, cmGeneratorTarget* target); void WriteVCProjFile(std::ostream& fout, const std::string& libName, - cmTarget &tgt); + cmGeneratorTarget* tgt); void WriteConfigurations(std::ostream& fout, std::vector<std::string> const& configs, - const std::string& libName, cmTarget &tgt); + const std::string& libName, cmGeneratorTarget* tgt); void WriteConfiguration(std::ostream& fout, const std::string& configName, - const std::string& libName, cmTarget &tgt); + const std::string& libName, cmGeneratorTarget* tgt); std::string EscapeForXML(const std::string& s); std::string ConvertToXMLOutputPath(const char* path); std::string ConvertToXMLOutputPathSingle(const char* path); void OutputTargetRules(std::ostream& fout, const std::string& configName, - cmTarget &target, const std::string& libName); + cmGeneratorTarget* target, + const std::string& libName); void OutputBuildTool(std::ostream& fout, const std::string& configName, - cmTarget& t, const Options& targetOptions); + cmGeneratorTarget* t, const Options& targetOptions); void OutputLibraryDirectories(std::ostream& fout, std::vector<std::string> const& dirs); - void WriteProjectSCC(std::ostream& fout, cmTarget& target); + void WriteProjectSCC(std::ostream& fout, cmGeneratorTarget *target); void WriteProjectStart(std::ostream& fout, const std::string& libName, - cmTarget &tgt, std::vector<cmSourceGroup> &sgs); + cmGeneratorTarget* tgt, + std::vector<cmSourceGroup> &sgs); void WriteProjectStartFortran(std::ostream& fout, const std::string& libName, - cmTarget &tgt); + cmGeneratorTarget* tgt); void WriteVCProjBeginGroup(std::ostream& fout, const char* group, const char* filter); @@ -105,10 +110,11 @@ private: const char* source, const cmCustomCommand& command, FCInfo& fcinfo); - void WriteTargetVersionAttribute(std::ostream& fout, cmTarget& target); + void WriteTargetVersionAttribute(std::ostream& fout, + cmGeneratorTarget* gt); bool WriteGroup(const cmSourceGroup *sg, - cmTarget& target, std::ostream &fout, + cmGeneratorTarget* target, std::ostream &fout, const std::string& libName, std::vector<std::string> const& configs); diff --git a/Source/cmLocalVisualStudioGenerator.cxx b/Source/cmLocalVisualStudioGenerator.cxx index c0072de..561f9a1 100644 --- a/Source/cmLocalVisualStudioGenerator.cxx +++ b/Source/cmLocalVisualStudioGenerator.cxx @@ -43,7 +43,7 @@ void cmLocalVisualStudioGenerator::ComputeObjectFilenames( std::map<cmSourceFile const*, std::string>& mapping, cmGeneratorTarget const* gt) { - std::string dir_max = this->ComputeLongestObjectDirectory(*gt->Target); + std::string dir_max = this->ComputeLongestObjectDirectory(gt); // Count the number of object files with each name. Note that // windows file names are not case sensitive. @@ -80,7 +80,7 @@ void cmLocalVisualStudioGenerator::ComputeObjectFilenames( //---------------------------------------------------------------------------- cmsys::auto_ptr<cmCustomCommand> -cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmTarget& target, +cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmGeneratorTarget* target, const std::string& config, bool isFortran) { @@ -89,11 +89,11 @@ cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmTarget& target, // If an executable exports symbols then VS wants to create an // import library but forgets to create the output directory. // The Intel Fortran plugin always forgets to the directory. - if(target.GetType() != cmTarget::EXECUTABLE && - !(isFortran && target.GetType() == cmTarget::SHARED_LIBRARY)) + if(target->GetType() != cmState::EXECUTABLE && + !(isFortran && target->GetType() == cmState::SHARED_LIBRARY)) { return pcc; } - std::string outDir = target.GetDirectory(config, false); - std::string impDir = target.GetDirectory(config, true); + std::string outDir = target->GetDirectory(config, false); + std::string impDir = target->GetDirectory(config, true); if(impDir == outDir) { return pcc; } // Add a pre-build event to create the directory. diff --git a/Source/cmLocalVisualStudioGenerator.h b/Source/cmLocalVisualStudioGenerator.h index 071bfb3..f95eefa 100644 --- a/Source/cmLocalVisualStudioGenerator.h +++ b/Source/cmLocalVisualStudioGenerator.h @@ -44,7 +44,8 @@ public: cmGlobalVisualStudioGenerator::VSVersion GetVersion() const; - virtual std::string ComputeLongestObjectDirectory(cmTarget&) const = 0; + virtual std::string + ComputeLongestObjectDirectory(cmGeneratorTarget const*) const = 0; virtual void AddCMakeListsRules() = 0; @@ -58,7 +59,8 @@ protected: /** Construct a custom command to make exe import lib dir. */ cmsys::auto_ptr<cmCustomCommand> - MaybeCreateImplibDir(cmTarget& target, const std::string& config, + MaybeCreateImplibDir(cmGeneratorTarget *target, + const std::string& config, bool isFortran); }; diff --git a/Source/cmLocalXCodeGenerator.cxx b/Source/cmLocalXCodeGenerator.cxx index b19112d..aec2603 100644 --- a/Source/cmLocalXCodeGenerator.cxx +++ b/Source/cmLocalXCodeGenerator.cxx @@ -31,7 +31,7 @@ cmLocalXCodeGenerator::~cmLocalXCodeGenerator() //---------------------------------------------------------------------------- std::string -cmLocalXCodeGenerator::GetTargetDirectory(cmTarget const&) const +cmLocalXCodeGenerator::GetTargetDirectory(cmGeneratorTarget const*) const { // No per-target directory for this generator (yet). return ""; @@ -51,12 +51,11 @@ void cmLocalXCodeGenerator::Generate() { cmLocalGenerator::Generate(); - cmTargets& targets = this->Makefile->GetTargets(); - for(cmTargets::iterator iter = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator iter = targets.begin(); iter != targets.end(); ++iter) { - cmTarget* t = &iter->second; - t->HasMacOSXRpathInstallNameDir(""); + (*iter)->HasMacOSXRpathInstallNameDir(""); } } @@ -65,12 +64,11 @@ void cmLocalXCodeGenerator::GenerateInstallRules() { cmLocalGenerator::GenerateInstallRules(); - cmTargets& targets = this->Makefile->GetTargets(); - for(cmTargets::iterator iter = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator iter = targets.begin(); iter != targets.end(); ++iter) { - cmTarget* t = &iter->second; - t->HasMacOSXRpathInstallNameDir(""); + (*iter)->HasMacOSXRpathInstallNameDir(""); } } diff --git a/Source/cmLocalXCodeGenerator.h b/Source/cmLocalXCodeGenerator.h index 6d0926f..4381a6d 100644 --- a/Source/cmLocalXCodeGenerator.h +++ b/Source/cmLocalXCodeGenerator.h @@ -28,7 +28,8 @@ public: cmMakefile* mf); virtual ~cmLocalXCodeGenerator(); - virtual std::string GetTargetDirectory(cmTarget const& target) const; + virtual + std::string GetTargetDirectory(cmGeneratorTarget const* target) const; virtual void AppendFlagEscape(std::string& flags, const std::string& rawFlag); virtual void Generate(); diff --git a/Source/cmMakeDepend.cxx b/Source/cmMakeDepend.cxx deleted file mode 100644 index cbc7e02..0000000 --- a/Source/cmMakeDepend.cxx +++ /dev/null @@ -1,361 +0,0 @@ -/*============================================================================ - CMake - Cross Platform Makefile Generator - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ -#include "cmMakeDepend.h" -#include "cmSystemTools.h" -#include "cmGeneratorExpression.h" -#include "cmAlgorithms.h" - -#include <cmsys/RegularExpression.hxx> -#include <cmsys/FStream.hxx> - -void cmDependInformation::AddDependencies(cmDependInformation* info) -{ - if(this != info) - { - this->DependencySet.insert(info); - } -} - -cmMakeDepend::cmMakeDepend() -{ - this->Verbose = false; - this->IncludeFileRegularExpression.compile("^.*$"); - this->ComplainFileRegularExpression.compile("^$"); -} - - -cmMakeDepend::~cmMakeDepend() -{ - cmDeleteAll(this->DependInformationMap); -} - - -// Set the makefile that depends will be made from. -// The pointer is kept so the cmSourceFile array can -// be updated with the depend information in the cmMakefile. - -void cmMakeDepend::SetMakefile(cmMakefile* makefile) -{ - this->Makefile = makefile; - - // Now extract the include file regular expression from the makefile. - this->IncludeFileRegularExpression.compile( - this->Makefile->GetIncludeRegularExpression()); - this->ComplainFileRegularExpression.compile( - this->Makefile->ComplainFileRegularExpression.c_str()); - - // Now extract any include paths from the targets - std::set<std::string> uniqueIncludes; - std::vector<std::string> orderedAndUniqueIncludes; - cmTargets &targets = this->Makefile->GetTargets(); - for (cmTargets::iterator l = targets.begin(); - l != targets.end(); ++l) - { - const char *incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES"); - if (!incDirProp) - { - continue; - } - - std::string incDirs = cmGeneratorExpression::Preprocess(incDirProp, - cmGeneratorExpression::StripAllGeneratorExpressions); - - std::vector<std::string> includes; - cmSystemTools::ExpandListArgument(incDirs, includes); - - for(std::vector<std::string>::const_iterator j = includes.begin(); - j != includes.end(); ++j) - { - std::string path = *j; - this->Makefile->ExpandVariablesInString(path); - if(uniqueIncludes.insert(path).second) - { - orderedAndUniqueIncludes.push_back(path); - } - } - } - - for(std::vector<std::string>::const_iterator - it = orderedAndUniqueIncludes.begin(); - it != orderedAndUniqueIncludes.end(); - ++it) - { - this->AddSearchPath(*it); - } -} - - -const cmDependInformation* cmMakeDepend::FindDependencies(const char* file) -{ - cmDependInformation* info = this->GetDependInformation(file,0); - this->GenerateDependInformation(info); - return info; -} - -void cmMakeDepend::GenerateDependInformation(cmDependInformation* info) -{ - // If dependencies are already done, stop now. - if(info->DependDone) - { - return; - } - else - { - // Make sure we don't visit the same file more than once. - info->DependDone = true; - } - const char* path = info->FullPath.c_str(); - if(!path) - { - cmSystemTools::Error( - "Attempt to find dependencies for file without path!"); - return; - } - - bool found = false; - - // If the file exists, use it to find dependency information. - if(cmSystemTools::FileExists(path, true)) - { - // Use the real file to find its dependencies. - this->DependWalk(info); - found = true; - } - - - // See if the cmSourceFile for it has any files specified as - // dependency hints. - if(info->SourceFile != 0) - { - - // Get the cmSourceFile corresponding to this. - const cmSourceFile& cFile = *(info->SourceFile); - // See if there are any hints for finding dependencies for the missing - // file. - if(!cFile.GetDepends().empty()) - { - // Dependency hints have been given. Use them to begin the - // recursion. - for(std::vector<std::string>::const_iterator file = - cFile.GetDepends().begin(); file != cFile.GetDepends().end(); - ++file) - { - this->AddDependency(info, file->c_str()); - } - - // Found dependency information. We are done. - found = true; - } - } - - if(!found) - { - // Try to find the file amongst the sources - cmSourceFile *srcFile = this->Makefile->GetSource - (cmSystemTools::GetFilenameWithoutExtension(path)); - if (srcFile) - { - if (srcFile->GetFullPath() == path) - { - found=true; - } - else - { - //try to guess which include path to use - for(std::vector<std::string>::iterator t = - this->IncludeDirectories.begin(); - t != this->IncludeDirectories.end(); ++t) - { - std::string incpath = *t; - if (!incpath.empty() && incpath[incpath.size() - 1] != '/') - { - incpath = incpath + "/"; - } - incpath = incpath + path; - if (srcFile->GetFullPath() == incpath) - { - // set the path to the guessed path - info->FullPath = incpath; - found=true; - } - } - } - } - } - - if(!found) - { - // Couldn't find any dependency information. - if(this->ComplainFileRegularExpression.find(info->IncludeName.c_str())) - { - cmSystemTools::Error("error cannot find dependencies for ", path); - } - else - { - // Destroy the name of the file so that it won't be output as a - // dependency. - info->FullPath = ""; - } - } -} - -// This function actually reads the file specified and scans it for -// #include directives -void cmMakeDepend::DependWalk(cmDependInformation* info) -{ - cmsys::RegularExpression includeLine - ("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]"); - cmsys::ifstream fin(info->FullPath.c_str()); - if(!fin) - { - cmSystemTools::Error("Cannot open ", info->FullPath.c_str()); - return; - } - - // TODO: Write real read loop (see cmSystemTools::CopyFile). - std::string line; - while( cmSystemTools::GetLineFromStream(fin, line) ) - { - if(includeLine.find(line.c_str())) - { - // extract the file being included - std::string includeFile = includeLine.match(1); - // see if the include matches the regular expression - if(!this->IncludeFileRegularExpression.find(includeFile)) - { - if(this->Verbose) - { - std::string message = "Skipping "; - message += includeFile; - message += " for file "; - message += info->FullPath.c_str(); - cmSystemTools::Error(message.c_str(), 0); - } - continue; - } - - // Add this file and all its dependencies. - this->AddDependency(info, includeFile.c_str()); - } - } -} - - -void cmMakeDepend::AddDependency(cmDependInformation* info, const char* file) -{ - cmDependInformation* dependInfo = - this->GetDependInformation(file, info->PathOnly.c_str()); - this->GenerateDependInformation(dependInfo); - info->AddDependencies(dependInfo); -} - -cmDependInformation* cmMakeDepend::GetDependInformation(const char* file, - const char *extraPath) -{ - // Get the full path for the file so that lookup is unambiguous. - std::string fullPath = this->FullPath(file, extraPath); - - // Try to find the file's instance of cmDependInformation. - DependInformationMapType::const_iterator result = - this->DependInformationMap.find(fullPath); - if(result != this->DependInformationMap.end()) - { - // Found an instance, return it. - return result->second; - } - else - { - // Didn't find an instance. Create a new one and save it. - cmDependInformation* info = new cmDependInformation; - info->FullPath = fullPath; - info->PathOnly = cmSystemTools::GetFilenamePath(fullPath); - info->IncludeName = file; - this->DependInformationMap[fullPath] = info; - return info; - } -} - - -// find the full path to fname by searching the this->IncludeDirectories array -std::string cmMakeDepend::FullPath(const char* fname, const char *extraPath) -{ - DirectoryToFileToPathMapType::iterator m; - if(extraPath) - { - m = this->DirectoryToFileToPathMap.find(extraPath); - } - else - { - m = this->DirectoryToFileToPathMap.find(""); - } - - if(m != this->DirectoryToFileToPathMap.end()) - { - FileToPathMapType& map = m->second; - FileToPathMapType::iterator p = map.find(fname); - if(p != map.end()) - { - return p->second; - } - } - - if(cmSystemTools::FileExists(fname, true)) - { - std::string fp = cmSystemTools::CollapseFullPath(fname); - this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp; - return fp; - } - - for(std::vector<std::string>::iterator i = this->IncludeDirectories.begin(); - i != this->IncludeDirectories.end(); ++i) - { - std::string path = *i; - if (!path.empty() && path[path.size() - 1] != '/') - { - path = path + "/"; - } - path = path + fname; - if(cmSystemTools::FileExists(path.c_str(), true) - && !cmSystemTools::FileIsDirectory(path)) - { - std::string fp = cmSystemTools::CollapseFullPath(path); - this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp; - return fp; - } - } - - if (extraPath) - { - std::string path = extraPath; - if (!path.empty() && path[path.size() - 1] != '/') - { - path = path + "/"; - } - path = path + fname; - if(cmSystemTools::FileExists(path.c_str(), true) - && !cmSystemTools::FileIsDirectory(path)) - { - std::string fp = cmSystemTools::CollapseFullPath(path); - this->DirectoryToFileToPathMap[extraPath][fname] = fp; - return fp; - } - } - - // Couldn't find the file. - return std::string(fname); -} - -// Add a directory to the search path -void cmMakeDepend::AddSearchPath(const std::string& path) -{ - this->IncludeDirectories.push_back(path); -} diff --git a/Source/cmMakeDepend.h b/Source/cmMakeDepend.h deleted file mode 100644 index 2c9d515..0000000 --- a/Source/cmMakeDepend.h +++ /dev/null @@ -1,150 +0,0 @@ -/*============================================================================ - CMake - Cross Platform Makefile Generator - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ -#ifndef cmMakeDepend_h -#define cmMakeDepend_h - -#include "cmMakefile.h" -#include "cmSourceFile.h" - -#include <cmsys/RegularExpression.hxx> - -/** \class cmDependInformation - * \brief Store dependency information for a single source file. - * - * This structure stores the depend information for a single source file. - */ -class cmDependInformation -{ -public: - /** - * Construct with dependency generation marked not done; instance - * not placed in cmMakefile's list. - */ - cmDependInformation(): DependDone(false), SourceFile(0) {} - - /** - * The set of files on which this one depends. - */ - typedef std::set<cmDependInformation*> DependencySetType; - DependencySetType DependencySet; - - /** - * This flag indicates whether dependency checking has been - * performed for this file. - */ - bool DependDone; - - /** - * If this object corresponds to a cmSourceFile instance, this points - * to it. - */ - const cmSourceFile *SourceFile; - - /** - * Full path to this file. - */ - std::string FullPath; - - /** - * Full path not including file name. - */ - std::string PathOnly; - - /** - * Name used to #include this file. - */ - std::string IncludeName; - - /** - * This method adds the dependencies of another file to this one. - */ - void AddDependencies(cmDependInformation*); -}; - - -// cmMakeDepend is used to generate dependancy information for -// the classes in a makefile -class cmMakeDepend -{ -public: - /** - * Construct the object with verbose turned off. - */ - cmMakeDepend(); - - /** - * Destructor. - */ - virtual ~cmMakeDepend(); - - /** - * Set the makefile that is used as a source of classes. - */ - virtual void SetMakefile(cmMakefile* makefile); - - /** - * Add a directory to the search path for include files. - */ - virtual void AddSearchPath(const std::string&); - - /** - * Generate dependencies for the file given. Returns a pointer to - * the cmDependInformation object for the file. - */ - const cmDependInformation* FindDependencies(const char* file); - -protected: - /** - * Compute the depend information for this class. - */ - virtual void DependWalk(cmDependInformation* info); - - /** - * Add a dependency. Possibly walk it for more dependencies. - */ - virtual void AddDependency(cmDependInformation* info, const char* file); - - /** - * Fill in the given object with dependency information. If the - * information is already complete, nothing is done. - */ - void GenerateDependInformation(cmDependInformation* info); - - /** - * Get an instance of cmDependInformation corresponding to the given file - * name. - */ - cmDependInformation* GetDependInformation(const char* file, - const char *extraPath); - - /** - * Find the full path name for the given file name. - * This uses the include directories. - * TODO: Cache path conversions to reduce FileExists calls. - */ - std::string FullPath(const char *filename, const char *extraPath); - - cmMakefile* Makefile; - bool Verbose; - cmsys::RegularExpression IncludeFileRegularExpression; - cmsys::RegularExpression ComplainFileRegularExpression; - std::vector<std::string> IncludeDirectories; - typedef std::map<std::string, std::string> FileToPathMapType; - typedef std::map<std::string, FileToPathMapType> - DirectoryToFileToPathMapType; - typedef std::map<std::string, cmDependInformation*> - DependInformationMapType; - DependInformationMapType DependInformationMap; - DirectoryToFileToPathMapType DirectoryToFileToPathMap; -}; - -#endif diff --git a/Source/cmMakeDirectoryCommand.h b/Source/cmMakeDirectoryCommand.h index 71b97eb..617f1fe 100644 --- a/Source/cmMakeDirectoryCommand.h +++ b/Source/cmMakeDirectoryCommand.h @@ -51,12 +51,6 @@ public: */ virtual bool IsScriptable() const { return true; } - /** This command is kept for compatibility with older CMake versions. */ - virtual bool IsDiscouraged() const - { - return true; - } - cmTypeMacro(cmMakeDirectoryCommand, cmCommand); }; diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index 8a3d197..4fb4579 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -50,47 +50,16 @@ cmMakefile::cmMakefile(cmGlobalGenerator* globalGenerator, { this->IsSourceFileTryCompile = false; - // Initialize these first since AddDefaultDefinitions calls AddDefinition this->WarnUnused = this->GetCMakeInstance()->GetWarnUnused(); this->CheckSystemVars = this->GetCMakeInstance()->GetCheckSystemVars(); - this->Configured = false; this->SuppressWatches = false; - // Setup the default include file regular expression (match everything). - this->SetProperty("INCLUDE_REGULAR_EXPRESSION", "^.*$"); // Setup the default include complaint regular expression (match nothing). this->ComplainFileRegularExpression = "^$"; - // Source and header file extensions that we can handle - - // Set up a list of source and header extensions - // these are used to find files when the extension - // is not given - // The "c" extension MUST precede the "C" extension. - this->SourceFileExtensions.push_back( "c" ); - this->SourceFileExtensions.push_back( "C" ); - - this->SourceFileExtensions.push_back( "c++" ); - this->SourceFileExtensions.push_back( "cc" ); - this->SourceFileExtensions.push_back( "cpp" ); - this->SourceFileExtensions.push_back( "cxx" ); - this->SourceFileExtensions.push_back( "m" ); - this->SourceFileExtensions.push_back( "M" ); - this->SourceFileExtensions.push_back( "mm" ); - - this->HeaderFileExtensions.push_back( "h" ); - this->HeaderFileExtensions.push_back( "hh" ); - this->HeaderFileExtensions.push_back( "h++" ); - this->HeaderFileExtensions.push_back( "hm" ); - this->HeaderFileExtensions.push_back( "hpp" ); - this->HeaderFileExtensions.push_back( "hxx" ); - this->HeaderFileExtensions.push_back( "in" ); - this->HeaderFileExtensions.push_back( "txx" ); this->DefineFlags = " "; - this->AddDefaultDefinitions(); - this->cmDefineRegex.compile("#cmakedefine[ \t]+([A-Za-z_0-9]*)"); this->cmDefine01Regex.compile("#cmakedefine01[ \t]+([A-Za-z_0-9]*)"); this->cmAtVarRegex.compile("(@[A-Za-z_0-9/.+-]+@)"); @@ -120,17 +89,6 @@ cmMakefile::cmMakefile(cmGlobalGenerator* globalGenerator, this->AddSourceGroup("Resources", "\\.plist$"); this->AddSourceGroup("Object Files", "\\.(lo|o|obj)$"); #endif - - { - const char* dir = this->GetCMakeInstance()->GetHomeDirectory(); - this->AddDefinition("CMAKE_SOURCE_DIR", dir); - this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", dir); - } - { - const char* dir = this->GetCMakeInstance()->GetHomeOutputDirectory(); - this->AddDefinition("CMAKE_BINARY_DIR", dir); - this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", dir); - } } cmMakefile::~cmMakefile() @@ -143,9 +101,6 @@ cmMakefile::~cmMakefile() cmDeleteAll(this->FinalPassCommands); cmDeleteAll(this->FunctionBlockers); cmDeleteAll(this->EvaluationFiles); - this->EvaluationFiles.clear(); - - this->FunctionBlockers.clear(); } //---------------------------------------------------------------------------- @@ -687,6 +642,29 @@ cmMakefile::GetEvaluationFiles() const return this->EvaluationFiles; } +std::vector<cmExportBuildFileGenerator*> +cmMakefile::GetExportBuildFileGenerators() const +{ + return this->ExportBuildFileGenerators; +} + +void cmMakefile::RemoveExportBuildFileGeneratorCMP0024( + cmExportBuildFileGenerator* gen) +{ + std::vector<cmExportBuildFileGenerator*>::iterator it = + std::find(this->ExportBuildFileGenerators.begin(), + this->ExportBuildFileGenerators.end(), gen); + if(it != this->ExportBuildFileGenerators.end()) + { + this->ExportBuildFileGenerators.erase(it); + } +} + +void cmMakefile::AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen) +{ + this->ExportBuildFileGenerators.push_back(gen); +} + namespace { struct file_not_persistent @@ -753,15 +731,26 @@ void cmMakefile::ConfigureFinalPass() "with CMake 2.4 or later. For compatibility with older versions please " "use any CMake 2.8.x release or lower."); } - for (cmTargets::iterator l = this->Targets.begin(); - l != this->Targets.end(); l++) +#if defined(_WIN32) && !defined(__CYGWIN__) + // Do old-style link dependency analysis only for CM_USE_OLD_VS6. + if(this->GetGlobalGenerator()->IsForVS6()) { - if (l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + for (cmTargets::iterator l = this->Targets.begin(); + l != this->Targets.end(); l++) { - continue; + if (l->second.GetType() == cmState::INTERFACE_LIBRARY) + { + continue; + } + // Erase any cached link information that might have been comptued + // on-demand during the configuration. This ensures that build + // system generation uses up-to-date information even if other cache + // invalidation code in this source file is buggy. + + l->second.AnalyzeLibDependenciesForVS6(*this); } - l->second.FinishConfigure(); } +#endif } //---------------------------------------------------------------------------- @@ -807,7 +796,7 @@ cmMakefile::AddCustomCommandToTarget(const std::string& target, return; } - if(ti->second.GetType() == cmTarget::OBJECT_LIBRARY) + if(ti->second.GetType() == cmState::OBJECT_LIBRARY) { std::ostringstream e; e << "Target \"" << target << "\" is an OBJECT library " @@ -815,7 +804,7 @@ cmMakefile::AddCustomCommandToTarget(const std::string& target, this->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } - if(ti->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if(ti->second.GetType() == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "Target \"" << target << "\" is an INTERFACE library " @@ -1181,7 +1170,7 @@ cmMakefile::AddUtilityCommand(const std::string& utilityName, bool uses_terminal) { // Create a target instance for this utility. - cmTarget* target = this->AddNewTarget(cmTarget::UTILITY, utilityName); + cmTarget* target = this->AddNewTarget(cmState::UTILITY, utilityName); if (excludeFromAll) { target->SetProperty("EXCLUDE_FROM_ALL", "TRUE"); @@ -1397,7 +1386,7 @@ bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove) } void cmMakefile::AddLinkLibrary(const std::string& lib, - cmTarget::LinkLibraryType llt) + cmTargetLinkLibraryType llt) { cmTarget::LibraryID tmp; tmp.first = lib; @@ -1407,7 +1396,7 @@ void cmMakefile::AddLinkLibrary(const std::string& lib, void cmMakefile::AddLinkLibraryForTarget(const std::string& target, const std::string& lib, - cmTarget::LinkLibraryType llt) + cmTargetLinkLibraryType llt) { cmTargets::iterator i = this->Targets.find(target); if ( i != this->Targets.end()) @@ -1416,14 +1405,14 @@ void cmMakefile::AddLinkLibraryForTarget(const std::string& target, if(tgt) { // if it is not a static or shared library then you can not link to it - if(!((tgt->GetType() == cmTarget::STATIC_LIBRARY) || - (tgt->GetType() == cmTarget::SHARED_LIBRARY) || - (tgt->GetType() == cmTarget::INTERFACE_LIBRARY) || + if(!((tgt->GetType() == cmState::STATIC_LIBRARY) || + (tgt->GetType() == cmState::SHARED_LIBRARY) || + (tgt->GetType() == cmState::INTERFACE_LIBRARY) || tgt->IsExecutableWithExports())) { std::ostringstream e; e << "Target \"" << lib << "\" of type " - << cmTarget::GetTargetTypeName(tgt->GetType()) + << cmState::GetTargetTypeName(tgt->GetType()) << " may not be linked into another target. " << "One may link only to STATIC or SHARED libraries, or " << "to executables with the ENABLE_EXPORTS property set."; @@ -1468,18 +1457,11 @@ void cmMakefile::AddLinkDirectoryForTarget(const std::string& target, void cmMakefile::AddLinkLibrary(const std::string& lib) { - this->AddLinkLibrary(lib,cmTarget::GENERAL); + this->AddLinkLibrary(lib,GENERAL_LibraryType); } void cmMakefile::InitializeFromParent(cmMakefile* parent) { - this->StateSnapshot.InitializeFromParent(); - - this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", - this->GetCurrentSourceDirectory()); - this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", - this->GetCurrentBinaryDirectory()); - this->SystemIncludeDirectories = parent->SystemIncludeDirectories; // define flags @@ -1518,7 +1500,7 @@ void cmMakefile::InitializeFromParent(cmMakefile* parent) parent->GetProperty("LINK_DIRECTORIES")); // the initial project name - this->SetProjectName(parent->GetProjectName()); + this->StateSnapshot.SetProjectName(parent->StateSnapshot.GetProjectName()); // Copy include regular expressions. this->ComplainFileRegularExpression = parent->ComplainFileRegularExpression; @@ -1658,7 +1640,6 @@ void cmMakefile::Configure() cmParseFileScope pfs(this); if (!listFile.ParseFile(currentStart.c_str(), this->IsRootMakefile(), this)) { - this->SetConfigured(); return; } } @@ -1675,11 +1656,11 @@ void cmMakefile::Configure() std::vector<cmMakefile*>::iterator sdi = subdirs.begin(); for (; sdi != subdirs.end(); ++sdi) { + (*sdi)->StateSnapshot.InitializeFromParent_ForSubdirsCommand(); this->ConfigureSubDirectory(*sdi); } this->AddCMakeDependFilesFromUser(); - this->SetConfigured(); } void cmMakefile::ConfigureSubDirectory(cmMakefile *mf) @@ -1723,7 +1704,6 @@ void cmMakefile::ConfigureSubDirectory(cmMakefile *mf) // NEW behavior prints the error. this->IssueMessage(cmake::FATAL_ERROR, e.str()); } - mf->SetConfigured(); return; } // finally configure the subdir @@ -1753,17 +1733,14 @@ void cmMakefile::AddSubDirectory(const std::string& srcPath, this->ContextStack.back()->Name, this->ContextStack.back()->Line); + newSnapshot.GetDirectory().SetCurrentSource(srcPath); + newSnapshot.GetDirectory().SetCurrentBinary(binPath); + + cmSystemTools::MakeDirectory(binPath.c_str()); + cmMakefile* subMf = new cmMakefile(this->GlobalGenerator, newSnapshot); this->GetGlobalGenerator()->AddMakefile(subMf); - // create a new local generator and set its parent - cmLocalGenerator *lg2 = this->GetGlobalGenerator() - ->CreateLocalGenerator(subMf); - this->GetGlobalGenerator()->AddLocalGenerator(lg2); - - // set the subdirs start dirs - subMf->SetCurrentSourceDirectory(srcPath); - subMf->SetCurrentBinaryDirectory(binPath); if(excludeFromAll) { subMf->SetProperty("EXCLUDE_FROM_ALL", "TRUE"); @@ -1779,35 +1756,26 @@ void cmMakefile::AddSubDirectory(const std::string& srcPath, } } -void cmMakefile::SetCurrentSourceDirectory(const std::string& dir) -{ - this->StateSnapshot.GetDirectory().SetCurrentSource(dir); - this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", - this->StateSnapshot.GetDirectory().GetCurrentSource()); -} - const char* cmMakefile::GetCurrentSourceDirectory() const { return this->StateSnapshot.GetDirectory().GetCurrentSource(); } -void cmMakefile::SetCurrentBinaryDirectory(const std::string& dir) -{ - this->StateSnapshot.GetDirectory().SetCurrentBinary(dir); - const char* binDir = this->StateSnapshot.GetDirectory().GetCurrentBinary(); - cmSystemTools::MakeDirectory(binDir); - this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", binDir); -} - const char* cmMakefile::GetCurrentBinaryDirectory() const { return this->StateSnapshot.GetDirectory().GetCurrentBinary(); } -void cmMakefile::AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt) +std::vector<cmTarget*> cmMakefile::GetImportedTargets() const { - this->GeneratorTargets[t] = gt; - this->GetGlobalGenerator()->AddGeneratorTarget(t, gt); + std::vector<cmTarget*> tgts; + tgts.reserve(this->ImportedTargets.size()); + for (TargetMap::const_iterator it = this->ImportedTargets.begin(); + it != this->ImportedTargets.end(); ++it) + { + tgts.push_back(it->second); + } + return tgts; } //---------------------------------------------------------------------------- @@ -1920,13 +1888,13 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value, nvalue += files[cc]; } - this->GetState()->AddCacheEntry(name, nvalue.c_str(), doc, type); + this->GetCMakeInstance()->AddCacheEntry(name, nvalue.c_str(), doc, type); val = this->GetState()->GetInitializedCacheValue(name); haveVal = true; } } - this->GetState()->AddCacheEntry(name, haveVal ? val.c_str() : 0, + this->GetCMakeInstance()->AddCacheEntry(name, haveVal ? val.c_str() : 0, doc, type); // if there was a definition then remove it this->StateSnapshot.RemoveDefinition(name); @@ -2042,20 +2010,15 @@ void cmMakefile::SetProjectName(std::string const& p) this->StateSnapshot.SetProjectName(p); } -std::string cmMakefile::GetProjectName() const -{ - return this->StateSnapshot.GetProjectName(); -} - void cmMakefile::AddGlobalLinkInformation(const std::string& name, cmTarget& target) { // for these targets do not add anything switch(target.GetType()) { - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: - case cmTarget::INTERFACE_LIBRARY: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: + case cmState::INTERFACE_LIBRARY: return; default:; } @@ -2085,27 +2048,28 @@ void cmMakefile::AddGlobalLinkInformation(const std::string& name, } -void cmMakefile::AddAlias(const std::string& lname, cmTarget *tgt) +void cmMakefile::AddAlias(const std::string& lname, + std::string const& tgtName) { - this->AliasTargets[lname] = tgt; - this->GetGlobalGenerator()->AddAlias(lname, tgt); + this->AliasTargets[lname] = tgtName; + this->GetGlobalGenerator()->AddAlias(lname, tgtName); } cmTarget* cmMakefile::AddLibrary(const std::string& lname, - cmTarget::TargetType type, + cmState::TargetType type, const std::vector<std::string> &srcs, bool excludeFromAll) { // wrong type ? default to STATIC - if ( (type != cmTarget::STATIC_LIBRARY) - && (type != cmTarget::SHARED_LIBRARY) - && (type != cmTarget::MODULE_LIBRARY) - && (type != cmTarget::OBJECT_LIBRARY) - && (type != cmTarget::INTERFACE_LIBRARY)) + if ( (type != cmState::STATIC_LIBRARY) + && (type != cmState::SHARED_LIBRARY) + && (type != cmState::MODULE_LIBRARY) + && (type != cmState::OBJECT_LIBRARY) + && (type != cmState::INTERFACE_LIBRARY)) { this->IssueMessage(cmake::INTERNAL_ERROR, "cmMakefile::AddLibrary given invalid target type."); - type = cmTarget::STATIC_LIBRARY; + type = cmState::STATIC_LIBRARY; } cmTarget* target = this->AddNewTarget(type, lname); @@ -2126,7 +2090,7 @@ cmTarget* cmMakefile::AddExecutable(const char *exeName, const std::vector<std::string> &srcs, bool excludeFromAll) { - cmTarget* target = this->AddNewTarget(cmTarget::EXECUTABLE, exeName); + cmTarget* target = this->AddNewTarget(cmState::EXECUTABLE, exeName); if(excludeFromAll) { target->SetProperty("EXCLUDE_FROM_ALL", "TRUE"); @@ -2138,14 +2102,13 @@ cmTarget* cmMakefile::AddExecutable(const char *exeName, //---------------------------------------------------------------------------- cmTarget* -cmMakefile::AddNewTarget(cmTarget::TargetType type, const std::string& name) +cmMakefile::AddNewTarget(cmState::TargetType type, const std::string& name) { cmTargets::iterator it = this->Targets.insert(cmTargets::value_type(name, cmTarget())).first; cmTarget& target = it->second; target.SetType(type, name); target.SetMakefile(this); - this->GetGlobalGenerator()->AddTarget(&it->second); return &it->second; } @@ -2209,7 +2172,7 @@ cmMakefile::GetSourceGroup(const std::vector<std::string>&name) const { cmSourceGroup* sg = 0; - // first look for source group starting with the same as the one we wants + // first look for source group starting with the same as the one we want for (std::vector<cmSourceGroup>::const_iterator sgIt = this->SourceGroups.begin(); sgIt != this->SourceGroups.end(); ++sgIt) @@ -2242,7 +2205,7 @@ void cmMakefile::AddSourceGroup(const std::string& name, { std::vector<std::string> nameVector; nameVector.push_back(name); - AddSourceGroup(nameVector, regex); + this->AddSourceGroup(nameVector, regex); } void cmMakefile::AddSourceGroup(const std::vector<std::string>& name, @@ -2334,8 +2297,8 @@ void cmMakefile::ExpandVariablesCMP0019() l != this->Targets.end(); ++l) { cmTarget &t = l->second; - if (t.GetType() == cmTarget::INTERFACE_LIBRARY - || t.GetType() == cmTarget::GLOBAL_TARGET) + if (t.GetType() == cmState::INTERFACE_LIBRARY + || t.GetType() == cmState::GLOBAL_TARGET) { continue; } @@ -2442,10 +2405,23 @@ bool cmMakefile::PlatformIsAppleIos() const sdkRoot = this->GetSafeDefinition("CMAKE_OSX_SYSROOT"); sdkRoot = cmSystemTools::LowerCase(sdkRoot); - return sdkRoot.find("iphoneos") == 0 || - sdkRoot.find("/iphoneos") != std::string::npos || - sdkRoot.find("iphonesimulator") == 0 || - sdkRoot.find("/iphonesimulator") != std::string::npos; + const std::string embedded[] = + { + "appletvos", "appletvsimulator", + "iphoneos", "iphonesimulator", + "watchos", "watchsimulator", + }; + + for(size_t i = 0; i < sizeof(embedded) / sizeof(embedded[0]); ++i) + { + if(sdkRoot.find(embedded[i]) == 0 || + sdkRoot.find(std::string("/") + embedded[i]) != std::string::npos) + { + return true; + } + } + + return false; } const char* cmMakefile::GetSONameFlag(const std::string& language) const @@ -3172,62 +3148,10 @@ void cmMakefile::RemoveVariablesInString(std::string& source, } } -/** - * Add the default definitions to the makefile. These values must not - * be dependent on anything that isn't known when this cmMakefile instance - * is constructed. - */ -void cmMakefile::AddDefaultDefinitions() -{ -/* Up to CMake 2.4 here only WIN32, UNIX and APPLE were set. - With CMake must separate between target and host platform. In most cases - the tests for WIN32, UNIX and APPLE will be for the target system, so an - additional set of variables for the host system is required -> - CMAKE_HOST_WIN32, CMAKE_HOST_UNIX, CMAKE_HOST_APPLE. - WIN32, UNIX and APPLE are now set in the platform files in - Modules/Platforms/. - To keep cmake scripts (-P) and custom language and compiler modules - working, these variables are still also set here in this place, but they - will be reset in CMakeSystemSpecificInformation.cmake before the platform - files are executed. */ -#if defined(_WIN32) - this->AddDefinition("WIN32", "1"); - this->AddDefinition("CMAKE_HOST_WIN32", "1"); -#else - this->AddDefinition("UNIX", "1"); - this->AddDefinition("CMAKE_HOST_UNIX", "1"); -#endif -#if defined(__CYGWIN__) - if(cmSystemTools::IsOn(cmSystemTools::GetEnv("CMAKE_LEGACY_CYGWIN_WIN32"))) - { - this->AddDefinition("WIN32", "1"); - this->AddDefinition("CMAKE_HOST_WIN32", "1"); - } -#endif -#if defined(__APPLE__) - this->AddDefinition("APPLE", "1"); - this->AddDefinition("CMAKE_HOST_APPLE", "1"); -#endif - - char temp[1024]; - sprintf(temp, "%d", cmVersion::GetMinorVersion()); - this->AddDefinition("CMAKE_MINOR_VERSION", temp); - sprintf(temp, "%d", cmVersion::GetMajorVersion()); - this->AddDefinition("CMAKE_MAJOR_VERSION", temp); - sprintf(temp, "%d", cmVersion::GetPatchVersion()); - this->AddDefinition("CMAKE_PATCH_VERSION", temp); - sprintf(temp, "%d", cmVersion::GetTweakVersion()); - this->AddDefinition("CMAKE_TWEAK_VERSION", temp); - this->AddDefinition("CMAKE_VERSION", cmVersion::GetCMakeVersion()); - - this->AddDefinition("CMAKE_FILES_DIRECTORY", - cmake::GetCMakeFilesDirectory()); -} - //---------------------------------------------------------------------------- std::string cmMakefile::GetConfigurations(std::vector<std::string>& configs, - bool single) const + bool singleConfig) const { if(this->GetGlobalGenerator()->IsMultiConfig()) { @@ -3241,7 +3165,7 @@ cmMakefile::GetConfigurations(std::vector<std::string>& configs, else { const std::string& buildType = this->GetSafeDefinition("CMAKE_BUILD_TYPE"); - if(single && !buildType.empty()) + if(singleConfig && !buildType.empty()) { configs.push_back(buildType); } @@ -4113,10 +4037,12 @@ cmTarget* cmMakefile::FindTarget(const std::string& name, { if (!excludeAliases) { - TargetMap::const_iterator i = this->AliasTargets.find(name); + std::map<std::string, std::string>::const_iterator i = + this->AliasTargets.find(name); if (i != this->AliasTargets.end()) { - return i->second; + cmTargets::iterator ai = this->Targets.find(i->second); + return &ai->second; } } cmTargets::iterator i = this->Targets.find( name ); @@ -4265,21 +4191,17 @@ void cmMakefile::RaiseScope(const std::string& var, const char *varDef) //---------------------------------------------------------------------------- cmTarget* cmMakefile::AddImportedTarget(const std::string& name, - cmTarget::TargetType type, + cmState::TargetType type, bool global) { // Create the target. cmsys::auto_ptr<cmTarget> target(new cmTarget); target->SetType(type, name); - target->MarkAsImported(); + target->MarkAsImported(global); target->SetMakefile(this); // Add to the set of available imported targets. this->ImportedTargets[name] = target.get(); - if(global) - { - this->GetGlobalGenerator()->AddTarget(target.get()); - } // Transfer ownership to this cmMakefile object. this->ImportedTargetsOwned.push_back(target.get()); @@ -4318,17 +4240,6 @@ bool cmMakefile::IsAlias(const std::string& name) const } //---------------------------------------------------------------------------- -cmGeneratorTarget* -cmMakefile::FindGeneratorTargetToUse(const std::string& name) const -{ - if (cmTarget *t = this->FindTargetToUse(name)) - { - return this->GetGlobalGenerator()->GetGeneratorTarget(t); - } - return 0; -} - -//---------------------------------------------------------------------------- bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg, bool isCustom) const { @@ -4377,7 +4288,7 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg, // The conflict is with a non-imported target. // Allow this if the user has requested support. cmake* cm = this->GetCMakeInstance(); - if(isCustom && existing->GetType() == cmTarget::UTILITY && + if(isCustom && existing->GetType() == cmState::UTILITY && this != existing->GetMakefile() && cm->GetState() ->GetGlobalPropertyAsBool("ALLOW_DUPLICATE_CUSTOM_TARGETS")) @@ -4393,22 +4304,22 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg, << "The existing target is "; switch(existing->GetType()) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: e << "an executable "; break; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: e << "a static library "; break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: e << "a shared library "; break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: e << "a module library "; break; - case cmTarget::UTILITY: + case cmState::UTILITY: e << "a custom target "; break; - case cmTarget::INTERFACE_LIBRARY: + case cmState::INTERFACE_LIBRARY: e << "an interface library "; break; default: break; @@ -4667,9 +4578,10 @@ bool cmMakefile::SetPolicyVersion(const char *version) } //---------------------------------------------------------------------------- -bool cmMakefile::HasCMP0054AlreadyBeenReported() const +bool cmMakefile::HasCMP0054AlreadyBeenReported( + cmListFileContext const& context) const { - return !this->CMP0054ReportedIds.insert(this->GetExecutionContext()).second; + return !this->CMP0054ReportedIds.insert(context).second; } //---------------------------------------------------------------------------- diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h index 3cf20a6..f1dd374 100644 --- a/Source/cmMakefile.h +++ b/Source/cmMakefile.h @@ -17,7 +17,6 @@ #include "cmSystemTools.h" #include "cmTarget.h" #include "cmNewLineStyle.h" -#include "cmGeneratorTarget.h" #include "cmExpandedCommandArgument.h" #include "cmake.h" #include "cmState.h" @@ -42,7 +41,6 @@ class cmFunctionBlocker; class cmCommand; class cmInstallGenerator; -class cmMakeDepend; class cmSourceFile; class cmTest; class cmTestGenerator; @@ -51,6 +49,7 @@ class cmake; class cmMakefileCall; class cmCMakePolicyCommand; class cmGeneratorExpressionEvaluationFile; +class cmExportBuildFileGenerator; /** \class cmMakefile * \brief Process the input CMakeLists.txt file. @@ -172,10 +171,10 @@ public: /** Create a new imported target with the name and type given. */ cmTarget* AddImportedTarget(const std::string& name, - cmTarget::TargetType type, + cmState::TargetType type, bool global); - cmTarget* AddNewTarget(cmTarget::TargetType type, const std::string& name); + cmTarget* AddNewTarget(cmState::TargetType type, const std::string& name); /** * Add an executable to the build. @@ -219,9 +218,9 @@ public: * Add a link library to the build. */ void AddLinkLibrary(const std::string&); - void AddLinkLibrary(const std::string&, cmTarget::LinkLibraryType type); + void AddLinkLibrary(const std::string&, cmTargetLinkLibraryType type); void AddLinkLibraryForTarget(const std::string& tgt, const std::string&, - cmTarget::LinkLibraryType type); + cmTargetLinkLibraryType type); void AddLinkDirectoryForTarget(const std::string& tgt, const std::string& d); /** @@ -274,11 +273,6 @@ public: */ void SetProjectName(std::string const& name); - /** - * Get the name of the project for this build. - */ - std::string GetProjectName() const; - /** Get the configurations to be generated. */ std::string GetConfigurations(std::vector<std::string>& configs, bool single = true) const; @@ -286,10 +280,10 @@ public: /** * Set the name of the library. */ - cmTarget* AddLibrary(const std::string& libname, cmTarget::TargetType type, + cmTarget* AddLibrary(const std::string& libname, cmState::TargetType type, const std::vector<std::string> &srcs, bool excludeFromAll = false); - void AddAlias(const std::string& libname, cmTarget *tgt); + void AddAlias(const std::string& libname, const std::string& tgt); #if defined(CMAKE_BUILD_WITH_CMAKE) /** @@ -336,7 +330,7 @@ public: * Determine if the given context, name pair has already been reported * in context of CMP0054. */ - bool HasCMP0054AlreadyBeenReported() const; + bool HasCMP0054AlreadyBeenReported(const cmListFileContext &context) const; bool IgnoreErrorsCMP0061() const; @@ -353,9 +347,7 @@ public: */ void SetArgcArgv(const std::vector<std::string>& args); - void SetCurrentSourceDirectory(const std::string& dir); const char* GetCurrentSourceDirectory() const; - void SetCurrentBinaryDirectory(const std::string& dir); const char* GetCurrentBinaryDirectory() const; //@} @@ -398,17 +390,7 @@ public: { return this->ImportedTargetsOwned; } - - const cmGeneratorTargetsType &GetGeneratorTargets() const - { - return this->GeneratorTargets; - } - - void SetGeneratorTargets(const cmGeneratorTargetsType &targets) - { - this->GeneratorTargets = targets; - } - void AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt); + std::vector<cmTarget*> GetImportedTargets() const; cmTarget* FindTarget(const std::string& name, bool excludeAliases = false) const; @@ -418,7 +400,11 @@ public: cmTarget* FindTargetToUse(const std::string& name, bool excludeAliases = false) const; bool IsAlias(const std::string& name) const; - cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const; + + std::map<std::string, std::string> GetAliasTargets() const + { + return this->AliasTargets; + } /** * Mark include directories as system directories. @@ -445,17 +431,6 @@ public: cmSourceFile* GetOrCreateSource(const std::string& sourceName, bool generated = false); - //@{ - /** - * Return a list of extensions associated with source and header - * files - */ - const std::vector<std::string>& GetSourceExtensions() const - {return this->SourceFileExtensions;} - const std::vector<std::string>& GetHeaderExtensions() const - {return this->HeaderFileExtensions;} - //@} - /** * Given a variable name, return its value (as a string). * If the variable is not found in this makefile instance, the @@ -750,9 +725,6 @@ public: cmStringRange GetCompileDefinitionsEntries() const; cmBacktraceRange GetCompileDefinitionsBacktraces() const; - bool IsConfigured() const { return this->Configured; } - void SetConfigured(){ this->Configured = true; } - void AddQtUiFileWithOptions(cmSourceFile *sf); std::vector<cmSourceFile*> GetQtUiFilesWithOptions() const; @@ -799,6 +771,11 @@ public: bool inputIsContent); std::vector<cmGeneratorExpressionEvaluationFile*> GetEvaluationFiles() const; + std::vector<cmExportBuildFileGenerator*> + GetExportBuildFileGenerators() const; + void RemoveExportBuildFileGeneratorCMP0024(cmExportBuildFileGenerator* gen); + void AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen); + protected: // add link libraries and directories to the target void AddGlobalLinkInformation(const std::string& name, cmTarget& target); @@ -819,8 +796,7 @@ protected: #else typedef std::map<std::string, cmTarget*> TargetMap; #endif - TargetMap AliasTargets; - cmGeneratorTargetsType GeneratorTargets; + std::map<std::string, std::string> AliasTargets; std::vector<cmSourceFile*> SourceFiles; // Tests @@ -842,8 +818,6 @@ protected: std::vector<cmTestGenerator*> TestGenerators; std::string ComplainFileRegularExpression; - std::vector<std::string> SourceFileExtensions; - std::vector<std::string> HeaderFileExtensions; std::string DefineFlags; // Track the value of the computed DEFINITIONS property. @@ -874,10 +848,6 @@ private: bool EnforceUniqueDir(const std::string& srcPath, const std::string& binPath) const; - friend class cmMakeDepend; // make depend needs direct access - // to the Sources array - - void AddDefaultDefinitions(); typedef std::vector<cmFunctionBlocker*> FunctionBlockersType; FunctionBlockersType FunctionBlockers; std::vector<FunctionBlockersType::size_type> FunctionBlockerBarriers; @@ -892,6 +862,7 @@ private: mutable cmsys::RegularExpression cmNamedCurly; std::vector<cmMakefile*> UnConfiguredDirectories; + std::vector<cmExportBuildFileGenerator*> ExportBuildFileGenerators; std::vector<cmGeneratorExpressionEvaluationFile*> EvaluationFiles; @@ -988,7 +959,6 @@ private: bool WarnUnused; bool CheckSystemVars; bool CheckCMP0000; - bool Configured; bool IsSourceFileTryCompile; mutable bool SuppressWatches; }; diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx index ccb0974..9e35e4c 100644 --- a/Source/cmMakefileExecutableTargetGenerator.cxx +++ b/Source/cmMakefileExecutableTargetGenerator.cxx @@ -16,7 +16,6 @@ #include "cmLocalUnixMakefileGenerator3.h" #include "cmMakefile.h" #include "cmSourceFile.h" -#include "cmTarget.h" #include "cmake.h" //---------------------------------------------------------------------------- @@ -99,8 +98,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) this->ConfigName); // Construct the full path version of the names. - std::string outpath = this->Target->GetDirectory(this->ConfigName); - if(this->Target->IsAppBundleOnApple()) + std::string outpath = this->GeneratorTarget->GetDirectory(this->ConfigName); + if(this->GeneratorTarget->IsAppBundleOnApple()) { this->OSXBundleGenerator->CreateAppBundle(targetName, outpath); } @@ -123,7 +122,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) cmSystemTools::MakeDirectory(outpath.c_str()); if(!targetNameImport.empty()) { - outpathImp = this->Target->GetDirectory(this->ConfigName, true); + outpathImp = this->GeneratorTarget->GetDirectory(this->ConfigName, true); cmSystemTools::MakeDirectory(outpathImp.c_str()); outpathImp += "/"; } @@ -133,7 +132,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) this->GeneratorTarget->GetCompilePDBDirectory(this->ConfigName); cmSystemTools::MakeDirectory(compilePdbOutputPath.c_str()); - std::string pdbOutputPath = this->Target->GetPDBDirectory(this->ConfigName); + std::string pdbOutputPath = + this->GeneratorTarget->GetPDBDirectory(this->ConfigName); cmSystemTools::MakeDirectory(pdbOutputPath.c_str()); pdbOutputPath += "/"; @@ -167,7 +167,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) if(linkLanguage.empty()) { cmSystemTools::Error("Cannot determine link language for target \"", - this->Target->GetName().c_str(), "\"."); + this->GeneratorTarget->GetName().c_str(), "\"."); return; } @@ -196,7 +196,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) this->ConfigName); - if(this->Target->GetPropertyAsBool("WIN32_EXECUTABLE")) + if(this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE")) { this->LocalGenerator->AppendFlags (linkFlags, this->Makefile->GetDefinition("CMAKE_CREATE_WIN32_EXE")); @@ -208,7 +208,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) } // Add symbol export flags if necessary. - if(this->Target->IsExecutableWithExports()) + if(this->GeneratorTarget->IsExecutableWithExports()) { std::string export_flag_var = "CMAKE_EXE_EXPORTS_"; export_flag_var += linkLanguage; @@ -225,11 +225,11 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) // Add target-specific linker flags. this->LocalGenerator->AppendFlags - (linkFlags, this->Target->GetProperty("LINK_FLAGS")); + (linkFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS")); std::string linkFlagsConfig = "LINK_FLAGS_"; linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName); this->LocalGenerator->AppendFlags - (linkFlags, this->Target->GetProperty(linkFlagsConfig)); + (linkFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig)); this->AddModuleDefinitionFlag(linkFlags); @@ -258,7 +258,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) cmLocalGenerator::START_OUTPUT, cmLocalGenerator::UNCHANGED)); std::string implib; - if(this->Target->GetImplibGNUtoMS(targetFullPathImport, implib)) + if(this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport, implib)) { exeCleanFiles.push_back(this->Convert(implib, cmLocalGenerator::START_OUTPUT, @@ -278,11 +278,13 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) if(!relink) { this->LocalGenerator - ->AppendCustomCommands(commands, this->Target->GetPreBuildCommands(), - this->Target); + ->AppendCustomCommands(commands, + this->GeneratorTarget->GetPreBuildCommands(), + this->GeneratorTarget); this->LocalGenerator - ->AppendCustomCommands(commands, this->Target->GetPreLinkCommands(), - this->Target); + ->AppendCustomCommands(commands, + this->GeneratorTarget->GetPreLinkCommands(), + this->GeneratorTarget); } // Determine whether a link script will be used. @@ -296,7 +298,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) std::string linkRule = this->GetLinkRule(linkRuleVar); std::vector<std::string> commands1; cmSystemTools::ExpandListArgument(linkRule, real_link_commands); - if(this->Target->IsExecutableWithExports()) + if(this->GeneratorTarget->IsExecutableWithExports()) { // If a separate rule for creating an import library is specified // add it now. @@ -353,12 +355,14 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) useResponseFileForObjects, buildObjs, depends, useWatcomQuote); + std::string manifests = this->GetManifests(); + cmLocalGenerator::RuleVariables vars; vars.RuleLauncher = "RULE_LAUNCH_LINK"; - vars.CMTarget = this->Target; + vars.CMTarget = this->GeneratorTarget; vars.Language = linkLanguage.c_str(); vars.Objects = buildObjs.c_str(); - std::string objectDir = this->Target->GetSupportDirectory(); + std::string objectDir = this->GeneratorTarget->GetSupportDirectory(); objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL); @@ -379,7 +383,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) std::ostringstream minorStream; int major; int minor; - this->Target->GetTargetVersion(major, minor); + this->GeneratorTarget->GetTargetVersion(major, minor); majorStream << major; minorStream << minor; targetVersionMajor = majorStream.str(); @@ -391,6 +395,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) vars.LinkLibraries = linkLibs.c_str(); vars.Flags = flags.c_str(); vars.LinkFlags = linkFlags.c_str(); + vars.Manifests = manifests.c_str(); + // Expand placeholders in the commands. this->LocalGenerator->TargetImplib = targetOutPathImport; for(std::vector<std::string>::iterator i = real_link_commands.begin(); @@ -443,8 +449,9 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) if(!relink) { this->LocalGenerator-> - AppendCustomCommands(commands, this->Target->GetPostBuildCommands(), - this->Target); + AppendCustomCommands(commands, + this->GeneratorTarget->GetPostBuildCommands(), + this->GeneratorTarget); } // Write the build rule. diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx index 2f995e8..1923ea4 100644 --- a/Source/cmMakefileLibraryTargetGenerator.cxx +++ b/Source/cmMakefileLibraryTargetGenerator.cxx @@ -16,7 +16,6 @@ #include "cmLocalUnixMakefileGenerator3.h" #include "cmMakefile.h" #include "cmSourceFile.h" -#include "cmTarget.h" #include "cmake.h" #include "cmAlgorithms.h" @@ -26,7 +25,7 @@ cmMakefileLibraryTargetGenerator cmMakefileTargetGenerator(target) { this->CustomCommandDriver = OnDepends; - if (this->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + if (this->GeneratorTarget->GetType() != cmState::INTERFACE_LIBRARY) { this->GeneratorTarget->GetLibraryNames( this->TargetNameOut, this->TargetNameSO, this->TargetNameReal, @@ -62,12 +61,12 @@ void cmMakefileLibraryTargetGenerator::WriteRuleFiles() // write the link rules // Write the rule for this target type. - switch(this->Target->GetType()) + switch(this->GeneratorTarget->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: this->WriteStaticLibraryRules(); break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: this->WriteSharedLibraryRules(false); if(this->GeneratorTarget->NeedRelinkBeforeInstall(this->ConfigName)) { @@ -75,7 +74,7 @@ void cmMakefileLibraryTargetGenerator::WriteRuleFiles() this->WriteSharedLibraryRules(true); } break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: this->WriteModuleLibraryRules(false); if(this->GeneratorTarget->NeedRelinkBeforeInstall(this->ConfigName)) { @@ -83,7 +82,7 @@ void cmMakefileLibraryTargetGenerator::WriteRuleFiles() this->WriteModuleLibraryRules(true); } break; - case cmTarget::OBJECT_LIBRARY: + case cmState::OBJECT_LIBRARY: this->WriteObjectLibraryRules(); break; default: @@ -114,19 +113,20 @@ void cmMakefileLibraryTargetGenerator::WriteObjectLibraryRules() // Add post-build rules. this->LocalGenerator-> - AppendCustomCommands(commands, this->Target->GetPostBuildCommands(), - this->Target); + AppendCustomCommands(commands, + this->GeneratorTarget->GetPostBuildCommands(), + this->GeneratorTarget); // Depend on the object files. this->AppendObjectDepends(depends); // Write the rule. this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, - this->Target->GetName(), + this->GeneratorTarget->GetName(), depends, commands, true); // Write the main driver rule to build everything in this target. - this->WriteTargetDriverRule(this->Target->GetName(), false); + this->WriteTargetDriverRule(this->GeneratorTarget->GetName(), false); } //---------------------------------------------------------------------------- @@ -146,14 +146,14 @@ void cmMakefileLibraryTargetGenerator::WriteStaticLibraryRules() std::string extraFlags; this->LocalGenerator->GetStaticLibraryFlags(extraFlags, - cmSystemTools::UpperCase(this->ConfigName), this->Target); + cmSystemTools::UpperCase(this->ConfigName), this->GeneratorTarget); this->WriteLibraryRules(linkRuleVar, extraFlags, false); } //---------------------------------------------------------------------------- void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink) { - if(this->Target->IsFrameworkOnApple()) + if(this->GeneratorTarget->IsFrameworkOnApple()) { this->WriteFrameworkRules(relink); return; @@ -166,11 +166,11 @@ void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink) std::string extraFlags; this->LocalGenerator->AppendFlags - (extraFlags, this->Target->GetProperty("LINK_FLAGS")); + (extraFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS")); std::string linkFlagsConfig = "LINK_FLAGS_"; linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName); this->LocalGenerator->AppendFlags - (extraFlags, this->Target->GetProperty(linkFlagsConfig)); + (extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig)); this->LocalGenerator->AddConfigVariableFlags (extraFlags, "CMAKE_SHARED_LINKER_FLAGS", this->ConfigName); @@ -190,11 +190,11 @@ void cmMakefileLibraryTargetGenerator::WriteModuleLibraryRules(bool relink) std::string extraFlags; this->LocalGenerator->AppendFlags(extraFlags, - this->Target->GetProperty("LINK_FLAGS")); + this->GeneratorTarget->GetProperty("LINK_FLAGS")); std::string linkFlagsConfig = "LINK_FLAGS_"; linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName); this->LocalGenerator->AppendFlags - (extraFlags, this->Target->GetProperty(linkFlagsConfig)); + (extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig)); this->LocalGenerator->AddConfigVariableFlags (extraFlags, "CMAKE_MODULE_LINKER_FLAGS", this->ConfigName); this->AddModuleDefinitionFlag(extraFlags); @@ -213,11 +213,11 @@ void cmMakefileLibraryTargetGenerator::WriteFrameworkRules(bool relink) std::string extraFlags; this->LocalGenerator->AppendFlags(extraFlags, - this->Target->GetProperty("LINK_FLAGS")); + this->GeneratorTarget->GetProperty("LINK_FLAGS")); std::string linkFlagsConfig = "LINK_FLAGS_"; linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName); this->LocalGenerator->AppendFlags - (extraFlags, this->Target->GetProperty(linkFlagsConfig)); + (extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig)); this->LocalGenerator->AddConfigVariableFlags (extraFlags, "CMAKE_MACOSX_FRAMEWORK_LINKER_FLAGS", this->ConfigName); @@ -244,7 +244,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules if(linkLanguage.empty()) { cmSystemTools::Error("Cannot determine link language for target \"", - this->Target->GetName().c_str(), "\"."); + this->GeneratorTarget->GetName().c_str(), "\"."); return; } @@ -253,8 +253,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules this->LocalGenerator->AppendFlags(linkFlags, extraFlags); // Add OSX version flags, if any. - if(this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY || + this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) { this->AppendOSXVerFlag(linkFlags, linkLanguage, "COMPATIBILITY", true); this->AppendOSXVerFlag(linkFlags, linkLanguage, "CURRENT", false); @@ -273,15 +273,15 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules // Construct the full path version of the names. std::string outpath; std::string outpathImp; - if(this->Target->IsFrameworkOnApple()) + if(this->GeneratorTarget->IsFrameworkOnApple()) { - outpath = this->Target->GetDirectory(this->ConfigName); + outpath = this->GeneratorTarget->GetDirectory(this->ConfigName); this->OSXBundleGenerator->CreateFramework(targetName, outpath); outpath += "/"; } - else if(this->Target->IsCFBundleOnApple()) + else if(this->GeneratorTarget->IsCFBundleOnApple()) { - outpath = this->Target->GetDirectory(this->ConfigName); + outpath = this->GeneratorTarget->GetDirectory(this->ConfigName); this->OSXBundleGenerator->CreateCFBundle(targetName, outpath); outpath += "/"; } @@ -299,12 +299,12 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules } else { - outpath = this->Target->GetDirectory(this->ConfigName); + outpath = this->GeneratorTarget->GetDirectory(this->ConfigName); cmSystemTools::MakeDirectory(outpath.c_str()); outpath += "/"; if(!targetNameImport.empty()) { - outpathImp = this->Target->GetDirectory(this->ConfigName, true); + outpathImp = this->GeneratorTarget->GetDirectory(this->ConfigName, true); cmSystemTools::MakeDirectory(outpathImp.c_str()); outpathImp += "/"; } @@ -314,7 +314,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules this->GeneratorTarget->GetCompilePDBDirectory(this->ConfigName); cmSystemTools::MakeDirectory(compilePdbOutputPath.c_str()); - std::string pdbOutputPath = this->Target->GetPDBDirectory(this->ConfigName); + std::string pdbOutputPath = + this->GeneratorTarget->GetPDBDirectory(this->ConfigName); cmSystemTools::MakeDirectory(pdbOutputPath.c_str()); pdbOutputPath += "/"; @@ -350,16 +351,16 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules // Add the link message. std::string buildEcho = "Linking "; buildEcho += linkLanguage; - switch(this->Target->GetType()) + switch(this->GeneratorTarget->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: buildEcho += " static library "; break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: buildEcho += " shared library "; break; - case cmTarget::MODULE_LIBRARY: - if (this->Target->IsCFBundleOnApple()) + case cmState::MODULE_LIBRARY: + if (this->GeneratorTarget->IsCFBundleOnApple()) buildEcho += " CFBundle"; buildEcho += " shared module "; break; @@ -374,12 +375,12 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules } const char* forbiddenFlagVar = 0; - switch(this->Target->GetType()) + switch(this->GeneratorTarget->GetType()) { - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: forbiddenFlagVar = "_CREATE_SHARED_LIBRARY_FORBIDDEN_FLAGS"; break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: forbiddenFlagVar = "_CREATE_SHARED_MODULE_FORBIDDEN_FLAGS"; break; default: break; @@ -409,7 +410,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules cmLocalGenerator::START_OUTPUT, cmLocalGenerator::UNCHANGED)); std::string implib; - if(this->Target->GetImplibGNUtoMS(targetFullPathImport, implib)) + if(this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport, implib)) { libCleanFiles.push_back(this->Convert(implib, cmLocalGenerator::START_OUTPUT, @@ -428,7 +429,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules #ifdef _WIN32 // There may be a manifest file for this target. Add it to the // clean set just in case. - if(this->Target->GetType() != cmTarget::STATIC_LIBRARY) + if(this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY) { libCleanFiles.push_back( this->Convert((targetFullPath+".manifest").c_str(), @@ -440,10 +441,10 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules std::vector<std::string> commands1; // Add a command to remove any existing files for this library. // for static libs only - if(this->Target->GetType() == cmTarget::STATIC_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) { this->LocalGenerator->AppendCleanCommand(commands1, libCleanFiles, - *this->Target, "target"); + this->GeneratorTarget, "target"); this->LocalGenerator->CreateCDCommand (commands1, this->Makefile->GetCurrentBinaryDirectory(), @@ -456,11 +457,13 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules if(!relink) { this->LocalGenerator - ->AppendCustomCommands(commands, this->Target->GetPreBuildCommands(), - this->Target); + ->AppendCustomCommands(commands, + this->GeneratorTarget->GetPreBuildCommands(), + this->GeneratorTarget); this->LocalGenerator - ->AppendCustomCommands(commands, this->Target->GetPreLinkCommands(), - this->Target); + ->AppendCustomCommands(commands, + this->GeneratorTarget->GetPreLinkCommands(), + this->GeneratorTarget); } // Determine whether a link script will be used. @@ -496,7 +499,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules std::vector<std::string> archiveAppendCommands; std::vector<std::string> archiveFinishCommands; std::string::size_type archiveCommandLimit = std::string::npos; - if(this->Target->GetType() == cmTarget::STATIC_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) { haveStaticLibraryRule = this->Makefile->GetDefinition(linkRuleVar)? true:false; @@ -551,7 +554,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules // Collect up flags to link in needed libraries. std::string linkLibs; - if(this->Target->GetType() != cmTarget::STATIC_LIBRARY) + if(this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY) { this->CreateLinkLibs(linkLibs, relink, useResponseFileForLibs, depends, useWatcomQuote); @@ -565,15 +568,15 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules useWatcomQuote); // maybe create .def file from list of objects - if (this->Target->GetType() == cmTarget::SHARED_LIBRARY && + if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if(this->Target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if(this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { std::string name_of_def_file = - this->Target->GetSupportDirectory(); + this->GeneratorTarget->GetSupportDirectory(); name_of_def_file += std::string("/") + - this->Target->GetName(); + this->GeneratorTarget->GetName(); name_of_def_file += ".def"; std::string cmd = cmSystemTools::GetCMakeCommand(); cmd = this->Convert(cmd, cmLocalGenerator::NONE, @@ -616,6 +619,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules } } + std::string manifests = this->GetManifests(); + cmLocalGenerator::RuleVariables vars; vars.TargetPDB = targetOutPathPDB.c_str(); @@ -627,7 +632,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules std::ostringstream minorStream; int major; int minor; - this->Target->GetTargetVersion(major, minor); + this->GeneratorTarget->GetTargetVersion(major, minor); majorStream << major; minorStream << minor; targetVersionMajor = majorStream.str(); @@ -637,10 +642,10 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules vars.TargetVersionMinor = targetVersionMinor.c_str(); vars.RuleLauncher = "RULE_LAUNCH_LINK"; - vars.CMTarget = this->Target; + vars.CMTarget = this->GeneratorTarget; vars.Language = linkLanguage.c_str(); vars.Objects = buildObjs.c_str(); - std::string objectDir = this->Target->GetSupportDirectory(); + std::string objectDir = this->GeneratorTarget->GetSupportDirectory(); objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL); @@ -660,9 +665,11 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules } vars.LinkFlags = linkFlags.c_str(); + vars.Manifests = manifests.c_str(); + // Compute the directory portion of the install_name setting. std::string install_name_dir; - if(this->Target->GetType() == cmTarget::SHARED_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY) { // Get the install_name directory for the build tree. install_name_dir = @@ -786,7 +793,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules // Add a rule to create necessary symlinks for the library. // Frameworks are handled by cmOSXBundleGenerator. - if(targetOutPath != targetOutPathReal && !this->Target->IsFrameworkOnApple()) + if(targetOutPath != targetOutPathReal + && !this->GeneratorTarget->IsFrameworkOnApple()) { std::string symlink = "$(CMAKE_COMMAND) -E cmake_symlink_library "; symlink += targetOutPathReal; @@ -805,8 +813,9 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules if(!relink) { this->LocalGenerator-> - AppendCustomCommands(commands, this->Target->GetPostBuildCommands(), - this->Target); + AppendCustomCommands(commands, + this->GeneratorTarget->GetPostBuildCommands(), + this->GeneratorTarget); } // Compute the list of outputs. @@ -857,7 +866,7 @@ cmMakefileLibraryTargetGenerator int major; int minor; int patch; - this->Target->GetTargetVersion(so, major, minor, patch); + this->GeneratorTarget->GetTargetVersion(so, major, minor, patch); if(major > 0 || minor > 0 || patch > 0) { // Append the flag since a non-zero version is specified. diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index cf88a74..7acccb3 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -18,7 +18,6 @@ #include "cmLocalUnixMakefileGenerator3.h" #include "cmMakefile.h" #include "cmSourceFile.h" -#include "cmTarget.h" #include "cmake.h" #include "cmState.h" #include "cmComputeLinkInformation.h" @@ -68,16 +67,16 @@ cmMakefileTargetGenerator::New(cmGeneratorTarget *tgt) switch (tgt->GetType()) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: result = new cmMakefileExecutableTargetGenerator(tgt); break; - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: result = new cmMakefileLibraryTargetGenerator(tgt); break; - case cmTarget::UTILITY: + case cmState::UTILITY: result = new cmMakefileUtilityTargetGenerator(tgt); break; default: @@ -92,7 +91,7 @@ void cmMakefileTargetGenerator::CreateRuleFile() { // Create a directory for this target. this->TargetBuildDirectory = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->TargetBuildDirectoryFull = this->LocalGenerator->ConvertToFullPath(this->TargetBuildDirectory); cmSystemTools::MakeDirectory(this->TargetBuildDirectoryFull.c_str()); @@ -147,8 +146,11 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules() cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(additional_clean_files); - cmSystemTools::ExpandListArgument(cge->Evaluate(this->Makefile, config, - false, this->Target, 0, 0), + cmSystemTools::ExpandListArgument(cge->Evaluate(this->LocalGenerator, + config, + false, + this->GeneratorTarget, + 0, 0), this->CleanFiles); } @@ -245,7 +247,8 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules() // Write an empty dependency file. cmGeneratedFileStream depFileStream(dependFileNameFull.c_str()); depFileStream - << "# Empty dependencies file for " << this->Target->GetName() << ".\n" + << "# Empty dependencies file for " + << this->GeneratorTarget->GetName() << ".\n" << "# This may be replaced when dependencies are built." << std::endl; } @@ -375,7 +378,8 @@ void cmMakefileTargetGenerator // Get the full path name of the object file. std::string const& objectName = this->GeneratorTarget ->GetObjectName(&source); - std::string obj = this->LocalGenerator->GetTargetDirectory(*this->Target); + std::string obj = + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); obj += "/"; obj += objectName; @@ -390,7 +394,7 @@ void cmMakefileTargetGenerator err << "Warning: Source file \"" << source.GetFullPath() << "\" is listed multiple times for target \"" - << this->Target->GetName() + << this->GeneratorTarget->GetName() << "\"."; cmSystemTools::Message(err.str().c_str(), "Warning"); return; @@ -419,7 +423,7 @@ void cmMakefileTargetGenerator this->WriteObjectBuildFile(obj, lang, source, depends); // The object file should be checked for dependency integrity. - std::string objFullPath = this->Makefile->GetCurrentBinaryDirectory(); + std::string objFullPath = this->LocalGenerator->GetCurrentBinaryDirectory(); objFullPath += "/"; objFullPath += obj; objFullPath = @@ -427,7 +431,7 @@ void cmMakefileTargetGenerator std::string srcFullPath = this->Convert(source.GetFullPath(), cmLocalGenerator::FULL); this->LocalGenerator-> - AddImplicitDepends(*this->Target, lang, + AddImplicitDepends(this->GeneratorTarget, lang, objFullPath.c_str(), srcFullPath.c_str()); } @@ -539,24 +543,26 @@ cmMakefileTargetGenerator std::string targetFullPathReal; std::string targetFullPathPDB; std::string targetFullPathCompilePDB; - if(this->Target->GetType() == cmTarget::EXECUTABLE || - this->Target->GetType() == cmTarget::STATIC_LIBRARY || - this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE || + this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY || + this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY || + this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) { targetFullPathReal = this->GeneratorTarget->GetFullPath(this->ConfigName, false, true); - targetFullPathPDB = this->Target->GetPDBDirectory(this->ConfigName); + targetFullPathPDB = + this->GeneratorTarget->GetPDBDirectory(this->ConfigName); targetFullPathPDB += "/"; targetFullPathPDB += this->GeneratorTarget->GetPDBName(this->ConfigName); } - if(this->Target->GetType() <= cmTarget::OBJECT_LIBRARY) + if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) { targetFullPathCompilePDB = this->GeneratorTarget->GetCompilePDBPath(this->ConfigName); if(targetFullPathCompilePDB.empty()) { - targetFullPathCompilePDB = this->Target->GetSupportDirectory() + "/"; + targetFullPathCompilePDB = + this->GeneratorTarget->GetSupportDirectory() + "/"; } } @@ -582,7 +588,7 @@ cmMakefileTargetGenerator } cmLocalGenerator::RuleVariables vars; vars.RuleLauncher = "RULE_LAUNCH_COMPILE"; - vars.CMTarget = this->Target; + vars.CMTarget = this->GeneratorTarget; vars.Language = lang.c_str(); vars.Target = targetOutPathReal.c_str(); vars.TargetPDB = targetOutPathPDB.c_str(); @@ -593,7 +599,7 @@ cmMakefileTargetGenerator cmLocalGenerator::NONE, cmLocalGenerator::SHELL); vars.Object = shellObj.c_str(); - std::string objectDir = this->Target->GetSupportDirectory(); + std::string objectDir = this->GeneratorTarget->GetSupportDirectory(); objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL); @@ -642,7 +648,8 @@ cmMakefileTargetGenerator this->LocalGenerator->ExpandRuleVariables(compileCommand, vars); std::string workingDirectory = this->LocalGenerator->Convert( - this->Makefile->GetCurrentBinaryDirectory(), cmLocalGenerator::FULL); + this->LocalGenerator->GetCurrentBinaryDirectory(), + cmLocalGenerator::FULL); compileCommand.replace(compileCommand.find(langFlags), langFlags.size(), this->GetFlags(lang)); std::string langDefines = std::string("$(") + lang + "_DEFINES)"; @@ -659,7 +666,7 @@ cmMakefileTargetGenerator if (!compileCommands.empty() && (lang == "C" || lang == "CXX")) { std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE"; - const char *iwyu = this->Target->GetProperty(iwyu_prop); + const char *iwyu = this->GeneratorTarget->GetProperty(iwyu_prop); if (iwyu && *iwyu) { std::string run_iwyu = "$(CMAKE_COMMAND) -E __run_iwyu --iwyu="; @@ -673,7 +680,7 @@ cmMakefileTargetGenerator if (!compileCommands.empty() && (lang == "C" || lang == "CXX")) { std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER"; - const char *clauncher = this->Target->GetProperty(clauncher_prop); + const char *clauncher = this->GeneratorTarget->GetProperty(clauncher_prop); if (clauncher && *clauncher) { std::vector<std::string> launcher_cmd; @@ -698,7 +705,7 @@ cmMakefileTargetGenerator // Change the command working directory to the local build tree. this->LocalGenerator->CreateCDCommand (compileCommands, - this->Makefile->GetCurrentBinaryDirectory(), + this->LocalGenerator->GetCurrentBinaryDirectory(), cmLocalGenerator::HOME_OUTPUT); commands.insert(commands.end(), compileCommands.begin(), compileCommands.end()); @@ -771,7 +778,7 @@ cmMakefileTargetGenerator this->LocalGenerator->CreateCDCommand (preprocessCommands, - this->Makefile->GetCurrentBinaryDirectory(), + this->LocalGenerator->GetCurrentBinaryDirectory(), cmLocalGenerator::HOME_OUTPUT); commands.insert(commands.end(), preprocessCommands.begin(), @@ -828,7 +835,7 @@ cmMakefileTargetGenerator this->LocalGenerator->CreateCDCommand (assemblyCommands, - this->Makefile->GetCurrentBinaryDirectory(), + this->LocalGenerator->GetCurrentBinaryDirectory(), cmLocalGenerator::HOME_OUTPUT); commands.insert(commands.end(), assemblyCommands.begin(), @@ -864,7 +871,7 @@ cmMakefileTargetGenerator temp += ".provides.build"; std::vector<std::string> r_commands; std::string tgtMakefileName = - this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); + this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget); tgtMakefileName += "/build.make"; r_commands.push_back (this->LocalGenerator->GetRecursiveMakeCall(tgtMakefileName.c_str(), @@ -892,7 +899,7 @@ void cmMakefileTargetGenerator::WriteTargetRequiresRules() // Construct the name of the dependency generation target. std::string depTarget = - this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); + this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget); depTarget += "/requires"; // This target drives dependency generation for all object files. @@ -921,15 +928,15 @@ void cmMakefileTargetGenerator::WriteTargetCleanRules() // Construct the clean target name. std::string cleanTarget = - this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); + this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget); cleanTarget += "/clean"; // Construct the clean command. this->LocalGenerator->AppendCleanCommand(commands, this->CleanFiles, - *this->Target); + this->GeneratorTarget); this->LocalGenerator->CreateCDCommand (commands, - this->Makefile->GetCurrentBinaryDirectory(), + this->LocalGenerator->GetCurrentBinaryDirectory(), cmLocalGenerator::HOME_OUTPUT); // Write the rule. @@ -1018,7 +1025,8 @@ bool cmMakefileTargetGenerator::WriteMakeRule( void cmMakefileTargetGenerator::WriteTargetDependRules() { // must write the targets depend info file - std::string dir = this->LocalGenerator->GetTargetDirectory(*this->Target); + std::string dir = + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->InfoFileNameFull = dir; this->InfoFileNameFull += "/DependInfo.cmake"; this->InfoFileNameFull = @@ -1031,7 +1039,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules() return; } this->LocalGenerator-> - WriteDependLanguageInfo(*this->InfoFileStream,*this->Target); + WriteDependLanguageInfo(*this->InfoFileStream, this->GeneratorTarget); // Store multiple output pairs in the depend info file. if(!this->MultipleOutputPairs.empty()) @@ -1080,7 +1088,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules() // Construct the name of the dependency generation target. std::string depTarget = - this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); + this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget); depTarget += "/depend"; // Add a command to call CMake to scan dependencies. CMake will @@ -1095,7 +1103,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules() // translation table for the dependency scanning process. depCmd << "cd " << (this->LocalGenerator->Convert( - this->Makefile->GetHomeOutputDirectory(), + this->LocalGenerator->GetBinaryDirectory(), cmLocalGenerator::FULL, cmLocalGenerator::SHELL)) << " && "; #endif @@ -1110,16 +1118,16 @@ void cmMakefileTargetGenerator::WriteTargetDependRules() // the state of our local generator sufficiently for its needs. depCmd << "$(CMAKE_COMMAND) -E cmake_depends \"" << this->GlobalGenerator->GetName() << "\" " - << this->Convert(this->Makefile->GetHomeDirectory(), + << this->Convert(this->LocalGenerator->GetSourceDirectory(), cmLocalGenerator::FULL, cmLocalGenerator::SHELL) << " " - << this->Convert(this->Makefile->GetCurrentSourceDirectory(), + << this->Convert(this->LocalGenerator->GetCurrentSourceDirectory(), cmLocalGenerator::FULL, cmLocalGenerator::SHELL) << " " - << this->Convert(this->Makefile->GetHomeOutputDirectory(), + << this->Convert(this->LocalGenerator->GetBinaryDirectory(), cmLocalGenerator::FULL, cmLocalGenerator::SHELL) << " " - << this->Convert(this->Makefile->GetCurrentBinaryDirectory(), + << this->Convert(this->LocalGenerator->GetCurrentBinaryDirectory(), cmLocalGenerator::FULL, cmLocalGenerator::SHELL) << " " << this->Convert(this->InfoFileNameFull, @@ -1149,7 +1157,7 @@ cmMakefileTargetGenerator { // Depend on all custom command outputs. std::vector<cmSourceFile*> sources; - this->Target->GetSourceFiles(sources, + this->GeneratorTarget->GetSourceFiles(sources, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); for(std::vector<cmSourceFile*>::const_iterator source = sources.begin(); source != sources.end(); ++source) @@ -1202,7 +1210,8 @@ void cmMakefileTargetGenerator // Now append the actual user-specified commands. std::ostringstream content; - this->LocalGenerator->AppendCustomCommand(commands, ccg, this->Target, false, + this->LocalGenerator->AppendCustomCommand(commands, ccg, + this->GeneratorTarget, false, cmLocalGenerator::HOME_OUTPUT, &content); @@ -1231,7 +1240,7 @@ void cmMakefileTargetGenerator std::string srcFullPath = this->Convert(idi->second, cmLocalGenerator::FULL); this->LocalGenerator-> - AddImplicitDepends(*this->Target, idi->first, + AddImplicitDepends(this->GeneratorTarget, idi->first, objFullPath.c_str(), srcFullPath.c_str()); } @@ -1242,7 +1251,7 @@ void cmMakefileTargetGenerator ::MakeEchoProgress(cmLocalUnixMakefileGenerator3::EchoProgress& progress) const { - progress.Dir = this->Makefile->GetHomeOutputDirectory(); + progress.Dir = this->LocalGenerator->GetBinaryDirectory(); progress.Dir += cmake::GetCMakeFilesDirectory(); std::ostringstream progressArg; progressArg << "$(CMAKE_PROGRESS_" << this->NumberOfProgressActions << ")"; @@ -1259,10 +1268,10 @@ cmMakefileTargetGenerator // Write a make variable assignment that lists all objects for the // target. variableName = - this->LocalGenerator->CreateMakeVariable(this->Target->GetName(), + this->LocalGenerator->CreateMakeVariable(this->GeneratorTarget->GetName(), "_OBJECTS"); *this->BuildFileStream - << "# Object files for target " << this->Target->GetName() << "\n" + << "# Object files for target " << this->GeneratorTarget->GetName() << "\n" << variableName << " ="; std::string object; const char* lineContinue = @@ -1284,12 +1293,12 @@ cmMakefileTargetGenerator // Write a make variable assignment that lists all external objects // for the target. variableNameExternal = - this->LocalGenerator->CreateMakeVariable(this->Target->GetName(), + this->LocalGenerator->CreateMakeVariable(this->GeneratorTarget->GetName(), "_EXTERNAL_OBJECTS"); *this->BuildFileStream << "\n" << "# External object files for target " - << this->Target->GetName() << "\n" + << this->GeneratorTarget->GetName() << "\n" << variableNameExternal << " ="; for(std::vector<std::string>::const_iterator i = this->ExternalObjects.begin(); @@ -1394,7 +1403,7 @@ void cmMakefileTargetGenerator::WriteTargetDriverRule( { // Compute the name of the driver target. std::string dir = - this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); + this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget); std::string buildTargetRuleName = dir; buildTargetRuleName += relink?"/preinstall":"/build"; buildTargetRuleName = this->Convert(buildTargetRuleName, @@ -1439,7 +1448,7 @@ void cmMakefileTargetGenerator ::AppendTargetDepends(std::vector<std::string>& depends) { // Static libraries never depend on anything for linking. - if(this->Target->GetType() == cmTarget::STATIC_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) { return; } @@ -1493,9 +1502,18 @@ void cmMakefileTargetGenerator depends.push_back(this->ModuleDefinitionFile); } + // Add a dependency on user-specified manifest files, if any. + std::vector<cmSourceFile const*> manifest_srcs; + this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName); + for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin(); + mi != manifest_srcs.end(); ++mi) + { + depends.push_back((*mi)->GetFullPath()); + } + // Add user-specified dependencies. if(const char* linkDepends = - this->Target->GetProperty("LINK_DEPENDS")) + this->GeneratorTarget->GetProperty("LINK_DEPENDS")) { cmSystemTools::ExpandListArgument(linkDepends, depends); } @@ -1506,7 +1524,7 @@ std::string cmMakefileTargetGenerator::GetLinkRule( const std::string& linkRuleVar) { std::string linkRule = this->Makefile->GetRequiredDefinition(linkRuleVar); - if(this->Target->HasImplibGNUtoMS()) + if(this->GeneratorTarget->HasImplibGNUtoMS()) { std::string ruleVar = "CMAKE_"; ruleVar += this->GeneratorTarget->GetLinkerLanguage(this->ConfigName); diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h index fd4527b..38f40c0 100644 --- a/Source/cmMakefileTargetGenerator.h +++ b/Source/cmMakefileTargetGenerator.h @@ -18,14 +18,12 @@ #include "cmOSXBundleGenerator.h" class cmCustomCommandGenerator; -class cmDependInformation; class cmDepends; class cmGeneratorTarget; class cmGeneratedFileStream; class cmGlobalUnixMakefileGenerator3; class cmLocalUnixMakefileGenerator3; class cmMakefile; -class cmTarget; class cmSourceFile; /** \class cmMakefileTargetGenerator @@ -52,7 +50,6 @@ public: std::string GetProgressFileNameFull() { return this->ProgressFileNameFull; } - cmTarget* GetTarget() { return this->Target;} cmGeneratorTarget* GetGeneratorTarget() { return this->GeneratorTarget;} protected: diff --git a/Source/cmMakefileUtilityTargetGenerator.cxx b/Source/cmMakefileUtilityTargetGenerator.cxx index 303ca63..5b62cbf 100644 --- a/Source/cmMakefileUtilityTargetGenerator.cxx +++ b/Source/cmMakefileUtilityTargetGenerator.cxx @@ -16,7 +16,6 @@ #include "cmLocalUnixMakefileGenerator3.h" #include "cmMakefile.h" #include "cmSourceFile.h" -#include "cmTarget.h" //---------------------------------------------------------------------------- cmMakefileUtilityTargetGenerator @@ -42,7 +41,8 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles() this->CreateRuleFile(); *this->BuildFileStream - << "# Utility rule file for " << this->Target->GetName() << ".\n\n"; + << "# Utility rule file for " + << this->GeneratorTarget->GetName() << ".\n\n"; if(!this->NoRuleMessages) { @@ -67,19 +67,21 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles() // Utility targets store their rules in pre- and post-build commands. this->LocalGenerator->AppendCustomDepends - (depends, this->Target->GetPreBuildCommands()); + (depends, this->GeneratorTarget->GetPreBuildCommands()); this->LocalGenerator->AppendCustomDepends - (depends, this->Target->GetPostBuildCommands()); + (depends, this->GeneratorTarget->GetPostBuildCommands()); this->LocalGenerator->AppendCustomCommands - (commands, this->Target->GetPreBuildCommands(), this->Target); + (commands, this->GeneratorTarget->GetPreBuildCommands(), + this->GeneratorTarget); // Depend on all custom command outputs for sources this->DriveCustomCommands(depends); this->LocalGenerator->AppendCustomCommands - (commands, this->Target->GetPostBuildCommands(), this->Target); + (commands, this->GeneratorTarget->GetPostBuildCommands(), + this->GeneratorTarget); // Add dependencies on targets that must be built first. this->AppendTargetDepends(depends); @@ -101,11 +103,11 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles() // Write the rule. this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, - this->Target->GetName(), + this->GeneratorTarget->GetName(), depends, commands, true); // Write the main driver rule to build everything in this target. - this->WriteTargetDriverRule(this->Target->GetName(), false); + this->WriteTargetDriverRule(this->GeneratorTarget->GetName(), false); // Write clean target this->WriteTargetCleanRules(); diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx index 10d30f3..8d0e2b3 100644 --- a/Source/cmMarkAsAdvancedCommand.cxx +++ b/Source/cmMarkAsAdvancedCommand.cxx @@ -39,7 +39,8 @@ bool cmMarkAsAdvancedCommand cmState* state = this->Makefile->GetState(); if (!state->GetCacheEntryValue(variable)) { - state->AddCacheEntry(variable, 0, 0, cmState::UNINITIALIZED); + this->Makefile->GetCMakeInstance()->AddCacheEntry( + variable, 0, 0, cmState::UNINITIALIZED); overwrite = true; } if (!state->GetCacheEntryValue(variable)) diff --git a/Source/cmMessageCommand.cxx b/Source/cmMessageCommand.cxx index 467555f..2854a82 100644 --- a/Source/cmMessageCommand.cxx +++ b/Source/cmMessageCommand.cxx @@ -43,19 +43,7 @@ bool cmMessageCommand } else if (*i == "AUTHOR_WARNING") { - if (this->Makefile->IsOn("CMAKE_ERROR_DEVELOPER_WARNINGS")) - { - fatal = true; - type = cmake::AUTHOR_ERROR; - } - else if (!this->Makefile->IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS")) - { - type = cmake::AUTHOR_WARNING; - } - else - { - return true; - } + type = cmake::AUTHOR_WARNING; ++i; } else if (*i == "STATUS") diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx index b855bea..17561b5 100644 --- a/Source/cmNinjaNormalTargetGenerator.cxx +++ b/Source/cmNinjaNormalTargetGenerator.cxx @@ -41,7 +41,7 @@ cmNinjaNormalTargetGenerator(cmGeneratorTarget* target) , TargetLinkLanguage("") { this->TargetLinkLanguage = target->GetLinkerLanguage(this->GetConfigName()); - if (target->GetType() == cmTarget::EXECUTABLE) + if (target->GetType() == cmState::EXECUTABLE) this->GetGeneratorTarget()->GetExecutableNames(this->TargetNameOut, this->TargetNameReal, this->TargetNameImport, @@ -55,11 +55,11 @@ cmNinjaNormalTargetGenerator(cmGeneratorTarget* target) this->TargetNamePDB, GetLocalGenerator()->GetConfigName()); - if(target->GetType() != cmTarget::OBJECT_LIBRARY) + if(target->GetType() != cmState::OBJECT_LIBRARY) { // on Windows the output dir is already needed at compile time // ensure the directory exists (OutDir test) - EnsureDirectoryExists(target->Target->GetDirectory(this->GetConfigName())); + EnsureDirectoryExists(target->GetDirectory(this->GetConfigName())); } this->OSXBundleGenerator = new cmOSXBundleGenerator(target, @@ -77,7 +77,7 @@ void cmNinjaNormalTargetGenerator::Generate() if (this->TargetLinkLanguage.empty()) { cmSystemTools::Error("CMake can not determine linker language for " "target: ", - this->GetTarget()->GetName().c_str()); + this->GetGeneratorTarget()->GetName().c_str()); return; } @@ -87,7 +87,7 @@ void cmNinjaNormalTargetGenerator::Generate() // Write the build statements this->WriteObjectBuildStatements(); - if(this->GetTarget()->GetType() == cmTarget::OBJECT_LIBRARY) + if(this->GetGeneratorTarget()->GetType() == cmState::OBJECT_LIBRARY) { this->WriteObjectLibStatement(); } @@ -103,7 +103,7 @@ void cmNinjaNormalTargetGenerator::WriteLanguagesRules() cmGlobalNinjaGenerator::WriteDivider(this->GetRulesFileStream()); this->GetRulesFileStream() << "# Rules for each languages for " - << cmTarget::GetTargetTypeName(this->GetTarget()->GetType()) + << cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) << " target " << this->GetTargetName() << "\n\n"; @@ -112,7 +112,7 @@ void cmNinjaNormalTargetGenerator::WriteLanguagesRules() // Write rules for languages compiled in this target. std::set<std::string> languages; std::vector<cmSourceFile*> sourceFiles; - this->GetTarget()->GetSourceFiles(sourceFiles, + this->GetGeneratorTarget()->GetSourceFiles(sourceFiles, this->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE")); for(std::vector<cmSourceFile*>::const_iterator i = sourceFiles.begin(); i != sourceFiles.end(); ++i) @@ -133,17 +133,17 @@ void cmNinjaNormalTargetGenerator::WriteLanguagesRules() const char *cmNinjaNormalTargetGenerator::GetVisibleTypeName() const { - switch (this->GetTarget()->GetType()) { - case cmTarget::STATIC_LIBRARY: + switch (this->GetGeneratorTarget()->GetType()) { + case cmState::STATIC_LIBRARY: return "static library"; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return "shared library"; - case cmTarget::MODULE_LIBRARY: - if (this->GetTarget()->IsCFBundleOnApple()) + case cmState::MODULE_LIBRARY: + if (this->GetGeneratorTarget()->IsCFBundleOnApple()) return "CFBundle shared module"; else return "shared module"; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return "executable"; default: return 0; @@ -156,9 +156,10 @@ cmNinjaNormalTargetGenerator { return this->TargetLinkLanguage + "_" - + cmTarget::GetTargetTypeName(this->GetTarget()->GetType()) + + cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) + "_LINKER__" - + cmGlobalNinjaGenerator::EncodeRuleName(this->GetTarget()->GetName()) + + cmGlobalNinjaGenerator::EncodeRuleName( + this->GetGeneratorTarget()->GetName()) ; } @@ -166,7 +167,8 @@ void cmNinjaNormalTargetGenerator ::WriteLinkRule(bool useResponseFile) { - cmTarget::TargetType targetType = this->GetTarget()->GetType(); + cmState::TargetType targetType = + this->GetGeneratorTarget()->GetType(); std::string ruleName = this->LanguageLinkerRule(); // Select whether to use a response file for objects. @@ -176,7 +178,7 @@ cmNinjaNormalTargetGenerator if (!this->GetGlobalGenerator()->HasRule(ruleName)) { cmLocalGenerator::RuleVariables vars; vars.RuleLauncher = "RULE_LAUNCH_LINK"; - vars.CMTarget = this->GetTarget(); + vars.CMTarget = this->GetGeneratorTarget(); vars.Language = this->TargetLinkLanguage.c_str(); std::string responseFlag; @@ -226,7 +228,7 @@ cmNinjaNormalTargetGenerator std::ostringstream minorStream; int major; int minor; - this->GetTarget()->GetTargetVersion(major, minor); + this->GetGeneratorTarget()->GetTargetVersion(major, minor); majorStream << major; minorStream << minor; targetVersionMajor = majorStream.str(); @@ -237,9 +239,10 @@ cmNinjaNormalTargetGenerator vars.Flags = "$FLAGS"; vars.LinkFlags = "$LINK_FLAGS"; + vars.Manifests = "$MANIFESTS"; std::string langFlags; - if (targetType != cmTarget::EXECUTABLE) + if (targetType != cmState::EXECUTABLE) { langFlags += "$LANGUAGE_COMPILE_FLAGS $ARCH_FLAGS"; vars.LanguageCompileFlags = langFlags.c_str(); @@ -278,11 +281,11 @@ cmNinjaNormalTargetGenerator } if (this->TargetNameOut != this->TargetNameReal && - !this->GetTarget()->IsFrameworkOnApple()) { + !this->GetGeneratorTarget()->IsFrameworkOnApple()) { std::string cmakeCommand = this->GetLocalGenerator()->ConvertToOutputFormat( cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL); - if (targetType == cmTarget::EXECUTABLE) + if (targetType == cmState::EXECUTABLE) this->GetGlobalGenerator()->AddRule("CMAKE_SYMLINK_EXECUTABLE", cmakeCommand + " -E cmake_symlink_executable" @@ -329,8 +332,8 @@ cmNinjaNormalTargetGenerator return linkCmds; } } - switch (this->GetTarget()->GetType()) { - case cmTarget::STATIC_LIBRARY: { + switch (this->GetGeneratorTarget()->GetType()) { + case cmState::STATIC_LIBRARY: { // We have archive link commands set. First, delete the existing archive. { std::string cmakeCommand = @@ -355,9 +358,9 @@ cmNinjaNormalTargetGenerator } return linkCmds; } - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::EXECUTABLE: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::EXECUTABLE: break; default: assert(0 && "Unexpected target type"); @@ -396,7 +399,6 @@ static int calculateCommandLineLengthLimit(int linkRuleLength) void cmNinjaNormalTargetGenerator::WriteLinkStatement() { - cmTarget& target = *this->GetTarget(); cmGeneratorTarget& gt = *this->GetGeneratorTarget(); const std::string cfgName = this->GetConfigName(); std::string targetOutput = ConvertToNinjaPath( @@ -409,10 +411,10 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() gt.GetFullPath(cfgName, /*implib=*/true)); - if (target.IsAppBundleOnApple()) + if (gt.IsAppBundleOnApple()) { // Create the app bundle - std::string outpath = target.GetDirectory(cfgName); + std::string outpath = gt.GetDirectory(cfgName); this->OSXBundleGenerator->CreateAppBundle(this->TargetNameOut, outpath); // Calculate the output path @@ -425,25 +427,25 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() targetOutputReal += this->TargetNameReal; targetOutputReal = this->ConvertToNinjaPath(targetOutputReal); } - else if (target.IsFrameworkOnApple()) + else if (gt.IsFrameworkOnApple()) { // Create the library framework. this->OSXBundleGenerator->CreateFramework(this->TargetNameOut, - target.GetDirectory(cfgName)); + gt.GetDirectory(cfgName)); } - else if(target.IsCFBundleOnApple()) + else if(gt.IsCFBundleOnApple()) { // Create the core foundation bundle. this->OSXBundleGenerator->CreateCFBundle(this->TargetNameOut, - target.GetDirectory(cfgName)); + gt.GetDirectory(cfgName)); } // Write comments. cmGlobalNinjaGenerator::WriteDivider(this->GetBuildFileStream()); - const cmTarget::TargetType targetType = target.GetType(); + const cmState::TargetType targetType = gt.GetType(); this->GetBuildFileStream() << "# Link build statements for " - << cmTarget::GetTargetTypeName(targetType) + << cmState::GetTargetTypeName(targetType) << " target " << this->GetTargetName() << "\n\n"; @@ -487,14 +489,13 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() &genTarget, useWatcomQuote); if(this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS") - && target.GetType() == cmTarget::SHARED_LIBRARY) + && gt.GetType() == cmState::SHARED_LIBRARY) { - if(target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if(gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { - std::string dllname = targetOutput; std::string name_of_def_file - = target.GetSupportDirectory(); - name_of_def_file += "/" + target.GetName(); + = gt.GetSupportDirectory(); + name_of_def_file += "/" + gt.GetName(); name_of_def_file += ".def "; vars["LINK_FLAGS"] += " /DEF:"; vars["LINK_FLAGS"] += this->GetLocalGenerator() @@ -503,18 +504,20 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() } } - this->addPoolNinjaVariable("JOB_POOL_LINK", &target, vars); + this->addPoolNinjaVariable("JOB_POOL_LINK", >, vars); this->AddModuleDefinitionFlag(vars["LINK_FLAGS"]); vars["LINK_FLAGS"] = cmGlobalNinjaGenerator ::EncodeLiteral(vars["LINK_FLAGS"]); + vars["MANIFESTS"] = this->GetManifests(); + vars["LINK_PATH"] = frameworkPath + linkPath; // Compute architecture specific link flags. Yes, these go into a different // variable for executables, probably due to a mistake made when duplicating // code between the Makefile executable and library generators. - if (targetType == cmTarget::EXECUTABLE) + if (targetType == cmState::EXECUTABLE) { std::string t = vars["FLAGS"]; localGen.AddArchitectureFlags(t, &genTarget, TargetLinkLanguage, cfgName); @@ -534,7 +537,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() { vars["SONAME_FLAG"] = mf->GetSONameFlag(this->TargetLinkLanguage); vars["SONAME"] = this->TargetNameSO; - if (targetType == cmTarget::SHARED_LIBRARY) + if (targetType == cmState::SHARED_LIBRARY) { std::string install_dir = this->GetGeneratorTarget()->GetInstallNameDirForBuildTree(cfgName); @@ -556,7 +559,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() cmLocalGenerator::SHELL); vars["TARGET_IMPLIB"] = impLibPath; EnsureParentDirectoryExists(impLibPath); - if(target.HasImportLibrary()) + if(genTarget.HasImportLibrary()) { byproducts.push_back(targetOutputImplib); } @@ -579,11 +582,14 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() vars["TARGET_PDB"] = base + suffix + dbg_suffix; } + const std::string objPath = GetGeneratorTarget()->GetSupportDirectory(); + vars["OBJECT_DIR"] = + this->GetLocalGenerator()->ConvertToOutputFormat( + this->ConvertToNinjaPath(objPath), cmLocalGenerator::SHELL); + EnsureDirectoryExists(objPath); + if (this->GetGlobalGenerator()->IsGCCOnWindows()) { - const std::string objPath = GetTarget()->GetSupportDirectory(); - vars["OBJECT_DIR"] = ConvertToNinjaPath(objPath); - EnsureDirectoryExists(objPath); // ar.exe can't handle backslashes in rsp files (implicitly used by gcc) std::string& linkLibraries = vars["LINK_LIBRARIES"]; std::replace(linkLibraries.begin(), linkLibraries.end(), '\\', '/'); @@ -592,9 +598,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() } const std::vector<cmCustomCommand> *cmdLists[3] = { - &target.GetPreBuildCommands(), - &target.GetPreLinkCommands(), - &target.GetPostBuildCommands() + >.GetPreBuildCommands(), + >.GetPreLinkCommands(), + >.GetPostBuildCommands() }; std::vector<std::string> preLinkCmdLines, postBuildCmdLines; @@ -619,18 +625,17 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() } // maybe create .def file from list of objects - if (target.GetType() == cmTarget::SHARED_LIBRARY && + if (gt.GetType() == cmState::SHARED_LIBRARY && this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if(target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if(gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { std::string cmakeCommand = this->GetLocalGenerator()->ConvertToOutputFormat( cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL); - std::string dllname = targetOutput; std::string name_of_def_file - = target.GetSupportDirectory(); - name_of_def_file += "/" + target.GetName(); + = gt.GetSupportDirectory(); + name_of_def_file += "/" + gt.GetName(); name_of_def_file += ".def"; std::string cmd = cmakeCommand; cmd += " -E __create_def "; @@ -661,8 +666,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() if (!preLinkCmdLines.empty()) { const std::string homeOutDir = localGen.ConvertToOutputFormat( - mf->GetHomeOutputDirectory(), - cmLocalGenerator::SHELL); + localGen.GetBinaryDirectory(), + cmLocalGenerator::SHELL); preLinkCmdLines.push_back("cd " + homeOutDir); } @@ -693,11 +698,11 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() const std::string rspfile = std::string(cmake::GetCMakeFilesDirectoryPostSlash()) - + target.GetName() + ".rsp"; + + gt.GetName() + ".rsp"; // Gather order-only dependencies. cmNinjaDeps orderOnlyDeps; - this->GetLocalGenerator()->AppendTargetDepends(this->GetTarget(), + this->GetLocalGenerator()->AppendTargetDepends(this->GetGeneratorTarget(), orderOnlyDeps); // Ninja should restat after linking if and only if there are byproducts. @@ -726,9 +731,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() &usedResponseFile); this->WriteLinkRule(usedResponseFile); - if (targetOutput != targetOutputReal && !target.IsFrameworkOnApple()) + if (targetOutput != targetOutputReal && !gt.IsFrameworkOnApple()) { - if (targetType == cmTarget::EXECUTABLE) + if (targetType == cmState::EXECUTABLE) { globalGen.WriteBuild(this->GetBuildFileStream(), "Create executable symlink " + targetOutput, @@ -766,8 +771,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() } // Add aliases for the file name and the target name. - globalGen.AddTargetAlias(this->TargetNameOut, &target); - globalGen.AddTargetAlias(this->GetTargetName(), &target); + globalGen.AddTargetAlias(this->TargetNameOut, >); + globalGen.AddTargetAlias(this->GetTargetName(), >); } //---------------------------------------------------------------------------- @@ -775,7 +780,8 @@ void cmNinjaNormalTargetGenerator::WriteObjectLibStatement() { // Write a phony output that depends on all object files. cmNinjaDeps outputs; - this->GetLocalGenerator()->AppendTargetOutputs(this->GetTarget(), outputs); + this->GetLocalGenerator()->AppendTargetOutputs(this->GetGeneratorTarget(), + outputs); cmNinjaDeps depends = this->GetObjects(); this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(), "Object library " @@ -785,5 +791,5 @@ void cmNinjaNormalTargetGenerator::WriteObjectLibStatement() // Add aliases for the target name. this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(), - this->GetTarget()); + this->GetGeneratorTarget()); } diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx index 81fdde2..dc2c7a6 100644 --- a/Source/cmNinjaTargetGenerator.cxx +++ b/Source/cmNinjaTargetGenerator.cxx @@ -31,23 +31,22 @@ cmNinjaTargetGenerator::New(cmGeneratorTarget* target) { switch (target->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::SHARED_LIBRARY: - case cmTarget::STATIC_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::SHARED_LIBRARY: + case cmState::STATIC_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: return new cmNinjaNormalTargetGenerator(target); - case cmTarget::UTILITY: + case cmState::UTILITY: return new cmNinjaUtilityTargetGenerator(target);; - case cmTarget::GLOBAL_TARGET: { + case cmState::GLOBAL_TARGET: { // We only want to process global targets that live in the home // (i.e. top-level) directory. CMake creates copies of these targets // in every directory, which we don't need. - cmMakefile *mf = target->Target->GetMakefile(); - if (strcmp(mf->GetCurrentSourceDirectory(), - mf->GetHomeDirectory()) == 0) + if (strcmp(target->GetLocalGenerator()->GetCurrentSourceDirectory(), + target->GetLocalGenerator()->GetSourceDirectory()) == 0) return new cmNinjaUtilityTargetGenerator(target); // else fallthrough } @@ -93,7 +92,7 @@ std::string cmNinjaTargetGenerator::LanguageCompilerRule( const std::string& lang) const { return lang + "_COMPILER__" + - cmGlobalNinjaGenerator::EncodeRuleName(this->Target->GetName()); + cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()); } std::string @@ -149,17 +148,9 @@ void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags, bool cmNinjaTargetGenerator::NeedDepTypeMSVC(const std::string& lang) const { - if (lang == "C" || lang == "CXX") - { - cmMakefile* mf = this->GetMakefile(); - return ( - strcmp(mf->GetSafeDefinition("CMAKE_C_COMPILER_ID"), "MSVC") == 0 || - strcmp(mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID"), "MSVC") == 0 || - strcmp(mf->GetSafeDefinition("CMAKE_C_SIMULATE_ID"), "MSVC") == 0 || - strcmp(mf->GetSafeDefinition("CMAKE_CXX_SIMULATE_ID"), "MSVC") == 0 - ); - } - return false; + return strcmp( + this->GetMakefile()->GetSafeDefinition("CMAKE_NINJA_DEPTYPE_" + lang), + "msvc") == 0; } // TODO: Refactor with @@ -190,8 +181,8 @@ ComputeDefines(cmSourceFile const* source, const std::string& language) cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const { // Static libraries never depend on other targets for linking. - if (this->Target->GetType() == cmTarget::STATIC_LIBRARY || - this->Target->GetType() == cmTarget::OBJECT_LIBRARY) + if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY || + this->GeneratorTarget->GetType() == cmState::OBJECT_LIBRARY) return cmNinjaDeps(); cmComputeLinkInformation* cli = @@ -209,8 +200,18 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const result.push_back(this->ConvertToNinjaPath(this->ModuleDefinitionFile)); } + // Add a dependency on user-specified manifest files, if any. + std::vector<cmSourceFile const*> manifest_srcs; + this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName); + for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin(); + mi != manifest_srcs.end(); ++mi) + { + result.push_back(this->ConvertToNinjaPath((*mi)->GetFullPath())); + } + // Add user-specified dependencies. - if (const char* linkDepends = this->Target->GetProperty("LINK_DEPENDS")) + if (const char* linkDepends = + this->GeneratorTarget->GetProperty("LINK_DEPENDS")) { std::vector<std::string> linkDeps; cmSystemTools::ExpandListArgument(linkDepends, linkDeps); @@ -237,7 +238,7 @@ cmNinjaTargetGenerator path += "/"; std::string const& objectName = this->GeneratorTarget ->GetObjectName(source); - path += this->LocalGenerator->GetTargetDirectory(*this->Target); + path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); path += "/"; path += objectName; return path; @@ -245,7 +246,7 @@ cmNinjaTargetGenerator std::string cmNinjaTargetGenerator::GetTargetOutputDir() const { - std::string dir = this->Target->GetDirectory(this->GetConfigName()); + std::string dir = this->GeneratorTarget->GetDirectory(this->GetConfigName()); return ConvertToNinjaPath(dir); } @@ -263,7 +264,7 @@ cmNinjaTargetGenerator std::string cmNinjaTargetGenerator::GetTargetName() const { - return this->Target->GetName(); + return this->GeneratorTarget->GetName(); } @@ -275,22 +276,22 @@ bool cmNinjaTargetGenerator::SetMsvcTargetPdbVariable(cmNinjaVars& vars) const { std::string pdbPath; std::string compilePdbPath; - if(this->Target->GetType() == cmTarget::EXECUTABLE || - this->Target->GetType() == cmTarget::STATIC_LIBRARY || - this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE || + this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY || + this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY || + this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) { - pdbPath = this->Target->GetPDBDirectory(this->GetConfigName()); + pdbPath = this->GeneratorTarget->GetPDBDirectory(this->GetConfigName()); pdbPath += "/"; pdbPath += this->GeneratorTarget->GetPDBName(this->GetConfigName()); } - if(this->Target->GetType() <= cmTarget::OBJECT_LIBRARY) + if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) { compilePdbPath = this->GeneratorTarget->GetCompilePDBPath(this->GetConfigName()); if(compilePdbPath.empty()) { - compilePdbPath = this->Target->GetSupportDirectory() + "/"; + compilePdbPath = this->GeneratorTarget->GetSupportDirectory() + "/"; } } @@ -326,7 +327,7 @@ cmNinjaTargetGenerator { cmLocalGenerator::RuleVariables vars; vars.RuleLauncher = "RULE_LAUNCH_COMPILE"; - vars.CMTarget = this->GetTarget(); + vars.CMTarget = this->GetGeneratorTarget(); vars.Language = lang.c_str(); vars.Source = "$in"; vars.Object = "$out"; @@ -350,7 +351,7 @@ cmNinjaTargetGenerator depfile = ""; flags += " /showIncludes"; } - else if (lang == "RC" && this->NeedDepTypeMSVC("C")) + else if (mf->IsOn("CMAKE_NINJA_CMCLDEPS_"+lang)) { // For the MS resource compiler we need cmcldeps, but skip dependencies // for source-file try_compile cases because they are always fresh. @@ -362,7 +363,7 @@ cmNinjaTargetGenerator mf->GetSafeDefinition("CMAKE_C_COMPILER") : mf->GetSafeDefinition("CMAKE_CXX_COMPILER"); cldeps = "\""; - cldeps += mf->GetSafeDefinition("CMAKE_CMCLDEPS_EXECUTABLE"); + cldeps += cmSystemTools::GetCMClDepsCommand(); cldeps += "\" " + lang + " $in \"$DEP_FILE\" $out \""; cldeps += mf->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX"); cldeps += "\" \"" + cl + "\" "; @@ -402,7 +403,7 @@ cmNinjaTargetGenerator if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) { std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE"; - const char *iwyu = this->Target->GetProperty(iwyu_prop); + const char *iwyu = this->GeneratorTarget->GetProperty(iwyu_prop); if (iwyu && *iwyu) { std::string run_iwyu = @@ -419,7 +420,7 @@ cmNinjaTargetGenerator if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) { std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER"; - const char *clauncher = this->Target->GetProperty(clauncher_prop); + const char *clauncher = this->GeneratorTarget->GetProperty(clauncher_prop); if (clauncher && *clauncher) { std::vector<std::string> launcher_cmd; @@ -472,7 +473,7 @@ cmNinjaTargetGenerator cmGlobalNinjaGenerator::WriteDivider(this->GetBuildFileStream()); this->GetBuildFileStream() << "# Object build statements for " - << cmTarget::GetTargetTypeName(this->GetTarget()->GetType()) + << cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) << " target " << this->GetTargetName() << "\n\n"; @@ -485,7 +486,8 @@ cmNinjaTargetGenerator si != customCommands.end(); ++si) { cmCustomCommand const* cc = (*si)->GetCustomCommand(); - this->GetLocalGenerator()->AddCustomCommandTarget(cc, this->GetTarget()); + this->GetLocalGenerator()->AddCustomCommandTarget(cc, + this->GetGeneratorTarget()); // Record the custom commands for this target. The container is used // in WriteObjectBuildStatement when called in a loop below. this->CustomCommands.push_back(cc); @@ -510,7 +512,8 @@ cmNinjaTargetGenerator } cmNinjaDeps orderOnlyDeps; - this->GetLocalGenerator()->AppendTargetDepends(this->Target, orderOnlyDeps); + this->GetLocalGenerator()->AppendTargetDepends(this->GeneratorTarget, + orderOnlyDeps); // Add order-only dependencies on custom command outputs. for(std::vector<cmCustomCommand const*>::const_iterator @@ -559,7 +562,7 @@ cmNinjaTargetGenerator std::string const language = source->GetLanguage(); std::string const sourceFileName = language=="RC" ? source->GetFullPath() : this->GetSourceFilePath(source); - std::string const objectDir = this->Target->GetSupportDirectory(); + std::string const objectDir = this->GeneratorTarget->GetSupportDirectory(); std::string const objectFileName = this->GetObjectFilePath(source); std::string const objectFileDir = cmSystemTools::GetFilenamePath(objectFileName); @@ -632,7 +635,8 @@ cmNinjaTargetGenerator ConvertToNinjaPath(objectFileDir), cmLocalGenerator::SHELL); - this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetTarget(), vars); + this->addPoolNinjaVariable("JOB_POOL_COMPILE", + this->GetGeneratorTarget(), vars); this->SetMsvcTargetPdbVariable(vars); @@ -762,14 +766,14 @@ cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()( // Get the input file location. std::string input = source.GetFullPath(); input = - this->Generator->GetLocalGenerator()->ConvertToNinjaPath(input); + this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(input); // Get the output file location. std::string output = macdir; output += "/"; output += cmSystemTools::GetFilenameName(input); output = - this->Generator->GetLocalGenerator()->ConvertToNinjaPath(output); + this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(output); // Write a build statement to copy the content into the bundle. this->Generator->GetGlobalGenerator()->WriteMacOSXContentBuild(input, @@ -781,7 +785,7 @@ cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()( void cmNinjaTargetGenerator::addPoolNinjaVariable( const std::string& pool_property, - cmTarget* target, + cmGeneratorTarget* target, cmNinjaVars& vars) { const char* pool = target->GetProperty(pool_property); diff --git a/Source/cmNinjaTargetGenerator.h b/Source/cmNinjaTargetGenerator.h index a10ceba..e3ec423 100644 --- a/Source/cmNinjaTargetGenerator.h +++ b/Source/cmNinjaTargetGenerator.h @@ -17,11 +17,11 @@ #include "cmStandardIncludes.h" #include "cmNinjaTypes.h" +#include "cmGlobalNinjaGenerator.h" #include "cmLocalNinjaGenerator.h" #include "cmOSXBundleGenerator.h" class cmTarget; -class cmGlobalNinjaGenerator; class cmGeneratedFileStream; class cmGeneratorTarget; class cmMakefile; @@ -53,9 +53,6 @@ protected: cmGeneratedFileStream& GetBuildFileStream() const; cmGeneratedFileStream& GetRulesFileStream() const; - cmTarget* GetTarget() const - { return this->Target; } - cmGeneratorTarget* GetGeneratorTarget() const { return this->GeneratorTarget; } @@ -87,10 +84,10 @@ protected: const std::string& language); std::string ConvertToNinjaPath(const std::string& path) const { - return this->GetLocalGenerator()->ConvertToNinjaPath(path); + return this->GetGlobalGenerator()->ConvertToNinjaPath(path); } - cmLocalNinjaGenerator::map_to_ninja_path MapToNinjaPath() const { - return this->GetLocalGenerator()->MapToNinjaPath(); + cmGlobalNinjaGenerator::MapToNinjaPathImpl MapToNinjaPath() const { + return this->GetGlobalGenerator()->MapToNinjaPath(); } /// @return the list of link dependency for the given target @a target. @@ -152,7 +149,7 @@ protected: std::set<std::string> MacContentFolders; void addPoolNinjaVariable(const std::string& pool_property, - cmTarget* target, + cmGeneratorTarget* target, cmNinjaVars& vars); private: diff --git a/Source/cmNinjaUtilityTargetGenerator.cxx b/Source/cmNinjaUtilityTargetGenerator.cxx index 58b901a..edc65f0 100644 --- a/Source/cmNinjaUtilityTargetGenerator.cxx +++ b/Source/cmNinjaUtilityTargetGenerator.cxx @@ -16,7 +16,6 @@ #include "cmGlobalNinjaGenerator.h" #include "cmMakefile.h" #include "cmSourceFile.h" -#include "cmTarget.h" #include "cmCustomCommandGenerator.h" cmNinjaUtilityTargetGenerator::cmNinjaUtilityTargetGenerator( @@ -34,8 +33,8 @@ void cmNinjaUtilityTargetGenerator::Generate() cmNinjaDeps deps, outputs, util_outputs(1, utilCommandName); const std::vector<cmCustomCommand> *cmdLists[2] = { - &this->GetTarget()->GetPreBuildCommands(), - &this->GetTarget()->GetPostBuildCommands() + &this->GetGeneratorTarget()->GetPreBuildCommands(), + &this->GetGeneratorTarget()->GetPostBuildCommands() }; bool uses_terminal = false; @@ -58,7 +57,7 @@ void cmNinjaUtilityTargetGenerator::Generate() std::vector<cmSourceFile*> sources; std::string config = this->GetMakefile() ->GetSafeDefinition("CMAKE_BUILD_TYPE"); - this->GetTarget()->GetSourceFiles(sources, config); + this->GetGeneratorTarget()->GetSourceFiles(sources, config); for(std::vector<cmSourceFile*>::const_iterator source = sources.begin(); source != sources.end(); ++source) { @@ -66,7 +65,8 @@ void cmNinjaUtilityTargetGenerator::Generate() { cmCustomCommandGenerator ccg(*cc, this->GetConfigName(), this->GetLocalGenerator()); - this->GetLocalGenerator()->AddCustomCommandTarget(cc, this->GetTarget()); + this->GetLocalGenerator()->AddCustomCommandTarget(cc, + this->GetGeneratorTarget()); // Depend on all custom command outputs. const std::vector<std::string>& ccOutputs = ccg.GetOutputs(); @@ -78,8 +78,10 @@ void cmNinjaUtilityTargetGenerator::Generate() } } - this->GetLocalGenerator()->AppendTargetOutputs(this->GetTarget(), outputs); - this->GetLocalGenerator()->AppendTargetDepends(this->GetTarget(), deps); + this->GetLocalGenerator()->AppendTargetOutputs(this->GetGeneratorTarget(), + outputs); + this->GetLocalGenerator()->AppendTargetDepends(this->GetGeneratorTarget(), + deps); if (commands.empty()) { this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(), @@ -90,7 +92,8 @@ void cmNinjaUtilityTargetGenerator::Generate() } else { std::string command = this->GetLocalGenerator()->BuildCommandLine(commands); - const char *echoStr = this->GetTarget()->GetProperty("EchoString"); + const char *echoStr = + this->GetGeneratorTarget()->GetProperty("EchoString"); std::string desc; if (echoStr) desc = echoStr; @@ -103,13 +106,13 @@ void cmNinjaUtilityTargetGenerator::Generate() command, "$(CMAKE_SOURCE_DIR)", this->GetLocalGenerator()->ConvertToOutputFormat( - this->GetTarget()->GetMakefile()->GetHomeDirectory(), + this->GetLocalGenerator()->GetSourceDirectory(), cmLocalGenerator::SHELL).c_str()); cmSystemTools::ReplaceString( command, "$(CMAKE_BINARY_DIR)", this->GetLocalGenerator()->ConvertToOutputFormat( - this->GetTarget()->GetMakefile()->GetHomeOutputDirectory(), + this->GetLocalGenerator()->GetBinaryDirectory(), cmLocalGenerator::SHELL).c_str()); cmSystemTools::ReplaceString(command, "$(ARGS)", ""); @@ -139,5 +142,5 @@ void cmNinjaUtilityTargetGenerator::Generate() } this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(), - this->GetTarget()); + this->GetGeneratorTarget()); } diff --git a/Source/cmOSXBundleGenerator.cxx b/Source/cmOSXBundleGenerator.cxx index 4fe99e3..3c4aa00 100644 --- a/Source/cmOSXBundleGenerator.cxx +++ b/Source/cmOSXBundleGenerator.cxx @@ -34,7 +34,7 @@ cmOSXBundleGenerator(cmGeneratorTarget* target, //---------------------------------------------------------------------------- bool cmOSXBundleGenerator::MustSkip() { - return !this->GT->Target->HaveWellDefinedOutputFiles(); + return !this->GT->HaveWellDefinedOutputFiles(); } //---------------------------------------------------------------------------- @@ -59,7 +59,7 @@ void cmOSXBundleGenerator::CreateAppBundle(const std::string& targetName, plist += "/"; plist += this->GT->GetAppBundleDirectory(this->ConfigName, true); plist += "/Info.plist"; - this->LocalGenerator->GenerateAppleInfoPList(this->GT->Target, + this->LocalGenerator->GenerateAppleInfoPList(this->GT, targetName, plist.c_str()); this->Makefile->AddCMakeOutputFile(plist); @@ -83,14 +83,14 @@ void cmOSXBundleGenerator::CreateFramework( std::string newoutpath = outpath + "/" + this->GT->GetFrameworkDirectory(this->ConfigName, false); - std::string frameworkVersion = this->GT->Target->GetFrameworkVersion(); + std::string frameworkVersion = this->GT->GetFrameworkVersion(); // Configure the Info.plist file into the Resources directory. this->MacContentFolders->insert("Resources"); std::string plist = newoutpath; plist += "/Resources/Info.plist"; std::string name = cmSystemTools::GetFilenameName(targetName); - this->LocalGenerator->GenerateFrameworkInfoPList(this->GT->Target, + this->LocalGenerator->GenerateFrameworkInfoPList(this->GT, name, plist.c_str()); @@ -182,7 +182,7 @@ void cmOSXBundleGenerator::CreateCFBundle(const std::string& targetName, this->GT->GetCFBundleDirectory(this->ConfigName, true); plist += "/Info.plist"; std::string name = cmSystemTools::GetFilenameName(targetName); - this->LocalGenerator->GenerateAppleInfoPList(this->GT->Target, + this->LocalGenerator->GenerateAppleInfoPList(this->GT, name, plist.c_str()); this->Makefile->AddCMakeOutputFile(plist); diff --git a/Source/cmOrderDirectories.cxx b/Source/cmOrderDirectories.cxx index 35ee127..e3eedc7 100644 --- a/Source/cmOrderDirectories.cxx +++ b/Source/cmOrderDirectories.cxx @@ -555,7 +555,7 @@ void cmOrderDirectories::FindImplicitConflicts() << "Some of these libraries may not be found correctly."; this->GlobalGenerator->GetCMakeInstance() ->IssueMessage(cmake::WARNING, w.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } //---------------------------------------------------------------------------- @@ -637,5 +637,5 @@ void cmOrderDirectories::DiagnoseCycle() e << "Some of these libraries may not be found correctly."; this->GlobalGenerator->GetCMakeInstance() ->IssueMessage(cmake::WARNING, e.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx index 7be5b3f..5acae2f 100644 --- a/Source/cmOutputConverter.cxx +++ b/Source/cmOutputConverter.cxx @@ -142,21 +142,7 @@ std::string cmOutputConverter::ConvertToOutputFormat(const std::string& source, } else if(output == SHELL || output == WATCOMQUOTE) { - // For the MSYS shell convert drive letters to posix paths, so - // that c:/some/path becomes /c/some/path. This is needed to - // avoid problems with the shell path translation. - if(this->GetState()->UseMSYSShell() && !this->LinkScriptShell) - { - if(result.size() > 2 && result[1] == ':') - { - result[1] = result[0]; - result[0] = '/'; - } - } - if(this->GetState()->UseWindowsShell()) - { - std::replace(result.begin(), result.end(), '/', '\\'); - } + result = this->ConvertDirectorySeparatorsForShell(source); result = this->EscapeForShell(result, true, false, output == WATCOMQUOTE); } else if(output == RESPONSE) @@ -167,6 +153,29 @@ std::string cmOutputConverter::ConvertToOutputFormat(const std::string& source, } //---------------------------------------------------------------------------- +std::string cmOutputConverter::ConvertDirectorySeparatorsForShell( + const std::string& source) const +{ + std::string result = source; + // For the MSYS shell convert drive letters to posix paths, so + // that c:/some/path becomes /c/some/path. This is needed to + // avoid problems with the shell path translation. + if(this->GetState()->UseMSYSShell() && !this->LinkScriptShell) + { + if(result.size() > 2 && result[1] == ':') + { + result[1] = result[0]; + result[0] = '/'; + } + } + if(this->GetState()->UseWindowsShell()) + { + std::replace(result.begin(), result.end(), '/', '\\'); + } + return result; +} + +//---------------------------------------------------------------------------- std::string cmOutputConverter::Convert(RelativeRoot remote, const std::string& local, OutputFormat output, diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h index ed7739e..852df5d 100644 --- a/Source/cmOutputConverter.h +++ b/Source/cmOutputConverter.h @@ -45,6 +45,8 @@ public: std::string Convert(RelativeRoot remote, const std::string& local, OutputFormat output = UNCHANGED, bool optional = false) const; + std::string ConvertDirectorySeparatorsForShell( + const std::string& source) const; /** * Get path for the specified relative root. diff --git a/Source/cmOutputRequiredFilesCommand.cxx b/Source/cmOutputRequiredFilesCommand.cxx index 2d57d3b..54208ac 100644 --- a/Source/cmOutputRequiredFilesCommand.cxx +++ b/Source/cmOutputRequiredFilesCommand.cxx @@ -10,108 +10,239 @@ See the License for more information. ============================================================================*/ #include "cmOutputRequiredFilesCommand.h" -#include "cmMakeDepend.h" #include "cmAlgorithms.h" #include <cmsys/FStream.hxx> -class cmLBDepend : public cmMakeDepend +/** \class cmDependInformation + * \brief Store dependency information for a single source file. + * + * This structure stores the depend information for a single source file. + */ +class cmDependInformation { +public: /** - * Compute the depend information for this class. + * Construct with dependency generation marked not done; instance + * not placed in cmMakefile's list. */ - virtual void DependWalk(cmDependInformation* info); -}; + cmDependInformation(): DependDone(false), SourceFile(0) {} -void cmLBDepend::DependWalk(cmDependInformation* info) -{ - cmsys::ifstream fin(info->FullPath.c_str()); - if(!fin) + /** + * The set of files on which this one depends. + */ + typedef std::set<cmDependInformation*> DependencySetType; + DependencySetType DependencySet; + + /** + * This flag indicates whether dependency checking has been + * performed for this file. + */ + bool DependDone; + + /** + * If this object corresponds to a cmSourceFile instance, this points + * to it. + */ + const cmSourceFile *SourceFile; + + /** + * Full path to this file. + */ + std::string FullPath; + + /** + * Full path not including file name. + */ + std::string PathOnly; + + /** + * Name used to #include this file. + */ + std::string IncludeName; + + /** + * This method adds the dependencies of another file to this one. + */ + void AddDependencies(cmDependInformation* info) + { + if(this != info) { - cmSystemTools::Error("error can not open ", info->FullPath.c_str()); - return; + this->DependencySet.insert(info); } + } +}; - std::string line; - while(cmSystemTools::GetLineFromStream(fin, line)) - { - if(cmHasLiteralPrefix(line.c_str(), "#include")) - { - // if it is an include line then create a string class - std::string currentline = line; - size_t qstart = currentline.find('\"', 8); - size_t qend; - // if a quote is not found look for a < - if(qstart == std::string::npos) - { - qstart = currentline.find('<', 8); - // if a < is not found then move on - if(qstart == std::string::npos) - { - cmSystemTools::Error("unknown include directive ", - currentline.c_str() ); - continue; - } - else - { - qend = currentline.find('>', qstart+1); - } - } - else +class cmLBDepend +{ +public: + /** + * Construct the object with verbose turned off. + */ + cmLBDepend() + { + this->Verbose = false; + this->IncludeFileRegularExpression.compile("^.*$"); + this->ComplainFileRegularExpression.compile("^$"); + } + + /** + * Destructor. + */ + ~cmLBDepend() + { + cmDeleteAll(this->DependInformationMap); + } + + /** + * Set the makefile that is used as a source of classes. + */ + void SetMakefile(cmMakefile* makefile) + { + this->Makefile = makefile; + + // Now extract the include file regular expression from the makefile. + this->IncludeFileRegularExpression.compile( + this->Makefile->GetIncludeRegularExpression()); + this->ComplainFileRegularExpression.compile( + this->Makefile->GetComplainRegularExpression()); + + // Now extract any include paths from the targets + std::set<std::string> uniqueIncludes; + std::vector<std::string> orderedAndUniqueIncludes; + cmTargets &targets = this->Makefile->GetTargets(); + for (cmTargets::iterator l = targets.begin(); + l != targets.end(); ++l) + { + const char *incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES"); + if (!incDirProp) { - qend = currentline.find('\"', qstart+1); + continue; } - // extract the file being included - std::string includeFile = currentline.substr(qstart+1, qend - qstart-1); - // see if the include matches the regular expression - if(!this->IncludeFileRegularExpression.find(includeFile)) + + std::string incDirs = + cmGeneratorExpression::Preprocess(incDirProp, + cmGeneratorExpression::StripAllGeneratorExpressions); + + std::vector<std::string> includes; + cmSystemTools::ExpandListArgument(incDirs, includes); + + for(std::vector<std::string>::const_iterator j = includes.begin(); + j != includes.end(); ++j) { - if(this->Verbose) + std::string path = *j; + this->Makefile->ExpandVariablesInString(path); + if(uniqueIncludes.insert(path).second) { - std::string message = "Skipping "; - message += includeFile; - message += " for file "; - message += info->FullPath.c_str(); - cmSystemTools::Error(message.c_str(), 0); + orderedAndUniqueIncludes.push_back(path); } - continue; } + } - // Add this file and all its dependencies. - this->AddDependency(info, includeFile.c_str()); - /// add the cxx file if it exists - std::string cxxFile = includeFile; - std::string::size_type pos = cxxFile.rfind('.'); - if(pos != std::string::npos) + for(std::vector<std::string>::const_iterator + it = orderedAndUniqueIncludes.begin(); + it != orderedAndUniqueIncludes.end(); + ++it) + { + this->AddSearchPath(*it); + } + } + + /** + * Add a directory to the search path for include files. + */ + void AddSearchPath(const std::string& path) + { + this->IncludeDirectories.push_back(path); + } + + /** + * Generate dependencies for the file given. Returns a pointer to + * the cmDependInformation object for the file. + */ + const cmDependInformation* FindDependencies(const char* file) + { + cmDependInformation* info = this->GetDependInformation(file,0); + this->GenerateDependInformation(info); + return info; + } + +protected: + /** + * Compute the depend information for this class. + */ + + void DependWalk(cmDependInformation* info) + { + cmsys::ifstream fin(info->FullPath.c_str()); + if(!fin) + { + cmSystemTools::Error("error can not open ", info->FullPath.c_str()); + return; + } + + std::string line; + while(cmSystemTools::GetLineFromStream(fin, line)) + { + if(cmHasLiteralPrefix(line.c_str(), "#include")) { - std::string root = cxxFile.substr(0, pos); - cxxFile = root + ".cxx"; - bool found = false; - // try jumping to .cxx .cpp and .c in order - if(cmSystemTools::FileExists(cxxFile.c_str())) + // if it is an include line then create a string class + std::string currentline = line; + size_t qstart = currentline.find('\"', 8); + size_t qend; + // if a quote is not found look for a < + if(qstart == std::string::npos) { - found = true; + qstart = currentline.find('<', 8); + // if a < is not found then move on + if(qstart == std::string::npos) + { + cmSystemTools::Error("unknown include directive ", + currentline.c_str() ); + continue; + } + else + { + qend = currentline.find('>', qstart+1); + } } - for(std::vector<std::string>::iterator i = - this->IncludeDirectories.begin(); - i != this->IncludeDirectories.end(); ++i) + else + { + qend = currentline.find('\"', qstart+1); + } + // extract the file being included + std::string includeFile = + currentline.substr(qstart+1, qend - qstart-1); + // see if the include matches the regular expression + if(!this->IncludeFileRegularExpression.find(includeFile)) { - std::string path = *i; - path = path + "/"; - path = path + cxxFile; - if(cmSystemTools::FileExists(path.c_str())) + if(this->Verbose) { - found = true; + std::string message = "Skipping "; + message += includeFile; + message += " for file "; + message += info->FullPath.c_str(); + cmSystemTools::Error(message.c_str(), 0); } + continue; } - if (!found) + + // Add this file and all its dependencies. + this->AddDependency(info, includeFile.c_str()); + /// add the cxx file if it exists + std::string cxxFile = includeFile; + std::string::size_type pos = cxxFile.rfind('.'); + if(pos != std::string::npos) { - cxxFile = root + ".cpp"; + std::string root = cxxFile.substr(0, pos); + cxxFile = root + ".cxx"; + bool found = false; + // try jumping to .cxx .cpp and .c in order if(cmSystemTools::FileExists(cxxFile.c_str())) { found = true; } for(std::vector<std::string>::iterator i = - this->IncludeDirectories.begin(); + this->IncludeDirectories.begin(); i != this->IncludeDirectories.end(); ++i) { std::string path = *i; @@ -122,55 +253,314 @@ void cmLBDepend::DependWalk(cmDependInformation* info) found = true; } } - } - if (!found) - { - cxxFile = root + ".c"; - if(cmSystemTools::FileExists(cxxFile.c_str())) + if (!found) { - found = true; - } - for(std::vector<std::string>::iterator i = - this->IncludeDirectories.begin(); - i != this->IncludeDirectories.end(); ++i) - { - std::string path = *i; - path = path + "/"; - path = path + cxxFile; - if(cmSystemTools::FileExists(path.c_str())) + cxxFile = root + ".cpp"; + if(cmSystemTools::FileExists(cxxFile.c_str())) { found = true; } + for(std::vector<std::string>::iterator i = + this->IncludeDirectories.begin(); + i != this->IncludeDirectories.end(); ++i) + { + std::string path = *i; + path = path + "/"; + path = path + cxxFile; + if(cmSystemTools::FileExists(path.c_str())) + { + found = true; + } + } } - } - if (!found) - { - cxxFile = root + ".txx"; - if(cmSystemTools::FileExists(cxxFile.c_str())) + if (!found) { - found = true; - } - for(std::vector<std::string>::iterator i = + cxxFile = root + ".c"; + if(cmSystemTools::FileExists(cxxFile.c_str())) + { + found = true; + } + for(std::vector<std::string>::iterator i = this->IncludeDirectories.begin(); - i != this->IncludeDirectories.end(); ++i) + i != this->IncludeDirectories.end(); ++i) + { + std::string path = *i; + path = path + "/"; + path = path + cxxFile; + if(cmSystemTools::FileExists(path.c_str())) + { + found = true; + } + } + } + if (!found) { - std::string path = *i; - path = path + "/"; - path = path + cxxFile; - if(cmSystemTools::FileExists(path.c_str())) + cxxFile = root + ".txx"; + if(cmSystemTools::FileExists(cxxFile.c_str())) { found = true; } + for(std::vector<std::string>::iterator i = + this->IncludeDirectories.begin(); + i != this->IncludeDirectories.end(); ++i) + { + std::string path = *i; + path = path + "/"; + path = path + cxxFile; + if(cmSystemTools::FileExists(path.c_str())) + { + found = true; + } + } + } + if (found) + { + this->AddDependency(info, cxxFile.c_str()); } } - if (found) + } + } + } + + /** + * Add a dependency. Possibly walk it for more dependencies. + */ + void AddDependency(cmDependInformation* info, const char* file) + { + cmDependInformation* dependInfo = + this->GetDependInformation(file, info->PathOnly.c_str()); + this->GenerateDependInformation(dependInfo); + info->AddDependencies(dependInfo); + } + + /** + * Fill in the given object with dependency information. If the + * information is already complete, nothing is done. + */ + void GenerateDependInformation(cmDependInformation* info) + { + // If dependencies are already done, stop now. + if(info->DependDone) + { + return; + } + else + { + // Make sure we don't visit the same file more than once. + info->DependDone = true; + } + const char* path = info->FullPath.c_str(); + if(!path) + { + cmSystemTools::Error( + "Attempt to find dependencies for file without path!"); + return; + } + + bool found = false; + + // If the file exists, use it to find dependency information. + if(cmSystemTools::FileExists(path, true)) + { + // Use the real file to find its dependencies. + this->DependWalk(info); + found = true; + } + + + // See if the cmSourceFile for it has any files specified as + // dependency hints. + if(info->SourceFile != 0) + { + + // Get the cmSourceFile corresponding to this. + const cmSourceFile& cFile = *(info->SourceFile); + // See if there are any hints for finding dependencies for the missing + // file. + if(!cFile.GetDepends().empty()) + { + // Dependency hints have been given. Use them to begin the + // recursion. + for(std::vector<std::string>::const_iterator file = + cFile.GetDepends().begin(); file != cFile.GetDepends().end(); + ++file) { - this->AddDependency(info, cxxFile.c_str()); + this->AddDependency(info, file->c_str()); } + + // Found dependency information. We are done. + found = true; } } - } -} + + if(!found) + { + // Try to find the file amongst the sources + cmSourceFile *srcFile = this->Makefile->GetSource + (cmSystemTools::GetFilenameWithoutExtension(path)); + if (srcFile) + { + if (srcFile->GetFullPath() == path) + { + found=true; + } + else + { + //try to guess which include path to use + for(std::vector<std::string>::iterator t = + this->IncludeDirectories.begin(); + t != this->IncludeDirectories.end(); ++t) + { + std::string incpath = *t; + if (!incpath.empty() && incpath[incpath.size() - 1] != '/') + { + incpath = incpath + "/"; + } + incpath = incpath + path; + if (srcFile->GetFullPath() == incpath) + { + // set the path to the guessed path + info->FullPath = incpath; + found=true; + } + } + } + } + } + + if(!found) + { + // Couldn't find any dependency information. + if(this->ComplainFileRegularExpression.find(info->IncludeName.c_str())) + { + cmSystemTools::Error("error cannot find dependencies for ", path); + } + else + { + // Destroy the name of the file so that it won't be output as a + // dependency. + info->FullPath = ""; + } + } + } + + /** + * Get an instance of cmDependInformation corresponding to the given file + * name. + */ + cmDependInformation* GetDependInformation(const char* file, + const char *extraPath) + { + // Get the full path for the file so that lookup is unambiguous. + std::string fullPath = this->FullPath(file, extraPath); + + // Try to find the file's instance of cmDependInformation. + DependInformationMapType::const_iterator result = + this->DependInformationMap.find(fullPath); + if(result != this->DependInformationMap.end()) + { + // Found an instance, return it. + return result->second; + } + else + { + // Didn't find an instance. Create a new one and save it. + cmDependInformation* info = new cmDependInformation; + info->FullPath = fullPath; + info->PathOnly = cmSystemTools::GetFilenamePath(fullPath); + info->IncludeName = file; + this->DependInformationMap[fullPath] = info; + return info; + } + } + + /** + * Find the full path name for the given file name. + * This uses the include directories. + * TODO: Cache path conversions to reduce FileExists calls. + */ + std::string FullPath(const char *fname, const char *extraPath) + { + DirectoryToFileToPathMapType::iterator m; + if(extraPath) + { + m = this->DirectoryToFileToPathMap.find(extraPath); + } + else + { + m = this->DirectoryToFileToPathMap.find(""); + } + + if(m != this->DirectoryToFileToPathMap.end()) + { + FileToPathMapType& map = m->second; + FileToPathMapType::iterator p = map.find(fname); + if(p != map.end()) + { + return p->second; + } + } + + if(cmSystemTools::FileExists(fname, true)) + { + std::string fp = cmSystemTools::CollapseFullPath(fname); + this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp; + return fp; + } + + for(std::vector<std::string>::iterator i = + this->IncludeDirectories.begin(); + i != this->IncludeDirectories.end(); ++i) + { + std::string path = *i; + if (!path.empty() && path[path.size() - 1] != '/') + { + path = path + "/"; + } + path = path + fname; + if(cmSystemTools::FileExists(path.c_str(), true) + && !cmSystemTools::FileIsDirectory(path)) + { + std::string fp = cmSystemTools::CollapseFullPath(path); + this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp; + return fp; + } + } + + if (extraPath) + { + std::string path = extraPath; + if (!path.empty() && path[path.size() - 1] != '/') + { + path = path + "/"; + } + path = path + fname; + if(cmSystemTools::FileExists(path.c_str(), true) + && !cmSystemTools::FileIsDirectory(path)) + { + std::string fp = cmSystemTools::CollapseFullPath(path); + this->DirectoryToFileToPathMap[extraPath][fname] = fp; + return fp; + } + } + + // Couldn't find the file. + return std::string(fname); + } + + cmMakefile* Makefile; + bool Verbose; + cmsys::RegularExpression IncludeFileRegularExpression; + cmsys::RegularExpression ComplainFileRegularExpression; + std::vector<std::string> IncludeDirectories; + typedef std::map<std::string, std::string> FileToPathMapType; + typedef std::map<std::string, FileToPathMapType> + DirectoryToFileToPathMapType; + typedef std::map<std::string, cmDependInformation*> + DependInformationMapType; + DependInformationMapType DependInformationMap; + DirectoryToFileToPathMapType DirectoryToFileToPathMap; +}; // cmOutputRequiredFilesCommand bool cmOutputRequiredFilesCommand diff --git a/Source/cmOutputRequiredFilesCommand.h b/Source/cmOutputRequiredFilesCommand.h index 95eba38..b5eb932 100644 --- a/Source/cmOutputRequiredFilesCommand.h +++ b/Source/cmOutputRequiredFilesCommand.h @@ -13,7 +13,8 @@ #define cmOutputRequiredFilesCommand_h #include "cmCommand.h" -#include "cmMakeDepend.h" + +class cmDependInformation; class cmOutputRequiredFilesCommand : public cmCommand { @@ -23,7 +24,6 @@ public: virtual bool InitialPass(std::vector<std::string> const& args, cmExecutionStatus &status); virtual std::string GetName() const { return "output_required_files";} - virtual bool IsDiscouraged() const { return true; } void ListDependencies(cmDependInformation const *info, FILE *fout, diff --git a/Source/cmPolicies.h b/Source/cmPolicies.h index a791b89..5023055 100644 --- a/Source/cmPolicies.h +++ b/Source/cmPolicies.h @@ -220,18 +220,39 @@ class cmPolicy; 3, 3, 0, cmPolicies::WARN) \ SELECT(POLICY, CMP0064, \ "Support new TEST if() operator.", \ - 3, 3, 0, cmPolicies::WARN) + 3, 4, 0, cmPolicies::WARN) \ + SELECT(POLICY, CMP0065, \ + "Do not add flags to export symbols from executables without " \ + "the ENABLE_EXPORTS target property.", \ + 3, 4, 0, cmPolicies::WARN) #define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1) #define CM_FOR_EACH_POLICY_ID(POLICY) \ CM_FOR_EACH_POLICY_TABLE(POLICY, CM_SELECT_ID) +#define CM_FOR_EACH_TARGET_POLICY(F) \ + F(CMP0003) \ + F(CMP0004) \ + F(CMP0008) \ + F(CMP0020) \ + F(CMP0021) \ + F(CMP0022) \ + F(CMP0027) \ + F(CMP0038) \ + F(CMP0041) \ + F(CMP0042) \ + F(CMP0046) \ + F(CMP0052) \ + F(CMP0060) \ + F(CMP0063) \ + F(CMP0065) + /** \class cmPolicies * \brief Handles changes in CMake behavior and policies * * See the cmake wiki section on - * <a href="http://www.cmake.org/Wiki/CMake/Policies">policies</a> + * <a href="https://cmake.org/Wiki/CMake/Policies">policies</a> * for an overview of this class's purpose */ class cmPolicies diff --git a/Source/cmQtAutoGeneratorInitializer.cxx b/Source/cmQtAutoGeneratorInitializer.cxx new file mode 100644 index 0000000..08caea3 --- /dev/null +++ b/Source/cmQtAutoGeneratorInitializer.cxx @@ -0,0 +1,1072 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2004-2011 Kitware, Inc. + Copyright 2011 Alexander Neundorf (neundorf@kde.org) + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ + +#include "cmQtAutoGeneratorInitializer.h" + +#include "cmLocalGenerator.h" +#include "cmMakefile.h" +#include "cmSourceFile.h" + +#include <sys/stat.h> + +#include <cmsys/FStream.hxx> + +#if defined(_WIN32) && !defined(__CYGWIN__) +# include "cmGlobalVisualStudioGenerator.h" +#endif + +static void SetupSourceFiles(cmGeneratorTarget const* target, + std::vector<std::string>& skipMoc, + std::vector<std::string>& mocSources, + std::vector<std::string>& mocHeaders, + std::vector<std::string>& skipUic) +{ + cmMakefile* makefile = target->Target->GetMakefile(); + + std::vector<cmSourceFile*> srcFiles; + target->GetConfigCommonSourceFiles(srcFiles); + + std::vector<std::string> newRccFiles; + + for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); + fileIt != srcFiles.end(); + ++fileIt) + { + cmSourceFile* sf = *fileIt; + std::string absFile = cmsys::SystemTools::GetRealPath( + sf->GetFullPath()); + bool skipFileForMoc = + cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC")); + bool generated = cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED")); + + if(cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC"))) + { + skipUic.push_back(absFile); + } + + std::string ext = sf->GetExtension(); + + if (target->GetPropertyAsBool("AUTORCC")) + { + if (ext == "qrc" + && !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"))) + { + std::string basename = cmsys::SystemTools:: + GetFilenameWithoutLastExtension(absFile); + + std::string rcc_output_dir = target->GetSupportDirectory(); + cmSystemTools::MakeDirectory(rcc_output_dir.c_str()); + std::string rcc_output_file = rcc_output_dir; + rcc_output_file += "/qrc_" + basename + ".cpp"; + makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", + rcc_output_file.c_str(), false); + makefile->GetOrCreateSource(rcc_output_file, true); + newRccFiles.push_back(rcc_output_file); + } + } + + if (!generated) + { + if (skipFileForMoc) + { + skipMoc.push_back(absFile); + } + else + { + cmSystemTools::FileFormat fileType = cmSystemTools::GetFileFormat( + ext.c_str()); + if (fileType == cmSystemTools::CXX_FILE_FORMAT) + { + mocSources.push_back(absFile); + } + else if (fileType == cmSystemTools::HEADER_FILE_FORMAT) + { + mocHeaders.push_back(absFile); + } + } + } + } + + for(std::vector<std::string>::const_iterator fileIt = newRccFiles.begin(); + fileIt != newRccFiles.end(); + ++fileIt) + { + const_cast<cmGeneratorTarget*>(target)->AddSource(*fileIt); + } +} + +static void GetCompileDefinitionsAndDirectories( + cmGeneratorTarget const* target, + const std::string& config, + std::string &incs, + std::string &defs) +{ + std::vector<std::string> includeDirs; + cmLocalGenerator *localGen = target->GetLocalGenerator(); + // Get the include dirs for this target, without stripping the implicit + // include dirs off, see http://public.kitware.com/Bug/view.php?id=13667 + localGen->GetIncludeDirectories(includeDirs, target, "CXX", config, false); + + incs = cmJoin(includeDirs, ";"); + + std::set<std::string> defines; + localGen->AddCompileDefinitions(defines, target, config, "CXX"); + + defs += cmJoin(defines, ";"); +} + +static void SetupAutoMocTarget(cmGeneratorTarget const* target, + const std::string &autogenTargetName, + std::vector<std::string> const& skipMoc, + std::vector<std::string> const& mocHeaders, + std::map<std::string, std::string> &configIncludes, + std::map<std::string, std::string> &configDefines) +{ + cmLocalGenerator* lg = target->GetLocalGenerator(); + cmMakefile* makefile = target->Target->GetMakefile(); + + const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS"); + std::string _moc_options = (tmp!=0 ? tmp : ""); + makefile->AddDefinition("_moc_options", + cmOutputConverter::EscapeForCMake(_moc_options).c_str()); + makefile->AddDefinition("_skip_moc", + cmOutputConverter::EscapeForCMake(cmJoin(skipMoc, ";")).c_str()); + makefile->AddDefinition("_moc_headers", + cmOutputConverter::EscapeForCMake(cmJoin(mocHeaders, ";")).c_str()); + bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE"); + makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE"); + + std::string _moc_incs; + std::string _moc_compile_defs; + std::vector<std::string> configs; + const std::string& config = makefile->GetConfigurations(configs); + GetCompileDefinitionsAndDirectories(target, config, + _moc_incs, _moc_compile_defs); + + makefile->AddDefinition("_moc_incs", + cmOutputConverter::EscapeForCMake(_moc_incs).c_str()); + makefile->AddDefinition("_moc_compile_defs", + cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str()); + + for (std::vector<std::string>::const_iterator li = configs.begin(); + li != configs.end(); ++li) + { + std::string config_moc_incs; + std::string config_moc_compile_defs; + GetCompileDefinitionsAndDirectories(target, *li, + config_moc_incs, + config_moc_compile_defs); + if (config_moc_incs != _moc_incs) + { + configIncludes[*li] = + cmOutputConverter::EscapeForCMake(config_moc_incs); + if(_moc_incs.empty()) + { + _moc_incs = config_moc_incs; + } + } + if (config_moc_compile_defs != _moc_compile_defs) + { + configDefines[*li] = + cmOutputConverter::EscapeForCMake(config_moc_compile_defs); + if(_moc_compile_defs.empty()) + { + _moc_compile_defs = config_moc_compile_defs; + } + } + } + + const char *qtVersion = makefile->GetDefinition("_target_qt_version"); + if (strcmp(qtVersion, "5") == 0) + { + cmGeneratorTarget *qt5Moc = + lg->FindGeneratorTargetToUse("Qt5::moc"); + if (!qt5Moc) + { + cmSystemTools::Error("Qt5::moc target not found ", + autogenTargetName.c_str()); + return; + } + makefile->AddDefinition("_qt_moc_executable", + qt5Moc->ImportedGetLocation("")); + } + else if (strcmp(qtVersion, "4") == 0) + { + cmGeneratorTarget *qt4Moc = + lg->FindGeneratorTargetToUse("Qt4::moc"); + if (!qt4Moc) + { + cmSystemTools::Error("Qt4::moc target not found ", + autogenTargetName.c_str()); + return; + } + makefile->AddDefinition("_qt_moc_executable", + qt4Moc->ImportedGetLocation("")); + } + else + { + cmSystemTools::Error("The CMAKE_AUTOMOC feature supports only Qt 4 and " + "Qt 5 ", autogenTargetName.c_str()); + } +} + +static void GetUicOpts(cmGeneratorTarget const* target, + const std::string& config, + std::string &optString) +{ + std::vector<std::string> opts; + target->GetAutoUicOptions(opts, config); + optString = cmJoin(opts, ";"); +} + +static void SetupAutoUicTarget(cmGeneratorTarget const* target, + std::vector<std::string> const& skipUic, + std::map<std::string, std::string> &configUicOptions) +{ + cmLocalGenerator* lg = target->GetLocalGenerator(); + cmMakefile *makefile = target->Target->GetMakefile(); + + std::set<std::string> skipped; + skipped.insert(skipUic.begin(), skipUic.end()); + + makefile->AddDefinition("_skip_uic", + cmOutputConverter::EscapeForCMake(cmJoin(skipUic, ";")).c_str()); + + std::vector<cmSourceFile*> uiFilesWithOptions + = makefile->GetQtUiFilesWithOptions(); + + const char *qtVersion = makefile->GetDefinition("_target_qt_version"); + + std::string _uic_opts; + std::vector<std::string> configs; + const std::string& config = makefile->GetConfigurations(configs); + GetUicOpts(target, config, _uic_opts); + + if (!_uic_opts.empty()) + { + _uic_opts = cmOutputConverter::EscapeForCMake(_uic_opts); + makefile->AddDefinition("_uic_target_options", _uic_opts.c_str()); + } + for (std::vector<std::string>::const_iterator li = configs.begin(); + li != configs.end(); ++li) + { + std::string config_uic_opts; + GetUicOpts(target, *li, config_uic_opts); + if (config_uic_opts != _uic_opts) + { + configUicOptions[*li] = + cmOutputConverter::EscapeForCMake(config_uic_opts); + if(_uic_opts.empty()) + { + _uic_opts = config_uic_opts; + } + } + } + + std::string uiFileFiles; + std::string uiFileOptions; + const char* sep = ""; + + for(std::vector<cmSourceFile*>::const_iterator fileIt = + uiFilesWithOptions.begin(); + fileIt != uiFilesWithOptions.end(); + ++fileIt) + { + cmSourceFile* sf = *fileIt; + std::string absFile = cmsys::SystemTools::GetRealPath( + sf->GetFullPath()); + + if (!skipped.insert(absFile).second) + { + continue; + } + uiFileFiles += sep; + uiFileFiles += absFile; + uiFileOptions += sep; + std::string opts = sf->GetProperty("AUTOUIC_OPTIONS"); + cmSystemTools::ReplaceString(opts, ";", "@list_sep@"); + uiFileOptions += opts; + sep = ";"; + } + + makefile->AddDefinition("_qt_uic_options_files", + cmOutputConverter::EscapeForCMake(uiFileFiles).c_str()); + makefile->AddDefinition("_qt_uic_options_options", + cmOutputConverter::EscapeForCMake(uiFileOptions).c_str()); + + std::string targetName = target->GetName(); + if (strcmp(qtVersion, "5") == 0) + { + cmGeneratorTarget *qt5Uic = + lg->FindGeneratorTargetToUse("Qt5::uic"); + if (!qt5Uic) + { + // Project does not use Qt5Widgets, but has AUTOUIC ON anyway + } + else + { + makefile->AddDefinition("_qt_uic_executable", + qt5Uic->ImportedGetLocation("")); + } + } + else if (strcmp(qtVersion, "4") == 0) + { + cmGeneratorTarget *qt4Uic = + lg->FindGeneratorTargetToUse("Qt4::uic"); + if (!qt4Uic) + { + cmSystemTools::Error("Qt4::uic target not found ", + targetName.c_str()); + return; + } + makefile->AddDefinition("_qt_uic_executable", + qt4Uic->ImportedGetLocation("")); + } + else + { + cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and " + "Qt 5 ", targetName.c_str()); + } +} + +static std::string GetRccExecutable(cmGeneratorTarget const* target) +{ + cmLocalGenerator* lg = target->GetLocalGenerator(); + cmMakefile *makefile = target->Target->GetMakefile(); + const char *qtVersion = makefile->GetDefinition("_target_qt_version"); + if (!qtVersion) + { + qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR"); + if (!qtVersion) + { + qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR"); + } + if (const char *targetQtVersion = + target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", + "")) + { + qtVersion = targetQtVersion; + } + } + + std::string targetName = target->GetName(); + if (strcmp(qtVersion, "5") == 0) + { + cmGeneratorTarget *qt5Rcc = + lg->FindGeneratorTargetToUse("Qt5::rcc"); + if (!qt5Rcc) + { + cmSystemTools::Error("Qt5::rcc target not found ", + targetName.c_str()); + return std::string(); + } + return qt5Rcc->ImportedGetLocation(""); + } + else if (strcmp(qtVersion, "4") == 0) + { + cmGeneratorTarget *qt4Rcc = + lg->FindGeneratorTargetToUse("Qt4::rcc"); + if (!qt4Rcc) + { + cmSystemTools::Error("Qt4::rcc target not found ", + targetName.c_str()); + return std::string(); + } + return qt4Rcc->ImportedGetLocation(""); + } + + cmSystemTools::Error("The CMAKE_AUTORCC feature supports only Qt 4 and " + "Qt 5 ", targetName.c_str()); + return std::string(); +} + +static void MergeRccOptions(std::vector<std::string> &opts, + const std::vector<std::string> &fileOpts, + bool isQt5) +{ + static const char* valueOptions[] = { + "name", + "root", + "compress", + "threshold" + }; + std::vector<std::string> extraOpts; + for(std::vector<std::string>::const_iterator it = fileOpts.begin(); + it != fileOpts.end(); ++it) + { + std::vector<std::string>::iterator existingIt + = std::find(opts.begin(), opts.end(), *it); + if (existingIt != opts.end()) + { + const char *o = it->c_str(); + if (*o == '-') + { + ++o; + } + if (isQt5 && *o == '-') + { + ++o; + } + if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions), + cmStrCmp(*it)) != cmArrayEnd(valueOptions)) + { + assert(existingIt + 1 != opts.end()); + *(existingIt + 1) = *(it + 1); + ++it; + } + } + else + { + extraOpts.push_back(*it); + } + } + opts.insert(opts.end(), extraOpts.begin(), extraOpts.end()); +} + +std::string GetAutogenTargetName( + cmGeneratorTarget const* target) +{ + std::string autogenTargetName = target->GetName(); + autogenTargetName += "_automoc"; + return autogenTargetName; +} + +std::string GetAutogenTargetDir( + cmGeneratorTarget const* target) +{ + cmMakefile* makefile = target->Target->GetMakefile(); + std::string targetDir = makefile->GetCurrentBinaryDirectory(); + targetDir += makefile->GetCMakeInstance()->GetCMakeFilesDirectory(); + targetDir += "/"; + targetDir += GetAutogenTargetName(target); + targetDir += ".dir/"; + return targetDir; +} + +static void copyTargetProperty(cmTarget* destinationTarget, + cmTarget* sourceTarget, + const std::string& propertyName) +{ + const char* propertyValue = sourceTarget->GetProperty(propertyName); + if (propertyValue) + { + destinationTarget->SetProperty(propertyName, propertyValue); + } +} + +static std::string cmQtAutoGeneratorsStripCR(std::string const& line) +{ + // Strip CR characters rcc may have printed (possibly more than one!). + std::string::size_type cr = line.find('\r'); + if (cr != line.npos) + { + return line.substr(0, cr); + } + return line; +} + +static std::string ReadAll(const std::string& filename) +{ + cmsys::ifstream file(filename.c_str()); + std::stringstream stream; + stream << file.rdbuf(); + file.close(); + return stream.str(); +} + +static std::string ListQt5RccInputs(cmSourceFile* sf, + cmGeneratorTarget const* target, + std::vector<std::string>& depends) +{ + std::string rccCommand + = GetRccExecutable(target); + + bool hasDashDashList = false; + { + std::vector<std::string> command; + command.push_back(rccCommand); + command.push_back("--help"); + std::string rccStdOut; + std::string rccStdErr; + int retVal = 0; + bool result = cmSystemTools::RunSingleCommand( + command, &rccStdOut, &rccStdErr, + &retVal, 0, cmSystemTools::OUTPUT_NONE); + if (result && retVal == 0 && + rccStdOut.find("--list") != std::string::npos) + { + hasDashDashList = true; + } + } + + std::vector<std::string> qrcEntries; + + std::vector<std::string> command; + command.push_back(rccCommand); + command.push_back(hasDashDashList? "--list" : "-list"); + + std::string absFile = cmsys::SystemTools::GetRealPath( + sf->GetFullPath()); + + command.push_back(absFile); + + std::string rccStdOut; + std::string rccStdErr; + int retVal = 0; + bool result = cmSystemTools::RunSingleCommand( + command, &rccStdOut, &rccStdErr, + &retVal, 0, cmSystemTools::OUTPUT_NONE); + if (!result || retVal) + { + std::cerr << "AUTOGEN: error: Rcc list process for " << sf->GetFullPath() + << " failed:\n" << rccStdOut << "\n" << rccStdErr << std::endl; + return std::string(); + } + + { + std::istringstream ostr(rccStdOut); + std::string oline; + while(std::getline(ostr, oline)) + { + oline = cmQtAutoGeneratorsStripCR(oline); + if(!oline.empty()) + { + qrcEntries.push_back(oline); + } + } + } + + { + std::istringstream estr(rccStdErr); + std::string eline; + while(std::getline(estr, eline)) + { + eline = cmQtAutoGeneratorsStripCR(eline); + if (cmHasLiteralPrefix(eline, "RCC: Error in")) + { + static std::string searchString = "Cannot find file '"; + + std::string::size_type pos = eline.find(searchString); + if (pos == std::string::npos) + { + std::cerr << "AUTOGEN: error: Rcc lists unparsable output " + << eline << std::endl; + return std::string(); + } + pos += searchString.length(); + std::string::size_type sz = eline.size() - pos - 1; + qrcEntries.push_back(eline.substr(pos, sz)); + } + } + } + + depends.insert(depends.end(), qrcEntries.begin(), qrcEntries.end()); + return cmJoin(qrcEntries, "@list_sep@"); +} + +static std::string ListQt4RccInputs(cmSourceFile* sf, + std::vector<std::string>& depends) +{ + const std::string qrcContents = ReadAll(sf->GetFullPath()); + + cmsys::RegularExpression fileMatchRegex("(<file[^<]+)"); + + std::string entriesList; + const char* sep = ""; + + size_t offset = 0; + while (fileMatchRegex.find(qrcContents.c_str() + offset)) + { + std::string qrcEntry = fileMatchRegex.match(1); + + offset += qrcEntry.size(); + + cmsys::RegularExpression fileReplaceRegex("(^<file[^>]*>)"); + fileReplaceRegex.find(qrcEntry); + std::string tag = fileReplaceRegex.match(1); + + qrcEntry = qrcEntry.substr(tag.size()); + + if (!cmSystemTools::FileIsFullPath(qrcEntry.c_str())) + { + qrcEntry = sf->GetLocation().GetDirectory() + "/" + qrcEntry; + } + + entriesList += sep; + entriesList += qrcEntry; + sep = "@list_sep@"; + depends.push_back(qrcEntry); + } + return entriesList; +} + +static void SetupAutoRccTarget(cmGeneratorTarget const* target) +{ + std::string _rcc_files; + const char* sepRccFiles = ""; + cmMakefile *makefile = target->Target->GetMakefile(); + + std::vector<cmSourceFile*> srcFiles; + target->GetConfigCommonSourceFiles(srcFiles); + + std::string qrcInputs; + const char* qrcInputsSep = ""; + + std::string rccFileFiles; + std::string rccFileOptions; + const char *optionSep = ""; + + const char *qtVersion = makefile->GetDefinition("_target_qt_version"); + + std::vector<std::string> rccOptions; + if (const char* opts = target->GetProperty("AUTORCC_OPTIONS")) + { + cmSystemTools::ExpandListArgument(opts, rccOptions); + } + std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR"); + if (qtMajorVersion == "") + { + qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR"); + } + + for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); + fileIt != srcFiles.end(); + ++fileIt) + { + cmSourceFile* sf = *fileIt; + std::string ext = sf->GetExtension(); + if (ext == "qrc") + { + std::string absFile = cmsys::SystemTools::GetRealPath( + sf->GetFullPath()); + bool skip = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC")); + + if (!skip) + { + _rcc_files += sepRccFiles; + _rcc_files += absFile; + sepRccFiles = ";"; + + if (const char *prop = sf->GetProperty("AUTORCC_OPTIONS")) + { + std::vector<std::string> optsVec; + cmSystemTools::ExpandListArgument(prop, optsVec); + MergeRccOptions(rccOptions, optsVec, + strcmp(qtVersion, "5") == 0); + } + + if (!rccOptions.empty()) + { + rccFileFiles += optionSep; + rccFileFiles += absFile; + rccFileOptions += optionSep; + } + const char *listSep = ""; + for(std::vector<std::string>::const_iterator it = rccOptions.begin(); + it != rccOptions.end(); + ++it) + { + rccFileOptions += listSep; + rccFileOptions += *it; + listSep = "@list_sep@"; + } + optionSep = ";"; + + std::vector<std::string> depends; + + std::string entriesList; + if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) + { + if (qtMajorVersion == "5") + { + entriesList = ListQt5RccInputs(sf, target, depends); + } + else + { + entriesList = ListQt4RccInputs(sf, depends); + } + if (entriesList.empty()) + { + return; + } + } + qrcInputs += qrcInputsSep; + qrcInputs += entriesList; + qrcInputsSep = ";"; + } + } + } + makefile->AddDefinition("_qt_rcc_inputs_" + target->GetName(), + cmOutputConverter::EscapeForCMake(qrcInputs).c_str()); + + makefile->AddDefinition("_rcc_files", + cmOutputConverter::EscapeForCMake(_rcc_files).c_str()); + + makefile->AddDefinition("_qt_rcc_options_files", + cmOutputConverter::EscapeForCMake(rccFileFiles).c_str()); + makefile->AddDefinition("_qt_rcc_options_options", + cmOutputConverter::EscapeForCMake(rccFileOptions).c_str()); + + makefile->AddDefinition("_qt_rcc_executable", + GetRccExecutable(target).c_str()); +} + +void cmQtAutoGeneratorInitializer::InitializeAutogenSources( + cmGeneratorTarget* target) +{ + cmMakefile* makefile = target->Target->GetMakefile(); + + if (target->GetPropertyAsBool("AUTOMOC")) + { + std::string automocTargetName = GetAutogenTargetName(target); + std::string mocCppFile = makefile->GetCurrentBinaryDirectory(); + mocCppFile += "/"; + mocCppFile += automocTargetName; + mocCppFile += ".cpp"; + makefile->GetOrCreateSource(mocCppFile, true); + makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", + mocCppFile.c_str(), false); + + target->AddSource(mocCppFile); + } +} + +void cmQtAutoGeneratorInitializer::InitializeAutogenTarget( + cmLocalGenerator* lg, + cmGeneratorTarget* target) +{ + cmMakefile* makefile = target->Target->GetMakefile(); + + std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR"); + if (qtMajorVersion == "") + { + qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR"); + } + + // create a custom target for running generators at buildtime: + std::string autogenTargetName = GetAutogenTargetName(target); + + std::string targetDir = GetAutogenTargetDir(target); + + cmCustomCommandLine currentLine; + currentLine.push_back(cmSystemTools::GetCMakeCommand()); + currentLine.push_back("-E"); + currentLine.push_back("cmake_autogen"); + currentLine.push_back(targetDir); + currentLine.push_back("$<CONFIGURATION>"); + + cmCustomCommandLines commandLines; + commandLines.push_back(currentLine); + + std::string workingDirectory = cmSystemTools::CollapseFullPath( + "", makefile->GetCurrentBinaryDirectory()); + + std::vector<std::string> depends; + if (const char *autogenDepends = + target->GetProperty("AUTOGEN_TARGET_DEPENDS")) + { + cmSystemTools::ExpandListArgument(autogenDepends, depends); + } + std::vector<std::string> toolNames; + if (target->GetPropertyAsBool("AUTOMOC")) + { + toolNames.push_back("moc"); + } + if (target->GetPropertyAsBool("AUTOUIC")) + { + toolNames.push_back("uic"); + } + if (target->GetPropertyAsBool("AUTORCC")) + { + toolNames.push_back("rcc"); + } + + std::string tools = toolNames[0]; + toolNames.erase(toolNames.begin()); + while (toolNames.size() > 1) + { + tools += ", " + toolNames[0]; + toolNames.erase(toolNames.begin()); + } + if (toolNames.size() == 1) + { + tools += " and " + toolNames[0]; + } + std::string autogenComment = "Automatic " + tools + " for target "; + autogenComment += target->GetName(); + +#if defined(_WIN32) && !defined(__CYGWIN__) + bool usePRE_BUILD = false; + cmGlobalGenerator* gg = lg->GetGlobalGenerator(); + if(gg->GetName().find("Visual Studio") != std::string::npos) + { + cmGlobalVisualStudioGenerator* vsgg = + static_cast<cmGlobalVisualStudioGenerator*>(gg); + // Under VS >= 7 use a PRE_BUILD event instead of a separate target to + // reduce the number of targets loaded into the IDE. + // This also works around a VS 11 bug that may skip updating the target: + // https://connect.microsoft.com/VisualStudio/feedback/details/769495 + usePRE_BUILD = vsgg->GetVersion() >= cmGlobalVisualStudioGenerator::VS7; + if(usePRE_BUILD) + { + for (std::vector<std::string>::iterator it = depends.begin(); + it != depends.end(); ++it) + { + if(!makefile->FindTargetToUse(it->c_str())) + { + usePRE_BUILD = false; + break; + } + } + } + } +#endif + + std::vector<std::string> rcc_output; + bool const isNinja = + lg->GetGlobalGenerator()->GetName() == "Ninja"; + if(isNinja +#if defined(_WIN32) && !defined(__CYGWIN__) + || usePRE_BUILD +#endif + ) + { + std::vector<cmSourceFile*> srcFiles; + target->GetConfigCommonSourceFiles(srcFiles); + for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); + fileIt != srcFiles.end(); + ++fileIt) + { + cmSourceFile* sf = *fileIt; + std::string absFile = cmsys::SystemTools::GetRealPath( + sf->GetFullPath()); + + std::string ext = sf->GetExtension(); + + if (target->GetPropertyAsBool("AUTORCC")) + { + if (ext == "qrc" + && !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"))) + { + std::string basename = cmsys::SystemTools:: + GetFilenameWithoutLastExtension(absFile); + + std::string rcc_output_dir = target->GetSupportDirectory(); + cmSystemTools::MakeDirectory(rcc_output_dir.c_str()); + std::string rcc_output_file = rcc_output_dir; + rcc_output_file += "/qrc_" + basename + ".cpp"; + rcc_output.push_back(rcc_output_file); + + if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) + { + if (qtMajorVersion == "5") + { + ListQt5RccInputs(sf, target, depends); + } + else + { + ListQt4RccInputs(sf, depends); + } +#if defined(_WIN32) && !defined(__CYGWIN__) + // Cannot use PRE_BUILD because the resource files themselves + // may not be sources within the target so VS may not know the + // target needs to re-build at all. + usePRE_BUILD = false; +#endif + } + } + } + } + } + +#if defined(_WIN32) && !defined(__CYGWIN__) + if(usePRE_BUILD) + { + // Add the pre-build command directly to bypass the OBJECT_LIBRARY + // rejection in cmMakefile::AddCustomCommandToTarget because we know + // PRE_BUILD will work for an OBJECT_LIBRARY in this specific case. + std::vector<std::string> no_output; + std::vector<std::string> no_byproducts; + cmCustomCommand cc(makefile, no_output, no_byproducts, depends, + commandLines, autogenComment.c_str(), + workingDirectory.c_str()); + cc.SetEscapeOldStyle(false); + cc.SetEscapeAllowMakeVars(true); + target->Target->AddPreBuildCommand(cc); + } + else +#endif + { + cmTarget* autogenTarget = makefile->AddUtilityCommand( + autogenTargetName, true, + workingDirectory.c_str(), + /*byproducts=*/rcc_output, depends, + commandLines, false, autogenComment.c_str()); + + cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg); + lg->AddGeneratorTarget(gt); + + // Set target folder + const char* autogenFolder = makefile->GetState() + ->GetGlobalProperty("AUTOMOC_TARGETS_FOLDER"); + if (!autogenFolder) + { + autogenFolder = makefile->GetState() + ->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER"); + } + if (autogenFolder && *autogenFolder) + { + autogenTarget->SetProperty("FOLDER", autogenFolder); + } + else + { + // inherit FOLDER property from target (#13688) + copyTargetProperty(gt->Target, target->Target, "FOLDER"); + } + + target->Target->AddUtility(autogenTargetName); + } +} + +void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget( + cmGeneratorTarget const* target) +{ + cmMakefile* makefile = target->Target->GetMakefile(); + + // forget the variables added here afterwards again: + cmMakefile::ScopePushPop varScope(makefile); + static_cast<void>(varScope); + + // create a custom target for running generators at buildtime: + std::string autogenTargetName = GetAutogenTargetName(target); + + makefile->AddDefinition("_moc_target_name", + cmOutputConverter::EscapeForCMake(autogenTargetName).c_str()); + makefile->AddDefinition("_origin_target_name", + cmOutputConverter::EscapeForCMake(target->GetName()).c_str()); + + std::string targetDir = GetAutogenTargetDir(target); + + const char *qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR"); + if (!qtVersion) + { + qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR"); + } + if (const char *targetQtVersion = + target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", "")) + { + qtVersion = targetQtVersion; + } + if (qtVersion) + { + makefile->AddDefinition("_target_qt_version", qtVersion); + } + + std::vector<std::string> skipUic; + std::vector<std::string> skipMoc; + std::vector<std::string> mocSources; + std::vector<std::string> mocHeaders; + std::map<std::string, std::string> configIncludes; + std::map<std::string, std::string> configDefines; + std::map<std::string, std::string> configUicOptions; + + if (target->GetPropertyAsBool("AUTOMOC") + || target->GetPropertyAsBool("AUTOUIC") + || target->GetPropertyAsBool("AUTORCC")) + { + SetupSourceFiles(target, skipMoc, mocSources, mocHeaders, skipUic); + } + makefile->AddDefinition("_cpp_files", + cmOutputConverter::EscapeForCMake(cmJoin(mocSources, ";")).c_str()); + if (target->GetPropertyAsBool("AUTOMOC")) + { + SetupAutoMocTarget(target, autogenTargetName, + skipMoc, mocHeaders, + configIncludes, configDefines); + } + if (target->GetPropertyAsBool("AUTOUIC")) + { + SetupAutoUicTarget(target, skipUic, configUicOptions); + } + if (target->GetPropertyAsBool("AUTORCC")) + { + SetupAutoRccTarget(target); + } + + const char* cmakeRoot = makefile->GetSafeDefinition("CMAKE_ROOT"); + std::string inputFile = cmakeRoot; + inputFile += "/Modules/AutogenInfo.cmake.in"; + std::string outputFile = targetDir; + outputFile += "/AutogenInfo.cmake"; + makefile->AddDefinition("_qt_rcc_inputs", + makefile->GetDefinition("_qt_rcc_inputs_" + target->GetName())); + makefile->ConfigureFile(inputFile.c_str(), outputFile.c_str(), + false, true, false); + + // Ensure we have write permission in case .in was read-only. + mode_t perm = 0; +#if defined(_WIN32) && !defined(__CYGWIN__) + mode_t mode_write = S_IWRITE; +#else + mode_t mode_write = S_IWUSR; +#endif + cmSystemTools::GetPermissions(outputFile, perm); + if (!(perm & mode_write)) + { + cmSystemTools::SetPermissions(outputFile, perm | mode_write); + } + if (!configDefines.empty() + || !configIncludes.empty() + || !configUicOptions.empty()) + { + cmsys::ofstream infoFile(outputFile.c_str(), std::ios::app); + if ( !infoFile ) + { + std::string error = "Internal CMake error when trying to open file: "; + error += outputFile.c_str(); + error += " for writing."; + cmSystemTools::Error(error.c_str()); + return; + } + if (!configDefines.empty()) + { + for (std::map<std::string, std::string>::iterator + it = configDefines.begin(), end = configDefines.end(); + it != end; ++it) + { + infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first << + " " << it->second << ")\n"; + } + } + if (!configIncludes.empty()) + { + for (std::map<std::string, std::string>::iterator + it = configIncludes.begin(), end = configIncludes.end(); + it != end; ++it) + { + infoFile << "set(AM_MOC_INCLUDES_" << it->first << + " " << it->second << ")\n"; + } + } + if (!configUicOptions.empty()) + { + for (std::map<std::string, std::string>::iterator + it = configUicOptions.begin(), end = configUicOptions.end(); + it != end; ++it) + { + infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first << + " " << it->second << ")\n"; + } + } + } +} diff --git a/Source/cmQtAutoGeneratorInitializer.h b/Source/cmQtAutoGeneratorInitializer.h new file mode 100644 index 0000000..eaf140d --- /dev/null +++ b/Source/cmQtAutoGeneratorInitializer.h @@ -0,0 +1,36 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2004-2011 Kitware, Inc. + Copyright 2011 Alexander Neundorf (neundorf@kde.org) + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ + +#ifndef cmQtAutoGeneratorInitializer_h +#define cmQtAutoGeneratorInitializer_h + +#include "cmStandardIncludes.h" + +#include <string> +#include <vector> +#include <map> + +class cmSourceFile; +class cmGeneratorTarget; +class cmLocalGenerator; + +class cmQtAutoGeneratorInitializer +{ +public: + static void InitializeAutogenSources(cmGeneratorTarget* target); + static void InitializeAutogenTarget(cmLocalGenerator* lg, + cmGeneratorTarget* target); + static void SetupAutoGenerateTarget(cmGeneratorTarget const* target); +}; + +#endif diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx index becfeba..b16eccd 100644 --- a/Source/cmQtAutoGenerators.cxx +++ b/Source/cmQtAutoGenerators.cxx @@ -12,17 +12,12 @@ ============================================================================*/ #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" +#include "cmOutputConverter.h" #include "cmMakefile.h" -#include "cmSourceFile.h" #include "cmSystemTools.h" #include "cmState.h" #include "cmAlgorithms.h" -#if defined(_WIN32) && !defined(__CYGWIN__) -# include "cmGlobalVisualStudioGenerator.h" -#endif - #include <sys/stat.h> #include <cmsys/Terminal.h> @@ -36,7 +31,6 @@ #include "cmQtAutoGenerators.h" - static bool requiresMocing(const std::string& text, std::string ¯oName) { // this simple check is much much faster than the regexp @@ -105,28 +99,6 @@ static std::string extractSubDir(const std::string& absPath, return subDir; } - -static void copyTargetProperty(cmTarget* destinationTarget, - cmTarget* sourceTarget, - const std::string& propertyName) -{ - const char* propertyValue = sourceTarget->GetProperty(propertyName); - if (propertyValue) - { - destinationTarget->SetProperty(propertyName, propertyValue); - } -} - - -static std::string ReadAll(const std::string& filename) -{ - cmsys::ifstream file(filename.c_str()); - std::stringstream stream; - stream << file.rdbuf(); - file.close(); - return stream.str(); -} - cmQtAutoGenerators::cmQtAutoGenerators() :Verbose(cmsys::SystemTools::GetEnv("VERBOSE") != 0) ,ColorOutput(true) @@ -151,692 +123,6 @@ cmQtAutoGenerators::cmQtAutoGenerators() } } -static std::string getAutogenTargetName(cmTarget const* target) -{ - std::string autogenTargetName = target->GetName(); - autogenTargetName += "_automoc"; - return autogenTargetName; -} - -static std::string getAutogenTargetDir(cmTarget const* target) -{ - cmMakefile* makefile = target->GetMakefile(); - std::string targetDir = makefile->GetCurrentBinaryDirectory(); - targetDir += makefile->GetCMakeInstance()->GetCMakeFilesDirectory(); - targetDir += "/"; - targetDir += getAutogenTargetName(target); - targetDir += ".dir/"; - return targetDir; -} - -static std::string cmQtAutoGeneratorsStripCR(std::string const& line) -{ - // Strip CR characters rcc may have printed (possibly more than one!). - std::string::size_type cr = line.find('\r'); - if (cr != line.npos) - { - return line.substr(0, cr); - } - return line; -} - -std::string cmQtAutoGenerators::ListQt5RccInputs(cmSourceFile* sf, - cmTarget const* target, - std::vector<std::string>& depends) -{ - std::string rccCommand = this->GetRccExecutable(target); - std::vector<std::string> qrcEntries; - - std::vector<std::string> command; - command.push_back(rccCommand); - command.push_back("-list"); - - std::string absFile = cmsys::SystemTools::GetRealPath( - sf->GetFullPath()); - - command.push_back(absFile); - - std::string rccStdOut; - std::string rccStdErr; - int retVal = 0; - bool result = cmSystemTools::RunSingleCommand( - command, &rccStdOut, &rccStdErr, - &retVal, 0, cmSystemTools::OUTPUT_NONE); - if (!result || retVal) - { - std::cerr << "AUTOGEN: error: Rcc list process for " << sf->GetFullPath() - << " failed:\n" << rccStdOut << "\n" << rccStdErr << std::endl; - return std::string(); - } - - { - std::istringstream ostr(rccStdOut); - std::string oline; - while(std::getline(ostr, oline)) - { - oline = cmQtAutoGeneratorsStripCR(oline); - if(!oline.empty()) - { - qrcEntries.push_back(oline); - } - } - } - - { - std::istringstream estr(rccStdErr); - std::string eline; - while(std::getline(estr, eline)) - { - eline = cmQtAutoGeneratorsStripCR(eline); - if (cmHasLiteralPrefix(eline, "RCC: Error in")) - { - static std::string searchString = "Cannot find file '"; - - std::string::size_type pos = eline.find(searchString); - if (pos == std::string::npos) - { - std::cerr << "AUTOGEN: error: Rcc lists unparsable output " - << eline << std::endl; - return std::string(); - } - pos += searchString.length(); - std::string::size_type sz = eline.size() - pos - 1; - qrcEntries.push_back(eline.substr(pos, sz)); - } - } - } - - depends.insert(depends.end(), qrcEntries.begin(), qrcEntries.end()); - return cmJoin(qrcEntries, "@list_sep@"); -} - -std::string cmQtAutoGenerators::ListQt4RccInputs(cmSourceFile* sf, - std::vector<std::string>& depends) -{ - const std::string qrcContents = ReadAll(sf->GetFullPath()); - - cmsys::RegularExpression fileMatchRegex("(<file[^<]+)"); - - std::string entriesList; - const char* sep = ""; - - size_t offset = 0; - while (fileMatchRegex.find(qrcContents.c_str() + offset)) - { - std::string qrcEntry = fileMatchRegex.match(1); - - offset += qrcEntry.size(); - - cmsys::RegularExpression fileReplaceRegex("(^<file[^>]*>)"); - fileReplaceRegex.find(qrcEntry); - std::string tag = fileReplaceRegex.match(1); - - qrcEntry = qrcEntry.substr(tag.size()); - - if (!cmSystemTools::FileIsFullPath(qrcEntry.c_str())) - { - qrcEntry = sf->GetLocation().GetDirectory() + "/" + qrcEntry; - } - - entriesList += sep; - entriesList += qrcEntry; - sep = "@list_sep@"; - depends.push_back(qrcEntry); - } - return entriesList; -} - -bool cmQtAutoGenerators::InitializeAutogenTarget(cmLocalGenerator* lg, - cmTarget* target) -{ - cmMakefile* makefile = target->GetMakefile(); - // don't do anything if there is no Qt4 or Qt5Core (which contains moc): - std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR"); - if (qtMajorVersion == "") - { - qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR"); - } - if (qtMajorVersion != "4" && qtMajorVersion != "5") - { - return false; - } - - if (target->GetPropertyAsBool("AUTOMOC")) - { - std::string automocTargetName = getAutogenTargetName(target); - std::string mocCppFile = makefile->GetCurrentBinaryDirectory(); - mocCppFile += "/"; - mocCppFile += automocTargetName; - mocCppFile += ".cpp"; - makefile->GetOrCreateSource(mocCppFile, true); - makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", - mocCppFile.c_str(), false); - - target->AddSource(mocCppFile); - } - // create a custom target for running generators at buildtime: - std::string autogenTargetName = getAutogenTargetName(target); - - std::string targetDir = getAutogenTargetDir(target); - - cmCustomCommandLine currentLine; - currentLine.push_back(cmSystemTools::GetCMakeCommand()); - currentLine.push_back("-E"); - currentLine.push_back("cmake_autogen"); - currentLine.push_back(targetDir); - currentLine.push_back("$<CONFIGURATION>"); - - cmCustomCommandLines commandLines; - commandLines.push_back(currentLine); - - std::string workingDirectory = cmSystemTools::CollapseFullPath( - "", makefile->GetCurrentBinaryDirectory()); - - std::vector<std::string> depends; - if (const char *autogenDepends = - target->GetProperty("AUTOGEN_TARGET_DEPENDS")) - { - cmSystemTools::ExpandListArgument(autogenDepends, depends); - } - std::vector<std::string> toolNames; - if (target->GetPropertyAsBool("AUTOMOC")) - { - toolNames.push_back("moc"); - } - if (target->GetPropertyAsBool("AUTOUIC")) - { - toolNames.push_back("uic"); - } - if (target->GetPropertyAsBool("AUTORCC")) - { - toolNames.push_back("rcc"); - } - - std::string tools = toolNames[0]; - toolNames.erase(toolNames.begin()); - while (toolNames.size() > 1) - { - tools += ", " + toolNames[0]; - toolNames.erase(toolNames.begin()); - } - if (toolNames.size() == 1) - { - tools += " and " + toolNames[0]; - } - std::string autogenComment = "Automatic " + tools + " for target "; - autogenComment += target->GetName(); - -#if defined(_WIN32) && !defined(__CYGWIN__) - bool usePRE_BUILD = false; - cmGlobalGenerator* gg = lg->GetGlobalGenerator(); - if(gg->GetName().find("Visual Studio") != std::string::npos) - { - cmGlobalVisualStudioGenerator* vsgg = - static_cast<cmGlobalVisualStudioGenerator*>(gg); - // Under VS >= 7 use a PRE_BUILD event instead of a separate target to - // reduce the number of targets loaded into the IDE. - // This also works around a VS 11 bug that may skip updating the target: - // https://connect.microsoft.com/VisualStudio/feedback/details/769495 - usePRE_BUILD = vsgg->GetVersion() >= cmGlobalVisualStudioGenerator::VS7; - if(usePRE_BUILD) - { - for (std::vector<std::string>::iterator it = depends.begin(); - it != depends.end(); ++it) - { - if(!makefile->FindTargetToUse(it->c_str())) - { - usePRE_BUILD = false; - break; - } - } - } - } -#endif - - std::vector<std::string> rcc_output; - bool const isNinja = - lg->GetGlobalGenerator()->GetName() == "Ninja"; - if(isNinja -#if defined(_WIN32) && !defined(__CYGWIN__) - || usePRE_BUILD -#endif - ) - { - std::vector<cmSourceFile*> srcFiles; - cmGeneratorTarget* gtgt = - lg->GetGlobalGenerator()->GetGeneratorTarget(target); - gtgt->GetConfigCommonSourceFiles(srcFiles); - for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); - fileIt != srcFiles.end(); - ++fileIt) - { - cmSourceFile* sf = *fileIt; - std::string absFile = cmsys::SystemTools::GetRealPath( - sf->GetFullPath()); - - std::string ext = sf->GetExtension(); - - if (target->GetPropertyAsBool("AUTORCC")) - { - if (ext == "qrc" - && !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"))) - { - std::string basename = cmsys::SystemTools:: - GetFilenameWithoutLastExtension(absFile); - - std::string rcc_output_dir = target->GetSupportDirectory(); - cmSystemTools::MakeDirectory(rcc_output_dir.c_str()); - std::string rcc_output_file = rcc_output_dir; - rcc_output_file += "/qrc_" + basename + ".cpp"; - rcc_output.push_back(rcc_output_file); - - if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) - { - if (qtMajorVersion == "5") - { - this->ListQt5RccInputs(sf, target, depends); - } - else - { - this->ListQt4RccInputs(sf, depends); - } -#if defined(_WIN32) && !defined(__CYGWIN__) - // Cannot use PRE_BUILD because the resource files themselves - // may not be sources within the target so VS may not know the - // target needs to re-build at all. - usePRE_BUILD = false; -#endif - } - } - } - } - } - -#if defined(_WIN32) && !defined(__CYGWIN__) - if(usePRE_BUILD) - { - // Add the pre-build command directly to bypass the OBJECT_LIBRARY - // rejection in cmMakefile::AddCustomCommandToTarget because we know - // PRE_BUILD will work for an OBJECT_LIBRARY in this specific case. - std::vector<std::string> no_output; - std::vector<std::string> no_byproducts; - cmCustomCommand cc(makefile, no_output, no_byproducts, depends, - commandLines, autogenComment.c_str(), - workingDirectory.c_str()); - cc.SetEscapeOldStyle(false); - cc.SetEscapeAllowMakeVars(true); - target->AddPreBuildCommand(cc); - } - else -#endif - { - cmTarget* autogenTarget = makefile->AddUtilityCommand( - autogenTargetName, true, - workingDirectory.c_str(), - /*byproducts=*/rcc_output, depends, - commandLines, false, autogenComment.c_str()); - - cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg); - makefile->AddGeneratorTarget(autogenTarget, gt); - - // Set target folder - const char* autogenFolder = makefile->GetState() - ->GetGlobalProperty("AUTOMOC_TARGETS_FOLDER"); - if (!autogenFolder) - { - autogenFolder = makefile->GetState() - ->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER"); - } - if (autogenFolder && *autogenFolder) - { - autogenTarget->SetProperty("FOLDER", autogenFolder); - } - else - { - // inherit FOLDER property from target (#13688) - copyTargetProperty(autogenTarget, target, "FOLDER"); - } - - target->AddUtility(autogenTargetName); - } - - return true; -} - -static void GetCompileDefinitionsAndDirectories(cmTarget const* target, - const std::string& config, - std::string &incs, - std::string &defs) -{ - cmMakefile* makefile = target->GetMakefile(); - cmGlobalGenerator* globalGen = makefile->GetGlobalGenerator(); - std::vector<std::string> includeDirs; - cmGeneratorTarget *gtgt = globalGen->GetGeneratorTarget(target); - cmLocalGenerator *localGen = gtgt->GetLocalGenerator(); - // Get the include dirs for this target, without stripping the implicit - // include dirs off, see http://public.kitware.com/Bug/view.php?id=13667 - localGen->GetIncludeDirectories(includeDirs, gtgt, "CXX", config, false); - - incs = cmJoin(includeDirs, ";"); - - std::set<std::string> defines; - localGen->AddCompileDefinitions(defines, target, config, "CXX"); - - defs += cmJoin(defines, ";"); -} - -void cmQtAutoGenerators::SetupAutoGenerateTarget(cmTarget const* target) -{ - cmMakefile* makefile = target->GetMakefile(); - - // forget the variables added here afterwards again: - cmMakefile::ScopePushPop varScope(makefile); - static_cast<void>(varScope); - - // create a custom target for running generators at buildtime: - std::string autogenTargetName = getAutogenTargetName(target); - - makefile->AddDefinition("_moc_target_name", - cmOutputConverter::EscapeForCMake(autogenTargetName).c_str()); - makefile->AddDefinition("_origin_target_name", - cmOutputConverter::EscapeForCMake(target->GetName()).c_str()); - - std::string targetDir = getAutogenTargetDir(target); - - const char *qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR"); - if (!qtVersion) - { - qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR"); - } - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - if (const char *targetQtVersion = - gtgt->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", "")) - { - qtVersion = targetQtVersion; - } - if (qtVersion) - { - makefile->AddDefinition("_target_qt_version", qtVersion); - } - - std::map<std::string, std::string> configIncludes; - std::map<std::string, std::string> configDefines; - std::map<std::string, std::string> configUicOptions; - - if (target->GetPropertyAsBool("AUTOMOC") - || target->GetPropertyAsBool("AUTOUIC") - || target->GetPropertyAsBool("AUTORCC")) - { - this->SetupSourceFiles(target); - } - makefile->AddDefinition("_cpp_files", - cmOutputConverter::EscapeForCMake(this->Sources).c_str()); - if (target->GetPropertyAsBool("AUTOMOC")) - { - this->SetupAutoMocTarget(target, autogenTargetName, - configIncludes, configDefines); - } - if (target->GetPropertyAsBool("AUTOUIC")) - { - this->SetupAutoUicTarget(target, configUicOptions); - } - if (target->GetPropertyAsBool("AUTORCC")) - { - this->SetupAutoRccTarget(target); - } - - const char* cmakeRoot = makefile->GetSafeDefinition("CMAKE_ROOT"); - std::string inputFile = cmakeRoot; - inputFile += "/Modules/AutogenInfo.cmake.in"; - std::string outputFile = targetDir; - outputFile += "/AutogenInfo.cmake"; - makefile->AddDefinition("_qt_rcc_inputs", - makefile->GetDefinition("_qt_rcc_inputs_" + target->GetName())); - makefile->ConfigureFile(inputFile.c_str(), outputFile.c_str(), - false, true, false); - - // Ensure we have write permission in case .in was read-only. - mode_t perm = 0; -#if defined(_WIN32) && !defined(__CYGWIN__) - mode_t mode_write = S_IWRITE; -#else - mode_t mode_write = S_IWUSR; -#endif - cmSystemTools::GetPermissions(outputFile, perm); - if (!(perm & mode_write)) - { - cmSystemTools::SetPermissions(outputFile, perm | mode_write); - } - if (!configDefines.empty() - || !configIncludes.empty() - || !configUicOptions.empty()) - { - cmsys::ofstream infoFile(outputFile.c_str(), std::ios::app); - if ( !infoFile ) - { - std::string error = "Internal CMake error when trying to open file: "; - error += outputFile.c_str(); - error += " for writing."; - cmSystemTools::Error(error.c_str()); - return; - } - if (!configDefines.empty()) - { - for (std::map<std::string, std::string>::iterator - it = configDefines.begin(), end = configDefines.end(); - it != end; ++it) - { - infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first << - " " << it->second << ")\n"; - } - } - if (!configIncludes.empty()) - { - for (std::map<std::string, std::string>::iterator - it = configIncludes.begin(), end = configIncludes.end(); - it != end; ++it) - { - infoFile << "set(AM_MOC_INCLUDES_" << it->first << - " " << it->second << ")\n"; - } - } - if (!configUicOptions.empty()) - { - for (std::map<std::string, std::string>::iterator - it = configUicOptions.begin(), end = configUicOptions.end(); - it != end; ++it) - { - infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first << - " " << it->second << ")\n"; - } - } - } -} - -void cmQtAutoGenerators::SetupSourceFiles(cmTarget const* target) -{ - cmMakefile* makefile = target->GetMakefile(); - - const char* sepFiles = ""; - const char* sepHeaders = ""; - - std::vector<cmSourceFile*> srcFiles; - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - gtgt->GetConfigCommonSourceFiles(srcFiles); - - const char *skipMocSep = ""; - const char *skipUicSep = ""; - - std::vector<std::string> newRccFiles; - - for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); - fileIt != srcFiles.end(); - ++fileIt) - { - cmSourceFile* sf = *fileIt; - std::string absFile = cmsys::SystemTools::GetRealPath( - sf->GetFullPath()); - bool skipMoc = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC")); - bool generated = cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED")); - - if(cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC"))) - { - this->SkipUic += skipUicSep; - this->SkipUic += absFile; - skipUicSep = ";"; - } - - std::string ext = sf->GetExtension(); - - if (target->GetPropertyAsBool("AUTORCC")) - { - if (ext == "qrc" - && !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"))) - { - std::string basename = cmsys::SystemTools:: - GetFilenameWithoutLastExtension(absFile); - - std::string rcc_output_dir = target->GetSupportDirectory(); - cmSystemTools::MakeDirectory(rcc_output_dir.c_str()); - std::string rcc_output_file = rcc_output_dir; - rcc_output_file += "/qrc_" + basename + ".cpp"; - makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", - rcc_output_file.c_str(), false); - makefile->GetOrCreateSource(rcc_output_file, true); - newRccFiles.push_back(rcc_output_file); - } - } - - if (!generated) - { - if (skipMoc) - { - this->SkipMoc += skipMocSep; - this->SkipMoc += absFile; - skipMocSep = ";"; - } - else - { - cmSystemTools::FileFormat fileType = cmSystemTools::GetFileFormat( - ext.c_str()); - if (fileType == cmSystemTools::CXX_FILE_FORMAT) - { - this->Sources += sepFiles; - this->Sources += absFile; - sepFiles = ";"; - } - else if (fileType == cmSystemTools::HEADER_FILE_FORMAT) - { - this->Headers += sepHeaders; - this->Headers += absFile; - sepHeaders = ";"; - } - } - } - } - - for(std::vector<std::string>::const_iterator fileIt = newRccFiles.begin(); - fileIt != newRccFiles.end(); - ++fileIt) - { - const_cast<cmTarget*>(target)->AddSource(*fileIt); - } -} - -void cmQtAutoGenerators::SetupAutoMocTarget(cmTarget const* target, - const std::string &autogenTargetName, - std::map<std::string, std::string> &configIncludes, - std::map<std::string, std::string> &configDefines) -{ - cmMakefile* makefile = target->GetMakefile(); - - const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS"); - std::string _moc_options = (tmp!=0 ? tmp : ""); - makefile->AddDefinition("_moc_options", - cmOutputConverter::EscapeForCMake(_moc_options).c_str()); - makefile->AddDefinition("_skip_moc", - cmOutputConverter::EscapeForCMake(this->SkipMoc).c_str()); - makefile->AddDefinition("_moc_headers", - cmOutputConverter::EscapeForCMake(this->Headers).c_str()); - bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE"); - makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE"); - - std::string _moc_incs; - std::string _moc_compile_defs; - std::vector<std::string> configs; - const std::string& config = makefile->GetConfigurations(configs); - GetCompileDefinitionsAndDirectories(target, config, - _moc_incs, _moc_compile_defs); - - makefile->AddDefinition("_moc_incs", - cmOutputConverter::EscapeForCMake(_moc_incs).c_str()); - makefile->AddDefinition("_moc_compile_defs", - cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str()); - - for (std::vector<std::string>::const_iterator li = configs.begin(); - li != configs.end(); ++li) - { - std::string config_moc_incs; - std::string config_moc_compile_defs; - GetCompileDefinitionsAndDirectories(target, *li, - config_moc_incs, - config_moc_compile_defs); - if (config_moc_incs != _moc_incs) - { - configIncludes[*li] = - cmOutputConverter::EscapeForCMake(config_moc_incs); - if(_moc_incs.empty()) - { - _moc_incs = config_moc_incs; - } - } - if (config_moc_compile_defs != _moc_compile_defs) - { - configDefines[*li] = - cmOutputConverter::EscapeForCMake(config_moc_compile_defs); - if(_moc_compile_defs.empty()) - { - _moc_compile_defs = config_moc_compile_defs; - } - } - } - - const char *qtVersion = makefile->GetDefinition("_target_qt_version"); - if (strcmp(qtVersion, "5") == 0) - { - cmTarget *qt5Moc = makefile->FindTargetToUse("Qt5::moc"); - if (!qt5Moc) - { - cmSystemTools::Error("Qt5::moc target not found ", - autogenTargetName.c_str()); - return; - } - makefile->AddDefinition("_qt_moc_executable", - qt5Moc->ImportedGetLocation("")); - } - else if (strcmp(qtVersion, "4") == 0) - { - cmTarget *qt4Moc = makefile->FindTargetToUse("Qt4::moc"); - if (!qt4Moc) - { - cmSystemTools::Error("Qt4::moc target not found ", - autogenTargetName.c_str()); - return; - } - makefile->AddDefinition("_qt_moc_executable", - qt4Moc->ImportedGetLocation("")); - } - else - { - cmSystemTools::Error("The CMAKE_AUTOMOC feature supports only Qt 4 and " - "Qt 5 ", autogenTargetName.c_str()); - } -} - void cmQtAutoGenerators::MergeUicOptions(std::vector<std::string> &opts, const std::vector<std::string> &fileOpts, bool isQt5) @@ -882,332 +168,6 @@ void cmQtAutoGenerators::MergeUicOptions(std::vector<std::string> &opts, opts.insert(opts.end(), extraOpts.begin(), extraOpts.end()); } -static void GetUicOpts(cmTarget const* target, const std::string& config, - std::string &optString) -{ - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - std::vector<std::string> opts; - gtgt->GetAutoUicOptions(opts, config); - optString = cmJoin(opts, ";"); -} - -void cmQtAutoGenerators::SetupAutoUicTarget(cmTarget const* target, - std::map<std::string, std::string> &configUicOptions) -{ - cmMakefile *makefile = target->GetMakefile(); - - std::set<std::string> skipped; - std::vector<std::string> skipVec; - cmSystemTools::ExpandListArgument(this->SkipUic, skipVec); - skipped.insert(skipVec.begin(), skipVec.end()); - - makefile->AddDefinition("_skip_uic", - cmOutputConverter::EscapeForCMake(this->SkipUic).c_str()); - - std::vector<cmSourceFile*> uiFilesWithOptions - = makefile->GetQtUiFilesWithOptions(); - - const char *qtVersion = makefile->GetDefinition("_target_qt_version"); - - std::string _uic_opts; - std::vector<std::string> configs; - const std::string& config = makefile->GetConfigurations(configs); - GetUicOpts(target, config, _uic_opts); - - if (!_uic_opts.empty()) - { - _uic_opts = cmOutputConverter::EscapeForCMake(_uic_opts); - makefile->AddDefinition("_uic_target_options", _uic_opts.c_str()); - } - for (std::vector<std::string>::const_iterator li = configs.begin(); - li != configs.end(); ++li) - { - std::string config_uic_opts; - GetUicOpts(target, *li, config_uic_opts); - if (config_uic_opts != _uic_opts) - { - configUicOptions[*li] = - cmOutputConverter::EscapeForCMake(config_uic_opts); - if(_uic_opts.empty()) - { - _uic_opts = config_uic_opts; - } - } - } - - std::string uiFileFiles; - std::string uiFileOptions; - const char* sep = ""; - - for(std::vector<cmSourceFile*>::const_iterator fileIt = - uiFilesWithOptions.begin(); - fileIt != uiFilesWithOptions.end(); - ++fileIt) - { - cmSourceFile* sf = *fileIt; - std::string absFile = cmsys::SystemTools::GetRealPath( - sf->GetFullPath()); - - if (!skipped.insert(absFile).second) - { - continue; - } - uiFileFiles += sep; - uiFileFiles += absFile; - uiFileOptions += sep; - std::string opts = sf->GetProperty("AUTOUIC_OPTIONS"); - cmSystemTools::ReplaceString(opts, ";", "@list_sep@"); - uiFileOptions += opts; - sep = ";"; - } - - makefile->AddDefinition("_qt_uic_options_files", - cmOutputConverter::EscapeForCMake(uiFileFiles).c_str()); - makefile->AddDefinition("_qt_uic_options_options", - cmOutputConverter::EscapeForCMake(uiFileOptions).c_str()); - - std::string targetName = target->GetName(); - if (strcmp(qtVersion, "5") == 0) - { - cmTarget *qt5Uic = makefile->FindTargetToUse("Qt5::uic"); - if (!qt5Uic) - { - // Project does not use Qt5Widgets, but has AUTOUIC ON anyway - } - else - { - makefile->AddDefinition("_qt_uic_executable", - qt5Uic->ImportedGetLocation("")); - } - } - else if (strcmp(qtVersion, "4") == 0) - { - cmTarget *qt4Uic = makefile->FindTargetToUse("Qt4::uic"); - if (!qt4Uic) - { - cmSystemTools::Error("Qt4::uic target not found ", - targetName.c_str()); - return; - } - makefile->AddDefinition("_qt_uic_executable", - qt4Uic->ImportedGetLocation("")); - } - else - { - cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and " - "Qt 5 ", targetName.c_str()); - } -} - -void cmQtAutoGenerators::MergeRccOptions(std::vector<std::string> &opts, - const std::vector<std::string> &fileOpts, - bool isQt5) -{ - static const char* valueOptions[] = { - "name", - "root", - "compress", - "threshold" - }; - std::vector<std::string> extraOpts; - for(std::vector<std::string>::const_iterator it = fileOpts.begin(); - it != fileOpts.end(); ++it) - { - std::vector<std::string>::iterator existingIt - = std::find(opts.begin(), opts.end(), *it); - if (existingIt != opts.end()) - { - const char *o = it->c_str(); - if (*o == '-') - { - ++o; - } - if (isQt5 && *o == '-') - { - ++o; - } - if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions), - cmStrCmp(*it)) != cmArrayEnd(valueOptions)) - { - assert(existingIt + 1 != opts.end()); - *(existingIt + 1) = *(it + 1); - ++it; - } - } - else - { - extraOpts.push_back(*it); - } - } - opts.insert(opts.end(), extraOpts.begin(), extraOpts.end()); -} - -void cmQtAutoGenerators::SetupAutoRccTarget(cmTarget const* target) -{ - std::string _rcc_files; - const char* sepRccFiles = ""; - cmMakefile *makefile = target->GetMakefile(); - - std::vector<cmSourceFile*> srcFiles; - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - gtgt->GetConfigCommonSourceFiles(srcFiles); - - std::string qrcInputs; - const char* qrcInputsSep = ""; - - std::string rccFileFiles; - std::string rccFileOptions; - const char *optionSep = ""; - - const char *qtVersion = makefile->GetDefinition("_target_qt_version"); - - std::vector<std::string> rccOptions; - if (const char* opts = target->GetProperty("AUTORCC_OPTIONS")) - { - cmSystemTools::ExpandListArgument(opts, rccOptions); - } - std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR"); - if (qtMajorVersion == "") - { - qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR"); - } - - for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); - fileIt != srcFiles.end(); - ++fileIt) - { - cmSourceFile* sf = *fileIt; - std::string ext = sf->GetExtension(); - if (ext == "qrc") - { - std::string absFile = cmsys::SystemTools::GetRealPath( - sf->GetFullPath()); - bool skip = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC")); - - if (!skip) - { - _rcc_files += sepRccFiles; - _rcc_files += absFile; - sepRccFiles = ";"; - - if (const char *prop = sf->GetProperty("AUTORCC_OPTIONS")) - { - std::vector<std::string> optsVec; - cmSystemTools::ExpandListArgument(prop, optsVec); - this->MergeRccOptions(rccOptions, optsVec, - strcmp(qtVersion, "5") == 0); - } - - if (!rccOptions.empty()) - { - rccFileFiles += optionSep; - rccFileFiles += absFile; - rccFileOptions += optionSep; - } - const char *listSep = ""; - for(std::vector<std::string>::const_iterator it = rccOptions.begin(); - it != rccOptions.end(); - ++it) - { - rccFileOptions += listSep; - rccFileOptions += *it; - listSep = "@list_sep@"; - } - optionSep = ";"; - - std::vector<std::string> depends; - - std::string entriesList; - if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) - { - if (qtMajorVersion == "5") - { - entriesList = this->ListQt5RccInputs(sf, target, depends); - } - else - { - entriesList = this->ListQt4RccInputs(sf, depends); - } - if (entriesList.empty()) - { - return; - } - } - qrcInputs += qrcInputsSep; - qrcInputs += entriesList; - qrcInputsSep = ";"; - } - } - } - makefile->AddDefinition("_qt_rcc_inputs_" + target->GetName(), - cmOutputConverter::EscapeForCMake(qrcInputs).c_str()); - - makefile->AddDefinition("_rcc_files", - cmOutputConverter::EscapeForCMake(_rcc_files).c_str()); - - makefile->AddDefinition("_qt_rcc_options_files", - cmOutputConverter::EscapeForCMake(rccFileFiles).c_str()); - makefile->AddDefinition("_qt_rcc_options_options", - cmOutputConverter::EscapeForCMake(rccFileOptions).c_str()); - - makefile->AddDefinition("_qt_rcc_executable", - this->GetRccExecutable(target).c_str()); -} - -std::string cmQtAutoGenerators::GetRccExecutable(cmTarget const* target) -{ - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - cmMakefile *makefile = target->GetMakefile(); - const char *qtVersion = makefile->GetDefinition("_target_qt_version"); - if (!qtVersion) - { - qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR"); - if (!qtVersion) - { - qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR"); - } - if (const char *targetQtVersion = - gtgt->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", "")) - { - qtVersion = targetQtVersion; - } - } - - std::string targetName = target->GetName(); - if (strcmp(qtVersion, "5") == 0) - { - cmTarget *qt5Rcc = makefile->FindTargetToUse("Qt5::rcc"); - if (!qt5Rcc) - { - cmSystemTools::Error("Qt5::rcc target not found ", - targetName.c_str()); - return std::string(); - } - return qt5Rcc->ImportedGetLocation(""); - } - else if (strcmp(qtVersion, "4") == 0) - { - cmTarget *qt4Rcc = makefile->FindTargetToUse("Qt4::rcc"); - if (!qt4Rcc) - { - cmSystemTools::Error("Qt4::rcc target not found ", - targetName.c_str()); - return std::string(); - } - return qt4Rcc->ImportedGetLocation(""); - } - - cmSystemTools::Error("The CMAKE_AUTORCC feature supports only Qt 4 and " - "Qt 5 ", targetName.c_str()); - return std::string(); -} - bool cmQtAutoGenerators::Run(const std::string& targetDirectory, const std::string& config) { @@ -1215,23 +175,24 @@ bool cmQtAutoGenerators::Run(const std::string& targetDirectory, cmake cm; cm.SetHomeOutputDirectory(targetDirectory); cm.SetHomeDirectory(targetDirectory); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmState::Snapshot snapshot = cm.GetCurrentSnapshot(); + snapshot.GetDirectory().SetCurrentBinary(targetDirectory); + snapshot.GetDirectory().SetCurrentSource(targetDirectory); + cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, snapshot)); - cmsys::auto_ptr<cmLocalGenerator> lg(gg.CreateLocalGenerator(mf.get())); - lg->GetMakefile()->SetCurrentBinaryDirectory(targetDirectory); - lg->GetMakefile()->SetCurrentSourceDirectory(targetDirectory); - gg.SetCurrentMakefile(lg->GetMakefile()); + gg.SetCurrentMakefile(mf.get()); - this->ReadAutogenInfoFile(lg->GetMakefile(), targetDirectory, config); - this->ReadOldMocDefinitionsFile(lg->GetMakefile(), targetDirectory); + this->ReadAutogenInfoFile(mf.get(), targetDirectory, config); + this->ReadOldMocDefinitionsFile(mf.get(), targetDirectory); this->Init(); if (this->QtMajorVersion == "4" || this->QtMajorVersion == "5") { - success = this->RunAutogen(lg->GetMakefile()); + success = this->RunAutogen(mf.get()); } this->WriteOldMocDefinitionsFile(targetDirectory); @@ -1533,6 +494,14 @@ void cmQtAutoGenerators::Init() } +static std::string ReadAll(const std::string& filename) +{ + cmsys::ifstream file(filename.c_str()); + std::stringstream stream; + stream << file.rdbuf(); + file.close(); + return stream.str(); +} bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile) { @@ -1559,7 +528,7 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile) cmSystemTools::ExpandListArgument(this->Sources, sourceFiles); const std::vector<std::string>& headerExtensions = - makefile->GetHeaderExtensions(); + makefile->GetCMakeInstance()->GetHeaderExtensions(); std::map<std::string, std::vector<std::string> > includedUis; std::map<std::string, std::vector<std::string> > skippedUis; @@ -2251,7 +1220,8 @@ bool cmQtAutoGenerators::GenerateUi(const std::string& realName, { std::vector<std::string> fileOpts; cmSystemTools::ExpandListArgument(optionIt->second, fileOpts); - this->MergeUicOptions(opts, fileOpts, this->QtMajorVersion == "5"); + cmQtAutoGenerators::MergeUicOptions(opts, fileOpts, + this->QtMajorVersion == "5"); } command.insert(command.end(), opts.begin(), opts.end()); diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h index 4f03348..ab7b6ed 100644 --- a/Source/cmQtAutoGenerators.h +++ b/Source/cmQtAutoGenerators.h @@ -15,10 +15,11 @@ #define cmQtAutoGenerators_h #include <list> +#include <vector> +#include <string> +#include <map> -class cmGlobalGenerator; class cmMakefile; -class cmLocalGenerator; class cmQtAutoGenerators { @@ -26,18 +27,7 @@ public: cmQtAutoGenerators(); bool Run(const std::string& targetDirectory, const std::string& config); - bool InitializeAutogenTarget(cmLocalGenerator* lg, cmTarget* target); - void SetupAutoGenerateTarget(cmTarget const* target); - void SetupSourceFiles(cmTarget const* target); - private: - void SetupAutoMocTarget(cmTarget const* target, - const std::string &autogenTargetName, - std::map<std::string, std::string> &configIncludes, - std::map<std::string, std::string> &configDefines); - void SetupAutoUicTarget(cmTarget const* target, - std::map<std::string, std::string> &configUicOptions); - void SetupAutoRccTarget(cmTarget const* target); bool ReadAutogenInfoFile(cmMakefile* makefile, const std::string& targetDirectory, @@ -83,20 +73,9 @@ private: bool EndsWith(const std::string& str, const std::string& with); bool StartsWith(const std::string& str, const std::string& with); - void MergeUicOptions(std::vector<std::string> &opts, - const std::vector<std::string> &fileOpts, bool isQt5); - - void MergeRccOptions(std::vector<std::string> &opts, + static void MergeUicOptions(std::vector<std::string> &opts, const std::vector<std::string> &fileOpts, bool isQt5); - std::string GetRccExecutable(cmTarget const* target); - - std::string ListQt5RccInputs(cmSourceFile* sf, cmTarget const* target, - std::vector<std::string>& depends); - - std::string ListQt4RccInputs(cmSourceFile* sf, - std::vector<std::string>& depends); - bool InputFilesNewerThanQrc(const std::string& qrcFile, const std::string& rccOutput); diff --git a/Source/cmRemoveCommand.h b/Source/cmRemoveCommand.h index 94161f8..410b370 100644 --- a/Source/cmRemoveCommand.h +++ b/Source/cmRemoveCommand.h @@ -47,12 +47,6 @@ public: */ virtual std::string GetName() const {return "remove";} - /** This command is kept for compatibility with older CMake versions. */ - virtual bool IsDiscouraged() const - { - return true; - } - cmTypeMacro(cmRemoveCommand, cmCommand); }; diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx index 306276b..1d70ad6 100644 --- a/Source/cmSetCommand.cxx +++ b/Source/cmSetCommand.cxx @@ -48,7 +48,7 @@ bool cmSetCommand return true; } - // if it will be cleared, then clear it if it isn;t already clear + // if it will be cleared, then clear it if it isn't already clear if (currValue) { cmSystemTools::PutEnv(putEnvArg); @@ -59,7 +59,7 @@ bool cmSetCommand // SET (VAR) // Removes the definition of VAR. if (args.size() == 1) { - this->Makefile->RemoveDefinition(args[0]); + this->Makefile->RemoveDefinition(variable); return true; } // SET (VAR PARENT_SCOPE) // Removes the definition of VAR diff --git a/Source/cmSetTargetPropertiesCommand.cxx b/Source/cmSetTargetPropertiesCommand.cxx index 06217bb..b1c13ac 100644 --- a/Source/cmSetTargetPropertiesCommand.cxx +++ b/Source/cmSetTargetPropertiesCommand.cxx @@ -10,7 +10,6 @@ See the License for more information. ============================================================================*/ #include "cmSetTargetPropertiesCommand.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" // cmSetTargetPropertiesCommand diff --git a/Source/cmSourceFile.cxx b/Source/cmSourceFile.cxx index 86f0a7a..a9ac549 100644 --- a/Source/cmSourceFile.cxx +++ b/Source/cmSourceFile.cxx @@ -12,7 +12,6 @@ #include "cmSourceFile.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmMakefile.h" #include "cmSystemTools.h" #include "cmake.h" @@ -168,8 +167,10 @@ bool cmSourceFile::FindFullPath(std::string* error) { tryDirs[0] = ""; } - const std::vector<std::string>& srcExts = mf->GetSourceExtensions(); - const std::vector<std::string>& hdrExts = mf->GetHeaderExtensions(); + const std::vector<std::string>& srcExts = + mf->GetCMakeInstance()->GetSourceExtensions(); + std::vector<std::string> hdrExts = + mf->GetCMakeInstance()->GetHeaderExtensions(); for(const char* const* di = tryDirs; *di; ++di) { std::string tryPath = this->Location.GetDirectory(); diff --git a/Source/cmSourceFileLocation.cxx b/Source/cmSourceFileLocation.cxx index 4a87cc2..00d5d6a 100644 --- a/Source/cmSourceFileLocation.cxx +++ b/Source/cmSourceFileLocation.cxx @@ -12,7 +12,6 @@ #include "cmSourceFileLocation.h" #include "cmMakefile.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmSystemTools.h" #include "cmAlgorithms.h" @@ -122,8 +121,10 @@ void cmSourceFileLocation::UpdateExtension(const std::string& name) // The global generator checks extensions of enabled languages. cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator(); cmMakefile const* mf = this->Makefile; - const std::vector<std::string>& srcExts = mf->GetSourceExtensions(); - const std::vector<std::string>& hdrExts = mf->GetHeaderExtensions(); + const std::vector<std::string>& srcExts = + mf->GetCMakeInstance()->GetSourceExtensions(); + const std::vector<std::string>& hdrExts = + mf->GetCMakeInstance()->GetHeaderExtensions(); if(!gg->GetLanguageFromExtension(ext.c_str()).empty() || std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end() || std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end()) @@ -194,12 +195,14 @@ cmSourceFileLocation // disk. One of these must match if loc refers to this source file. std::string const& ext = this->Name.substr(loc.Name.size()+1); cmMakefile const* mf = this->Makefile; - const std::vector<std::string>& srcExts = mf->GetSourceExtensions(); + const std::vector<std::string>& srcExts = + mf->GetCMakeInstance()->GetSourceExtensions(); if(std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end()) { return true; } - const std::vector<std::string>& hdrExts = mf->GetHeaderExtensions(); + std::vector<std::string> hdrExts = + mf->GetCMakeInstance()->GetHeaderExtensions(); if(std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end()) { return true; diff --git a/Source/cmStandardIncludes.h b/Source/cmStandardIncludes.h index 468a589..dd8fa9c 100644 --- a/Source/cmStandardIncludes.h +++ b/Source/cmStandardIncludes.h @@ -123,4 +123,10 @@ static thisClass* SafeDownCast(cmObject *c) \ } \ class cmTypeMacro_UseTrailingSemicolon +enum cmTargetLinkLibraryType { + GENERAL_LibraryType, + DEBUG_LibraryType, + OPTIMIZED_LibraryType +}; + #endif diff --git a/Source/cmState.cxx b/Source/cmState.cxx index b30c10b..c491c7d 100644 --- a/Source/cmState.cxx +++ b/Source/cmState.cxx @@ -12,6 +12,7 @@ #include "cmState.h" #include "cmake.h" +#include "cmVersion.h" #include "cmCacheManager.h" #include "cmCommand.h" #include "cmAlgorithms.h" @@ -82,9 +83,8 @@ struct cmState::BuildsystemDirectoryStateType std::vector<cmState::Snapshot> Children; }; -cmState::cmState(cmake* cm) - : CMakeInstance(cm), - IsInTryCompile(false), +cmState::cmState() + : IsInTryCompile(false), WindowsShell(false), WindowsVSIDE(false), WatcomWMake(false), @@ -92,13 +92,42 @@ cmState::cmState(cmake* cm) NMake(false), MSYSShell(false) { + this->CacheManager = new cmCacheManager; } cmState::~cmState() { + delete this->CacheManager; cmDeleteAll(this->Commands); } +const char* cmState::GetTargetTypeName(cmState::TargetType targetType) +{ + switch( targetType ) + { + case cmState::STATIC_LIBRARY: + return "STATIC_LIBRARY"; + case cmState::MODULE_LIBRARY: + return "MODULE_LIBRARY"; + case cmState::SHARED_LIBRARY: + return "SHARED_LIBRARY"; + case cmState::OBJECT_LIBRARY: + return "OBJECT_LIBRARY"; + case cmState::EXECUTABLE: + return "EXECUTABLE"; + case cmState::UTILITY: + return "UTILITY"; + case cmState::GLOBAL_TARGET: + return "GLOBAL_TARGET"; + case cmState::INTERFACE_LIBRARY: + return "INTERFACE_LIBRARY"; + case cmState::UNKNOWN_LIBRARY: + return "UNKNOWN_LIBRARY"; + } + assert(0 && "Unexpected target type"); + return 0; +} + const char* cmCacheEntryTypes[] = { "BOOL", "PATH", @@ -147,12 +176,30 @@ bool cmState::IsCacheEntryType(std::string const& key) return false; } +bool cmState::LoadCache(const std::string& path, bool internal, + std::set<std::string>& excludes, + std::set<std::string>& includes) +{ + return this->CacheManager->LoadCache(path, internal, + excludes, includes); +} + +bool cmState::SaveCache(const std::string& path) +{ + return this->CacheManager->SaveCache(path); +} + +bool cmState::DeleteCache(const std::string& path) +{ + return this->CacheManager->DeleteCache(path); +} + std::vector<std::string> cmState::GetCacheEntryKeys() const { std::vector<std::string> definitions; - definitions.reserve(this->CMakeInstance->GetCacheManager()->GetSize()); + definitions.reserve(this->CacheManager->GetSize()); cmCacheManager::CacheIterator cit = - this->CMakeInstance->GetCacheManager()->GetCacheIterator(); + this->CacheManager->GetCacheIterator(); for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() ) { definitions.push_back(cit.GetName()); @@ -162,7 +209,7 @@ std::vector<std::string> cmState::GetCacheEntryKeys() const const char* cmState::GetCacheEntryValue(std::string const& key) const { - cmCacheManager::CacheEntry* e = this->CMakeInstance->GetCacheManager() + cmCacheManager::CacheEntry* e = this->CacheManager ->GetCacheEntry(key); if (!e) { @@ -174,21 +221,21 @@ const char* cmState::GetCacheEntryValue(std::string const& key) const const char* cmState::GetInitializedCacheValue(std::string const& key) const { - return this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue(key); + return this->CacheManager->GetInitializedCacheValue(key); } cmState::CacheEntryType cmState::GetCacheEntryType(std::string const& key) const { cmCacheManager::CacheIterator it = - this->CMakeInstance->GetCacheManager()->GetCacheIterator(key.c_str()); + this->CacheManager->GetCacheIterator(key.c_str()); return it.GetType(); } void cmState::SetCacheEntryValue(std::string const& key, std::string const& value) { - this->CMakeInstance->GetCacheManager()->SetCacheEntryValue(key, value); + this->CacheManager->SetCacheEntryValue(key, value); } void cmState::SetCacheEntryProperty(std::string const& key, @@ -196,7 +243,7 @@ void cmState::SetCacheEntryProperty(std::string const& key, std::string const& value) { cmCacheManager::CacheIterator it = - this->CMakeInstance->GetCacheManager()->GetCacheIterator(key.c_str()); + this->CacheManager->GetCacheIterator(key.c_str()); it.SetProperty(propertyName, value.c_str()); } @@ -205,14 +252,14 @@ void cmState::SetCacheEntryBoolProperty(std::string const& key, bool value) { cmCacheManager::CacheIterator it = - this->CMakeInstance->GetCacheManager()->GetCacheIterator(key.c_str()); + this->CacheManager->GetCacheIterator(key.c_str()); it.SetProperty(propertyName, value); } const char* cmState::GetCacheEntryProperty(std::string const& key, std::string const& propertyName) { - cmCacheManager::CacheIterator it = this->CMakeInstance->GetCacheManager() + cmCacheManager::CacheIterator it = this->CacheManager ->GetCacheIterator(key.c_str()); if (!it.PropertyExists(propertyName)) { @@ -224,7 +271,7 @@ const char* cmState::GetCacheEntryProperty(std::string const& key, bool cmState::GetCacheEntryPropertyAsBool(std::string const& key, std::string const& propertyName) { - return this->CMakeInstance->GetCacheManager() + return this->CacheManager ->GetCacheIterator(key.c_str()).GetPropertyAsBool(propertyName); } @@ -232,13 +279,13 @@ void cmState::AddCacheEntry(const std::string& key, const char* value, const char* helpString, cmState::CacheEntryType type) { - this->CMakeInstance->GetCacheManager()->AddCacheEntry(key, value, + this->CacheManager->AddCacheEntry(key, value, helpString, type); } void cmState::RemoveCacheEntry(std::string const& key) { - this->CMakeInstance->GetCacheManager()->RemoveCacheEntry(key); + this->CacheManager->RemoveCacheEntry(key); } void cmState::AppendCacheEntryProperty(const std::string& key, @@ -246,7 +293,7 @@ void cmState::AppendCacheEntryProperty(const std::string& key, const std::string& value, bool asString) { - this->CMakeInstance->GetCacheManager() + this->CacheManager ->GetCacheIterator(key.c_str()).AppendProperty(property, value.c_str(), asString); @@ -255,7 +302,7 @@ void cmState::AppendCacheEntryProperty(const std::string& key, void cmState::RemoveCacheEntryProperty(std::string const& key, std::string const& propertyName) { - this->CMakeInstance->GetCacheManager() + this->CacheManager ->GetCacheIterator(key.c_str()).SetProperty(propertyName, (void*)0); } @@ -287,11 +334,21 @@ cmState::Snapshot cmState::Reset() pos->PolicyScope = this->PolicyStack.Root(); assert(pos->Policies.IsValid()); assert(pos->PolicyRoot.IsValid()); + + { + std::string srcDir = + cmDefinitions::Get("CMAKE_SOURCE_DIR", pos->Vars, pos->Root); + std::string binDir = + cmDefinitions::Get("CMAKE_BINARY_DIR", pos->Vars, pos->Root); this->VarTree.Clear(); pos->Vars = this->VarTree.Extend(this->VarTree.Root()); pos->Parent = this->VarTree.Root(); pos->Root = this->VarTree.Root(); + pos->Vars->Set("CMAKE_SOURCE_DIR", srcDir.c_str()); + pos->Vars->Set("CMAKE_BINARY_DIR", binDir.c_str()); + } + this->DefineProperty ("RULE_LAUNCH_COMPILE", cmProperty::DIRECTORY, "", "", true); @@ -659,6 +716,16 @@ bool cmState::UseMSYSShell() const return this->MSYSShell; } +unsigned int cmState::GetCacheMajorVersion() const +{ + return this->CacheManager->GetCacheMajorVersion(); +} + +unsigned int cmState::GetCacheMinorVersion() const +{ + return this->CacheManager->GetCacheMinorVersion(); +} + const char* cmState::GetBinaryDirectory() const { return this->BinaryDirectory.c_str(); @@ -805,8 +872,12 @@ cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot, pos->Parent = origin; pos->Root = origin; pos->Vars = this->VarTree.Extend(origin); + cmState::Snapshot snapshot = cmState::Snapshot(this, pos); originSnapshot.Position->BuildSystemDirectory->Children.push_back(snapshot); + snapshot.SetDefaultDefinitions(); + snapshot.InitializeFromParent(); + snapshot.SetDirectoryDefinitions(); return snapshot; } @@ -978,6 +1049,8 @@ void cmState::Directory::SetCurrentSource(std::string const& dir) loc, this->DirectoryState->CurrentSourceDirectoryComponents); this->ComputeRelativePathTopSource(); + + this->Snapshot_.SetDefinition("CMAKE_CURRENT_SOURCE_DIR", loc.c_str()); } const char* cmState::Directory::GetCurrentBinary() const @@ -996,6 +1069,8 @@ void cmState::Directory::SetCurrentBinary(std::string const& dir) loc, this->DirectoryState->CurrentBinaryDirectoryComponents); this->ComputeRelativePathTopBinary(); + + this->Snapshot_.SetDefinition("CMAKE_CURRENT_BINARY_DIR", loc.c_str()); } void cmState::Snapshot::SetListFile(const std::string& listfile) @@ -1067,7 +1142,8 @@ cmState::Snapshot cmState::Snapshot::GetBuildsystemDirectoryParent() const PositionType parentPos = this->Position->DirectoryParent; if (parentPos != this->State->SnapshotData.Root()) { - snapshot = Snapshot(this->State, parentPos); + snapshot = Snapshot(this->State, + parentPos->BuildSystemDirectory->DirectoryEnd); } return snapshot; @@ -1286,6 +1362,70 @@ void InitializeContentFromParent(T& parentContent, contentEndPosition = thisContent.size(); } +void cmState::Snapshot::SetDefaultDefinitions() +{ + /* Up to CMake 2.4 here only WIN32, UNIX and APPLE were set. + With CMake must separate between target and host platform. In most cases + the tests for WIN32, UNIX and APPLE will be for the target system, so an + additional set of variables for the host system is required -> + CMAKE_HOST_WIN32, CMAKE_HOST_UNIX, CMAKE_HOST_APPLE. + WIN32, UNIX and APPLE are now set in the platform files in + Modules/Platforms/. + To keep cmake scripts (-P) and custom language and compiler modules + working, these variables are still also set here in this place, but they + will be reset in CMakeSystemSpecificInformation.cmake before the platform + files are executed. */ + #if defined(_WIN32) + this->SetDefinition("WIN32", "1"); + this->SetDefinition("CMAKE_HOST_WIN32", "1"); + #else + this->SetDefinition("UNIX", "1"); + this->SetDefinition("CMAKE_HOST_UNIX", "1"); + #endif + #if defined(__CYGWIN__) + if(cmSystemTools::IsOn(cmSystemTools::GetEnv("CMAKE_LEGACY_CYGWIN_WIN32"))) + { + this->SetDefinition("WIN32", "1"); + this->SetDefinition("CMAKE_HOST_WIN32", "1"); + } + #endif + #if defined(__APPLE__) + this->SetDefinition("APPLE", "1"); + this->SetDefinition("CMAKE_HOST_APPLE", "1"); + #endif + + char temp[1024]; + sprintf(temp, "%d", cmVersion::GetMinorVersion()); + this->SetDefinition("CMAKE_MINOR_VERSION", temp); + sprintf(temp, "%d", cmVersion::GetMajorVersion()); + this->SetDefinition("CMAKE_MAJOR_VERSION", temp); + sprintf(temp, "%d", cmVersion::GetPatchVersion()); + this->SetDefinition("CMAKE_PATCH_VERSION", temp); + sprintf(temp, "%d", cmVersion::GetTweakVersion()); + this->SetDefinition("CMAKE_TWEAK_VERSION", temp); + this->SetDefinition("CMAKE_VERSION", + cmVersion::GetCMakeVersion()); + + this->SetDefinition("CMAKE_FILES_DIRECTORY", + cmake::GetCMakeFilesDirectory()); + + // Setup the default include file regular expression (match everything). + this->Position->BuildSystemDirectory + ->Properties.SetProperty("INCLUDE_REGULAR_EXPRESSION", "^.*$"); +} + +void cmState::Snapshot::SetDirectoryDefinitions() +{ + this->SetDefinition("CMAKE_SOURCE_DIR", + this->State->GetSourceDirectory()); + this->SetDefinition("CMAKE_CURRENT_SOURCE_DIR", + this->State->GetSourceDirectory()); + this->SetDefinition("CMAKE_BINARY_DIR", + this->State->GetBinaryDirectory()); + this->SetDefinition("CMAKE_CURRENT_BINARY_DIR", + this->State->GetBinaryDirectory()); +} + void cmState::Snapshot::InitializeFromParent() { PositionType parent = this->Position->DirectoryParent; @@ -1334,6 +1474,20 @@ std::string cmState::Snapshot::GetProjectName() const return this->Position->BuildSystemDirectory->ProjectName; } +void cmState::Snapshot::InitializeFromParent_ForSubdirsCommand() +{ + std::string currentSrcDir = this->GetDefinition("CMAKE_CURRENT_SOURCE_DIR"); + std::string currentBinDir = this->GetDefinition("CMAKE_CURRENT_BINARY_DIR"); + this->InitializeFromParent(); + this->SetDefinition("CMAKE_SOURCE_DIR", + this->State->GetSourceDirectory()); + this->SetDefinition("CMAKE_BINARY_DIR", + this->State->GetBinaryDirectory()); + + this->SetDefinition("CMAKE_CURRENT_SOURCE_DIR", currentSrcDir.c_str()); + this->SetDefinition("CMAKE_CURRENT_BINARY_DIR", currentBinDir.c_str()); +} + cmState::Directory::Directory( cmLinkedTree<BuildsystemDirectoryStateType>::iterator iter, const cmState::Snapshot& snapshot) @@ -1376,11 +1530,16 @@ cmBacktraceRange GetPropertyBacktraces(T const& content, template <typename T, typename U, typename V> void AppendEntry(T& content, U& backtraces, V& endContentPosition, - const std::string& vec, const cmListFileBacktrace& lfbt) + const std::string& value, const cmListFileBacktrace& lfbt) { + if (value.empty()) + { + return; + } + assert(endContentPosition == content.size()); - content.push_back(vec); + content.push_back(value); backtraces.push_back(lfbt); endContentPosition = content.size(); @@ -1733,3 +1892,87 @@ bool operator!=(const cmState::Snapshot& lhs, const cmState::Snapshot& rhs) { return lhs.Position != rhs.Position; } + +static bool ParseEntryWithoutType(const std::string& entry, + std::string& var, + std::string& value) +{ + // input line is: key=value + static cmsys::RegularExpression reg( + "^([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); + // input line is: "key"=value + static cmsys::RegularExpression regQuoted( + "^\"([^\"]*)\"=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); + bool flag = false; + if(regQuoted.find(entry)) + { + var = regQuoted.match(1); + value = regQuoted.match(2); + flag = true; + } + else if (reg.find(entry)) + { + var = reg.match(1); + value = reg.match(2); + flag = true; + } + + // if value is enclosed in single quotes ('foo') then remove them + // it is used to enclose trailing space or tab + if (flag && + value.size() >= 2 && + value[0] == '\'' && + value[value.size() - 1] == '\'') + { + value = value.substr(1, + value.size() - 2); + } + + return flag; +} + +bool cmState::ParseCacheEntry(const std::string& entry, + std::string& var, + std::string& value, + CacheEntryType& type) +{ + // input line is: key:type=value + static cmsys::RegularExpression reg( + "^([^=:]*):([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); + // input line is: "key":type=value + static cmsys::RegularExpression regQuoted( + "^\"([^\"]*)\":([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); + bool flag = false; + if(regQuoted.find(entry)) + { + var = regQuoted.match(1); + type = cmState::StringToCacheEntryType(regQuoted.match(2).c_str()); + value = regQuoted.match(3); + flag = true; + } + else if (reg.find(entry)) + { + var = reg.match(1); + type = cmState::StringToCacheEntryType(reg.match(2).c_str()); + value = reg.match(3); + flag = true; + } + + // if value is enclosed in single quotes ('foo') then remove them + // it is used to enclose trailing space or tab + if (flag && + value.size() >= 2 && + value[0] == '\'' && + value[value.size() - 1] == '\'') + { + value = value.substr(1, + value.size() - 2); + } + + if (!flag) + { + return ParseEntryWithoutType(entry, var, value); + } + + return flag; +} diff --git a/Source/cmState.h b/Source/cmState.h index 99e537c..7d1fc80 100644 --- a/Source/cmState.h +++ b/Source/cmState.h @@ -23,6 +23,7 @@ class cmake; class cmCommand; class cmDefinitions; class cmListFileBacktrace; +class cmCacheManager; class cmState { @@ -32,7 +33,7 @@ class cmState typedef cmLinkedTree<SnapshotDataType>::iterator PositionType; friend class Snapshot; public: - cmState(cmake* cm); + cmState(); ~cmState(); enum SnapshotType @@ -75,8 +76,6 @@ public: Snapshot GetCallStackParent() const; SnapshotType GetType() const; - void InitializeFromParent(); - void SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status); cmPolicies::PolicyStatus GetPolicy(cmPolicies::PolicyID id) const; bool HasDefinedPolicyCMP0011(); @@ -91,12 +90,17 @@ public: void SetProjectName(std::string const& name); std::string GetProjectName() const; + void InitializeFromParent_ForSubdirsCommand(); + struct StrictWeakOrder { bool operator()(const cmState::Snapshot& lhs, const cmState::Snapshot& rhs) const; }; + void SetDirectoryDefinitions(); + void SetDefaultDefinitions(); + private: friend bool operator==(const cmState::Snapshot& lhs, const cmState::Snapshot& rhs); @@ -105,6 +109,9 @@ public: friend class cmState; friend class Directory; friend struct StrictWeakOrder; + + void InitializeFromParent(); + cmState* State; cmState::PositionType Position; }; @@ -174,6 +181,14 @@ public: friend class Snapshot; }; + enum TargetType { EXECUTABLE, STATIC_LIBRARY, + SHARED_LIBRARY, MODULE_LIBRARY, + OBJECT_LIBRARY, UTILITY, GLOBAL_TARGET, + INTERFACE_LIBRARY, + UNKNOWN_LIBRARY}; + + static const char* GetTargetTypeName(cmState::TargetType targetType); + Snapshot CreateBaseSnapshot(); Snapshot CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot, @@ -207,6 +222,14 @@ public: static const char* CacheEntryTypeToString(CacheEntryType); static bool IsCacheEntryType(std::string const& key); + bool LoadCache(const std::string& path, bool internal, + std::set<std::string>& excludes, + std::set<std::string>& includes); + + bool SaveCache(const std::string& path) ; + + bool DeleteCache(const std::string& path); + std::vector<std::string> GetCacheEntryKeys() const; const char* GetCacheEntryValue(std::string const& key) const; const char* GetInitializedCacheValue(std::string const& key) const; @@ -214,8 +237,6 @@ public: void SetCacheEntryValue(std::string const& key, std::string const& value); void SetCacheValue(std::string const& key, std::string const& value); - void AddCacheEntry(const std::string& key, const char* value, - const char* helpString, CacheEntryType type); void RemoveCacheEntry(std::string const& key); void SetCacheEntryProperty(std::string const& key, @@ -235,6 +256,12 @@ public: void RemoveCacheEntryProperty(std::string const& key, std::string const& propertyName); + ///! Break up a line like VAR:type="value" into var, type and value + static bool ParseCacheEntry(const std::string& entry, + std::string& var, + std::string& value, + CacheEntryType& type); + Snapshot Reset(); // Define a property void DefineProperty(const std::string& name, cmProperty::ScopeType scope, @@ -295,12 +322,19 @@ public: void SetMSYSShell(bool mSYSShell); bool UseMSYSShell() const; + unsigned int GetCacheMajorVersion() const; + unsigned int GetCacheMinorVersion() const; + private: + friend class cmake; + void AddCacheEntry(const std::string& key, const char* value, + const char* helpString, CacheEntryType type); + std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> PropertyDefinitions; std::vector<std::string> EnabledLanguages; std::map<std::string, cmCommand*> Commands; cmPropertyMap GlobalProperties; - cmake* CMakeInstance; + cmCacheManager* CacheManager; cmLinkedTree<BuildsystemDirectoryStateType> BuildsystemDirectory; diff --git a/Source/cmSubdirCommand.h b/Source/cmSubdirCommand.h index 6addd8f..bcefd2c 100644 --- a/Source/cmSubdirCommand.h +++ b/Source/cmSubdirCommand.h @@ -44,12 +44,6 @@ public: */ virtual std::string GetName() const { return "subdirs";} - /** This command is kept for compatibility with older CMake versions. */ - virtual bool IsDiscouraged() const - { - return true; - } - cmTypeMacro(cmSubdirCommand, cmCommand); }; diff --git a/Source/cmSubdirDependsCommand.h b/Source/cmSubdirDependsCommand.h index 75a5685..3f3507e 100644 --- a/Source/cmSubdirDependsCommand.h +++ b/Source/cmSubdirDependsCommand.h @@ -21,7 +21,6 @@ public: virtual bool InitialPass(std::vector<std::string> const& args, cmExecutionStatus &status); virtual std::string GetName() const { return "subdir_depends";} - virtual bool IsDiscouraged() const { return true; } cmTypeMacro(cmSubdirDependsCommand, cmCommand); }; diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx index 65bfe79..b2827dc 100644 --- a/Source/cmSystemTools.cxx +++ b/Source/cmSystemTools.cxx @@ -29,6 +29,9 @@ # include "cmArchiveWrite.h" # include "cmLocale.h" # include <cm_libarchive.h> +# ifndef __LA_INT64_T +# define __LA_INT64_T la_int64_t +# endif #endif #include <cmsys/FStream.hxx> #include <cmsys/Terminal.h> @@ -68,6 +71,11 @@ # include "cmMachO.h" #endif +static bool cm_isspace(char c) +{ + return ((c & 0x80) == 0) && isspace(c); +} + class cmSystemToolsFileTime { public: @@ -228,13 +236,13 @@ std::string cmSystemTools::HelpFileName(std::string name) std::string cmSystemTools::TrimWhitespace(const std::string& s) { std::string::const_iterator start = s.begin(); - while(start != s.end() && *start <= ' ') + while (start != s.end() && cm_isspace(*start)) ++start; if (start == s.end()) return ""; std::string::const_iterator stop = s.end()-1; - while(*stop <= ' ') + while (cm_isspace(*stop)) --stop; return std::string(start, stop+1); } @@ -496,7 +504,7 @@ void cmSystemTools::ParseWindowsCommandLine(const char* command, { arg.append(backslashes, '\\'); backslashes = 0; - if(((*c & 0x80) == 0 ) && isspace(*c)) + if (cm_isspace(*c)) { if(in_quotes) { @@ -1018,7 +1026,7 @@ std::string cmSystemTools::ComputeCertificateThumbprint( { std::string thumbprint; -#ifdef _WIN32 +#if defined(CMAKE_BUILD_WITH_CMAKE) && defined(_WIN32) BYTE* certData = NULL; CRYPT_INTEGER_BLOB cryptBlob; HCERTSTORE certStore = NULL; @@ -2040,10 +2048,11 @@ bool cmSystemTools::CopyFileTime(const char* fromFile, const char* toFile) cmSystemToolsWindowsHandle hFrom = CreateFileW(SystemTools::ConvertToWindowsExtendedPath(fromFile).c_str(), GENERIC_READ, FILE_SHARE_READ, 0, - OPEN_EXISTING, 0, 0); + OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); cmSystemToolsWindowsHandle hTo = CreateFileW(SystemTools::ConvertToWindowsExtendedPath(toFile).c_str(), - GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); + FILE_WRITE_ATTRIBUTES, 0, 0, OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, 0); if(!hFrom || !hTo) { return false; @@ -2095,7 +2104,8 @@ bool cmSystemTools::FileTimeGet(const char* fname, cmSystemToolsFileTime* t) #if defined(_WIN32) && !defined(__CYGWIN__) cmSystemToolsWindowsHandle h = CreateFileW(SystemTools::ConvertToWindowsExtendedPath(fname).c_str(), - GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0); + GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, 0); if(!h) { return false; @@ -2122,7 +2132,8 @@ bool cmSystemTools::FileTimeSet(const char* fname, cmSystemToolsFileTime* t) #if defined(_WIN32) && !defined(__CYGWIN__) cmSystemToolsWindowsHandle h = CreateFileW(SystemTools::ConvertToWindowsExtendedPath(fname).c_str(), - GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); + FILE_WRITE_ATTRIBUTES, 0, 0, OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, 0); if(!h) { return false; @@ -2211,6 +2222,7 @@ static std::string cmSystemToolsCTestCommand; static std::string cmSystemToolsCPackCommand; static std::string cmSystemToolsCMakeCursesCommand; static std::string cmSystemToolsCMakeGUICommand; +static std::string cmSystemToolsCMClDepsCommand; static std::string cmSystemToolsCMakeRoot; void cmSystemTools::FindCMakeResources(const char* argv0) { @@ -2303,6 +2315,13 @@ void cmSystemTools::FindCMakeResources(const char* argv0) { cmSystemToolsCMakeCursesCommand = ""; } + cmSystemToolsCMClDepsCommand = exe_dir; + cmSystemToolsCMClDepsCommand += "/cmcldeps"; + cmSystemToolsCMClDepsCommand += cmSystemTools::GetExecutableExtension(); + if(!cmSystemTools::FileExists(cmSystemToolsCMClDepsCommand.c_str())) + { + cmSystemToolsCMClDepsCommand = ""; + } #ifdef CMAKE_BUILD_WITH_CMAKE // Install tree has "<prefix>/bin/cmake" and "<prefix><CMAKE_DATA_DIR>". @@ -2370,6 +2389,12 @@ std::string const& cmSystemTools::GetCMakeGUICommand() } //---------------------------------------------------------------------------- +std::string const& cmSystemTools::GetCMClDepsCommand() +{ + return cmSystemToolsCMClDepsCommand; +} + +//---------------------------------------------------------------------------- std::string const& cmSystemTools::GetCMakeRoot() { return cmSystemToolsCMakeRoot; @@ -2755,6 +2780,14 @@ bool cmSystemTools::VersionCompare(cmSystemTools::CompareOp op, } //---------------------------------------------------------------------------- +bool cmSystemTools::VersionCompareGreater(std::string const& lhs, + std::string const& rhs) +{ + return cmSystemTools::VersionCompare( + cmSystemTools::OP_GREATER, lhs.c_str(), rhs.c_str()); +} + +//---------------------------------------------------------------------------- bool cmSystemTools::RemoveRPath(std::string const& file, std::string* emsg, bool* removed) { diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h index d14897f..b6b0978 100644 --- a/Source/cmSystemTools.h +++ b/Source/cmSystemTools.h @@ -294,6 +294,8 @@ public: * Compare versions */ static bool VersionCompare(CompareOp op, const char* lhs, const char* rhs); + static bool VersionCompareGreater(std::string const& lhs, + std::string const& rhs); /** * Determine the file type based on the extension @@ -426,6 +428,7 @@ public: static std::string const& GetCMakeCommand(); static std::string const& GetCMakeGUICommand(); static std::string const& GetCMakeCursesCommand(); + static std::string const& GetCMClDepsCommand(); static std::string const& GetCMakeRoot(); /** Echo a message in color using KWSys's Terminal cprintf. */ diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx index 590654d..9ea1a34 100644 --- a/Source/cmTarget.cxx +++ b/Source/cmTarget.cxx @@ -33,91 +33,10 @@ #define UNORDERED_SET std::set #endif -const char* cmTarget::GetTargetTypeName(TargetType targetType) -{ - switch( targetType ) - { - case cmTarget::STATIC_LIBRARY: - return "STATIC_LIBRARY"; - case cmTarget::MODULE_LIBRARY: - return "MODULE_LIBRARY"; - case cmTarget::SHARED_LIBRARY: - return "SHARED_LIBRARY"; - case cmTarget::OBJECT_LIBRARY: - return "OBJECT_LIBRARY"; - case cmTarget::EXECUTABLE: - return "EXECUTABLE"; - case cmTarget::UTILITY: - return "UTILITY"; - case cmTarget::GLOBAL_TARGET: - return "GLOBAL_TARGET"; - case cmTarget::INTERFACE_LIBRARY: - return "INTERFACE_LIBRARY"; - case cmTarget::UNKNOWN_LIBRARY: - return "UNKNOWN_LIBRARY"; - } - assert(0 && "Unexpected target type"); - return 0; -} - -//---------------------------------------------------------------------------- -struct cmTarget::OutputInfo -{ - std::string OutDir; - std::string ImpDir; - std::string PdbDir; - bool empty() const - { return OutDir.empty() && ImpDir.empty() && PdbDir.empty(); } -}; - //---------------------------------------------------------------------------- class cmTargetInternals { public: - cmTargetInternals() - : Backtrace() - { - this->UtilityItemsDone = false; - } - cmTargetInternals(cmTargetInternals const&) - : Backtrace() - { - this->UtilityItemsDone = false; - } - ~cmTargetInternals(); - - // The backtrace when the target was created. - cmListFileBacktrace Backtrace; - - typedef std::map<std::string, cmTarget::OutputInfo> OutputInfoMapType; - OutputInfoMapType OutputInfoMap; - - typedef std::map<std::string, cmTarget::ImportInfo> ImportInfoMapType; - ImportInfoMapType ImportInfoMap; - - struct HeadToLinkImplementationMap: - public std::map<cmTarget const*, cmOptionalLinkImplementation> {}; - typedef std::map<std::string, - HeadToLinkImplementationMap> LinkImplMapType; - LinkImplMapType LinkImplMap; - - typedef std::map<std::string, std::vector<cmSourceFile*> > - SourceFilesMapType; - SourceFilesMapType SourceFilesMap; - - std::set<cmLinkItem> UtilityItems; - bool UtilityItemsDone; - - class TargetPropertyEntry { - static cmLinkImplItem NoLinkImplItem; - public: - TargetPropertyEntry(cmsys::auto_ptr<cmCompiledGeneratorExpression> cge, - cmLinkImplItem const& item = NoLinkImplItem) - : ge(cge), LinkImplItem(item) - {} - const cmsys::auto_ptr<cmCompiledGeneratorExpression> ge; - cmLinkImplItem const& LinkImplItem; - }; std::vector<std::string> IncludeDirectoriesEntries; std::vector<cmListFileBacktrace> IncludeDirectoriesBacktraces; std::vector<std::string> CompileOptionsEntries; @@ -126,21 +45,12 @@ public: std::vector<cmListFileBacktrace> CompileFeaturesBacktraces; std::vector<std::string> CompileDefinitionsEntries; std::vector<cmListFileBacktrace> CompileDefinitionsBacktraces; - std::vector<TargetPropertyEntry*> SourceEntries; - std::vector<cmValueWithOrigin> LinkImplementationPropertyEntries; - - void AddInterfaceEntries( - cmTarget const* thisTarget, std::string const& config, - std::string const& prop, std::vector<TargetPropertyEntry*>& entries); + std::vector<std::string> SourceEntries; + std::vector<cmListFileBacktrace> SourceBacktraces; + std::vector<std::string> LinkImplementationPropertyEntries; + std::vector<cmListFileBacktrace> LinkImplementationPropertyBacktraces; }; -cmLinkImplItem cmTargetInternals::TargetPropertyEntry::NoLinkImplItem; - -//---------------------------------------------------------------------------- -cmTargetInternals::~cmTargetInternals() -{ -} - //---------------------------------------------------------------------------- cmTarget::cmTarget() { @@ -151,20 +61,18 @@ cmTarget::cmTarget() this->HaveInstallRule = false; this->DLLPlatform = false; this->IsAndroid = false; - this->IsApple = false; this->IsImportedTarget = false; + this->ImportedGloballyVisible = false; this->BuildInterfaceIncludesAppended = false; - this->DebugSourcesDone = false; - this->LinkImplementationLanguageIsContextDependent = true; } -void cmTarget::SetType(TargetType type, const std::string& name) +void cmTarget::SetType(cmState::TargetType type, const std::string& name) { this->Name = name; // only add dependency information for library targets this->TargetTypeValue = type; - if(this->TargetTypeValue >= STATIC_LIBRARY - && this->TargetTypeValue <= MODULE_LIBRARY) + if(this->TargetTypeValue >= cmState::STATIC_LIBRARY + && this->TargetTypeValue <= cmState::MODULE_LIBRARY) { this->RecordDependencies = true; } @@ -190,11 +98,9 @@ void cmTarget::SetMakefile(cmMakefile* mf) strcmp(this->Makefile->GetSafeDefinition("CMAKE_SYSTEM_NAME"), "Android") == 0; - // Check whether we are targeting an Apple platform. - this->IsApple = this->Makefile->IsOn("APPLE"); - // Setup default property values. - if (this->GetType() != INTERFACE_LIBRARY && this->GetType() != UTILITY) + if (this->GetType() != cmState::INTERFACE_LIBRARY + && this->GetType() != cmState::UTILITY) { this->SetPropertyDefault("ANDROID_API", 0); this->SetPropertyDefault("ANDROID_API_MIN", 0); @@ -257,7 +163,7 @@ void cmTarget::SetMakefile(cmMakefile* mf) mf->GetConfigurations(configNames); // Setup per-configuration property default values. - if (this->GetType() != UTILITY) + if (this->GetType() != cmState::UTILITY) { const char* configProps[] = { "ARCHIVE_OUTPUT_DIRECTORY_", @@ -273,7 +179,7 @@ void cmTarget::SetMakefile(cmMakefile* mf) std::string configUpper = cmSystemTools::UpperCase(*ci); for(const char** p = configProps; *p; ++p) { - if (this->TargetTypeValue == INTERFACE_LIBRARY + if (this->TargetTypeValue == cmState::INTERFACE_LIBRARY && strcmp(*p, "MAP_IMPORTED_CONFIG_") != 0) { continue; @@ -288,8 +194,8 @@ void cmTarget::SetMakefile(cmMakefile* mf) // compatibility with previous CMake versions in which executables // did not support this variable. Projects may still specify the // property directly. - if(this->TargetTypeValue != cmTarget::EXECUTABLE - && this->TargetTypeValue != cmTarget::INTERFACE_LIBRARY) + if(this->TargetTypeValue != cmState::EXECUTABLE + && this->TargetTypeValue != cmState::INTERFACE_LIBRARY) { std::string property = cmSystemTools::UpperCase(*ci); property += "_POSTFIX"; @@ -299,7 +205,7 @@ void cmTarget::SetMakefile(cmMakefile* mf) } // Save the backtrace of target construction. - this->Internal->Backtrace = this->Makefile->GetBacktrace(); + this->Backtrace = this->Makefile->GetBacktrace(); if (!this->IsImported()) { @@ -336,29 +242,32 @@ void cmTarget::SetMakefile(cmMakefile* mf) parentOptionsBts.begin(), parentOptionsBts.end()); } - if (this->GetType() != INTERFACE_LIBRARY && this->GetType() != UTILITY) + if (this->GetType() != cmState::INTERFACE_LIBRARY + && this->GetType() != cmState::UTILITY) { this->SetPropertyDefault("C_VISIBILITY_PRESET", 0); this->SetPropertyDefault("CXX_VISIBILITY_PRESET", 0); this->SetPropertyDefault("VISIBILITY_INLINES_HIDDEN", 0); } - if(this->TargetTypeValue == cmTarget::EXECUTABLE) + if(this->TargetTypeValue == cmState::EXECUTABLE) { this->SetPropertyDefault("ANDROID_GUI", 0); this->SetPropertyDefault("CROSSCOMPILING_EMULATOR", 0); + this->SetPropertyDefault("ENABLE_EXPORTS", 0); } - if(this->TargetTypeValue == cmTarget::SHARED_LIBRARY - || this->TargetTypeValue == cmTarget::MODULE_LIBRARY) + if(this->TargetTypeValue == cmState::SHARED_LIBRARY + || this->TargetTypeValue == cmState::MODULE_LIBRARY) { this->SetProperty("POSITION_INDEPENDENT_CODE", "True"); } - if(this->TargetTypeValue == cmTarget::SHARED_LIBRARY) + if(this->TargetTypeValue == cmState::SHARED_LIBRARY) { this->SetPropertyDefault("WINDOWS_EXPORT_ALL_SYMBOLS", 0); } - if (this->GetType() != INTERFACE_LIBRARY && this->GetType() != UTILITY) + if (this->GetType() != cmState::INTERFACE_LIBRARY + && this->GetType() != cmState::UTILITY) { this->SetPropertyDefault("POSITION_INDEPENDENT_CODE", 0); } @@ -366,42 +275,29 @@ void cmTarget::SetMakefile(cmMakefile* mf) // Record current policies for later use. this->Makefile->RecordPolicies(this->PolicyMap); - if (this->TargetTypeValue == INTERFACE_LIBRARY) + if (this->TargetTypeValue == cmState::INTERFACE_LIBRARY) { // This policy is checked in a few conditions. The properties relevant - // to the policy are always ignored for INTERFACE_LIBRARY targets, + // to the policy are always ignored for cmState::INTERFACE_LIBRARY targets, // so ensure that the conditions don't lead to nonsense. this->PolicyMap.Set(cmPolicies::CMP0022, cmPolicies::NEW); } - if (this->GetType() != INTERFACE_LIBRARY && this->GetType() != UTILITY) + if (this->GetType() != cmState::INTERFACE_LIBRARY + && this->GetType() != cmState::UTILITY) { this->SetPropertyDefault("JOB_POOL_COMPILE", 0); this->SetPropertyDefault("JOB_POOL_LINK", 0); } } -void CreatePropertyGeneratorExpressions( - std::vector<std::string> const& entries, - std::vector<cmListFileBacktrace> const& backtraces, - std::vector<cmTargetInternals::TargetPropertyEntry*>& items) -{ - std::vector<cmListFileBacktrace>::const_iterator btIt = backtraces.begin(); - for (std::vector<std::string>::const_iterator it = entries.begin(); - it != entries.end(); ++it, ++btIt) - { - cmGeneratorExpression ge(*btIt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*it); - items.push_back(new cmTargetInternals::TargetPropertyEntry(cge)); - } -} - //---------------------------------------------------------------------------- void cmTarget::AddUtility(const std::string& u, cmMakefile *makefile) { if(this->Utilities.insert(u).second && makefile) { - UtilityBacktraces.insert(std::make_pair(u, makefile->GetBacktrace())); + this->UtilityBacktraces.insert( + std::make_pair(u, makefile->GetBacktrace())); } } @@ -417,98 +313,30 @@ cmListFileBacktrace const* cmTarget::GetUtilityBacktrace( } //---------------------------------------------------------------------------- -std::set<cmLinkItem> const& cmTarget::GetUtilityItems() const -{ - if(!this->Internal->UtilityItemsDone) - { - this->Internal->UtilityItemsDone = true; - for(std::set<std::string>::const_iterator i = this->Utilities.begin(); - i != this->Utilities.end(); ++i) - { - this->Internal->UtilityItems.insert( - cmLinkItem(*i, this->Makefile->FindTargetToUse(*i))); - } - } - return this->Internal->UtilityItems; -} - -//---------------------------------------------------------------------------- -void cmTarget::FinishConfigure() -{ - // Erase any cached link information that might have been comptued - // on-demand during the configuration. This ensures that build - // system generation uses up-to-date information even if other cache - // invalidation code in this source file is buggy. - this->ClearLinkMaps(); - -#if defined(_WIN32) && !defined(__CYGWIN__) - // Do old-style link dependency analysis only for CM_USE_OLD_VS6. - if(this->Makefile->GetGlobalGenerator()->IsForVS6()) - { - this->AnalyzeLibDependenciesForVS6(*this->Makefile); - } -#endif -} - -//---------------------------------------------------------------------------- -void cmTarget::ClearLinkMaps() -{ - this->LinkImplementationLanguageIsContextDependent = true; - this->Internal->LinkImplMap.clear(); - this->Internal->SourceFilesMap.clear(); -} - -//---------------------------------------------------------------------------- cmListFileBacktrace const& cmTarget::GetBacktrace() const { - return this->Internal->Backtrace; -} - -//---------------------------------------------------------------------------- -std::string cmTarget::GetSupportDirectory() const -{ - std::string dir = this->Makefile->GetCurrentBinaryDirectory(); - dir += cmake::GetCMakeFilesDirectory(); - dir += "/"; - dir += this->Name; -#if defined(__VMS) - dir += "_dir"; -#else - dir += ".dir"; -#endif - return dir; + return this->Backtrace; } //---------------------------------------------------------------------------- bool cmTarget::IsExecutableWithExports() const { - return (this->GetType() == cmTarget::EXECUTABLE && + return (this->GetType() == cmState::EXECUTABLE && this->GetPropertyAsBool("ENABLE_EXPORTS")); } //---------------------------------------------------------------------------- -bool cmTarget::IsLinkable() const -{ - return (this->GetType() == cmTarget::STATIC_LIBRARY || - this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY || - this->GetType() == cmTarget::UNKNOWN_LIBRARY || - this->GetType() == cmTarget::INTERFACE_LIBRARY || - this->IsExecutableWithExports()); -} - -//---------------------------------------------------------------------------- bool cmTarget::HasImportLibrary() const { return (this->DLLPlatform && - (this->GetType() == cmTarget::SHARED_LIBRARY || + (this->GetType() == cmState::SHARED_LIBRARY || this->IsExecutableWithExports())); } //---------------------------------------------------------------------------- bool cmTarget::IsFrameworkOnApple() const { - return (this->GetType() == cmTarget::SHARED_LIBRARY && + return (this->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("APPLE") && this->GetPropertyAsBool("FRAMEWORK")); } @@ -516,268 +344,19 @@ bool cmTarget::IsFrameworkOnApple() const //---------------------------------------------------------------------------- bool cmTarget::IsAppBundleOnApple() const { - return (this->GetType() == cmTarget::EXECUTABLE && + return (this->GetType() == cmState::EXECUTABLE && this->Makefile->IsOn("APPLE") && this->GetPropertyAsBool("MACOSX_BUNDLE")); } //---------------------------------------------------------------------------- -bool cmTarget::IsCFBundleOnApple() const -{ - return (this->GetType() == cmTarget::MODULE_LIBRARY && - this->Makefile->IsOn("APPLE") && - this->GetPropertyAsBool("BUNDLE")); -} - -//---------------------------------------------------------------------------- -bool cmTarget::IsXCTestOnApple() const -{ - return (this->IsCFBundleOnApple() && - this->GetPropertyAsBool("XCTEST")); -} - -//---------------------------------------------------------------------------- -static bool processSources(cmTarget const* tgt, - const std::vector<cmTargetInternals::TargetPropertyEntry*> &entries, - std::vector<std::string> &srcs, - UNORDERED_SET<std::string> &uniqueSrcs, - cmGeneratorExpressionDAGChecker *dagChecker, - std::string const& config, bool debugSources) -{ - cmMakefile *mf = tgt->GetMakefile(); - - bool contextDependent = false; - - for (std::vector<cmTargetInternals::TargetPropertyEntry*>::const_iterator - it = entries.begin(), end = entries.end(); it != end; ++it) - { - cmLinkImplItem const& item = (*it)->LinkImplItem; - std::string const& targetName = item; - std::vector<std::string> entrySources; - cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(mf, - config, - false, - tgt, - tgt, - dagChecker), - entrySources); - - if ((*it)->ge->GetHadContextSensitiveCondition()) - { - contextDependent = true; - } - - for(std::vector<std::string>::iterator i = entrySources.begin(); - i != entrySources.end(); ++i) - { - std::string& src = *i; - cmSourceFile* sf = mf->GetOrCreateSource(src); - std::string e; - std::string fullPath = sf->GetFullPath(&e); - if(fullPath.empty()) - { - if(!e.empty()) - { - cmake* cm = mf->GetCMakeInstance(); - cm->IssueMessage(cmake::FATAL_ERROR, e, - tgt->GetBacktrace()); - } - return contextDependent; - } - - if (!targetName.empty() && !cmSystemTools::FileIsFullPath(src.c_str())) - { - std::ostringstream err; - if (!targetName.empty()) - { - err << "Target \"" << targetName << "\" contains relative " - "path in its INTERFACE_SOURCES:\n" - " \"" << src << "\""; - } - else - { - err << "Found relative path while evaluating sources of " - "\"" << tgt->GetName() << "\":\n \"" << src << "\"\n"; - } - tgt->GetMakefile()->IssueMessage(cmake::FATAL_ERROR, err.str()); - return contextDependent; - } - src = fullPath; - } - std::string usedSources; - for(std::vector<std::string>::iterator - li = entrySources.begin(); li != entrySources.end(); ++li) - { - std::string src = *li; - - if(uniqueSrcs.insert(src).second) - { - srcs.push_back(src); - if (debugSources) - { - usedSources += " * " + src + "\n"; - } - } - } - if (!usedSources.empty()) - { - mf->GetCMakeInstance()->IssueMessage(cmake::LOG, - std::string("Used sources for target ") - + tgt->GetName() + ":\n" - + usedSources, (*it)->ge->GetBacktrace()); - } - } - return contextDependent; -} - -//---------------------------------------------------------------------------- -void cmTarget::GetSourceFiles(std::vector<std::string> &files, - const std::string& config) const -{ - assert(this->GetType() != INTERFACE_LIBRARY); - - if (!this->Makefile->IsConfigured()) - { - // At configure-time, this method can be called as part of getting the - // LOCATION property or to export() a file to be include()d. However - // there is no cmGeneratorTarget at configure-time, so search the SOURCES - // for TARGET_OBJECTS instead for backwards compatibility with OLD - // behavior of CMP0024 and CMP0026 only. - - typedef cmTargetInternals::TargetPropertyEntry - TargetPropertyEntry; - for(std::vector<TargetPropertyEntry*>::const_iterator - i = this->Internal->SourceEntries.begin(); - i != this->Internal->SourceEntries.end(); ++i) - { - std::string entry = (*i)->ge->GetInput(); - - std::vector<std::string> items; - cmSystemTools::ExpandListArgument(entry, items); - for (std::vector<std::string>::const_iterator - li = items.begin(); li != items.end(); ++li) - { - if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") && - (*li)[li->size() - 1] == '>') - { - continue; - } - files.push_back(*li); - } - } - return; - } - - std::vector<std::string> debugProperties; - const char *debugProp = - this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES"); - if (debugProp) - { - cmSystemTools::ExpandListArgument(debugProp, debugProperties); - } - - bool debugSources = !this->DebugSourcesDone - && std::find(debugProperties.begin(), - debugProperties.end(), - "SOURCES") - != debugProperties.end(); - - if (this->Makefile->IsConfigured()) - { - this->DebugSourcesDone = true; - } - - cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), - "SOURCES", 0, 0); - - UNORDERED_SET<std::string> uniqueSrcs; - bool contextDependentDirectSources = processSources(this, - this->Internal->SourceEntries, - files, - uniqueSrcs, - &dagChecker, - config, - debugSources); - - std::vector<cmTargetInternals::TargetPropertyEntry*> - linkInterfaceSourcesEntries; - - this->Internal->AddInterfaceEntries( - this, config, "INTERFACE_SOURCES", - linkInterfaceSourcesEntries); - - std::vector<std::string>::size_type numFilesBefore = files.size(); - bool contextDependentInterfaceSources = processSources(this, - linkInterfaceSourcesEntries, - files, - uniqueSrcs, - &dagChecker, - config, - debugSources); - - if (!contextDependentDirectSources - && !(contextDependentInterfaceSources && numFilesBefore < files.size())) - { - this->LinkImplementationLanguageIsContextDependent = false; - } - - cmDeleteAll(linkInterfaceSourcesEntries); -} - -//---------------------------------------------------------------------------- -void cmTarget::GetSourceFiles(std::vector<cmSourceFile*> &files, - const std::string& config) const -{ - - // Lookup any existing link implementation for this configuration. - std::string key = cmSystemTools::UpperCase(config); - - if(!this->LinkImplementationLanguageIsContextDependent) - { - files = this->Internal->SourceFilesMap.begin()->second; - return; - } - - cmTargetInternals::SourceFilesMapType::iterator - it = this->Internal->SourceFilesMap.find(key); - if(it != this->Internal->SourceFilesMap.end()) - { - files = it->second; - } - else - { - std::vector<std::string> srcs; - this->GetSourceFiles(srcs, config); - - std::set<cmSourceFile*> emitted; - - for(std::vector<std::string>::const_iterator i = srcs.begin(); - i != srcs.end(); ++i) - { - cmSourceFile* sf = this->Makefile->GetOrCreateSource(*i); - if (emitted.insert(sf).second) - { - files.push_back(sf); - } - } - this->Internal->SourceFilesMap[key] = files; - } -} - -//---------------------------------------------------------------------------- void cmTarget::AddTracedSources(std::vector<std::string> const& srcs) { - std::string srcFiles = cmJoin(srcs, ";"); - if (!srcFiles.empty()) + if (!srcs.empty()) { - this->Internal->SourceFilesMap.clear(); - this->LinkImplementationLanguageIsContextDependent = true; cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmGeneratorExpression ge(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles); - cge->SetEvaluateForBuildsystem(true); - this->Internal->SourceEntries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge)); + this->Internal->SourceEntries.push_back(cmJoin(srcs, ";")); + this->Internal->SourceBacktraces.push_back(lfbt); } } @@ -810,14 +389,9 @@ void cmTarget::AddSources(std::vector<std::string> const& srcs) } if (!srcFiles.empty()) { - this->Internal->SourceFilesMap.clear(); - this->LinkImplementationLanguageIsContextDependent = true; cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmGeneratorExpression ge(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles); - cge->SetEvaluateForBuildsystem(true); - this->Internal->SourceEntries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge)); + this->Internal->SourceEntries.push_back(srcFiles); + this->Internal->SourceBacktraces.push_back(lfbt); } } @@ -921,10 +495,10 @@ public: } - bool operator()(cmTargetInternals::TargetPropertyEntry* entry) + bool operator()(std::string const& entry) { std::vector<std::string> files; - cmSystemTools::ExpandListArgument(entry->ge->GetInput(), files); + cmSystemTools::ExpandListArgument(entry, files); std::vector<cmSourceFileLocation> locations(files.size()); std::transform(files.begin(), files.end(), locations.begin(), CreateLocation(this->Needle.GetMakefile())); @@ -943,14 +517,9 @@ cmSourceFile* cmTarget::AddSource(const std::string& src) TargetPropertyEntryFinder(sfl)) == this->Internal->SourceEntries.end()) { - this->Internal->SourceFilesMap.clear(); - this->LinkImplementationLanguageIsContextDependent = true; cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmGeneratorExpression ge(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(src); - cge->SetEvaluateForBuildsystem(true); - this->Internal->SourceEntries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge)); + this->Internal->SourceEntries.push_back(src); + this->Internal->SourceBacktraces.push_back(lfbt); } if (cmGeneratorExpression::Find(src) != std::string::npos) { @@ -995,31 +564,6 @@ const std::vector<std::string>& cmTarget::GetLinkDirectories() const } //---------------------------------------------------------------------------- -cmTarget::LinkLibraryType cmTarget::ComputeLinkType( - const std::string& config) const -{ - // No configuration is always optimized. - if(config.empty()) - { - return cmTarget::OPTIMIZED; - } - - // Get the list of configurations considered to be DEBUG. - std::vector<std::string> debugConfigs = - this->Makefile->GetCMakeInstance()->GetDebugConfigs(); - - // Check if any entry in the list matches this configuration. - std::string configUpper = cmSystemTools::UpperCase(config); - if (std::find(debugConfigs.begin(), debugConfigs.end(), configUpper) != - debugConfigs.end()) - { - return cmTarget::DEBUG; - } - // The current configuration is not a debug configuration. - return cmTarget::OPTIMIZED; -} - -//---------------------------------------------------------------------------- void cmTarget::ClearDependencyInformation( cmMakefile& mf, const std::string& target ) { @@ -1048,17 +592,10 @@ void cmTarget::ClearDependencyInformation( cmMakefile& mf, } //---------------------------------------------------------------------------- -bool cmTarget::NameResolvesToFramework(const std::string& libname) const -{ - return this->Makefile->GetGlobalGenerator()-> - NameResolvesToFramework(libname); -} - -//---------------------------------------------------------------------------- std::string cmTarget::GetDebugGeneratorExpressions(const std::string &value, - cmTarget::LinkLibraryType llt) const + cmTargetLinkLibraryType llt) const { - if (llt == GENERAL) + if (llt == GENERAL_LibraryType) { return value; } @@ -1079,7 +616,7 @@ std::string cmTarget::GetDebugGeneratorExpressions(const std::string &value, configString = "$<OR:" + configString + ">"; } - if (llt == OPTIMIZED) + if (llt == OPTIMIZED_LibraryType) { configString = "$<NOT:" + configString + ">"; } @@ -1136,22 +673,23 @@ void cmTarget::GetTllSignatureTraces(std::ostringstream &s, void cmTarget::AddLinkLibrary(cmMakefile& mf, const std::string& target, const std::string& lib, - LinkLibraryType llt) + cmTargetLinkLibraryType llt) { cmTarget *tgt = this->Makefile->FindTargetToUse(lib); { const bool isNonImportedTarget = tgt && !tgt->IsImported(); - const std::string libName = (isNonImportedTarget && llt != GENERAL) - ? targetNameGenex(lib) - : lib; + const std::string libName = + (isNonImportedTarget && llt != GENERAL_LibraryType) + ? targetNameGenex(lib) + : lib; this->AppendProperty("LINK_LIBRARIES", this->GetDebugGeneratorExpressions(libName, llt).c_str()); } if (cmGeneratorExpression::Find(lib) != std::string::npos - || (tgt && tgt->GetType() == INTERFACE_LIBRARY) + || (tgt && tgt->GetType() == cmState::INTERFACE_LIBRARY) || (target == lib )) { return; @@ -1164,7 +702,6 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf, this->LinkLibrariesForVS6.push_back( tmp ); #endif this->OriginalLinkLibraries.push_back(tmp); - this->ClearLinkMaps(); // Add the explicit dependency information for this target. This is // simply a set of libraries separated by ";". There should always @@ -1186,13 +723,13 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf, } switch (llt) { - case cmTarget::GENERAL: + case GENERAL_LibraryType: dependencies += "general"; break; - case cmTarget::DEBUG: + case DEBUG_LibraryType: dependencies += "debug"; break; - case cmTarget::OPTIMIZED: + case OPTIMIZED_LibraryType: dependencies += "optimized"; break; } @@ -1253,6 +790,26 @@ cmBacktraceRange cmTarget::GetCompileDefinitionsBacktraces() const return cmMakeRange(this->Internal->CompileDefinitionsBacktraces); } +cmStringRange cmTarget::GetSourceEntries() const +{ + return cmMakeRange(this->Internal->SourceEntries); +} + +cmBacktraceRange cmTarget::GetSourceBacktraces() const +{ + return cmMakeRange(this->Internal->SourceBacktraces); +} + +cmStringRange cmTarget::GetLinkImplementationEntries() const +{ + return cmMakeRange(this->Internal->LinkImplementationPropertyEntries); +} + +cmBacktraceRange cmTarget::GetLinkImplementationBacktraces() const +{ + return cmMakeRange(this->Internal->LinkImplementationPropertyBacktraces); +} + #if defined(_WIN32) && !defined(__CYGWIN__) //---------------------------------------------------------------------------- void @@ -1506,7 +1063,7 @@ void cmTarget::GatherDependenciesForVS6( const cmMakefile& mf, // Parse the dependency information, which is a set of // type, library pairs separated by ";". There is always a trailing ";". - cmTarget::LinkLibraryType llt = cmTarget::GENERAL; + cmTargetLinkLibraryType llt = GENERAL_LibraryType; std::string depline = deps; std::string::size_type start = 0; std::string::size_type end; @@ -1518,22 +1075,22 @@ void cmTarget::GatherDependenciesForVS6( const cmMakefile& mf, { if (l == "debug") { - llt = cmTarget::DEBUG; + llt = DEBUG_LibraryType; } else if (l == "optimized") { - llt = cmTarget::OPTIMIZED; + llt = OPTIMIZED_LibraryType; } else if (l == "general") { - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; } else { LibraryID lib2(l,llt); this->InsertDependencyForVS6( dep_map, lib, lib2); this->GatherDependenciesForVS6( mf, lib2, dep_map); - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; } } start = end+1; // skip the ; @@ -1581,7 +1138,7 @@ static bool whiteListedInterfaceProperty(const std::string& prop) //---------------------------------------------------------------------------- void cmTarget::SetProperty(const std::string& prop, const char* value) { - if (this->GetType() == INTERFACE_LIBRARY + if (this->GetType() == cmState::INTERFACE_LIBRARY && !whiteListedInterfaceProperty(prop)) { std::ostringstream e; @@ -1601,33 +1158,45 @@ void cmTarget::SetProperty(const std::string& prop, const char* value) { this->Internal->IncludeDirectoriesEntries.clear(); this->Internal->IncludeDirectoriesBacktraces.clear(); - this->Internal->IncludeDirectoriesEntries.push_back(value); - cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - this->Internal->IncludeDirectoriesBacktraces.push_back(lfbt); + if (value) + { + this->Internal->IncludeDirectoriesEntries.push_back(value); + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + this->Internal->IncludeDirectoriesBacktraces.push_back(lfbt); + } } else if(prop == "COMPILE_OPTIONS") { this->Internal->CompileOptionsEntries.clear(); this->Internal->CompileOptionsBacktraces.clear(); - this->Internal->CompileOptionsEntries.push_back(value); - cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - this->Internal->CompileOptionsBacktraces.push_back(lfbt); + if (value) + { + this->Internal->CompileOptionsEntries.push_back(value); + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + this->Internal->CompileOptionsBacktraces.push_back(lfbt); + } } else if(prop == "COMPILE_FEATURES") { this->Internal->CompileFeaturesEntries.clear(); this->Internal->CompileFeaturesBacktraces.clear(); - this->Internal->CompileFeaturesEntries.push_back(value); - cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - this->Internal->CompileFeaturesBacktraces.push_back(lfbt); + if (value) + { + this->Internal->CompileFeaturesEntries.push_back(value); + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + this->Internal->CompileFeaturesBacktraces.push_back(lfbt); + } } else if(prop == "COMPILE_DEFINITIONS") { this->Internal->CompileDefinitionsEntries.clear(); this->Internal->CompileDefinitionsBacktraces.clear(); - this->Internal->CompileDefinitionsEntries.push_back(value); - cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - this->Internal->CompileDefinitionsBacktraces.push_back(lfbt); + if (value) + { + this->Internal->CompileDefinitionsEntries.push_back(value); + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + this->Internal->CompileDefinitionsBacktraces.push_back(lfbt); + } } else if(prop == "EXPORT_NAME" && this->IsImported()) { @@ -1639,11 +1208,12 @@ void cmTarget::SetProperty(const std::string& prop, const char* value) else if (prop == "LINK_LIBRARIES") { this->Internal->LinkImplementationPropertyEntries.clear(); + this->Internal->LinkImplementationPropertyBacktraces.clear(); if (value) { cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmValueWithOrigin entry(value, lfbt); - this->Internal->LinkImplementationPropertyEntries.push_back(entry); + this->Internal->LinkImplementationPropertyEntries.push_back(value); + this->Internal->LinkImplementationPropertyBacktraces.push_back(lfbt); } } else if (prop == "SOURCES") @@ -1656,18 +1226,19 @@ void cmTarget::SetProperty(const std::string& prop, const char* value) this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } - this->Internal->SourceFilesMap.clear(); - cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmGeneratorExpression ge(lfbt); + this->Internal->SourceEntries.clear(); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value); - this->Internal->SourceEntries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge)); + this->Internal->SourceBacktraces.clear(); + if (value) + { + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + this->Internal->SourceEntries.push_back(value); + this->Internal->SourceBacktraces.push_back(lfbt); + } } else { this->Properties.SetProperty(prop, value); - this->MaybeInvalidatePropertyCache(prop); } } @@ -1675,7 +1246,7 @@ void cmTarget::SetProperty(const std::string& prop, const char* value) void cmTarget::AppendProperty(const std::string& prop, const char* value, bool asString) { - if (this->GetType() == INTERFACE_LIBRARY + if (this->GetType() == cmState::INTERFACE_LIBRARY && !whiteListedInterfaceProperty(prop)) { std::ostringstream e; @@ -1693,27 +1264,39 @@ void cmTarget::AppendProperty(const std::string& prop, const char* value, } else if(prop == "INCLUDE_DIRECTORIES") { - this->Internal->IncludeDirectoriesEntries.push_back(value); - cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - this->Internal->IncludeDirectoriesBacktraces.push_back(lfbt); + if (value && *value) + { + this->Internal->IncludeDirectoriesEntries.push_back(value); + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + this->Internal->IncludeDirectoriesBacktraces.push_back(lfbt); + } } else if(prop == "COMPILE_OPTIONS") { - this->Internal->CompileOptionsEntries.push_back(value); - cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - this->Internal->CompileOptionsBacktraces.push_back(lfbt); + if (value && *value) + { + this->Internal->CompileOptionsEntries.push_back(value); + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + this->Internal->CompileOptionsBacktraces.push_back(lfbt); + } } else if(prop == "COMPILE_FEATURES") { - this->Internal->CompileFeaturesEntries.push_back(value); - cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - this->Internal->CompileFeaturesBacktraces.push_back(lfbt); + if (value && *value) + { + this->Internal->CompileFeaturesEntries.push_back(value); + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + this->Internal->CompileFeaturesBacktraces.push_back(lfbt); + } } else if(prop == "COMPILE_DEFINITIONS") { - this->Internal->CompileDefinitionsEntries.push_back(value); - cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - this->Internal->CompileDefinitionsBacktraces.push_back(lfbt); + if (value && *value) + { + this->Internal->CompileDefinitionsEntries.push_back(value); + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + this->Internal->CompileDefinitionsBacktraces.push_back(lfbt); + } } else if(prop == "EXPORT_NAME" && this->IsImported()) { @@ -1724,11 +1307,11 @@ void cmTarget::AppendProperty(const std::string& prop, const char* value, } else if (prop == "LINK_LIBRARIES") { - if (value) + if (value && *value) { cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmValueWithOrigin entry(value, lfbt); - this->Internal->LinkImplementationPropertyEntries.push_back(entry); + this->Internal->LinkImplementationPropertyEntries.push_back(value); + this->Internal->LinkImplementationPropertyBacktraces.push_back(lfbt); } } else if (prop == "SOURCES") @@ -1741,47 +1324,23 @@ void cmTarget::AppendProperty(const std::string& prop, const char* value, this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } - this->Internal->SourceFilesMap.clear(); cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmGeneratorExpression ge(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value); - this->Internal->SourceEntries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge)); + this->Internal->SourceEntries.push_back(value); + this->Internal->SourceBacktraces.push_back(lfbt); } else { this->Properties.AppendProperty(prop, value, asString); - this->MaybeInvalidatePropertyCache(prop); - } -} - -//---------------------------------------------------------------------------- -std::string cmTarget::GetExportName() const -{ - const char *exportName = this->GetProperty("EXPORT_NAME"); - - if (exportName && *exportName) - { - if (!cmGeneratorExpression::IsValidTargetName(exportName)) - { - std::ostringstream e; - e << "EXPORT_NAME property \"" << exportName << "\" for \"" - << this->GetName() << "\": is not valid."; - cmSystemTools::Error(e.str().c_str()); - return ""; - } - return exportName; } - return this->GetName(); } //---------------------------------------------------------------------------- void cmTarget::AppendBuildInterfaceIncludes() { - if(this->GetType() != cmTarget::SHARED_LIBRARY && - this->GetType() != cmTarget::STATIC_LIBRARY && - this->GetType() != cmTarget::MODULE_LIBRARY && - this->GetType() != cmTarget::INTERFACE_LIBRARY && + if(this->GetType() != cmState::SHARED_LIBRARY && + this->GetType() != cmState::STATIC_LIBRARY && + this->GetType() != cmState::MODULE_LIBRARY && + this->GetType() != cmState::INTERFACE_LIBRARY && !this->IsExecutableWithExports()) { return; @@ -1850,20 +1409,6 @@ void cmTarget::InsertCompileDefinition(std::string const& entry, } //---------------------------------------------------------------------------- -void cmTarget::MaybeInvalidatePropertyCache(const std::string& prop) -{ - // Wipe out maps caching information affected by this property. - if(this->IsImported() && cmHasLiteralPrefix(prop, "IMPORTED")) - { - this->Internal->ImportInfoMap.clear(); - } - if(!this->IsImported() && cmHasLiteralPrefix(prop, "LINK_INTERFACE_")) - { - this->ClearLinkMaps(); - } -} - -//---------------------------------------------------------------------------- static void cmTargetCheckLINK_INTERFACE_LIBRARIES( const std::string& prop, const char* value, cmMakefile* context, bool imported) @@ -1958,157 +1503,10 @@ void cmTarget::CheckProperty(const std::string& prop, } //---------------------------------------------------------------------------- -void cmTarget::MarkAsImported() +void cmTarget::MarkAsImported(bool global) { this->IsImportedTarget = true; -} - -//---------------------------------------------------------------------------- -bool cmTarget::HaveWellDefinedOutputFiles() const -{ - return - this->GetType() == cmTarget::STATIC_LIBRARY || - this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY || - this->GetType() == cmTarget::EXECUTABLE; -} - -//---------------------------------------------------------------------------- -cmTarget::OutputInfo const* cmTarget::GetOutputInfo( - const std::string& config) const -{ - // There is no output information for imported targets. - if(this->IsImported()) - { - return 0; - } - - // Only libraries and executables have well-defined output files. - if(!this->HaveWellDefinedOutputFiles()) - { - std::string msg = "cmTarget::GetOutputInfo called for "; - msg += this->GetName(); - msg += " which has type "; - msg += cmTarget::GetTargetTypeName(this->GetType()); - this->GetMakefile()->IssueMessage(cmake::INTERNAL_ERROR, msg); - return 0; - } - - // Lookup/compute/cache the output information for this configuration. - std::string config_upper; - if(!config.empty()) - { - config_upper = cmSystemTools::UpperCase(config); - } - typedef cmTargetInternals::OutputInfoMapType OutputInfoMapType; - OutputInfoMapType::iterator i = - this->Internal->OutputInfoMap.find(config_upper); - if(i == this->Internal->OutputInfoMap.end()) - { - // Add empty info in map to detect potential recursion. - OutputInfo info; - OutputInfoMapType::value_type entry(config_upper, info); - i = this->Internal->OutputInfoMap.insert(entry).first; - - // Compute output directories. - this->ComputeOutputDir(config, false, info.OutDir); - this->ComputeOutputDir(config, true, info.ImpDir); - if(!this->ComputePDBOutputDir("PDB", config, info.PdbDir)) - { - info.PdbDir = info.OutDir; - } - - // Now update the previously-prepared map entry. - i->second = info; - } - else if(i->second.empty()) - { - // An empty map entry indicates we have been called recursively - // from the above block. - this->Makefile->GetCMakeInstance()->IssueMessage( - cmake::FATAL_ERROR, - "Target '" + this->GetName() + "' OUTPUT_DIRECTORY depends on itself.", - this->GetBacktrace()); - return 0; - } - return &i->second; -} - -//---------------------------------------------------------------------------- -std::string cmTarget::GetDirectory(const std::string& config, - bool implib) const -{ - if (this->IsImported()) - { - // Return the directory from which the target is imported. - return - cmSystemTools::GetFilenamePath( - this->ImportedGetFullPath(config, implib)); - } - else if(OutputInfo const* info = this->GetOutputInfo(config)) - { - // Return the directory in which the target will be built. - return implib? info->ImpDir : info->OutDir; - } - return ""; -} - -//---------------------------------------------------------------------------- -std::string cmTarget::GetPDBDirectory(const std::string& config) const -{ - if(OutputInfo const* info = this->GetOutputInfo(config)) - { - // Return the directory in which the target will be built. - return info->PdbDir; - } - return ""; -} - -//---------------------------------------------------------------------------- -const char* cmTarget::ImportedGetLocation(const std::string& config) const -{ - static std::string location; - assert(this->IsImported()); - location = this->ImportedGetFullPath(config, false); - return location.c_str(); -} - -//---------------------------------------------------------------------------- -void cmTarget::GetTargetVersion(int& major, int& minor) const -{ - int patch; - this->GetTargetVersion(false, major, minor, patch); -} - -//---------------------------------------------------------------------------- -void cmTarget::GetTargetVersion(bool soversion, - int& major, int& minor, int& patch) const -{ - // Set the default values. - major = 0; - minor = 0; - patch = 0; - - assert(this->GetType() != INTERFACE_LIBRARY); - - // Look for a VERSION or SOVERSION property. - const char* prop = soversion? "SOVERSION" : "VERSION"; - if(const char* version = this->GetProperty(prop)) - { - // Try to parse the version number and store the results that were - // successfully parsed. - int parsed_major; - int parsed_minor; - int parsed_patch; - switch(sscanf(version, "%d.%d.%d", - &parsed_major, &parsed_minor, &parsed_patch)) - { - case 3: patch = parsed_patch; // no break! - case 2: minor = parsed_minor; // no break! - case 1: major = parsed_major; // no break! - default: break; - } - } + this->ImportedGloballyVisible = global; } //---------------------------------------------------------------------------- @@ -2157,7 +1555,7 @@ const char *cmTarget::GetProperty(const std::string& prop) const const char *cmTarget::GetProperty(const std::string& prop, cmMakefile* context) const { - if (this->GetType() == INTERFACE_LIBRARY + if (this->GetType() == cmState::INTERFACE_LIBRARY && !whiteListedInterfaceProperty(prop)) { std::ostringstream e; @@ -2169,11 +1567,11 @@ const char *cmTarget::GetProperty(const std::string& prop, // Watch for special "computed" properties that are dependent on // other properties or variables. Always recompute them. - if(this->GetType() == cmTarget::EXECUTABLE || - this->GetType() == cmTarget::STATIC_LIBRARY || - this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY || - this->GetType() == cmTarget::UNKNOWN_LIBRARY) + if(this->GetType() == cmState::EXECUTABLE || + this->GetType() == cmState::STATIC_LIBRARY || + this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY || + this->GetType() == cmState::UNKNOWN_LIBRARY) { static const std::string propLOCATION = "LOCATION"; if(prop == propLOCATION) @@ -2201,7 +1599,7 @@ const char *cmTarget::GetProperty(const std::string& prop, // CMake time. cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator(); gg->CreateGenerationObjects(); - cmGeneratorTarget* gt = gg->GetGeneratorTarget(this); + cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName()); this->Properties.SetProperty(propLOCATION, gt->GetLocationForBuild()); } @@ -2226,7 +1624,7 @@ const char *cmTarget::GetProperty(const std::string& prop, { cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator(); gg->CreateGenerationObjects(); - cmGeneratorTarget* gt = gg->GetGeneratorTarget(this); + cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName()); this->Properties.SetProperty( prop, gt->GetFullPath(configName, false).c_str()); } @@ -2250,7 +1648,7 @@ const char *cmTarget::GetProperty(const std::string& prop, { cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator(); gg->CreateGenerationObjects(); - cmGeneratorTarget* gt = gg->GetGeneratorTarget(this); + cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName()); this->Properties.SetProperty( prop, gt->GetFullPath(configName, false).c_str()); } @@ -2296,23 +1694,13 @@ const char *cmTarget::GetProperty(const std::string& prop, } static std::string output; - output = ""; - std::string sep; - for (std::vector<cmValueWithOrigin>::const_iterator - it = this->Internal->LinkImplementationPropertyEntries.begin(), - end = this->Internal->LinkImplementationPropertyEntries.end(); - it != end; ++it) - { - output += sep; - output += it->Value; - sep = ";"; - } + output = cmJoin(this->Internal->LinkImplementationPropertyEntries, ";"); return output.c_str(); } // the type property returns what type the target is else if (prop == propTYPE) { - return cmTarget::GetTargetTypeName(this->GetType()); + return cmState::GetTargetTypeName(this->GetType()); } else if(prop == propINCLUDE_DIRECTORIES) { @@ -2383,13 +1771,11 @@ const char *cmTarget::GetProperty(const std::string& prop, std::ostringstream ss; const char* sep = ""; - typedef cmTargetInternals::TargetPropertyEntry - TargetPropertyEntry; - for(std::vector<TargetPropertyEntry*>::const_iterator + for(std::vector<std::string>::const_iterator i = this->Internal->SourceEntries.begin(); i != this->Internal->SourceEntries.end(); ++i) { - std::string entry = (*i)->ge->GetInput(); + std::string const& entry = *i; std::vector<std::string> files; cmSystemTools::ExpandListArgument(entry, files); @@ -2495,17 +1881,17 @@ const char* cmTarget::GetSuffixVariableInternal(bool implib) const { switch(this->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: return "CMAKE_STATIC_LIBRARY_SUFFIX"; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return (implib ? "CMAKE_IMPORT_LIBRARY_SUFFIX" : "CMAKE_SHARED_LIBRARY_SUFFIX"); - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: return (implib ? "CMAKE_IMPORT_LIBRARY_SUFFIX" : "CMAKE_SHARED_MODULE_SUFFIX"); - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return (implib ? "CMAKE_IMPORT_LIBRARY_SUFFIX" // Android GUI application packages store the native @@ -2524,17 +1910,17 @@ const char* cmTarget::GetPrefixVariableInternal(bool implib) const { switch(this->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: return "CMAKE_STATIC_LIBRARY_PREFIX"; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return (implib ? "CMAKE_IMPORT_LIBRARY_PREFIX" : "CMAKE_SHARED_LIBRARY_PREFIX"); - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: return (implib ? "CMAKE_IMPORT_LIBRARY_PREFIX" : "CMAKE_SHARED_MODULE_PREFIX"); - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return (implib ? "CMAKE_IMPORT_LIBRARY_PREFIX" // Android GUI application packages store the native @@ -2548,148 +1934,76 @@ const char* cmTarget::GetPrefixVariableInternal(bool implib) const } //---------------------------------------------------------------------------- -bool cmTarget::HasMacOSXRpathInstallNameDir(const std::string& config) const +std::string +cmTarget::ImportedGetFullPath(const std::string& config, bool pimplib) const { - bool install_name_is_rpath = false; - bool macosx_rpath = false; + assert(this->IsImported()); - if(!this->IsImportedTarget) + // Lookup/compute/cache the import information for this + // configuration. + std::string config_upper; + if(!config.empty()) { - if(this->GetType() != cmTarget::SHARED_LIBRARY) - { - return false; - } - const char* install_name = this->GetProperty("INSTALL_NAME_DIR"); - bool use_install_name = - this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH"); - if(install_name && use_install_name && - std::string(install_name) == "@rpath") - { - install_name_is_rpath = true; - } - else if(install_name && use_install_name) - { - return false; - } - if(!install_name_is_rpath) - { - macosx_rpath = this->MacOSXRpathInstallNameDirDefault(); - } + config_upper = cmSystemTools::UpperCase(config); } else { - // Lookup the imported soname. - if(cmTarget::ImportInfo const* info = this->GetImportInfo(config)) + config_upper = "NOCONFIG"; + } + + std::string result; + + const char* loc = 0; + const char* imp = 0; + std::string suffix; + + if(this->GetType() != cmState::INTERFACE_LIBRARY + && this->GetMappedConfig(config_upper, &loc, &imp, suffix)) + { + if (!pimplib) { - if(!info->NoSOName && !info->SOName.empty()) + if(loc) { - if(info->SOName.find("@rpath/") == 0) - { - install_name_is_rpath = true; - } + result = loc; } else { - std::string install_name; - cmSystemTools::GuessLibraryInstallName(info->Location, install_name); - if(install_name.find("@rpath") != std::string::npos) + std::string impProp = "IMPORTED_LOCATION"; + impProp += suffix; + if(const char* config_location = this->GetProperty(impProp)) + { + result = config_location; + } + else if(const char* location = + this->GetProperty("IMPORTED_LOCATION")) { - install_name_is_rpath = true; + result = location; } } } - } - - if(!install_name_is_rpath && !macosx_rpath) - { - return false; - } - - if(!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG")) - { - std::ostringstream w; - w << "Attempting to use"; - if(macosx_rpath) - { - w << " MACOSX_RPATH"; - } else { - w << " @rpath"; - } - w << " without CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG being set."; - w << " This could be because you are using a Mac OS X version"; - w << " less than 10.5 or because CMake's platform configuration is"; - w << " corrupt."; - cmake* cm = this->Makefile->GetCMakeInstance(); - cm->IssueMessage(cmake::FATAL_ERROR, w.str(), this->GetBacktrace()); - } - - return true; -} - -//---------------------------------------------------------------------------- -bool cmTarget::MacOSXRpathInstallNameDirDefault() const -{ - // we can't do rpaths when unsupported - if(!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG")) - { - return false; - } - - const char* macosx_rpath_str = this->GetProperty("MACOSX_RPATH"); - if(macosx_rpath_str) - { - return this->GetPropertyAsBool("MACOSX_RPATH"); - } - - cmPolicies::PolicyStatus cmp0042 = this->GetPolicyStatusCMP0042(); - - if(cmp0042 == cmPolicies::WARN) - { - this->Makefile->GetGlobalGenerator()-> - AddCMP0042WarnTarget(this->GetName()); - } - - if(cmp0042 == cmPolicies::NEW) - { - return true; - } - - return false; -} - -//---------------------------------------------------------------------------- -bool cmTarget::IsImportedSharedLibWithoutSOName( - const std::string& config) const -{ - if(this->IsImported() && this->GetType() == cmTarget::SHARED_LIBRARY) - { - if(cmTarget::ImportInfo const* info = this->GetImportInfo(config)) - { - return info->NoSOName; + if(imp) + { + result = imp; + } + else if(this->GetType() == cmState::SHARED_LIBRARY || + this->IsExecutableWithExports()) + { + std::string impProp = "IMPORTED_IMPLIB"; + impProp += suffix; + if(const char* config_implib = this->GetProperty(impProp)) + { + result = config_implib; + } + else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB")) + { + result = implib; + } + } } } - return false; -} -//---------------------------------------------------------------------------- -std::string -cmTarget::GetFullNameImported(const std::string& config, bool implib) const -{ - return cmSystemTools::GetFilenameName( - this->ImportedGetFullPath(config, implib)); -} - -//---------------------------------------------------------------------------- -std::string -cmTarget::ImportedGetFullPath(const std::string& config, bool implib) const -{ - std::string result; - if(cmTarget::ImportInfo const* info = this->GetImportInfo(config)) - { - result = implib? info->ImportLibrary : info->Location; - } if(result.empty()) { result = this->GetName(); @@ -2699,43 +2013,6 @@ cmTarget::ImportedGetFullPath(const std::string& config, bool implib) const } //---------------------------------------------------------------------------- -void cmTarget::ComputeVersionedName(std::string& vName, - std::string const& prefix, - std::string const& base, - std::string const& suffix, - std::string const& name, - const char* version) const -{ - vName = this->IsApple? (prefix+base) : name; - if(version) - { - vName += "."; - vName += version; - } - vName += this->IsApple? suffix : std::string(); -} - -//---------------------------------------------------------------------------- -bool cmTarget::HasImplibGNUtoMS() const -{ - return this->HasImportLibrary() && this->GetPropertyAsBool("GNUtoMS"); -} - -//---------------------------------------------------------------------------- -bool cmTarget::GetImplibGNUtoMS(std::string const& gnuName, - std::string& out, const char* newExt) const -{ - if(this->HasImplibGNUtoMS() && - gnuName.size() > 6 && gnuName.substr(gnuName.size()-6) == ".dll.a") - { - out = gnuName.substr(0, gnuName.size()-6); - out += newExt? newExt : ".lib"; - return true; - } - return false; -} - -//---------------------------------------------------------------------------- void cmTarget::SetPropertyDefault(const std::string& property, const char* default_value) { @@ -2753,383 +2030,15 @@ void cmTarget::SetPropertyDefault(const std::string& property, } } -//---------------------------------------------------------------------------- -bool cmTarget::HaveInstallTreeRPATH() const -{ - const char* install_rpath = this->GetProperty("INSTALL_RPATH"); - return (install_rpath && *install_rpath) && - !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH"); -} - -//---------------------------------------------------------------------------- -const char* cmTarget::GetOutputTargetType(bool implib) const -{ - switch(this->GetType()) - { - case cmTarget::SHARED_LIBRARY: - if(this->DLLPlatform) - { - if(implib) - { - // A DLL import library is treated as an archive target. - return "ARCHIVE"; - } - else - { - // A DLL shared library is treated as a runtime target. - return "RUNTIME"; - } - } - else - { - // For non-DLL platforms shared libraries are treated as - // library targets. - return "LIBRARY"; - } - case cmTarget::STATIC_LIBRARY: - // Static libraries are always treated as archive targets. - return "ARCHIVE"; - case cmTarget::MODULE_LIBRARY: - if(implib) - { - // Module libraries are always treated as library targets. - return "ARCHIVE"; - } - else - { - // Module import libraries are treated as archive targets. - return "LIBRARY"; - } - case cmTarget::EXECUTABLE: - if(implib) - { - // Executable import libraries are treated as archive targets. - return "ARCHIVE"; - } - else - { - // Executables are always treated as runtime targets. - return "RUNTIME"; - } - default: - break; - } - return ""; -} - -//---------------------------------------------------------------------------- -bool cmTarget::ComputeOutputDir(const std::string& config, - bool implib, std::string& out) const -{ - bool usesDefaultOutputDir = false; - std::string conf = config; - - // Look for a target property defining the target output directory - // based on the target type. - std::string targetTypeName = this->GetOutputTargetType(implib); - const char* propertyName = 0; - std::string propertyNameStr = targetTypeName; - if(!propertyNameStr.empty()) - { - propertyNameStr += "_OUTPUT_DIRECTORY"; - propertyName = propertyNameStr.c_str(); - } - - // Check for a per-configuration output directory target property. - std::string configUpper = cmSystemTools::UpperCase(conf); - const char* configProp = 0; - std::string configPropStr = targetTypeName; - if(!configPropStr.empty()) - { - configPropStr += "_OUTPUT_DIRECTORY_"; - configPropStr += configUpper; - configProp = configPropStr.c_str(); - } - - // Select an output directory. - if(const char* config_outdir = this->GetProperty(configProp)) - { - // Use the user-specified per-configuration output directory. - cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = - ge.Parse(config_outdir); - out = cge->Evaluate(this->Makefile, config); - - // Skip per-configuration subdirectory. - conf = ""; - } - else if(const char* outdir = this->GetProperty(propertyName)) - { - // Use the user-specified output directory. - cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = - ge.Parse(outdir); - out = cge->Evaluate(this->Makefile, config); - - // Skip per-configuration subdirectory if the value contained a - // generator expression. - if (out != outdir) - { - conf = ""; - } - } - else if(this->GetType() == cmTarget::EXECUTABLE) - { - // Lookup the output path for executables. - out = this->Makefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH"); - } - else if(this->GetType() == cmTarget::STATIC_LIBRARY || - this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY) - { - // Lookup the output path for libraries. - out = this->Makefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH"); - } - if(out.empty()) - { - // Default to the current output directory. - usesDefaultOutputDir = true; - out = "."; - } - - // Convert the output path to a full path in case it is - // specified as a relative path. Treat a relative path as - // relative to the current output directory for this makefile. - out = (cmSystemTools::CollapseFullPath - (out, this->Makefile->GetCurrentBinaryDirectory())); - - // The generator may add the configuration's subdirectory. - if(!conf.empty()) - { - bool iosPlatform = this->Makefile->PlatformIsAppleIos(); - std::string suffix = - usesDefaultOutputDir && iosPlatform ? "${EFFECTIVE_PLATFORM_NAME}" : ""; - this->Makefile->GetGlobalGenerator()-> - AppendDirectoryForConfig("/", conf, suffix, out); - } - - return usesDefaultOutputDir; -} - -//---------------------------------------------------------------------------- -bool cmTarget::ComputePDBOutputDir(const std::string& kind, - const std::string& config, - std::string& out) const -{ - // Look for a target property defining the target output directory - // based on the target type. - const char* propertyName = 0; - std::string propertyNameStr = kind; - if(!propertyNameStr.empty()) - { - propertyNameStr += "_OUTPUT_DIRECTORY"; - propertyName = propertyNameStr.c_str(); - } - std::string conf = config; - - // Check for a per-configuration output directory target property. - std::string configUpper = cmSystemTools::UpperCase(conf); - const char* configProp = 0; - std::string configPropStr = kind; - if(!configPropStr.empty()) - { - configPropStr += "_OUTPUT_DIRECTORY_"; - configPropStr += configUpper; - configProp = configPropStr.c_str(); - } - - // Select an output directory. - if(const char* config_outdir = this->GetProperty(configProp)) - { - // Use the user-specified per-configuration output directory. - out = config_outdir; - - // Skip per-configuration subdirectory. - conf = ""; - } - else if(const char* outdir = this->GetProperty(propertyName)) - { - // Use the user-specified output directory. - out = outdir; - } - if(out.empty()) - { - return false; - } - - // Convert the output path to a full path in case it is - // specified as a relative path. Treat a relative path as - // relative to the current output directory for this makefile. - out = (cmSystemTools::CollapseFullPath - (out, this->Makefile->GetCurrentBinaryDirectory())); - - // The generator may add the configuration's subdirectory. - if(!conf.empty()) - { - this->Makefile->GetGlobalGenerator()-> - AppendDirectoryForConfig("/", conf, "", out); - } - return true; -} - -//---------------------------------------------------------------------------- -bool cmTarget::UsesDefaultOutputDir(const std::string& config, - bool implib) const -{ - std::string dir; - return this->ComputeOutputDir(config, implib, dir); -} - -//---------------------------------------------------------------------------- -std::string cmTarget::GetFrameworkVersion() const -{ - assert(this->GetType() != INTERFACE_LIBRARY); - - if(const char* fversion = this->GetProperty("FRAMEWORK_VERSION")) - { - return fversion; - } - else if(const char* tversion = this->GetProperty("VERSION")) - { - return tversion; - } - else - { - return "A"; - } -} - -//---------------------------------------------------------------------------- -const char* cmTarget::GetExportMacro() const -{ - // Define the symbol for targets that export symbols. - if(this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY || - this->IsExecutableWithExports()) - { - if(const char* custom_export_name = this->GetProperty("DEFINE_SYMBOL")) - { - this->ExportMacro = custom_export_name; - } - else - { - std::string in = this->GetName(); - in += "_EXPORTS"; - this->ExportMacro = cmSystemTools::MakeCindentifier(in); - } - return this->ExportMacro.c_str(); - } - else - { - return 0; - } -} - -//---------------------------------------------------------------------------- -bool cmTarget::IsNullImpliedByLinkLibraries(const std::string &p) const -{ - return this->LinkImplicitNullProperties.find(p) - != this->LinkImplicitNullProperties.end(); -} - -//---------------------------------------------------------------------------- -void -cmTarget::GetObjectLibrariesCMP0026(std::vector<cmTarget*>& objlibs) const -{ - // At configure-time, this method can be called as part of getting the - // LOCATION property or to export() a file to be include()d. However - // there is no cmGeneratorTarget at configure-time, so search the SOURCES - // for TARGET_OBJECTS instead for backwards compatibility with OLD - // behavior of CMP0024 and CMP0026 only. - typedef cmTargetInternals::TargetPropertyEntry - TargetPropertyEntry; - for(std::vector<TargetPropertyEntry*>::const_iterator - i = this->Internal->SourceEntries.begin(); - i != this->Internal->SourceEntries.end(); ++i) - { - std::string entry = (*i)->ge->GetInput(); - - std::vector<std::string> files; - cmSystemTools::ExpandListArgument(entry, files); - for (std::vector<std::string>::const_iterator - li = files.begin(); li != files.end(); ++li) - { - if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") && - (*li)[li->size() - 1] == '>') - { - std::string objLibName = li->substr(17, li->size()-18); - - if (cmGeneratorExpression::Find(objLibName) != std::string::npos) - { - continue; - } - cmTarget *objLib = this->Makefile->FindTargetToUse(objLibName); - if(objLib) - { - objlibs.push_back(objLib); - } - } - } - } -} - -//---------------------------------------------------------------------------- -cmTarget::ImportInfo const* -cmTarget::GetImportInfo(const std::string& config) const -{ - // There is no imported information for non-imported targets. - if(!this->IsImported()) - { - return 0; - } - - // Lookup/compute/cache the import information for this - // configuration. - std::string config_upper; - if(!config.empty()) - { - config_upper = cmSystemTools::UpperCase(config); - } - else - { - config_upper = "NOCONFIG"; - } - typedef cmTargetInternals::ImportInfoMapType ImportInfoMapType; - - ImportInfoMapType::const_iterator i = - this->Internal->ImportInfoMap.find(config_upper); - if(i == this->Internal->ImportInfoMap.end()) - { - ImportInfo info; - this->ComputeImportInfo(config_upper, info); - ImportInfoMapType::value_type entry(config_upper, info); - i = this->Internal->ImportInfoMap.insert(entry).first; - } - - if(this->GetType() == INTERFACE_LIBRARY) - { - return &i->second; - } - // If the location is empty then the target is not available for - // this configuration. - if(i->second.Location.empty() && i->second.ImportLibrary.empty()) - { - return 0; - } - - // Return the import information. - return &i->second; -} - bool cmTarget::GetMappedConfig(std::string const& desired_config, const char** loc, const char** imp, std::string& suffix) const { - if (this->GetType() == INTERFACE_LIBRARY) + if (this->GetType() == cmState::INTERFACE_LIBRARY) { // This method attempts to find a config-specific LOCATION for the - // IMPORTED library. In the case of INTERFACE_LIBRARY, there is no + // IMPORTED library. In the case of cmState::INTERFACE_LIBRARY, there is no // LOCATION at all, so leaving *loc and *imp unchanged is the appropriate // and valid response. return true; @@ -3253,445 +2162,6 @@ bool cmTarget::GetMappedConfig(std::string const& desired_config, } //---------------------------------------------------------------------------- -void cmTarget::ComputeImportInfo(std::string const& desired_config, - ImportInfo& info) const -{ - // This method finds information about an imported target from its - // properties. The "IMPORTED_" namespace is reserved for properties - // defined by the project exporting the target. - - // Initialize members. - info.NoSOName = false; - - const char* loc = 0; - const char* imp = 0; - std::string suffix; - if (!this->GetMappedConfig(desired_config, &loc, &imp, suffix)) - { - return; - } - - // Get the link interface. - { - std::string linkProp = "INTERFACE_LINK_LIBRARIES"; - const char *propertyLibs = this->GetProperty(linkProp); - - if (this->GetType() != INTERFACE_LIBRARY) - { - if(!propertyLibs) - { - linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES"; - linkProp += suffix; - propertyLibs = this->GetProperty(linkProp); - } - - if(!propertyLibs) - { - linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES"; - propertyLibs = this->GetProperty(linkProp); - } - } - if(propertyLibs) - { - info.LibrariesProp = linkProp; - info.Libraries = propertyLibs; - } - } - if(this->GetType() == INTERFACE_LIBRARY) - { - return; - } - - // A provided configuration has been chosen. Load the - // configuration's properties. - - // Get the location. - if(loc) - { - info.Location = loc; - } - else - { - std::string impProp = "IMPORTED_LOCATION"; - impProp += suffix; - if(const char* config_location = this->GetProperty(impProp)) - { - info.Location = config_location; - } - else if(const char* location = this->GetProperty("IMPORTED_LOCATION")) - { - info.Location = location; - } - } - - // Get the soname. - if(this->GetType() == cmTarget::SHARED_LIBRARY) - { - std::string soProp = "IMPORTED_SONAME"; - soProp += suffix; - if(const char* config_soname = this->GetProperty(soProp)) - { - info.SOName = config_soname; - } - else if(const char* soname = this->GetProperty("IMPORTED_SONAME")) - { - info.SOName = soname; - } - } - - // Get the "no-soname" mark. - if(this->GetType() == cmTarget::SHARED_LIBRARY) - { - std::string soProp = "IMPORTED_NO_SONAME"; - soProp += suffix; - if(const char* config_no_soname = this->GetProperty(soProp)) - { - info.NoSOName = cmSystemTools::IsOn(config_no_soname); - } - else if(const char* no_soname = this->GetProperty("IMPORTED_NO_SONAME")) - { - info.NoSOName = cmSystemTools::IsOn(no_soname); - } - } - - // Get the import library. - if(imp) - { - info.ImportLibrary = imp; - } - else if(this->GetType() == cmTarget::SHARED_LIBRARY || - this->IsExecutableWithExports()) - { - std::string impProp = "IMPORTED_IMPLIB"; - impProp += suffix; - if(const char* config_implib = this->GetProperty(impProp)) - { - info.ImportLibrary = config_implib; - } - else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB")) - { - info.ImportLibrary = implib; - } - } - - // Get the link dependencies. - { - std::string linkProp = "IMPORTED_LINK_DEPENDENT_LIBRARIES"; - linkProp += suffix; - if(const char* config_libs = this->GetProperty(linkProp)) - { - info.SharedDeps = config_libs; - } - else if(const char* libs = - this->GetProperty("IMPORTED_LINK_DEPENDENT_LIBRARIES")) - { - info.SharedDeps = libs; - } - } - - // Get the link languages. - if(this->LinkLanguagePropagatesToDependents()) - { - std::string linkProp = "IMPORTED_LINK_INTERFACE_LANGUAGES"; - linkProp += suffix; - if(const char* config_libs = this->GetProperty(linkProp)) - { - info.Languages = config_libs; - } - else if(const char* libs = - this->GetProperty("IMPORTED_LINK_INTERFACE_LANGUAGES")) - { - info.Languages = libs; - } - } - - // Get the cyclic repetition count. - if(this->GetType() == cmTarget::STATIC_LIBRARY) - { - std::string linkProp = "IMPORTED_LINK_INTERFACE_MULTIPLICITY"; - linkProp += suffix; - if(const char* config_reps = this->GetProperty(linkProp)) - { - sscanf(config_reps, "%u", &info.Multiplicity); - } - else if(const char* reps = - this->GetProperty("IMPORTED_LINK_INTERFACE_MULTIPLICITY")) - { - sscanf(reps, "%u", &info.Multiplicity); - } - } -} - -//---------------------------------------------------------------------------- -void cmTargetInternals::AddInterfaceEntries( - cmTarget const* thisTarget, std::string const& config, - std::string const& prop, std::vector<TargetPropertyEntry*>& entries) -{ - if(cmLinkImplementationLibraries const* impl = - thisTarget->GetLinkImplementationLibraries(config)) - { - for (std::vector<cmLinkImplItem>::const_iterator - it = impl->Libraries.begin(), end = impl->Libraries.end(); - it != end; ++it) - { - if(it->Target) - { - std::string genex = - "$<TARGET_PROPERTY:" + *it + "," + prop + ">"; - cmGeneratorExpression ge(it->Backtrace); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex); - cge->SetEvaluateForBuildsystem(true); - entries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge, *it)); - } - } - } -} - -cmOptionalLinkImplementation& -cmTarget::GetLinkImplMap(std::string const& config) const -{ - // Populate the link implementation for this configuration. - std::string CONFIG = cmSystemTools::UpperCase(config); - return Internal->LinkImplMap[CONFIG][this]; -} - -//---------------------------------------------------------------------------- -cmLinkImplementationLibraries const* -cmTarget::GetLinkImplementationLibraries(const std::string& config) const -{ - return this->GetLinkImplementationLibrariesInternal(config, this); -} - -//---------------------------------------------------------------------------- -cmLinkImplementationLibraries const* -cmTarget::GetLinkImplementationLibrariesInternal(const std::string& config, - cmTarget const* head) const -{ - // There is no link implementation for imported targets. - if(this->IsImported()) - { - return 0; - } - - // Populate the link implementation libraries for this configuration. - std::string CONFIG = cmSystemTools::UpperCase(config); - cmTargetInternals::HeadToLinkImplementationMap& hm = - this->Internal->LinkImplMap[CONFIG]; - - // If the link implementation does not depend on the head target - // then return the one we computed first. - if(!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition) - { - return &hm.begin()->second; - } - - cmOptionalLinkImplementation& impl = hm[head]; - if(!impl.LibrariesDone) - { - impl.LibrariesDone = true; - this->ComputeLinkImplementationLibraries(config, impl, head); - } - return &impl; -} - -//---------------------------------------------------------------------------- -void cmTarget::ComputeLinkImplementationLibraries( - const std::string& config, - cmOptionalLinkImplementation& impl, - cmTarget const* head) const -{ - // Collect libraries directly linked in this configuration. - for (std::vector<cmValueWithOrigin>::const_iterator - le = this->Internal->LinkImplementationPropertyEntries.begin(), - end = this->Internal->LinkImplementationPropertyEntries.end(); - le != end; ++le) - { - std::vector<std::string> llibs; - cmGeneratorExpressionDAGChecker dagChecker( - this->GetName(), - "LINK_LIBRARIES", 0, 0); - cmGeneratorExpression ge(le->Backtrace); - cmsys::auto_ptr<cmCompiledGeneratorExpression> const cge = - ge.Parse(le->Value); - std::string const evaluated = - cge->Evaluate(this->Makefile, config, false, head, &dagChecker); - cmSystemTools::ExpandListArgument(evaluated, llibs); - if(cge->GetHadHeadSensitiveCondition()) - { - impl.HadHeadSensitiveCondition = true; - } - - for(std::vector<std::string>::const_iterator li = llibs.begin(); - li != llibs.end(); ++li) - { - // Skip entries that resolve to the target itself or are empty. - std::string name = this->CheckCMP0004(*li); - if(name == this->GetName() || name.empty()) - { - if(name == this->GetName()) - { - bool noMessage = false; - cmake::MessageType messageType = cmake::FATAL_ERROR; - std::ostringstream e; - switch(this->GetPolicyStatusCMP0038()) - { - case cmPolicies::WARN: - { - e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0038) << "\n"; - messageType = cmake::AUTHOR_WARNING; - } - break; - case cmPolicies::OLD: - noMessage = true; - case cmPolicies::REQUIRED_IF_USED: - case cmPolicies::REQUIRED_ALWAYS: - case cmPolicies::NEW: - // Issue the fatal message. - break; - } - - if(!noMessage) - { - e << "Target \"" << this->GetName() << "\" links to itself."; - this->Makefile->GetCMakeInstance()->IssueMessage( - messageType, e.str(), this->GetBacktrace()); - if (messageType == cmake::FATAL_ERROR) - { - return; - } - } - } - continue; - } - - // The entry is meant for this configuration. - impl.Libraries.push_back( - cmLinkImplItem(name, this->FindTargetToLink(name), - le->Backtrace, evaluated != le->Value)); - } - - std::set<std::string> const& seenProps = cge->GetSeenTargetProperties(); - for (std::set<std::string>::const_iterator it = seenProps.begin(); - it != seenProps.end(); ++it) - { - if (!this->GetProperty(*it)) - { - this->LinkImplicitNullProperties.insert(*it); - } - } - cge->GetMaxLanguageStandard(this, this->MaxLanguageStandards); - } - - cmTarget::LinkLibraryType linkType = this->ComputeLinkType(config); - cmTarget::LinkLibraryVectorType const& oldllibs = - this->GetOriginalLinkLibraries(); - for(cmTarget::LinkLibraryVectorType::const_iterator li = oldllibs.begin(); - li != oldllibs.end(); ++li) - { - if(li->second != cmTarget::GENERAL && li->second != linkType) - { - std::string name = this->CheckCMP0004(li->first); - if(name == this->GetName() || name.empty()) - { - continue; - } - // Support OLD behavior for CMP0003. - impl.WrongConfigLibraries.push_back( - cmLinkItem(name, this->FindTargetToLink(name))); - } - } -} - -//---------------------------------------------------------------------------- -cmTarget const* cmTarget::FindTargetToLink(std::string const& name) const -{ - cmTarget const* tgt = this->Makefile->FindTargetToUse(name); - - // Skip targets that will not really be linked. This is probably a - // name conflict between an external library and an executable - // within the project. - if(tgt && tgt->GetType() == cmTarget::EXECUTABLE && - !tgt->IsExecutableWithExports()) - { - tgt = 0; - } - - if(tgt && tgt->GetType() == cmTarget::OBJECT_LIBRARY) - { - std::ostringstream e; - e << "Target \"" << this->GetName() << "\" links to " - "OBJECT library \"" << tgt->GetName() << "\" but this is not " - "allowed. " - "One may link only to STATIC or SHARED libraries, or to executables " - "with the ENABLE_EXPORTS property set."; - cmake* cm = this->Makefile->GetCMakeInstance(); - cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace()); - tgt = 0; - } - - // Return the target found, if any. - return tgt; -} - -//---------------------------------------------------------------------------- -std::string cmTarget::CheckCMP0004(std::string const& item) const -{ - // Strip whitespace off the library names because we used to do this - // in case variables were expanded at generate time. We no longer - // do the expansion but users link to libraries like " ${VAR} ". - std::string lib = item; - std::string::size_type pos = lib.find_first_not_of(" \t\r\n"); - if(pos != lib.npos) - { - lib = lib.substr(pos, lib.npos); - } - pos = lib.find_last_not_of(" \t\r\n"); - if(pos != lib.npos) - { - lib = lib.substr(0, pos+1); - } - if(lib != item) - { - cmake* cm = this->Makefile->GetCMakeInstance(); - switch(this->GetPolicyStatusCMP0004()) - { - case cmPolicies::WARN: - { - std::ostringstream w; - w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0004) << "\n" - << "Target \"" << this->GetName() << "\" links to item \"" - << item << "\" which has leading or trailing whitespace."; - cm->IssueMessage(cmake::AUTHOR_WARNING, w.str(), - this->GetBacktrace()); - } - case cmPolicies::OLD: - break; - case cmPolicies::NEW: - { - std::ostringstream e; - e << "Target \"" << this->GetName() << "\" links to item \"" - << item << "\" which has leading or trailing whitespace. " - << "This is now an error according to policy CMP0004."; - cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace()); - } - break; - case cmPolicies::REQUIRED_IF_USED: - case cmPolicies::REQUIRED_ALWAYS: - { - std::ostringstream e; - e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0004) << "\n" - << "Target \"" << this->GetName() << "\" links to item \"" - << item << "\" which has leading or trailing whitespace."; - cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace()); - } - break; - } - } - return lib; -} - -//---------------------------------------------------------------------------- cmTargetInternalPointer::cmTargetInternalPointer() { this->Pointer = new cmTargetInternals; @@ -3710,7 +2180,6 @@ cmTargetInternalPointer //---------------------------------------------------------------------------- cmTargetInternalPointer::~cmTargetInternalPointer() { - cmDeleteAll(this->Pointer->SourceEntries); delete this->Pointer; } diff --git a/Source/cmTarget.h b/Source/cmTarget.h index c86ec24..97b0871 100644 --- a/Source/cmTarget.h +++ b/Source/cmTarget.h @@ -16,7 +16,6 @@ #include "cmPropertyMap.h" #include "cmPolicies.h" #include "cmListFileCache.h" -#include "cmLinkItem.h" #include <cmsys/auto_ptr.hxx> #if defined(CMAKE_BUILD_WITH_CMAKE) @@ -27,27 +26,10 @@ # endif #endif -#define CM_FOR_EACH_TARGET_POLICY(F) \ - F(CMP0003) \ - F(CMP0004) \ - F(CMP0008) \ - F(CMP0020) \ - F(CMP0021) \ - F(CMP0022) \ - F(CMP0027) \ - F(CMP0038) \ - F(CMP0041) \ - F(CMP0042) \ - F(CMP0046) \ - F(CMP0052) \ - F(CMP0060) \ - F(CMP0063) - class cmake; class cmMakefile; class cmSourceFile; class cmGlobalGenerator; -class cmComputeLinkInformation; class cmListFileBacktrace; class cmTarget; class cmGeneratorTarget; @@ -77,18 +59,12 @@ class cmTarget { public: cmTarget(); - enum TargetType { EXECUTABLE, STATIC_LIBRARY, - SHARED_LIBRARY, MODULE_LIBRARY, - OBJECT_LIBRARY, UTILITY, GLOBAL_TARGET, - INTERFACE_LIBRARY, - UNKNOWN_LIBRARY}; - static const char* GetTargetTypeName(TargetType targetType); enum CustomCommandType { PRE_BUILD, PRE_LINK, POST_BUILD }; /** * Return the type of target. */ - TargetType GetType() const + cmState::TargetType GetType() const { return this->TargetTypeValue; } @@ -96,13 +72,12 @@ public: /** * Set the target type */ - void SetType(TargetType f, const std::string& name); + void SetType(cmState::TargetType f, const std::string& name); - void MarkAsImported(); + void MarkAsImported(bool global = false); ///! Set/Get the name of the target const std::string& GetName() const {return this->Name;} - std::string GetExportName() const; ///! Set the cmMakefile that owns this target void SetMakefile(cmMakefile *mf); @@ -133,11 +108,6 @@ public: {this->PostBuildCommands.push_back(cmd);} /** - * Get the list of the source files used by this target - */ - void GetSourceFiles(std::vector<cmSourceFile*> &files, - const std::string& config) const; - /** * Add sources to the target. */ void AddSources(std::vector<std::string> const& srcs); @@ -145,28 +115,21 @@ public: cmSourceFile* AddSourceCMP0049(const std::string& src); cmSourceFile* AddSource(const std::string& src); - enum LinkLibraryType {GENERAL, DEBUG, OPTIMIZED}; - //* how we identify a library, by name and type - typedef std::pair<std::string, LinkLibraryType> LibraryID; + typedef std::pair<std::string, cmTargetLinkLibraryType> LibraryID; typedef std::vector<LibraryID > LinkLibraryVectorType; const LinkLibraryVectorType &GetOriginalLinkLibraries() const {return this->OriginalLinkLibraries;} - /** Compute the link type to use for the given configuration. */ - LinkLibraryType ComputeLinkType(const std::string& config) const; - /** * Clear the dependency information recorded for this target, if any. */ void ClearDependencyInformation(cmMakefile& mf, const std::string& target); - // Check to see if a library is a framework and treat it different on Mac - bool NameResolvesToFramework(const std::string& libname) const; void AddLinkLibrary(cmMakefile& mf, const std::string& target, const std::string& lib, - LinkLibraryType llt); + cmTargetLinkLibraryType llt); enum TLLSignature { KeywordTLLSignature, PlainTLLSignature @@ -210,12 +173,8 @@ public: void AddUtility(const std::string& u, cmMakefile *makefile = 0); ///! Get the utilities used by this target std::set<std::string>const& GetUtilities() const { return this->Utilities; } - std::set<cmLinkItem>const& GetUtilityItems() const; cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const; - /** Finalize the target at the end of the Configure step. */ - void FinishConfigure(); - ///! Set/Get a property of this target file void SetProperty(const std::string& prop, const char *value); void AppendProperty(const std::string& prop, const char* value, @@ -226,70 +185,8 @@ public: void CheckProperty(const std::string& prop, cmMakefile* context) const; bool IsImported() const {return this->IsImportedTarget;} - - void GetObjectLibrariesCMP0026(std::vector<cmTarget*>& objlibs) const; - - cmLinkImplementationLibraries const* - GetLinkImplementationLibraries(const std::string& config) const; - - void ComputeLinkImplementationLibraries(const std::string& config, - cmOptionalLinkImplementation& impl, - cmTarget const* head) const; - - cmOptionalLinkImplementation& - GetLinkImplMap(std::string const& config) const; - - cmTarget const* FindTargetToLink(std::string const& name) const; - - /** Strip off leading and trailing whitespace from an item named in - the link dependencies of this target. */ - std::string CheckCMP0004(std::string const& item) const; - - /** Get the directory in which this target will be built. If the - configuration name is given then the generator will add its - subdirectory for that configuration. Otherwise just the canonical - output directory is given. */ - std::string GetDirectory(const std::string& config = "", - bool implib = false) const; - - /** Get the directory in which this targets .pdb files will be placed. - If the configuration name is given then the generator will add its - subdirectory for that configuration. Otherwise just the canonical - pdb output directory is given. */ - std::string GetPDBDirectory(const std::string& config) const; - - const char* ImportedGetLocation(const std::string& config) const; - - /** Get the target major and minor version numbers interpreted from - the VERSION property. Version 0 is returned if the property is - not set or cannot be parsed. */ - void GetTargetVersion(int& major, int& minor) const; - - /** Get the target major, minor, and patch version numbers - interpreted from the VERSION or SOVERSION property. Version 0 - is returned if the property is not set or cannot be parsed. */ - void - GetTargetVersion(bool soversion, int& major, int& minor, int& patch) const; - - /** Whether this library has \@rpath and platform supports it. */ - bool HasMacOSXRpathInstallNameDir(const std::string& config) const; - - /** Whether this library defaults to \@rpath. */ - bool MacOSXRpathInstallNameDirDefault() const; - - /** Test for special case of a third-party shared library that has - no soname at all. */ - bool IsImportedSharedLibWithoutSOName(const std::string& config) const; - - /** Does this target have a GNU implib to convert to MS format? */ - bool HasImplibGNUtoMS() const; - - /** Convert the given GNU import library name (.dll.a) to a name with a new - extension (.lib or ${CMAKE_IMPORT_LIBRARY_SUFFIX}). */ - bool GetImplibGNUtoMS(std::string const& gnuName, std::string& out, - const char* newExt = 0) const; - - bool HaveInstallTreeRPATH() const; + bool IsImportedGloballyVisible() const + { return this->ImportedGloballyVisible; } // Get the properties cmPropertyMap &GetProperties() const { return this->Properties; } @@ -299,53 +196,20 @@ public: const char** imp, std::string& suffix) const; - /** Get the macro to define when building sources in this target. - If no macro should be defined null is returned. */ - const char* GetExportMacro() const; - /** Return whether this target is an executable with symbol exports enabled. */ bool IsExecutableWithExports() const; - /** Return whether this target may be used to link another target. */ - bool IsLinkable() const; - - /** Return whether or not the target is for a DLL platform. */ - bool IsDLLPlatform() const { return this->DLLPlatform; } - - /** Return whether or not the target has a DLL import library. */ - bool HasImportLibrary() const; - /** Return whether this target is a shared library Framework on Apple. */ bool IsFrameworkOnApple() const; - /** Return whether this target is a CFBundle (plugin) on Apple. */ - bool IsCFBundleOnApple() const; - - /** Return whether this target is a XCTest on Apple. */ - bool IsXCTestOnApple() const; - /** Return whether this target is an executable Bundle on Apple. */ bool IsAppBundleOnApple() const; - /** Return the framework version string. Undefined if - IsFrameworkOnApple returns false. */ - std::string GetFrameworkVersion() const; - /** Get a backtrace from the creation of the target. */ cmListFileBacktrace const& GetBacktrace() const; - /** Get a build-tree directory in which to place target support files. */ - std::string GetSupportDirectory() const; - - /** Return whether this target uses the default value for its output - directory. */ - bool UsesDefaultOutputDir(const std::string& config, bool implib) const; - - /** @return whether this target have a well defined output file name. */ - bool HaveWellDefinedOutputFiles() const; - void InsertInclude(std::string const& entry, cmListFileBacktrace const& bt, bool before = false); @@ -357,24 +221,13 @@ public: void AppendBuildInterfaceIncludes(); - bool IsNullImpliedByLinkLibraries(const std::string &p) const; - std::string GetDebugGeneratorExpressions(const std::string &value, - cmTarget::LinkLibraryType llt) const; + cmTargetLinkLibraryType llt) const; void AddSystemIncludeDirectories(const std::set<std::string> &incs); std::set<std::string> const & GetSystemIncludeDirectories() const { return this->SystemIncludeDirectories; } - bool LinkLanguagePropagatesToDependents() const - { return this->TargetTypeValue == STATIC_LIBRARY; } - - std::map<std::string, std::string> const& - GetMaxLanguageStandards() const - { - return this->MaxLanguageStandards; - } - cmStringRange GetIncludeDirectoriesEntries() const; cmBacktraceRange GetIncludeDirectoriesBacktraces() const; @@ -387,11 +240,22 @@ public: cmStringRange GetCompileDefinitionsEntries() const; cmBacktraceRange GetCompileDefinitionsBacktraces() const; + cmStringRange GetSourceEntries() const; + cmBacktraceRange GetSourceBacktraces() const; + cmStringRange GetLinkImplementationEntries() const; + cmBacktraceRange GetLinkImplementationBacktraces() const; + #if defined(_WIN32) && !defined(__CYGWIN__) const LinkLibraryVectorType &GetLinkLibrariesForVS6() const { return this->LinkLibrariesForVS6;} + + void AnalyzeLibDependenciesForVS6( const cmMakefile& mf ); #endif + struct StrictTargetComparison { + bool operator()(cmTarget const* t1, cmTarget const* t2) const; + }; + private: bool HandleLocationPropertyPolicy(cmMakefile* context) const; @@ -444,8 +308,6 @@ private: void GatherDependenciesForVS6( const cmMakefile& mf, const LibraryID& lib, DependencyMap& dep_map); - - void AnalyzeLibDependenciesForVS6( const cmMakefile& mf ); #endif const char* GetSuffixVariableInternal(bool implib) const; @@ -456,31 +318,19 @@ private: void SetPropertyDefault(const std::string& property, const char* default_value); - // Returns ARCHIVE, LIBRARY, or RUNTIME based on platform and type. - const char* GetOutputTargetType(bool implib) const; - - std::string GetFullNameImported(const std::string& config, - bool implib) const; - std::string ImportedGetFullPath(const std::string& config, bool implib) const; - - void GetSourceFiles(std::vector<std::string> &files, - const std::string& config) const; private: mutable cmPropertyMap Properties; std::set<std::string> SystemIncludeDirectories; std::set<std::string> LinkDirectoriesEmmitted; std::set<std::string> Utilities; - mutable std::set<std::string> LinkImplicitNullProperties; std::map<std::string, cmListFileBacktrace> UtilityBacktraces; - mutable std::map<std::string, std::string> MaxLanguageStandards; cmPolicies::PolicyMap PolicyMap; std::string Name; std::string InstallPath; std::string RuntimeInstallPath; - mutable std::string ExportMacro; std::vector<std::string> LinkDirectories; std::vector<cmCustomCommand> PreBuildCommands; std::vector<cmCustomCommand> PreLinkCommands; @@ -493,69 +343,29 @@ private: #endif cmMakefile* Makefile; cmTargetInternalPointer Internal; - TargetType TargetTypeValue; + cmState::TargetType TargetTypeValue; bool HaveInstallRule; bool RecordDependencies; bool DLLPlatform; bool IsAndroid; - bool IsApple; bool IsImportedTarget; + bool ImportedGloballyVisible; bool BuildInterfaceIncludesAppended; - mutable bool DebugSourcesDone; - mutable bool LinkImplementationLanguageIsContextDependent; #if defined(_WIN32) && !defined(__CYGWIN__) bool LinkLibrariesForVS6Analyzed; #endif - // Cache target output paths for each configuration. - struct OutputInfo; - OutputInfo const* GetOutputInfo(const std::string& config) const; - bool - ComputeOutputDir(const std::string& config, - bool implib, std::string& out) const; - bool ComputePDBOutputDir(const std::string& kind, const std::string& config, - std::string& out) const; - - // Cache import information from properties for each configuration. - struct ImportInfo - { - ImportInfo(): NoSOName(false), Multiplicity(0) {} - bool NoSOName; - int Multiplicity; - std::string Location; - std::string SOName; - std::string ImportLibrary; - std::string Languages; - std::string Libraries; - std::string LibrariesProp; - std::string SharedDeps; - }; - - ImportInfo const* GetImportInfo(const std::string& config) const; - void ComputeImportInfo(std::string const& desired_config, - ImportInfo& info) const; - - cmLinkImplementationLibraries const* - GetLinkImplementationLibrariesInternal(const std::string& config, - cmTarget const* head) const; - std::string ProcessSourceItemCMP0049(const std::string& s); - void ClearLinkMaps(); - - void MaybeInvalidatePropertyCache(const std::string& prop); + /** Return whether or not the target has a DLL import library. */ + bool HasImportLibrary() const; // Internal representation details. friend class cmTargetInternals; friend class cmGeneratorTarget; friend class cmTargetTraceDependencies; - void ComputeVersionedName(std::string& vName, - std::string const& prefix, - std::string const& base, - std::string const& suffix, - std::string const& name, - const char* version) const; + cmListFileBacktrace Backtrace; }; #ifdef CMAKE_BUILD_WITH_CMAKE diff --git a/Source/cmTargetExport.h b/Source/cmTargetExport.h index 7665888..2781337 100644 --- a/Source/cmTargetExport.h +++ b/Source/cmTargetExport.h @@ -14,7 +14,7 @@ #include "cmStandardIncludes.h" -class cmTarget; +class cmGeneratorTarget; class cmInstallTargetGenerator; class cmInstallFilesGenerator; @@ -25,7 +25,8 @@ class cmInstallFilesGenerator; class cmTargetExport { public: - cmTarget* Target; ///< The target + std::string TargetName; + cmGeneratorTarget* Target; ///@name Generators ///@{ diff --git a/Source/cmTargetLinkLibrariesCommand.cxx b/Source/cmTargetLinkLibrariesCommand.cxx index b57b921..435346a 100644 --- a/Source/cmTargetLinkLibrariesCommand.cxx +++ b/Source/cmTargetLinkLibrariesCommand.cxx @@ -88,7 +88,7 @@ bool cmTargetLinkLibrariesCommand return true; } - if(this->Target->GetType() == cmTarget::OBJECT_LIBRARY) + if(this->Target->GetType() == cmState::OBJECT_LIBRARY) { std::ostringstream e; e << "Object library target \"" << args[0] << "\" " @@ -98,7 +98,7 @@ bool cmTargetLinkLibrariesCommand return true; } - if (this->Target->GetType() == cmTarget::UTILITY) + if (this->Target->GetType() == cmState::UTILITY) { std::ostringstream e; const char *modal = 0; @@ -136,7 +136,7 @@ bool cmTargetLinkLibrariesCommand } // Keep track of link configuration specifiers. - cmTarget::LinkLibraryType llt = cmTarget::GENERAL; + cmTargetLinkLibraryType llt = GENERAL_LibraryType; bool haveLLT = false; // Start with primary linking and switch to link interface @@ -242,27 +242,27 @@ bool cmTargetLinkLibrariesCommand { if(haveLLT) { - this->LinkLibraryTypeSpecifierWarning(llt, cmTarget::DEBUG); + this->LinkLibraryTypeSpecifierWarning(llt, DEBUG_LibraryType); } - llt = cmTarget::DEBUG; + llt = DEBUG_LibraryType; haveLLT = true; } else if(args[i] == "optimized") { if(haveLLT) { - this->LinkLibraryTypeSpecifierWarning(llt, cmTarget::OPTIMIZED); + this->LinkLibraryTypeSpecifierWarning(llt, OPTIMIZED_LibraryType); } - llt = cmTarget::OPTIMIZED; + llt = OPTIMIZED_LibraryType; haveLLT = true; } else if(args[i] == "general") { if(haveLLT) { - this->LinkLibraryTypeSpecifierWarning(llt, cmTarget::GENERAL); + this->LinkLibraryTypeSpecifierWarning(llt, GENERAL_LibraryType); } - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; haveLLT = true; } else if(haveLLT) @@ -282,7 +282,7 @@ bool cmTargetLinkLibrariesCommand // specifed that a library is both debug and optimized. (this check is // only there for backwards compatibility when mixing projects built // with old versions of CMake and new) - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; std::string linkType = args[0]; linkType += "_LINK_TYPE"; const char* linkTypeString = @@ -291,11 +291,11 @@ bool cmTargetLinkLibrariesCommand { if(strcmp(linkTypeString, "debug") == 0) { - llt = cmTarget::DEBUG; + llt = DEBUG_LibraryType; } if(strcmp(linkTypeString, "optimized") == 0) { - llt = cmTarget::OPTIMIZED; + llt = OPTIMIZED_LibraryType; } } if (!this->HandleLibrary(args[i], llt)) @@ -350,9 +350,9 @@ cmTargetLinkLibrariesCommand //---------------------------------------------------------------------------- bool cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, - cmTarget::LinkLibraryType llt) + cmTargetLinkLibraryType llt) { - if(this->Target->GetType() == cmTarget::INTERFACE_LIBRARY + if(this->Target->GetType() == cmState::INTERFACE_LIBRARY && this->CurrentProcessingState != ProcessingKeywordLinkInterface) { this->Makefile->IssueMessage(cmake::FATAL_ERROR, @@ -428,7 +428,7 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, else if(this->CurrentProcessingState != ProcessingKeywordPublicInterface && this->CurrentProcessingState != ProcessingPlainPublicInterface) { - if (this->Target->GetType() == cmTarget::STATIC_LIBRARY) + if (this->Target->GetType() == cmState::STATIC_LIBRARY) { std::string configLib = this->Target ->GetDebugGeneratorExpressions(lib, llt); @@ -458,7 +458,7 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, return true; } - if (this->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (this->Target->GetType() == cmState::INTERFACE_LIBRARY) { return true; } @@ -469,7 +469,7 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, std::string prop; // Include this library in the link interface for the target. - if(llt == cmTarget::DEBUG || llt == cmTarget::GENERAL) + if(llt == DEBUG_LibraryType || llt == GENERAL_LibraryType) { // Put in the DEBUG configuration interfaces. for(std::vector<std::string>::const_iterator i = debugConfigs.begin(); @@ -480,7 +480,7 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, this->Target->AppendProperty(prop, lib.c_str()); } } - if(llt == cmTarget::OPTIMIZED || llt == cmTarget::GENERAL) + if(llt == OPTIMIZED_LibraryType || llt == GENERAL_LibraryType) { // Put in the non-DEBUG configuration interfaces. this->Target->AppendProperty("LINK_INTERFACE_LIBRARIES", lib.c_str()); diff --git a/Source/cmTargetLinkLibrariesCommand.h b/Source/cmTargetLinkLibrariesCommand.h index 47dd8bd..f061e6d 100644 --- a/Source/cmTargetLinkLibrariesCommand.h +++ b/Source/cmTargetLinkLibrariesCommand.h @@ -62,7 +62,7 @@ private: ProcessingState CurrentProcessingState; - bool HandleLibrary(const std::string& lib, cmTarget::LinkLibraryType llt); + bool HandleLibrary(const std::string& lib, cmTargetLinkLibraryType llt); }; diff --git a/Source/cmTargetPropCommandBase.cxx b/Source/cmTargetPropCommandBase.cxx index 4696de4..bfc19a4 100644 --- a/Source/cmTargetPropCommandBase.cxx +++ b/Source/cmTargetPropCommandBase.cxx @@ -44,12 +44,12 @@ bool cmTargetPropCommandBase this->HandleMissingTarget(args[0]); return false; } - if ((this->Target->GetType() != cmTarget::SHARED_LIBRARY) - && (this->Target->GetType() != cmTarget::STATIC_LIBRARY) - && (this->Target->GetType() != cmTarget::OBJECT_LIBRARY) - && (this->Target->GetType() != cmTarget::MODULE_LIBRARY) - && (this->Target->GetType() != cmTarget::INTERFACE_LIBRARY) - && (this->Target->GetType() != cmTarget::EXECUTABLE)) + if ((this->Target->GetType() != cmState::SHARED_LIBRARY) + && (this->Target->GetType() != cmState::STATIC_LIBRARY) + && (this->Target->GetType() != cmState::OBJECT_LIBRARY) + && (this->Target->GetType() != cmState::MODULE_LIBRARY) + && (this->Target->GetType() != cmState::INTERFACE_LIBRARY) + && (this->Target->GetType() != cmState::EXECUTABLE)) { this->SetError("called with non-compilable target type"); return false; @@ -114,7 +114,7 @@ bool cmTargetPropCommandBase return false; } - if (this->Target->GetType() == cmTarget::INTERFACE_LIBRARY + if (this->Target->GetType() == cmState::INTERFACE_LIBRARY && scope != "INTERFACE") { this->SetError("may only be set INTERFACE properties on INTERFACE " diff --git a/Source/cmTestGenerator.cxx b/Source/cmTestGenerator.cxx index 9d85f5a..b411f15 100644 --- a/Source/cmTestGenerator.cxx +++ b/Source/cmTestGenerator.cxx @@ -13,10 +13,8 @@ #include "cmGeneratorExpression.h" #include "cmOutputConverter.h" -#include "cmMakefile.h" #include "cmLocalGenerator.h" #include "cmSystemTools.h" -#include "cmTarget.h" #include "cmTest.h" //---------------------------------------------------------------------------- @@ -89,8 +87,8 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os, // be translated. std::string exe = command[0]; cmGeneratorTarget* target = - this->LG->GetMakefile()->FindGeneratorTargetToUse(exe); - if(target && target->GetType() == cmTarget::EXECUTABLE) + this->LG->FindGeneratorTargetToUse(exe); + if(target && target->GetType() == cmState::EXECUTABLE) { // Use the target file on disk. exe = target->GetFullPath(config); @@ -117,7 +115,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os, else { // Use the command name given. - exe = ge.Parse(exe.c_str())->Evaluate(this->LG->GetMakefile(), config); + exe = ge.Parse(exe.c_str())->Evaluate(this->LG, config); cmSystemTools::ConvertToUnixSlashes(exe); } @@ -128,7 +126,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os, { os << " " << cmOutputConverter::EscapeForCMake( ge.Parse(*ci)->Evaluate( - this->LG->GetMakefile(), config)); + this->LG, config)); } // Finish the test command. @@ -145,7 +143,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os, { os << " " << i->first << " " << cmOutputConverter::EscapeForCMake( - ge.Parse(i->second.GetValue())->Evaluate(this->LG->GetMakefile(), + ge.Parse(i->second.GetValue())->Evaluate(this->LG, config)); } os << ")" << std::endl; diff --git a/Source/cmUseMangledMesaCommand.h b/Source/cmUseMangledMesaCommand.h index da927c7..1af2bfe 100644 --- a/Source/cmUseMangledMesaCommand.h +++ b/Source/cmUseMangledMesaCommand.h @@ -23,7 +23,6 @@ public: cmExecutionStatus &status); virtual std::string GetName() const { return "use_mangled_mesa";} virtual bool IsScriptable() const { return true; } - virtual bool IsDiscouraged() const { return true; } protected: void CopyAndFullPathMesaHeader(const char* source, const char* outdir); diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx index 486328f..3f1e333 100644 --- a/Source/cmUtilitySourceCommand.cxx +++ b/Source/cmUtilitySourceCommand.cxx @@ -11,8 +11,6 @@ ============================================================================*/ #include "cmUtilitySourceCommand.h" -#include "cmCacheManager.h" - // cmUtilitySourceCommand bool cmUtilitySourceCommand ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &) @@ -54,13 +52,13 @@ bool cmUtilitySourceCommand } else { - cmCacheManager *manager = - this->Makefile->GetCMakeInstance()->GetCacheManager(); + cmState *state = + this->Makefile->GetState(); haveCacheValue = (cacheValue && (strstr(cacheValue, "(IntDir)") == 0 || (intDir && strcmp(intDir, "$(IntDir)") == 0)) && - (manager->GetCacheMajorVersion() != 0 && - manager->GetCacheMinorVersion() != 0 )); + (state->GetCacheMajorVersion() != 0 && + state->GetCacheMinorVersion() != 0 )); } if(haveCacheValue) diff --git a/Source/cmUtilitySourceCommand.h b/Source/cmUtilitySourceCommand.h index 23afdbe..8863ff5 100644 --- a/Source/cmUtilitySourceCommand.h +++ b/Source/cmUtilitySourceCommand.h @@ -22,7 +22,6 @@ public: virtual bool InitialPass(std::vector<std::string> const& args, cmExecutionStatus &status); virtual std::string GetName() const { return "utility_source";} - virtual bool IsDiscouraged() const { return true; } }; #endif diff --git a/Source/cmVariableRequiresCommand.h b/Source/cmVariableRequiresCommand.h index 7e68de1..5b0477f 100644 --- a/Source/cmVariableRequiresCommand.h +++ b/Source/cmVariableRequiresCommand.h @@ -22,7 +22,6 @@ public: virtual bool InitialPass(std::vector<std::string> const& args, cmExecutionStatus &status); virtual std::string GetName() const { return "variable_requires";} - virtual bool IsDiscouraged() const { return true; } }; diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx index 4c380f7..7da00fa 100644 --- a/Source/cmVisualStudio10TargetGenerator.cxx +++ b/Source/cmVisualStudio10TargetGenerator.cxx @@ -9,10 +9,10 @@ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the License for more information. ============================================================================*/ +#include "windows.h" #include "cmVisualStudio10TargetGenerator.h" #include "cmGlobalVisualStudio10Generator.h" #include "cmGeneratorTarget.h" -#include "cmTarget.h" #include "cmComputeLinkInformation.h" #include "cmGeneratedFileStream.h" #include "cmMakefile.h" @@ -166,18 +166,17 @@ static std::string cmVS10EscapeComment(std::string comment) } cmVisualStudio10TargetGenerator:: -cmVisualStudio10TargetGenerator(cmTarget* target, +cmVisualStudio10TargetGenerator(cmGeneratorTarget* target, cmGlobalVisualStudio10Generator* gg) { this->GlobalGenerator = gg; - this->Target = target; - this->GeneratorTarget = gg->GetGeneratorTarget(target); - this->Makefile = target->GetMakefile(); + this->GeneratorTarget = target; + this->Makefile = target->Target->GetMakefile(); this->Makefile->GetConfigurations(this->Configurations); this->LocalGenerator = (cmLocalVisualStudio7Generator*) this->GeneratorTarget->GetLocalGenerator(); - this->Name = this->Target->GetName(); + this->Name = this->GeneratorTarget->GetName(); this->GUID = this->GlobalGenerator->GetGUID(this->Name.c_str()); this->Platform = gg->GetPlatformName(); this->NsightTegra = gg->IsNsightTegra(); @@ -194,8 +193,8 @@ cmVisualStudio10TargetGenerator(cmTarget* target, this->BuildFileStream = 0; this->IsMissingFiles = false; this->DefaultArtifactDir = - this->Makefile->GetCurrentBinaryDirectory() + std::string("/") + - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetCurrentBinaryDirectory() + std::string("/") + + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); } cmVisualStudio10TargetGenerator::~cmVisualStudio10TargetGenerator() @@ -268,16 +267,17 @@ void cmVisualStudio10TargetGenerator::WriteString(const char* line, void cmVisualStudio10TargetGenerator::Generate() { // do not generate external ms projects - if(this->Target->GetType() == cmTarget::INTERFACE_LIBRARY - || this->Target->GetProperty("EXTERNAL_MSPROJECT")) + if(this->GeneratorTarget->GetType() == cmState::INTERFACE_LIBRARY + || this->GeneratorTarget->GetProperty("EXTERNAL_MSPROJECT")) { return; } // Tell the global generator the name of the project file - this->Target->SetProperty("GENERATOR_FILE_NAME",this->Name.c_str()); - this->Target->SetProperty("GENERATOR_FILE_NAME_EXT", + this->GeneratorTarget->Target + ->SetProperty("GENERATOR_FILE_NAME",this->Name.c_str()); + this->GeneratorTarget->Target->SetProperty("GENERATOR_FILE_NAME_EXT", ".vcxproj"); - if(this->Target->GetType() <= cmTarget::OBJECT_LIBRARY) + if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) { if(!this->ComputeClOptions()) { @@ -296,8 +296,7 @@ void cmVisualStudio10TargetGenerator::Generate() return; } } - cmMakefile* mf = this->Target->GetMakefile(); - std::string path = mf->GetCurrentBinaryDirectory(); + std::string path = this->LocalGenerator->GetCurrentBinaryDirectory(); path += "/"; path += this->Name; path += ".vcxproj"; @@ -360,14 +359,15 @@ void cmVisualStudio10TargetGenerator::Generate() this->WriteString("<ProjectGUID>", 2); (*this->BuildFileStream) << "{" << this->GUID << "}</ProjectGUID>\n"; - if(this->MSTools && this->Target->GetType() <= cmTarget::GLOBAL_TARGET) + if(this->MSTools + && this->GeneratorTarget->GetType() <= cmState::GLOBAL_TARGET) { this->WriteApplicationTypeSettings(); this->VerifyNecessaryFiles(); } const char* vsProjectTypes = - this->Target->GetProperty("VS_GLOBAL_PROJECT_TYPES"); + this->GeneratorTarget->GetProperty("VS_GLOBAL_PROJECT_TYPES"); if(vsProjectTypes) { this->WriteString("<ProjectTypes>", 2); @@ -375,9 +375,12 @@ void cmVisualStudio10TargetGenerator::Generate() "</ProjectTypes>\n"; } - const char* vsProjectName = this->Target->GetProperty("VS_SCC_PROJECTNAME"); - const char* vsLocalPath = this->Target->GetProperty("VS_SCC_LOCALPATH"); - const char* vsProvider = this->Target->GetProperty("VS_SCC_PROVIDER"); + const char* vsProjectName = + this->GeneratorTarget->GetProperty("VS_SCC_PROJECTNAME"); + const char* vsLocalPath = + this->GeneratorTarget->GetProperty("VS_SCC_LOCALPATH"); + const char* vsProvider = + this->GeneratorTarget->GetProperty("VS_SCC_PROVIDER"); if( vsProjectName && vsLocalPath && vsProvider ) { @@ -391,7 +394,8 @@ void cmVisualStudio10TargetGenerator::Generate() (*this->BuildFileStream) << cmVS10EscapeXML(vsProvider) << "</SccProvider>\n"; - const char* vsAuxPath = this->Target->GetProperty("VS_SCC_AUXPATH"); + const char* vsAuxPath = + this->GeneratorTarget->GetProperty("VS_SCC_AUXPATH"); if( vsAuxPath ) { this->WriteString("<SccAuxPath>", 2); @@ -400,13 +404,13 @@ void cmVisualStudio10TargetGenerator::Generate() } } - if(this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT")) + if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT")) { this->WriteString("<WinMDAssembly>true</WinMDAssembly>\n", 2); } const char* vsGlobalKeyword = - this->Target->GetProperty("VS_GLOBAL_KEYWORD"); + this->GeneratorTarget->GetProperty("VS_GLOBAL_KEYWORD"); if(!vsGlobalKeyword) { this->WriteString("<Keyword>Win32Proj</Keyword>\n", 2); @@ -419,7 +423,7 @@ void cmVisualStudio10TargetGenerator::Generate() } const char* vsGlobalRootNamespace = - this->Target->GetProperty("VS_GLOBAL_ROOTNAMESPACE"); + this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE"); if(vsGlobalRootNamespace) { this->WriteString("<RootNamespace>", 2); @@ -430,14 +434,14 @@ void cmVisualStudio10TargetGenerator::Generate() this->WriteString("<Platform>", 2); (*this->BuildFileStream) << cmVS10EscapeXML(this->Platform) << "</Platform>\n"; - const char* projLabel = this->Target->GetProperty("PROJECT_LABEL"); + const char* projLabel = this->GeneratorTarget->GetProperty("PROJECT_LABEL"); if(!projLabel) { projLabel = this->Name.c_str(); } this->WriteString("<ProjectName>", 2); (*this->BuildFileStream) << cmVS10EscapeXML(projLabel) << "</ProjectName>\n"; - if(const char* targetFrameworkVersion = this->Target->GetProperty( + if(const char* targetFrameworkVersion = this->GeneratorTarget->GetProperty( "VS_DOTNET_TARGET_FRAMEWORK_VERSION")) { this->WriteString("<TargetFrameworkVersion>", 2); @@ -462,6 +466,7 @@ void cmVisualStudio10TargetGenerator::Generate() this->WriteString("<Import Project=\"" VS10_USER_PROPS "\"" " Condition=\"exists('" VS10_USER_PROPS "')\"" " Label=\"LocalAppDataPlatform\" />\n", 2); + this->WritePlatformExtensions(); this->WriteString("</ImportGroup>\n", 1); this->WriteString("<PropertyGroup Label=\"UserMacros\" />\n", 1); this->WriteWinRTPackageCertificateKeyFile(); @@ -474,6 +479,7 @@ void cmVisualStudio10TargetGenerator::Generate() this->WriteXamlFilesGroup(); this->WriteWinRTReferences(); this->WriteProjectReferences(); + this->WriteSDKReferences(); this->WriteString( "<Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.targets\"" " />\n", 1); @@ -494,7 +500,7 @@ void cmVisualStudio10TargetGenerator::WriteDotNetReferences() { std::vector<std::string> references; if(const char* vsDotNetReferences = - this->Target->GetProperty("VS_DOTNET_REFERENCES")) + this->GeneratorTarget->GetProperty("VS_DOTNET_REFERENCES")) { cmSystemTools::ExpandListArgument(vsDotNetReferences, references); } @@ -540,7 +546,7 @@ void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup() i != this->Configurations.end(); ++i) { this->WritePlatformConfigTag("LogicalName", i->c_str(), 3); - if(this->Target->GetProperty("VS_GLOBAL_ROOTNAMESPACE")) + if(this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE")) { (*this->BuildFileStream ) << "$(RootNamespace)."; } @@ -607,7 +613,7 @@ void cmVisualStudio10TargetGenerator::WriteWinRTReferences() { std::vector<std::string> references; if(const char* vsWinRTReferences = - this->Target->GetProperty("VS_WINRT_REFERENCES")) + this->GeneratorTarget->GetProperty("VS_WINRT_REFERENCES")) { cmSystemTools::ExpandListArgument(vsWinRTReferences, references); } @@ -664,19 +670,19 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues() i->c_str(), 1, " Label=\"Configuration\"", "\n"); std::string configType = "<ConfigurationType>"; - switch(this->Target->GetType()) + switch(this->GeneratorTarget->GetType()) { - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: configType += "DynamicLibrary"; break; - case cmTarget::OBJECT_LIBRARY: - case cmTarget::STATIC_LIBRARY: + case cmState::OBJECT_LIBRARY: + case cmState::STATIC_LIBRARY: configType += "StaticLibrary"; break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: if(this->NsightTegra && - !this->Target->GetPropertyAsBool("ANDROID_GUI")) + !this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI")) { // Android executables are .so too. configType += "DynamicLibrary"; @@ -686,8 +692,8 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues() configType += "Application"; } break; - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: if(this->NsightTegra) { // Tegra-Android platform does not understand "Utility". @@ -698,8 +704,8 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues() configType += "Utility"; } break; - case cmTarget::UNKNOWN_LIBRARY: - case cmTarget::INTERFACE_LIBRARY: + case cmState::UNKNOWN_LIBRARY: + case cmState::INTERFACE_LIBRARY: break; } configType += "</ConfigurationType>\n"; @@ -725,7 +731,8 @@ void cmVisualStudio10TargetGenerator cmGlobalVisualStudio10Generator* gg = static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator); const char* mfcFlag = - this->Target->GetMakefile()->GetDefinition("CMAKE_MFC_FLAG"); + this->GeneratorTarget-> + Target->GetMakefile()->GetDefinition("CMAKE_MFC_FLAG"); std::string mfcFlagValue = mfcFlag ? mfcFlag : "0"; std::string useOfMfcValue = "false"; @@ -741,16 +748,16 @@ void cmVisualStudio10TargetGenerator mfcLine += useOfMfcValue + "</UseOfMfc>\n"; this->WriteString(mfcLine.c_str(), 2); - if((this->Target->GetType() <= cmTarget::OBJECT_LIBRARY && + if((this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY && this->ClOptions[config]->UsingUnicode()) || - this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT") || + this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") || this->GlobalGenerator->TargetsWindowsPhone() || this->GlobalGenerator->TargetsWindowsStore() || - this->Target->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) + this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) { this->WriteString("<CharacterSet>Unicode</CharacterSet>\n", 2); } - else if (this->Target->GetType() <= cmTarget::MODULE_LIBRARY && + else if (this->GeneratorTarget->GetType() <= cmState::MODULE_LIBRARY && this->ClOptions[config]->UsingSBCS()) { this->WriteString("<CharacterSet>NotSet</CharacterSet>\n", 2); @@ -766,8 +773,8 @@ void cmVisualStudio10TargetGenerator pts += "</PlatformToolset>\n"; this->WriteString(pts.c_str(), 2); } - if(this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT") || - this->Target->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) + if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") || + this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) { this->WriteString("<WindowsAppContainer>true" "</WindowsAppContainer>\n", 2); @@ -785,27 +792,29 @@ void cmVisualStudio10TargetGenerator ntv += toolset? toolset : "Default"; ntv += "</NdkToolchainVersion>\n"; this->WriteString(ntv.c_str(), 2); - if(const char* minApi = this->Target->GetProperty("ANDROID_API_MIN")) + if(const char* minApi = + this->GeneratorTarget->GetProperty("ANDROID_API_MIN")) { this->WriteString("<AndroidMinAPI>", 2); (*this->BuildFileStream ) << "android-" << cmVS10EscapeXML(minApi) << "</AndroidMinAPI>\n"; } - if(const char* api = this->Target->GetProperty("ANDROID_API")) + if(const char* api = this->GeneratorTarget->GetProperty("ANDROID_API")) { this->WriteString("<AndroidTargetAPI>", 2); (*this->BuildFileStream ) << "android-" << cmVS10EscapeXML(api) << "</AndroidTargetAPI>\n"; } - if(const char* cpuArch = this->Target->GetProperty("ANDROID_ARCH")) + if(const char* cpuArch = this->GeneratorTarget->GetProperty("ANDROID_ARCH")) { this->WriteString("<AndroidArch>", 2); (*this->BuildFileStream) << cmVS10EscapeXML(cpuArch) << "</AndroidArch>\n"; } - if(const char* stlType = this->Target->GetProperty("ANDROID_STL_TYPE")) + if(const char* stlType = + this->GeneratorTarget->GetProperty("ANDROID_STL_TYPE")) { this->WriteString("<AndroidStlType>", 2); (*this->BuildFileStream) << cmVS10EscapeXML(stlType) << @@ -871,6 +880,9 @@ cmVisualStudio10TargetGenerator::WriteCustomRule(cmSourceFile const* source, fout << "# generated from CMake\n"; fout.flush(); fout.close(); + // Force given file to have a very old timestamp, thus + // preventing dependent rebuilds. + this->ForceOld(sourcePath); } else { @@ -945,7 +957,7 @@ cmVisualStudio10TargetGenerator::ConvertPath(std::string const& path, { return forceRelative ? cmSystemTools::RelativePath( - this->Makefile->GetCurrentBinaryDirectory(), path.c_str()) + this->LocalGenerator->GetCurrentBinaryDirectory(), path.c_str()) : path.c_str(); } @@ -984,7 +996,7 @@ void cmVisualStudio10TargetGenerator::WriteGroups() this->AddMissingSourceGroups(groupsUsed, sourceGroups); // Write out group file - std::string path = this->Makefile->GetCurrentBinaryDirectory(); + std::string path = this->LocalGenerator->GetCurrentBinaryDirectory(); path += "/"; path += this->Name; path += ".vcxproj.filters"; @@ -1299,10 +1311,15 @@ void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf) { tool = "Image"; } + else if(ext == "resw") + { + tool = "PRIResource"; + } else if(ext == "xml") { tool = "XML"; } + if(this->NsightTegra) { // Nsight Tegra needs specific file types to check up-to-dateness. @@ -1364,7 +1381,7 @@ void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf) } for(size_t i = 0; i != this->Configurations.size(); ++i) { - if(0 == strcmp(cge->Evaluate(this->Makefile, + if(0 == strcmp(cge->Evaluate(this->LocalGenerator, this->Configurations[i]), "1")) { this->WriteString("<DeploymentContent Condition=\"" @@ -1441,7 +1458,7 @@ void cmVisualStudio10TargetGenerator::WriteSource( std::string sourceRel = this->ConvertPath(sf->GetFullPath(), true); size_t const maxLen = 250; if(sf->GetCustomCommand() || - ((strlen(this->Makefile->GetCurrentBinaryDirectory()) + 1 + + ((strlen(this->LocalGenerator->GetCurrentBinaryDirectory()) + 1 + sourceRel.length()) <= maxLen)) { forceRelative = true; @@ -1449,7 +1466,8 @@ void cmVisualStudio10TargetGenerator::WriteSource( } else { - this->GlobalGenerator->PathTooLong(this->Target, sf, sourceRel); + this->GlobalGenerator->PathTooLong(this->GeneratorTarget, + sf, sourceRel); } } this->ConvertToWindowsSlash(sourceFile); @@ -1474,7 +1492,7 @@ void cmVisualStudio10TargetGenerator::WriteSources( void cmVisualStudio10TargetGenerator::WriteAllSources() { - if(this->Target->GetType() > cmTarget::UTILITY) + if(this->GeneratorTarget->GetType() > cmState::UTILITY) { return; } @@ -1736,8 +1754,8 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags( void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions() { - cmTarget::TargetType ttype = this->Target->GetType(); - if(ttype > cmTarget::GLOBAL_TARGET) + cmState::TargetType ttype = this->GeneratorTarget->GetType(); + if(ttype > cmState::GLOBAL_TARGET) { return; } @@ -1749,7 +1767,7 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions() config = this->Configurations.begin(); config != this->Configurations.end(); ++config) { - if(ttype >= cmTarget::UTILITY) + if(ttype >= cmState::UTILITY) { this->WritePlatformConfigTag("IntDir", config->c_str(), 3); *this->BuildFileStream @@ -1759,21 +1777,21 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions() else { std::string intermediateDir = this->LocalGenerator-> - GetTargetDirectory(*this->Target); + GetTargetDirectory(this->GeneratorTarget); intermediateDir += "/"; intermediateDir += *config; intermediateDir += "/"; std::string outDir; std::string targetNameFull; - if(ttype == cmTarget::OBJECT_LIBRARY) + if(ttype == cmState::OBJECT_LIBRARY) { outDir = intermediateDir; - targetNameFull = this->Target->GetName(); + targetNameFull = this->GeneratorTarget->GetName(); targetNameFull += ".lib"; } else { - outDir = this->Target->GetDirectory(config->c_str()) + "/"; + outDir = this->GeneratorTarget->GetDirectory(config->c_str()) + "/"; targetNameFull = this->GeneratorTarget->GetFullName(config->c_str()); } this->ConvertToWindowsSlash(intermediateDir); @@ -1821,8 +1839,8 @@ OutputLinkIncremental(std::string const& configName) } // static libraries and things greater than modules do not need // to set this option - if(this->Target->GetType() == cmTarget::STATIC_LIBRARY - || this->Target->GetType() > cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY + || this->GeneratorTarget->GetType() > cmState::MODULE_LIBRARY) { return; } @@ -1902,12 +1920,12 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions( std::string baseFlagVar = "CMAKE_"; baseFlagVar += linkLanguage; baseFlagVar += "_FLAGS"; - flags = this-> + flags = this->GeneratorTarget-> Target->GetMakefile()->GetRequiredDefinition(baseFlagVar.c_str()); std::string flagVar = baseFlagVar + std::string("_") + cmSystemTools::UpperCase(configName); flags += " "; - flags += this-> + flags += this->GeneratorTarget-> Target->GetMakefile()->GetRequiredDefinition(flagVar.c_str()); } // set the correct language @@ -1919,11 +1937,12 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions( { clOptions.AddFlag("CompileAs", "CompileAsCpp"); } - this->LocalGenerator->AddCompileOptions(flags, this->Target, + this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, linkLanguage, configName.c_str()); // Get preprocessor definitions for this directory. - std::string defineFlags = this->Target->GetMakefile()->GetDefineFlags(); + std::string defineFlags = + this->GeneratorTarget->Target->GetMakefile()->GetDefineFlags(); if(this->MSTools) { clOptions.FixExceptionHandlingDefault(); @@ -1948,7 +1967,8 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions( configDefine += configName; configDefine += "\""; clOptions.AddDefine(configDefine); - if(const char* exportMacro = this->Target->GetExportMacro()) + if(const char* exportMacro = + this->GeneratorTarget->GetExportMacro()) { clOptions.AddDefine(exportMacro); } @@ -1956,12 +1976,12 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions( if (this->MSTools) { // If we have the VS_WINRT_COMPONENT set then force Compile as WinRT. - if (this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT")) + if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT")) { clOptions.AddFlag("CompileAsWinRT", "true"); // For WinRT components, add the _WINRT_DLL define to produce a lib - if (this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY ) + if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY || + this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY ) { clOptions.AddDefine("_WINRT_DLL"); } @@ -2005,7 +2025,7 @@ void cmVisualStudio10TargetGenerator::WriteClOptions( if(this->NsightTegra) { if(const char* processMax = - this->Target->GetProperty("ANDROID_PROCESS_MAX")) + this->GeneratorTarget->GetProperty("ANDROID_PROCESS_MAX")) { this->WriteString("<ProcessMax>", 3); *this->BuildFileStream << cmVS10EscapeXML(processMax) << @@ -2169,14 +2189,14 @@ WriteMasmOptions(std::string const& configName, void cmVisualStudio10TargetGenerator::WriteLibOptions(std::string const& config) { - if(this->Target->GetType() != cmTarget::STATIC_LIBRARY && - this->Target->GetType() != cmTarget::OBJECT_LIBRARY) + if(this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY && + this->GeneratorTarget->GetType() != cmState::OBJECT_LIBRARY) { return; } std::string libflags; this->LocalGenerator->GetStaticLibraryFlags(libflags, - cmSystemTools::UpperCase(config), this->Target); + cmSystemTools::UpperCase(config), this->GeneratorTarget); if(!libflags.empty()) { this->WriteString("<Lib>\n", 2); @@ -2203,6 +2223,33 @@ cmVisualStudio10TargetGenerator::WriteLibOptions(std::string const& config) } } +void cmVisualStudio10TargetGenerator::WriteManifestOptions( + std::string const& config) +{ + if (this->GeneratorTarget->GetType() != cmState::EXECUTABLE && + this->GeneratorTarget->GetType() != cmState::SHARED_LIBRARY && + this->GeneratorTarget->GetType() != cmState::MODULE_LIBRARY) + { + return; + } + + std::vector<cmSourceFile const*> manifest_srcs; + this->GeneratorTarget->GetManifests(manifest_srcs, config); + if (!manifest_srcs.empty()) + { + this->WriteString("<Manifest>\n", 2); + this->WriteString("<AdditionalManifestFiles>", 3); + for (std::vector<cmSourceFile const*>::const_iterator + mi = manifest_srcs.begin(); mi != manifest_srcs.end(); ++mi) + { + std::string m = this->ConvertPath((*mi)->GetFullPath(), false); + this->ConvertToWindowsSlash(m); + (*this->BuildFileStream) << m << ";"; + } + (*this->BuildFileStream) << "</AdditionalManifestFiles>\n"; + this->WriteString("</Manifest>\n", 2); + } +} //---------------------------------------------------------------------------- void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( @@ -2210,7 +2257,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( { // Look through the sources for AndroidManifest.xml and use // its location as the root source directory. - std::string rootDir = this->Makefile->GetCurrentSourceDirectory(); + std::string rootDir = this->LocalGenerator->GetCurrentSourceDirectory(); { std::vector<cmSourceFile const*> extraSources; this->GeneratorTarget->GetExtraSources(extraSources, ""); @@ -2236,18 +2283,18 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( cmVS10EscapeXML(antBuildPath) << "</AntBuildPath>\n"; } - if (this->Target->GetPropertyAsBool("ANDROID_SKIP_ANT_STEP")) + if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_SKIP_ANT_STEP")) { this->WriteString("<SkipAntStep>true</SkipAntStep>\n", 3); } - if (this->Target->GetPropertyAsBool("ANDROID_PROGUARD")) + if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_PROGUARD")) { this->WriteString("<EnableProGuard>true</EnableProGuard>\n", 3); } if (const char* proGuardConfigLocation = - this->Target->GetProperty("ANDROID_PROGUARD_CONFIG_PATH")) + this->GeneratorTarget->GetProperty("ANDROID_PROGUARD_CONFIG_PATH")) { this->WriteString("<ProGuardConfigLocation>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(proGuardConfigLocation) << @@ -2255,7 +2302,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( } if (const char* securePropertiesLocation = - this->Target->GetProperty("ANDROID_SECURE_PROPS_PATH")) + this->GeneratorTarget->GetProperty("ANDROID_SECURE_PROPS_PATH")) { this->WriteString("<SecurePropertiesLocation>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(securePropertiesLocation) << @@ -2263,31 +2310,33 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( } if (const char* nativeLibDirectoriesExpression = - this->Target->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES")) + this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES")) { cmGeneratorExpression ge; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(nativeLibDirectoriesExpression); - std::string nativeLibDirs = cge->Evaluate(this->Makefile, configName); + std::string nativeLibDirs = cge->Evaluate(this->LocalGenerator, + configName); this->WriteString("<NativeLibDirectories>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDirs) << "</NativeLibDirectories>\n"; } if (const char* nativeLibDependenciesExpression = - this->Target->GetProperty("ANDROID_NATIVE_LIB_DEPENDENCIES")) + this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DEPENDENCIES")) { cmGeneratorExpression ge; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(nativeLibDependenciesExpression); - std::string nativeLibDeps = cge->Evaluate(this->Makefile, configName); + std::string nativeLibDeps = cge->Evaluate(this->LocalGenerator, + configName); this->WriteString("<NativeLibDependencies>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDeps) << "</NativeLibDependencies>\n"; } if (const char* javaSourceDir = - this->Target->GetProperty("ANDROID_JAVA_SOURCE_DIR")) + this->GeneratorTarget->GetProperty("ANDROID_JAVA_SOURCE_DIR")) { this->WriteString("<JavaSourceDir>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(javaSourceDir) << @@ -2295,19 +2344,20 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( } if (const char* jarDirectoriesExpression = - this->Target->GetProperty("ANDROID_JAR_DIRECTORIES")) + this->GeneratorTarget->GetProperty("ANDROID_JAR_DIRECTORIES")) { cmGeneratorExpression ge; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(jarDirectoriesExpression); - std::string jarDirectories = cge->Evaluate(this->Makefile, configName); + std::string jarDirectories = cge->Evaluate(this->LocalGenerator, + configName); this->WriteString("<JarDirectories>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(jarDirectories) << "</JarDirectories>\n"; } if (const char* jarDeps = - this->Target->GetProperty("ANDROID_JAR_DEPENDENCIES")) + this->GeneratorTarget->GetProperty("ANDROID_JAR_DEPENDENCIES")) { this->WriteString("<JarDependencies>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(jarDeps) << @@ -2315,7 +2365,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( } if (const char* assetsDirectories = - this->Target->GetProperty("ANDROID_ASSETS_DIRECTORIES")) + this->GeneratorTarget->GetProperty("ANDROID_ASSETS_DIRECTORIES")) { this->WriteString("<AssetsDirectories>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(assetsDirectories) << @@ -2331,7 +2381,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( } if (const char* antAdditionalOptions = - this->Target->GetProperty("ANDROID_ANT_ADDITIONAL_OPTIONS")) + this->GeneratorTarget->GetProperty("ANDROID_ANT_ADDITIONAL_OPTIONS")) { this->WriteString("<AdditionalOptions>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(antAdditionalOptions) << @@ -2344,9 +2394,9 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( //---------------------------------------------------------------------------- bool cmVisualStudio10TargetGenerator::ComputeLinkOptions() { - if(this->Target->GetType() == cmTarget::EXECUTABLE || - this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE || + this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY || + this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) { for(std::vector<std::string>::const_iterator i = this->Configurations.begin(); @@ -2383,11 +2433,11 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) std::string CONFIG = cmSystemTools::UpperCase(config); const char* linkType = "SHARED"; - if(this->Target->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) { linkType = "MODULE"; } - if(this->Target->GetType() == cmTarget::EXECUTABLE) + if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { linkType = "EXE"; } @@ -2396,13 +2446,14 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) linkFlagVarBase += linkType; linkFlagVarBase += "_LINKER_FLAGS"; flags += " "; - flags += this-> + flags += this->GeneratorTarget-> Target->GetMakefile()->GetRequiredDefinition(linkFlagVarBase.c_str()); std::string linkFlagVar = linkFlagVarBase + "_" + CONFIG; flags += " "; - flags += this-> + flags += this->GeneratorTarget-> Target->GetMakefile()->GetRequiredDefinition(linkFlagVar.c_str()); - const char* targetLinkFlags = this->Target->GetProperty("LINK_FLAGS"); + const char* targetLinkFlags = + this->GeneratorTarget->GetProperty("LINK_FLAGS"); if(targetLinkFlags) { flags += " "; @@ -2410,7 +2461,8 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) } std::string flagsProp = "LINK_FLAGS_"; flagsProp += CONFIG; - if(const char* flagsConfig = this->Target->GetProperty(flagsProp.c_str())) + if(const char* flagsConfig = + this->GeneratorTarget->GetProperty(flagsProp.c_str())) { flags += " "; flags += flagsConfig; @@ -2470,7 +2522,7 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) std::string targetNameFull; std::string targetNameImport; std::string targetNamePDB; - if(this->Target->GetType() == cmTarget::EXECUTABLE) + if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { this->GeneratorTarget->GetExecutableNames(targetName, targetNameFull, targetNameImport, targetNamePDB, @@ -2488,12 +2540,12 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) { linkOptions.AddFlag("Version", ""); - if ( this->Target->GetPropertyAsBool("WIN32_EXECUTABLE") ) + if ( this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE") ) { if (this->GlobalGenerator->TargetsWindowsCE()) { linkOptions.AddFlag("SubSystem", "WindowsCE"); - if (this->Target->GetType() == cmTarget::EXECUTABLE) + if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { if (this->ClOptions[config]->UsingUnicode()) { @@ -2515,7 +2567,7 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) if (this->GlobalGenerator->TargetsWindowsCE()) { linkOptions.AddFlag("SubSystem", "WindowsCE"); - if (this->Target->GetType() == cmTarget::EXECUTABLE) + if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { if (this->ClOptions[config]->UsingUnicode()) { @@ -2547,10 +2599,11 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) { linkOptions.AddFlag("GenerateDebugInformation", "false"); } - std::string pdb = this->Target->GetPDBDirectory(config.c_str()); + std::string pdb = this->GeneratorTarget->GetPDBDirectory(config.c_str()); pdb += "/"; pdb += targetNamePDB; - std::string imLib = this->Target->GetDirectory(config.c_str(), true); + std::string imLib = + this->GeneratorTarget->GetDirectory(config.c_str(), true); imLib += "/"; imLib += targetNameImport; @@ -2559,7 +2612,8 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) // A Windows Runtime component uses internal .NET metadata, // so does not have an import library. - if(this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT")) + if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") && + this->GeneratorTarget->GetType() != cmState::EXECUTABLE) { linkOptions.AddFlag("GenerateWindowsMetadata", "true"); } @@ -2597,10 +2651,10 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) "%(IgnoreSpecificDefaultLibraries)"); } - if (this->Target->GetType() == cmTarget::SHARED_LIBRARY && + if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if (this->Target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if (this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { linkOptions.AddFlag("ModuleDefinitionFile", "$(IntDir)exportall.def"); } @@ -2614,8 +2668,8 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) void cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const& config) { - if(this->Target->GetType() == cmTarget::STATIC_LIBRARY - || this->Target->GetType() > cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY + || this->GeneratorTarget->GetType() > cmState::MODULE_LIBRARY) { return; } @@ -2626,11 +2680,12 @@ cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const& config) linkOptions.OutputFlagMap(*this->BuildFileStream, " "); this->WriteString("</Link>\n", 2); - if(!this->GlobalGenerator->NeedLinkLibraryDependencies(*this->Target)) + if(!this->GlobalGenerator->NeedLinkLibraryDependencies( + this->GeneratorTarget)) { this->WriteString("<ProjectReference>\n", 2); this->WriteString( - " <LinkLibraryDependencies>false</LinkLibraryDependencies>\n", 2); + "<LinkLibraryDependencies>false</LinkLibraryDependencies>\n", 3); this->WriteString("</ProjectReference>\n", 2); } } @@ -2653,7 +2708,7 @@ void cmVisualStudio10TargetGenerator::AddLibraries( libVec.push_back(path); } else if (!l->Target - || l->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + || l->Target->GetType() != cmState::INTERFACE_LIBRARY) { libVec.push_back(l->Value); } @@ -2725,7 +2780,7 @@ void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups() this->WritePlatformConfigTag("ItemDefinitionGroup", i->c_str(), 1); *this->BuildFileStream << "\n"; // output cl compile flags <ClCompile></ClCompile> - if(this->Target->GetType() <= cmTarget::OBJECT_LIBRARY) + if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) { this->WriteClOptions(*i, includes); // output rc compile flags <ResourceCompile></ResourceCompile> @@ -2740,9 +2795,11 @@ void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups() this->WriteLinkOptions(*i); // output lib flags <Lib></Lib> this->WriteLibOptions(*i); + // output manifest flags <Manifest></Manifest> + this->WriteManifestOptions(*i); if(this->NsightTegra && - this->Target->GetType() == cmTarget::EXECUTABLE && - this->Target->GetPropertyAsBool("ANDROID_GUI")) + this->GeneratorTarget->GetType() == cmState::EXECUTABLE && + this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI")) { this->WriteAntBuildOptions(*i); } @@ -2754,14 +2811,14 @@ void cmVisualStudio10TargetGenerator::WriteEvents(std::string const& configName) { bool addedPrelink = false; - if (this->Target->GetType() == cmTarget::SHARED_LIBRARY && + if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if (this->Target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if (this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { addedPrelink = true; std::vector<cmCustomCommand> commands = - this->Target->GetPreLinkCommands(); + this->GeneratorTarget->GetPreLinkCommands(); this->GlobalGenerator->AddSymbolExportCommand( this->GeneratorTarget, commands, configName); this->WriteEvent("PreLinkEvent", commands, configName); @@ -2770,12 +2827,12 @@ cmVisualStudio10TargetGenerator::WriteEvents(std::string const& configName) if (!addedPrelink) { this->WriteEvent("PreLinkEvent", - this->Target->GetPreLinkCommands(), configName); + this->GeneratorTarget->GetPreLinkCommands(), configName); } this->WriteEvent("PreBuildEvent", - this->Target->GetPreBuildCommands(), configName); + this->GeneratorTarget->GetPreBuildCommands(), configName); this->WriteEvent("PostBuildEvent", - this->Target->GetPostBuildCommands(), configName); + this->GeneratorTarget->GetPostBuildCommands(), configName); } void cmVisualStudio10TargetGenerator::WriteEvent( @@ -2820,25 +2877,25 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences() = this->GlobalGenerator->GetTargetDirectDepends(this->GeneratorTarget); typedef cmGlobalVisualStudioGenerator::OrderedTargetDependSet OrderedTargetDependSet; - OrderedTargetDependSet depends(unordered); + OrderedTargetDependSet depends(unordered, CMAKE_CHECK_BUILD_SYSTEM_TARGET); this->WriteString("<ItemGroup>\n", 1); for( OrderedTargetDependSet::const_iterator i = depends.begin(); i != depends.end(); ++i) { - cmTarget const* dt = (*i)->Target; - if(dt->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget const* dt = *i; + if(dt->GetType() == cmState::INTERFACE_LIBRARY) { continue; } // skip fortran targets as they can not be processed by MSBuild // the only reference will be in the .sln file if(static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator) - ->TargetIsFortranOnly(*dt)) + ->TargetIsFortranOnly(dt)) { continue; } this->WriteString("<ProjectReference Include=\"", 2); - cmMakefile* mf = dt->GetMakefile(); + cmLocalGenerator* lg = dt->GetLocalGenerator(); std::string name = dt->GetName(); std::string path; const char* p = dt->GetProperty("EXTERNAL_MSPROJECT"); @@ -2848,7 +2905,7 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences() } else { - path = mf->GetCurrentBinaryDirectory(); + path = lg->GetCurrentBinaryDirectory(); path += "/"; path += dt->GetName(); path += ".vcxproj"; @@ -2863,11 +2920,106 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences() this->WriteString("</ItemGroup>\n", 1); } +void cmVisualStudio10TargetGenerator::WritePlatformExtensions() +{ + // This only applies to Windows 10 apps + if (this->GlobalGenerator->TargetsWindowsStore() && + cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0")) + { + const char* desktopExtensionsVersion = + this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION"); + if (desktopExtensionsVersion) + { + this->WriteSinglePlatformExtension("WindowsDesktop", + desktopExtensionsVersion); + } + const char* mobileExtensionsVersion = + this->GeneratorTarget->GetProperty("VS_MOBILE_EXTENSIONS_VERSION"); + if (mobileExtensionsVersion) + { + this->WriteSinglePlatformExtension("WindowsMobile", + mobileExtensionsVersion); + } + } +} + +void cmVisualStudio10TargetGenerator::WriteSinglePlatformExtension( + std::string const& extension, + std::string const& version + ) +{ + this->WriteString("<Import Project=", 2); + (*this->BuildFileStream) + << "\"$([Microsoft.Build.Utilities.ToolLocationHelper]" + << "::GetPlatformExtensionSDKLocation(`" + << extension <<", Version=" << version + << "`, $(TargetPlatformIdentifier), $(TargetPlatformVersion), null, " + << "$(ExtensionSDKDirectoryRoot), null))" + << "\\DesignTime\\CommonConfiguration\\Neutral\\" + << extension << ".props\" " + << "Condition=\"exists('$(" + << "[Microsoft.Build.Utilities.ToolLocationHelper]" + << "::GetPlatformExtensionSDKLocation(`" + << extension << ", Version=" << version + << "`, $(TargetPlatformIdentifier), $(TargetPlatformVersion), null, " + << "$(ExtensionSDKDirectoryRoot), null))" + << "\\DesignTime\\CommonConfiguration\\Neutral\\" + << extension << ".props')\" />\n"; +} + +void cmVisualStudio10TargetGenerator::WriteSDKReferences() +{ + // This only applies to Windows 10 apps + if (this->GlobalGenerator->TargetsWindowsStore() && + cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0")) + { + const char* desktopExtensionsVersion = + this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION"); + const char* mobileExtensionsVersion = + this->GeneratorTarget->GetProperty("VS_MOBILE_EXTENSIONS_VERSION"); + const char* iotExtensionsVersion = + this->GeneratorTarget->GetProperty("VS_IOT_EXTENSIONS_VERSION"); + + if(desktopExtensionsVersion || mobileExtensionsVersion || + iotExtensionsVersion) + { + this->WriteString("<ItemGroup>\n", 1); + if(desktopExtensionsVersion) + { + this->WriteSingleSDKReference("WindowsDesktop", + desktopExtensionsVersion); + } + if(mobileExtensionsVersion) + { + this->WriteSingleSDKReference("WindowsMobile", + mobileExtensionsVersion); + } + if(iotExtensionsVersion) + { + this->WriteSingleSDKReference("WindowsIoT", + iotExtensionsVersion); + } + this->WriteString("</ItemGroup>\n", 1); + } + } +} + +void cmVisualStudio10TargetGenerator::WriteSingleSDKReference( + std::string const& extension, + std::string const& version + ) +{ + this->WriteString("<SDKReference Include=\"", 2); + (*this->BuildFileStream) << extension + << ", Version=" << version << "\" />\n"; +} + + void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile() { if((this->GlobalGenerator->TargetsWindowsStore() || this->GlobalGenerator->TargetsWindowsPhone()) - && (cmTarget::EXECUTABLE == this->Target->GetType())) + && (cmState::EXECUTABLE == this->GeneratorTarget->GetType())) { std::string pfxFile; std::vector<cmSourceFile const*> certificates; @@ -2886,7 +3038,7 @@ void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile() { // Move the manifest to a project directory to avoid clashes std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); this->WriteString("<PropertyGroup>\n", 1); this->WriteString("<AppxPackageArtifactsDir>", 2); @@ -2973,6 +3125,8 @@ IsXamlSource(const std::string& sourceFile) void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings() { + cmGlobalVisualStudio10Generator* gg = + static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator); bool isAppContainer = false; bool const isWindowsPhone = this->GlobalGenerator->TargetsWindowsPhone(); bool const isWindowsStore = this->GlobalGenerator->TargetsWindowsStore(); @@ -2983,34 +3137,52 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings() (*this->BuildFileStream) << (isWindowsPhone ? "Windows Phone" : "Windows Store") << "</ApplicationType>\n"; - this->WriteString("<ApplicationTypeRevision>", 2); - (*this->BuildFileStream) << cmVS10EscapeXML(v) - << "</ApplicationTypeRevision>\n"; this->WriteString("<DefaultLanguage>en-US" "</DefaultLanguage>\n", 2); - if(v == "8.1") + if (cmHasLiteralPrefix(v, "10.0")) { + this->WriteString("<ApplicationTypeRevision>", 2); + (*this->BuildFileStream) << cmVS10EscapeXML("10.0") + << "</ApplicationTypeRevision>\n"; + // Visual Studio 14.0 is necessary for building 10.0 apps + this->WriteString("<MinimumVisualStudioVersion>14.0" + "</MinimumVisualStudioVersion>\n", 2); + + if(this->GeneratorTarget->GetType() < cmState::UTILITY) + { + isAppContainer = true; + } + } + else if(v == "8.1") + { + this->WriteString("<ApplicationTypeRevision>", 2); + (*this->BuildFileStream) << cmVS10EscapeXML(v) + << "</ApplicationTypeRevision>\n"; // Visual Studio 12.0 is necessary for building 8.1 apps this->WriteString("<MinimumVisualStudioVersion>12.0" "</MinimumVisualStudioVersion>\n", 2); - if (this->Target->GetType() < cmTarget::UTILITY) + if (this->GeneratorTarget->GetType() < cmState::UTILITY) { isAppContainer = true; } } else if (v == "8.0") { + this->WriteString("<ApplicationTypeRevision>", 2); + (*this->BuildFileStream) << cmVS10EscapeXML(v) + << "</ApplicationTypeRevision>\n"; // Visual Studio 11.0 is necessary for building 8.0 apps this->WriteString("<MinimumVisualStudioVersion>11.0" "</MinimumVisualStudioVersion>\n", 2); - if (isWindowsStore && this->Target->GetType() < cmTarget::UTILITY) + if (isWindowsStore + && this->GeneratorTarget->GetType() < cmState::UTILITY) { isAppContainer = true; } else if (isWindowsPhone && - this->Target->GetType() == cmTarget::EXECUTABLE) + this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { this->WriteString("<XapOutputs>true</XapOutputs>\n", 2); this->WriteString("<XapFilename>", 2); @@ -3029,13 +3201,46 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings() this->WriteString("<WindowsSDKDesktopARMSupport>true" "</WindowsSDKDesktopARMSupport>\n", 2); } + std::string const& targetPlatformVersion = + gg->GetWindowsTargetPlatformVersion(); + if (!targetPlatformVersion.empty()) + { + this->WriteString("<WindowsTargetPlatformVersion>", 2); + (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformVersion) << + "</WindowsTargetPlatformVersion>\n"; + } + const char* targetPlatformMinVersion = + this->GeneratorTarget + ->GetProperty("VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION"); + if(targetPlatformMinVersion) + { + this->WriteString("<WindowsTargetPlatformMinVersion>", 2); + (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformMinVersion) << + "</WindowsTargetPlatformMinVersion>\n"; + } + else if (isWindowsStore && cmHasLiteralPrefix(v, "10.0")) + { + // If the min version is not set, then use the TargetPlatformVersion + if (!targetPlatformVersion.empty()) + { + this->WriteString("<WindowsTargetPlatformMinVersion>", 2); + (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformVersion) << + "</WindowsTargetPlatformMinVersion>\n"; + } + } + + // Added IoT Startup Task support + if(this->GeneratorTarget->GetPropertyAsBool("VS_IOT_STARTUP_TASK")) + { + this->WriteString("<ContainsStartupTask>true</ContainsStartupTask>\n", 2); + } } void cmVisualStudio10TargetGenerator::VerifyNecessaryFiles() { // For Windows and Windows Phone executables, we will assume that if a // manifest is not present that we need to add all the necessary files - if (this->Target->GetType() == cmTarget::EXECUTABLE) + if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { std::vector<cmSourceFile const*> manifestSources; this->GeneratorTarget->GetAppManifest(manifestSources, ""); @@ -3081,7 +3286,7 @@ void cmVisualStudio10TargetGenerator::VerifyNecessaryFiles() { this->IsMissingFiles = true; } - else if (v == "8.1") + else if (v == "8.1" || cmHasLiteralPrefix(v, "10.0")) { this->IsMissingFiles = true; } @@ -3115,6 +3320,10 @@ void cmVisualStudio10TargetGenerator::WriteMissingFiles() { this->WriteMissingFilesWS81(); } + else if (cmHasLiteralPrefix(v, "10.0")) + { + this->WriteMissingFilesWS10_0(); + } } } @@ -3126,13 +3335,15 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80() // For WP80, the manifest needs to be in the same folder as the project // this can cause an overwrite problem if projects aren't organized in // folders - std::string manifestFile = this->Makefile->GetCurrentBinaryDirectory() + + std::string manifestFile = + this->LocalGenerator->GetCurrentBinaryDirectory() + std::string("/WMAppManifest.xml"); std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir); - std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); + std::string targetNameXML = + cmVS10EscapeXML(this->GeneratorTarget->GetName()); cmGeneratedFileStream fout(manifestFile.c_str()); fout.SetCopyIfDifferent(true); @@ -3212,10 +3423,11 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP81() std::string manifestFile = this->DefaultArtifactDir + "/package.appxManifest"; std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir); - std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); + std::string targetNameXML = + cmVS10EscapeXML(this->GeneratorTarget->GetName()); cmGeneratedFileStream fout(manifestFile.c_str()); fout.SetCopyIfDifferent(true); @@ -3272,10 +3484,11 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS80() std::string manifestFile = this->DefaultArtifactDir + "/package.appxManifest"; std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir); - std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); + std::string targetNameXML = + cmVS10EscapeXML(this->GeneratorTarget->GetName()); cmGeneratedFileStream fout(manifestFile.c_str()); fout.SetCopyIfDifferent(true); @@ -3324,10 +3537,11 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS81() std::string manifestFile = this->DefaultArtifactDir + "/package.appxManifest"; std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir); - std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); + std::string targetNameXML = + cmVS10EscapeXML(this->GeneratorTarget->GetName()); cmGeneratedFileStream fout(manifestFile.c_str()); fout.SetCopyIfDifferent(true); @@ -3376,6 +3590,65 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS81() this->WriteCommonMissingFiles(manifestFile); } +void cmVisualStudio10TargetGenerator::WriteMissingFilesWS10_0() +{ + std::string manifestFile = + this->DefaultArtifactDir + "/package.appxManifest"; + std::string artifactDir = + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); + this->ConvertToWindowsSlash(artifactDir); + std::string artifactDirXML = cmVS10EscapeXML(artifactDir); + std::string targetNameXML = + cmVS10EscapeXML(this->GeneratorTarget->GetName()); + + cmGeneratedFileStream fout(manifestFile.c_str()); + fout.SetCopyIfDifferent(true); + + fout << + "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" + "<Package\n\t" + "xmlns=\"http://schemas.microsoft.com/appx/manifest/foundation/windows10\"" + "\txmlns:mp=\"http://schemas.microsoft.com/appx/2014/phone/manifest\"\n" + "\txmlns:uap=\"http://schemas.microsoft.com/appx/manifest/uap/windows10\"" + "\n\tIgnorableNamespaces=\"uap mp\">\n\n" + "\t<Identity Name=\"" << this->GUID << "\" Publisher=\"CN=CMake\"" + " Version=\"1.0.0.0\" />\n" + "\t<mp:PhoneIdentity PhoneProductId=\"" << this->GUID << + "\" PhonePublisherId=\"00000000-0000-0000-0000-000000000000\"/>\n" + "\t<Properties>\n" + "\t\t<DisplayName>" << targetNameXML << "</DisplayName>\n" + "\t\t<PublisherDisplayName>CMake</PublisherDisplayName>\n" + "\t\t<Logo>" << artifactDirXML << "\\StoreLogo.png</Logo>\n" + "\t</Properties>\n" + "\t<Dependencies>\n" + "\t\t<TargetDeviceFamily Name=\"Windows.Universal\" " + "MinVersion=\"10.0.0.0\" MaxVersionTested=\"10.0.0.0\" />\n" + "\t</Dependencies>\n" + + "\t<Resources>\n" + "\t\t<Resource Language=\"x-generate\" />\n" + "\t</Resources>\n" + "\t<Applications>\n" + "\t\t<Application Id=\"App\"" + " Executable=\"" << targetNameXML << ".exe\"" + " EntryPoint=\"" << targetNameXML << ".App\">\n" + "\t\t\t<uap:VisualElements\n" + "\t\t\t\tDisplayName=\"" << targetNameXML << "\"\n" + "\t\t\t\tDescription=\"" << targetNameXML << "\"\n" + "\t\t\t\tBackgroundColor=\"#336699\"\n" + "\t\t\t\tSquare150x150Logo=\"" << artifactDirXML << "\\Logo.png\"\n" + "\t\t\t\tSquare44x44Logo=\"" << artifactDirXML << + "\\SmallLogo44x44.png\">\n" + "\t\t\t\t<uap:SplashScreen" + " Image=\"" << artifactDirXML << "\\SplashScreen.png\" />\n" + "\t\t\t</uap:VisualElements>\n" + "\t\t</Application>\n" + "\t</Applications>\n" + "</Package>\n"; + + this->WriteCommonMissingFiles(manifestFile); +} + void cmVisualStudio10TargetGenerator ::WriteCommonMissingFiles(const std::string& manifestFile) @@ -3399,6 +3672,14 @@ cmVisualStudio10TargetGenerator (*this->BuildFileStream) << cmVS10EscapeXML(smallLogo) << "\" />\n"; this->AddedFiles.push_back(smallLogo); + std::string smallLogo44 = this->DefaultArtifactDir + "/SmallLogo44x44.png"; + cmSystemTools::CopyAFile(templateFolder + "/SmallLogo44x44.png", + smallLogo44, false); + this->ConvertToWindowsSlash(smallLogo44); + this->WriteString("<Image Include=\"", 2); + (*this->BuildFileStream) << cmVS10EscapeXML(smallLogo44) << "\" />\n"; + this->AddedFiles.push_back(smallLogo44); + std::string logo = this->DefaultArtifactDir + "/Logo.png"; cmSystemTools::CopyAFile(templateFolder + "/Logo.png", logo, false); @@ -3429,3 +3710,26 @@ cmVisualStudio10TargetGenerator this->WriteString("<None Include=\"", 2); (*this->BuildFileStream) << cmVS10EscapeXML(keyFile) << "\" />\n"; } + +bool cmVisualStudio10TargetGenerator::ForceOld(const std::string& source) const +{ + HANDLE h = CreateFileW( + cmSystemTools::ConvertToWindowsExtendedPath(source).c_str(), + FILE_WRITE_ATTRIBUTES, + FILE_SHARE_WRITE, 0, OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, 0); + if (!h) + { + return false; + } + + FILETIME const ftime_20010101 = { 3365781504u, 29389701u }; + if (!SetFileTime(h, &ftime_20010101, &ftime_20010101, &ftime_20010101)) + { + CloseHandle(h); + return false; + } + + CloseHandle(h); + return true; +} diff --git a/Source/cmVisualStudio10TargetGenerator.h b/Source/cmVisualStudio10TargetGenerator.h index 451f8b2..044e0dd 100644 --- a/Source/cmVisualStudio10TargetGenerator.h +++ b/Source/cmVisualStudio10TargetGenerator.h @@ -13,7 +13,6 @@ #define cmVisualStudioTargetGenerator_h #include "cmStandardIncludes.h" -class cmTarget; class cmMakefile; class cmGeneratorTarget; class cmGeneratedFileStream; @@ -29,7 +28,7 @@ struct cmIDEFlagTable; class cmVisualStudio10TargetGenerator { public: - cmVisualStudio10TargetGenerator(cmTarget* target, + cmVisualStudio10TargetGenerator(cmGeneratorTarget* target, cmGlobalVisualStudio10Generator* gg); ~cmVisualStudio10TargetGenerator(); void Generate(); @@ -78,6 +77,13 @@ private: void WriteMissingFilesWP81(); void WriteMissingFilesWS80(); void WriteMissingFilesWS81(); + void WriteMissingFilesWS10_0(); + void WritePlatformExtensions(); + void WriteSinglePlatformExtension(std::string const& extension, + std::string const& version); + void WriteSDKReferences(); + void WriteSingleSDKReference(std::string const& extension, + std::string const& version); void WriteCommonMissingFiles(const std::string& manifestFile); void WriteTargetSpecificReferences(); @@ -111,6 +117,7 @@ private: void AddLibraries(cmComputeLinkInformation& cli, std::vector<std::string>& libVec); void WriteLibOptions(std::string const& config); + void WriteManifestOptions(std::string const& config); void WriteEvents(std::string const& configName); void WriteEvent(const char* name, std::vector<cmCustomCommand> const& commands, @@ -129,6 +136,8 @@ private: cmIDEFlagTable const* GetLinkFlagTable() const; cmIDEFlagTable const* GetMasmFlagTable() const; + bool ForceOld(const std::string& source) const; + private: typedef cmVisualStudioGeneratorOptions Options; typedef std::map<std::string, Options*> OptionsMap; @@ -138,7 +147,6 @@ private: OptionsMap LinkOptions; std::string PathToVcxproj; std::vector<std::string> Configurations; - cmTarget* Target; cmGeneratorTarget* GeneratorTarget; cmMakefile* Makefile; std::string Platform; diff --git a/Source/cmWhileCommand.cxx b/Source/cmWhileCommand.cxx index 012c580..4b7afd8 100644 --- a/Source/cmWhileCommand.cxx +++ b/Source/cmWhileCommand.cxx @@ -49,7 +49,20 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf, mf.ExpandArguments(this->Args, expandedArguments); cmake::MessageType messageType; - cmConditionEvaluator conditionEvaluator(mf); + cmListFileContext execContext = this->GetStartingContext(); + + cmCommandContext commandContext; + commandContext.Line = execContext.Line; + commandContext.Name = execContext.Name; + + cmListFileContext conditionContext = + cmConditionEvaluator::GetConditionContext( + &mf, commandContext, + this->GetStartingContext().FilePath); + + cmConditionEvaluator conditionEvaluator( + mf, conditionContext, + mf.GetBacktrace(commandContext)); bool isTrue = conditionEvaluator.IsTrue( expandedArguments, errorString, messageType); diff --git a/Source/cmWriteFileCommand.h b/Source/cmWriteFileCommand.h index 0d06878..89dc9ff 100644 --- a/Source/cmWriteFileCommand.h +++ b/Source/cmWriteFileCommand.h @@ -46,12 +46,6 @@ public: */ virtual std::string GetName() const { return "write_file";} - /** This command is kept for compatibility with older CMake versions. */ - virtual bool IsDiscouraged() const - { - return true; - } - cmTypeMacro(cmWriteFileCommand, cmCommand); }; diff --git a/Source/cmXCodeObject.h b/Source/cmXCodeObject.h index ed2940a..bd0f43f 100644 --- a/Source/cmXCodeObject.h +++ b/Source/cmXCodeObject.h @@ -13,7 +13,7 @@ #define cmXCodeObject_h #include "cmStandardIncludes.h" -class cmTarget; +class cmGeneratorTarget; class cmXCodeObject { @@ -75,7 +75,7 @@ public: } static void Indent(int level, std::ostream& out); void Print(std::ostream& out); - virtual void PrintComment(std::ostream&) {}; + virtual void PrintComment(std::ostream&) {} static void PrintList(std::vector<cmXCodeObject*> const&, std::ostream& out); @@ -87,11 +87,11 @@ public: { this->Id = id; } - cmTarget* GetTarget() + cmGeneratorTarget* GetTarget() { return this->Target; } - void SetTarget(cmTarget* t) + void SetTarget(cmGeneratorTarget* t) { this->Target = t; } @@ -105,7 +105,7 @@ public: } return 0; } - // serach the attribute list for an object of the specified type + // search the attribute list for an object of the specified type cmXCodeObject* GetObject(cmXCodeObject::PBXType t) { for(std::vector<cmXCodeObject*>::iterator i = this->List.begin(); @@ -146,7 +146,7 @@ public: protected: void PrintString(std::ostream& os) const; - cmTarget* Target; + cmGeneratorTarget* Target; Type TypeValue; std::string Id; PBXType IsA; diff --git a/Source/cmake.cxx b/Source/cmake.cxx index f069481..d5bc3d2 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -10,7 +10,6 @@ See the License for more information. ============================================================================*/ #include "cmake.h" -#include "cmCacheManager.h" #include "cmMakefile.h" #include "cmLocalGenerator.h" #include "cmExternalMakefileProjectGenerator.h" @@ -128,12 +127,14 @@ cmake::cmake() this->WarnUnused = false; this->WarnUnusedCli = true; this->CheckSystemVars = false; + this->SuppressDevWarnings = false; + this->DoSuppressDevWarnings = false; this->DebugOutput = false; this->DebugTryCompile = false; this->ClearBuildSystem = false; this->FileComparison = new cmFileTimeComparison; - this->State = new cmState(this); + this->State = new cmState; this->CurrentSnapshot = this->State->CreateBaseSnapshot(); #ifdef __APPLE__ @@ -149,7 +150,6 @@ cmake::cmake() #endif this->Verbose = false; - this->CacheManager = new cmCacheManager(this); this->GlobalGenerator = 0; this->ProgressCallback = 0; this->ProgressCallbackClientData = 0; @@ -165,11 +165,34 @@ cmake::cmake() // Make sure we can capture the build tool output. cmSystemTools::EnableVSConsoleOutput(); + + // Set up a list of source and header extensions + // these are used to find files when the extension + // is not given + // The "c" extension MUST precede the "C" extension. + this->SourceFileExtensions.push_back( "c" ); + this->SourceFileExtensions.push_back( "C" ); + + this->SourceFileExtensions.push_back( "c++" ); + this->SourceFileExtensions.push_back( "cc" ); + this->SourceFileExtensions.push_back( "cpp" ); + this->SourceFileExtensions.push_back( "cxx" ); + this->SourceFileExtensions.push_back( "m" ); + this->SourceFileExtensions.push_back( "M" ); + this->SourceFileExtensions.push_back( "mm" ); + + this->HeaderFileExtensions.push_back( "h" ); + this->HeaderFileExtensions.push_back( "hh" ); + this->HeaderFileExtensions.push_back( "h++" ); + this->HeaderFileExtensions.push_back( "hm" ); + this->HeaderFileExtensions.push_back( "hpp" ); + this->HeaderFileExtensions.push_back( "hxx" ); + this->HeaderFileExtensions.push_back( "in" ); + this->HeaderFileExtensions.push_back( "txx" ); } cmake::~cmake() { - delete this->CacheManager; delete this->State; if (this->GlobalGenerator) { @@ -187,6 +210,7 @@ void cmake::CleanupCommandsAndMacros() { this->CurrentSnapshot = this->State->Reset(); this->State->RemoveUserDefinedCommands(); + this->CurrentSnapshot.SetDefaultDefinitions(); } // Parse the args @@ -214,7 +238,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args) } std::string var, value; cmState::CacheEntryType type = cmState::UNINITIALIZED; - if(cmCacheManager::ParseEntry(entry, var, value, type)) + if(cmState::ParseCacheEntry(entry, var, value, type)) { // The value is transformed if it is a filepath for example, so // we can't compare whether the value is already in the cache until @@ -230,7 +254,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args) } } - this->State->AddCacheEntry(var, value.c_str(), + this->AddCacheEntry(var, value.c_str(), "No help, variable specified on the command line.", type); if(this->WarnUnusedCli) @@ -250,70 +274,15 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args) return false; } } - else if(cmHasLiteralPrefix(arg, "-W")) + else if(arg.find("-Wno-dev",0) == 0) { - std::string entry = arg.substr(2); - if (entry.empty()) - { - ++i; - if (i < args.size()) - { - entry = args[i]; - } - else - { - cmSystemTools::Error( - "-W must be followed with [no-][error=]<name>."); - return false; - } + this->SuppressDevWarnings = true; + this->DoSuppressDevWarnings = true; } - - std::string name; - bool foundNo = false; - bool foundError = false; - unsigned int nameStartPosition = 0; - - if (entry.find("no-", nameStartPosition) == 0) - { - foundNo = true; - nameStartPosition += 3; - } - - if (entry.find("error=", nameStartPosition) == 0) - { - foundError = true; - nameStartPosition += 6; - } - - name = entry.substr(nameStartPosition); - if (name.empty()) - { - cmSystemTools::Error("No warning name provided."); - return false; - } - - if (!foundNo && !foundError) - { - // -W<name> - this->WarningLevels[name] = std::max(this->WarningLevels[name], - WARNING_LEVEL); - } - else if (foundNo && !foundError) - { - // -Wno<name> - this->WarningLevels[name] = IGNORE_LEVEL; - } - else if (!foundNo && foundError) - { - // -Werror=<name> - this->WarningLevels[name] = ERROR_LEVEL; - } - else - { - // -Wno-error=<name> - this->WarningLevels[name] = std::min(this->WarningLevels[name], - WARNING_LEVEL); - } + else if(arg.find("-Wdev",0) == 0) + { + this->SuppressDevWarnings = false; + this->DoSuppressDevWarnings = true; } else if(arg.find("-U",0) == 0) { @@ -430,21 +399,21 @@ void cmake::ReadListFile(const std::vector<std::string>& args, this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory()); this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory()); cmState::Snapshot snapshot = this->GetCurrentSnapshot(); - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(gg, snapshot)); - cmsys::auto_ptr<cmLocalGenerator> lg(gg->CreateLocalGenerator(mf.get())); - lg->GetMakefile()->SetCurrentBinaryDirectory + snapshot.GetDirectory().SetCurrentBinary (cmSystemTools::GetCurrentWorkingDirectory()); - lg->GetMakefile()->SetCurrentSourceDirectory + snapshot.GetDirectory().SetCurrentSource (cmSystemTools::GetCurrentWorkingDirectory()); + snapshot.SetDefaultDefinitions(); + cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(gg, snapshot)); if (this->GetWorkingMode() != NORMAL_MODE) { std::string file(cmSystemTools::CollapseFullPath(path)); cmSystemTools::ConvertToUnixSlashes(file); - lg->GetMakefile()->SetScriptModeFile(file.c_str()); + mf->SetScriptModeFile(file.c_str()); - lg->GetMakefile()->SetArgcArgv(args); + mf->SetArgcArgv(args); } - if (!lg->GetMakefile()->ReadListFile(path)) + if (!mf->ReadListFile(path)) { cmSystemTools::Error("Error processing file: ", path); } @@ -472,13 +441,14 @@ bool cmake::FindPackage(const std::vector<std::string>& args) this->SetGlobalGenerator(gg); cmState::Snapshot snapshot = this->GetCurrentSnapshot(); - // read in the list file to fill the cache - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(gg, snapshot)); - cmsys::auto_ptr<cmLocalGenerator> lg(gg->CreateLocalGenerator(mf.get())); - mf->SetCurrentBinaryDirectory + snapshot.GetDirectory().SetCurrentBinary (cmSystemTools::GetCurrentWorkingDirectory()); - mf->SetCurrentSourceDirectory + snapshot.GetDirectory().SetCurrentSource (cmSystemTools::GetCurrentWorkingDirectory()); + // read in the list file to fill the cache + snapshot.SetDefaultDefinitions(); + cmMakefile* mf = new cmMakefile(gg, snapshot); + gg->AddMakefile(mf); mf->SetArgcArgv(args); @@ -511,6 +481,8 @@ bool cmake::FindPackage(const std::vector<std::string>& args) std::vector<std::string> includeDirs; cmSystemTools::ExpandListArgument(includes, includeDirs); + gg->CreateGenerationObjects(); + cmLocalGenerator* lg = gg->LocalGenerators[0]; std::string includeFlags = lg->GetIncludeFlags(includeDirs, 0, language); std::string definitions = mf->GetSafeDefinition("PACKAGE_DEFINITIONS"); @@ -531,7 +503,7 @@ bool cmake::FindPackage(const std::vector<std::string>& args) ++libIt) { mf->AddLinkLibraryForTarget(targetName, *libIt, - cmTarget::GENERAL); + GENERAL_LibraryType); } @@ -540,8 +512,9 @@ bool cmake::FindPackage(const std::vector<std::string>& args) std::string linkPath; std::string flags; std::string linkFlags; - gg->CreateGeneratorTargets(cmGlobalGenerator::AllTargets, lg.get()); - cmGeneratorTarget *gtgt = gg->GetGeneratorTarget(tgt); + gg->CreateGenerationObjects(); + cmGeneratorTarget *gtgt = gg->FindGeneratorTarget(tgt->GetName()); + cmLocalGenerator* lg = gtgt->GetLocalGenerator(); lg->GetTargetFlags(linkLibs, frameworkPath, linkPath, flags, linkFlags, gtgt, false); linkLibs = frameworkPath + linkPath + linkLibs; @@ -645,7 +618,11 @@ void cmake::SetArgs(const std::vector<std::string>& args, // skip for now i++; } - else if(arg.find("-W",0) == 0) + else if(arg.find("-Wno-dev",0) == 0) + { + // skip for now + } + else if(arg.find("-Wdev",0) == 0) { // skip for now } @@ -898,14 +875,14 @@ void cmake::SetDirectoriesFromFile(const char* arg) int cmake::AddCMakePaths() { // Save the value in the cache - this->CacheManager->AddCacheEntry + this->AddCacheEntry ("CMAKE_COMMAND", cmSystemTools::GetCMakeCommand().c_str(), "Path to CMake executable.", cmState::INTERNAL); #ifdef CMAKE_BUILD_WITH_CMAKE - this->CacheManager->AddCacheEntry + this->AddCacheEntry ("CMAKE_CTEST_COMMAND", cmSystemTools::GetCTestCommand().c_str(), "Path to ctest program executable.", cmState::INTERNAL); - this->CacheManager->AddCacheEntry + this->AddCacheEntry ("CMAKE_CPACK_COMMAND", cmSystemTools::GetCPackCommand().c_str(), "Path to cpack program executable.", cmState::INTERNAL); #endif @@ -919,7 +896,7 @@ int cmake::AddCMakePaths() cmSystemTools::GetCMakeRoot().c_str()); return 0; } - this->CacheManager->AddCacheEntry + this->AddCacheEntry ("CMAKE_ROOT", cmSystemTools::GetCMakeRoot().c_str(), "Path to CMake installation.", cmState::INTERNAL); @@ -1033,6 +1010,10 @@ cmGlobalGenerator* cmake::CreateGlobalGenerator(const std::string& gname) void cmake::SetHomeDirectory(const std::string& dir) { this->State->SetSourceDirectory(dir); + if (this->CurrentSnapshot.IsValid()) + { + this->CurrentSnapshot.SetDefinition("CMAKE_SOURCE_DIR", dir); + } } const char* cmake::GetHomeDirectory() const @@ -1043,6 +1024,10 @@ const char* cmake::GetHomeDirectory() const void cmake::SetHomeOutputDirectory(const std::string& dir) { this->State->SetBinaryDirectory(dir); + if (this->CurrentSnapshot.IsValid()) + { + this->CurrentSnapshot.SetDefinition("CMAKE_BINARY_DIR", dir); + } } const char* cmake::GetHomeOutputDirectory() const @@ -1136,10 +1121,10 @@ int cmake::DoPreConfigureChecks() } // do a sanity check on some values - if(this->CacheManager->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY")) + if(this->State->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY")) { std::string cacheStart = - this->CacheManager->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY"); + this->State->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY"); cacheStart += "/CMakeLists.txt"; std::string currentStart = this->GetHomeDirectory(); currentStart += "/CMakeLists.txt"; @@ -1196,12 +1181,12 @@ int cmake::HandleDeleteCacheVariables(const std::string& var) save.value = *i; warning << *i << "\n"; const char* existingValue = - this->CacheManager->GetCacheEntryValue(save.key); + this->State->GetCacheEntryValue(save.key); if(existingValue) { - save.type = this->CacheManager->GetCacheEntryType(save.key); + save.type = this->State->GetCacheEntryType(save.key); if(const char* help = - this->CacheManager->GetCacheEntryProperty(save.key, "HELPSTRING")) + this->State->GetCacheEntryProperty(save.key, "HELPSTRING")) { save.help = help; } @@ -1210,7 +1195,7 @@ int cmake::HandleDeleteCacheVariables(const std::string& var) } // remove the cache - this->CacheManager->DeleteCache(this->GetHomeOutputDirectory()); + this->DeleteCache(this->GetHomeOutputDirectory()); // load the empty cache this->LoadCache(); // restore the changed compilers @@ -1232,121 +1217,25 @@ int cmake::HandleDeleteCacheVariables(const std::string& var) int cmake::Configure() { - WarningLevel warningLevel; - - if (this->WarningLevels.count("deprecated") == 1) - { - warningLevel = this->WarningLevels["deprecated"]; - if (warningLevel == IGNORE_LEVEL) - { - this->CacheManager-> - AddCacheEntry("CMAKE_WARN_DEPRECATED", "FALSE", - "Whether to issue deprecation warnings for" - " macros and functions.", - cmState::BOOL); - this->CacheManager-> - AddCacheEntry("CMAKE_ERROR_DEPRECATED", "FALSE", - "Whether to issue deprecation errors for macros" - " and functions.", - cmState::BOOL); - } - if (warningLevel == WARNING_LEVEL) - { - this->CacheManager-> - AddCacheEntry("CMAKE_WARN_DEPRECATED", "TRUE", - "Whether to issue deprecation warnings for" - " macros and functions.", - cmState::BOOL); - } - else if (warningLevel == ERROR_LEVEL) - { - this->CacheManager-> - AddCacheEntry("CMAKE_ERROR_DEPRECATED", "TRUE", - "Whether to issue deprecation errors for macros" - " and functions.", - cmState::BOOL); - } - } - - if (this->WarningLevels.count("dev") == 1) + if(this->DoSuppressDevWarnings) { - bool setDeprecatedVariables = false; - - const char* cachedWarnDeprecated = - this->State->GetCacheEntryValue("CMAKE_WARN_DEPRECATED"); - const char* cachedErrorDeprecated = - this->State->GetCacheEntryValue("CMAKE_ERROR_DEPRECATED"); - - // don't overwrite deprecated warning setting from a previous invocation - if (!cachedWarnDeprecated && !cachedErrorDeprecated) - { - setDeprecatedVariables = true; - } - - warningLevel = this->WarningLevels["dev"]; - if (warningLevel == IGNORE_LEVEL) + if(this->SuppressDevWarnings) { - this->CacheManager-> + this-> AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "TRUE", "Suppress Warnings that are meant for" " the author of the CMakeLists.txt files.", cmState::INTERNAL); - this->CacheManager-> - AddCacheEntry("CMAKE_ERROR_DEVELOPER_WARNINGS", "FALSE", - "Suppress errors that are meant for" - " the author of the CMakeLists.txt files.", - cmState::INTERNAL); - - if (setDeprecatedVariables) - { - this->CacheManager-> - AddCacheEntry("CMAKE_WARN_DEPRECATED", "FALSE", - "Whether to issue deprecation warnings for" - " macros and functions.", - cmState::BOOL); - this->CacheManager-> - AddCacheEntry("CMAKE_ERROR_DEPRECATED", "FALSE", - "Whether to issue deprecation errors for macros" - " and functions.", - cmState::BOOL); - } } - else if (warningLevel == WARNING_LEVEL) + else { - this->CacheManager-> + this-> AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "FALSE", "Suppress Warnings that are meant for" " the author of the CMakeLists.txt files.", cmState::INTERNAL); - - if (setDeprecatedVariables) - { - this->CacheManager-> - AddCacheEntry("CMAKE_WARN_DEPRECATED", "TRUE", - "Whether to issue deprecation warnings for" - " macros and functions.", - cmState::BOOL); - } - } - else if (warningLevel == ERROR_LEVEL) - { - this->CacheManager-> - AddCacheEntry("CMAKE_ERROR_DEVELOPER_WARNINGS", "TRUE", - "Suppress errors that are meant for" - " the author of the CMakeLists.txt files.", - cmState::INTERNAL); - - if (setDeprecatedVariables) - { - this->CacheManager-> - AddCacheEntry("CMAKE_ERROR_DEPRECATED", "TRUE", - "Whether to issue deprecation errors for macros" - " and functions.", - cmState::BOOL); - } } } - int ret = this->ActualConfigure(); const char* delCacheVars = this->State ->GetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_"); @@ -1375,7 +1264,7 @@ int cmake::ActualConfigure() } if ( !res ) { - this->CacheManager->AddCacheEntry + this->AddCacheEntry ("CMAKE_HOME_DIRECTORY", this->GetHomeDirectory(), "Source directory with the top level CMakeLists.txt file for this " @@ -1387,9 +1276,9 @@ int cmake::ActualConfigure() if(!this->GlobalGenerator) { const char* genName = - this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR"); + this->State->GetInitializedCacheValue("CMAKE_GENERATOR"); const char* extraGenName = - this->CacheManager->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR"); + this->State->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR"); if(genName) { std::string fullName = cmExternalMakefileProjectGenerator:: @@ -1467,7 +1356,7 @@ int cmake::ActualConfigure() } } - const char* genName = this->CacheManager + const char* genName = this->State ->GetInitializedCacheValue("CMAKE_GENERATOR"); if(genName) { @@ -1484,20 +1373,20 @@ int cmake::ActualConfigure() return -2; } } - if(!this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR")) + if(!this->State->GetInitializedCacheValue("CMAKE_GENERATOR")) { - this->CacheManager->AddCacheEntry("CMAKE_GENERATOR", + this->AddCacheEntry("CMAKE_GENERATOR", this->GlobalGenerator->GetName().c_str(), "Name of generator.", cmState::INTERNAL); - this->CacheManager->AddCacheEntry("CMAKE_EXTRA_GENERATOR", + this->AddCacheEntry("CMAKE_EXTRA_GENERATOR", this->GlobalGenerator->GetExtraGeneratorName().c_str(), "Name of external makefile project generator.", cmState::INTERNAL); } if(const char* platformName = - this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR_PLATFORM")) + this->State->GetInitializedCacheValue("CMAKE_GENERATOR_PLATFORM")) { if(this->GeneratorPlatform.empty()) { @@ -1518,14 +1407,14 @@ int cmake::ActualConfigure() } else { - this->CacheManager->AddCacheEntry("CMAKE_GENERATOR_PLATFORM", + this->AddCacheEntry("CMAKE_GENERATOR_PLATFORM", this->GeneratorPlatform.c_str(), "Name of generator platform.", cmState::INTERNAL); } if(const char* tsName = - this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR_TOOLSET")) + this->State->GetInitializedCacheValue("CMAKE_GENERATOR_TOOLSET")) { if(this->GeneratorToolset.empty()) { @@ -1546,7 +1435,7 @@ int cmake::ActualConfigure() } else { - this->CacheManager->AddCacheEntry("CMAKE_GENERATOR_TOOLSET", + this->AddCacheEntry("CMAKE_GENERATOR_TOOLSET", this->GeneratorToolset.c_str(), "Name of generator toolset.", cmState::INTERNAL); @@ -1580,7 +1469,7 @@ int cmake::ActualConfigure() { if(!this->State->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH")) { - this->State->AddCacheEntry + this->AddCacheEntry ("LIBRARY_OUTPUT_PATH", "", "Single output directory for building all libraries.", cmState::PATH); @@ -1588,7 +1477,7 @@ int cmake::ActualConfigure() if(!this->State ->GetInitializedCacheValue("EXECUTABLE_OUTPUT_PATH")) { - this->State->AddCacheEntry + this->AddCacheEntry ("EXECUTABLE_OUTPUT_PATH", "", "Single output directory for building all executables.", cmState::PATH); @@ -1608,7 +1497,7 @@ int cmake::ActualConfigure() // only save the cache if there were no fatal errors if ( this->GetWorkingMode() == NORMAL_MODE ) { - this->CacheManager->SaveCache(this->GetHomeOutputDirectory()); + this->SaveCache(this->GetHomeOutputDirectory()); } if(cmSystemTools::GetErrorOccuredFlag()) { @@ -1677,18 +1566,6 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure) { this->AddCMakePaths(); } - - // don't turn dev warnings into errors by default, if no value has been - // specified for the flag, disable it - if (!this->State->GetCacheEntryValue("CMAKE_ERROR_DEVELOPER_WARNINGS")) - { - this->CacheManager-> - AddCacheEntry("CMAKE_ERROR_DEVELOPER_WARNINGS", "FALSE", - "Suppress errors that are meant for" - " the author of the CMakeLists.txt files.", - cmState::INTERNAL); - } - // Add any cache args if ( !this->SetCacheArgs(args) ) { @@ -1790,7 +1667,7 @@ int cmake::Generate() // for the Visual Studio and Xcode generators.) if ( this->GetWorkingMode() == NORMAL_MODE ) { - this->CacheManager->SaveCache(this->GetHomeOutputDirectory()); + this->SaveCache(this->GetHomeOutputDirectory()); } return 0; } @@ -1799,14 +1676,15 @@ void cmake::AddCacheEntry(const std::string& key, const char* value, const char* helpString, int type) { - this->CacheManager->AddCacheEntry(key, value, + this->State->AddCacheEntry(key, value, helpString, cmState::CacheEntryType(type)); + this->UnwatchUnusedCli(key); } const char* cmake::GetCacheDefinition(const std::string& name) const { - return this->CacheManager->GetInitializedCacheValue(name); + return this->State->GetInitializedCacheValue(name); } void cmake::AddDefaultCommands() @@ -1879,7 +1757,7 @@ bool cmake::ParseCacheEntry(const std::string& entry, std::string& value, cmState::CacheEntryType& type) { - return cmCacheManager::ParseEntry(entry, var, value, type); + return cmState::ParseCacheEntry(entry, var, value, type); } int cmake::LoadCache() @@ -1910,24 +1788,43 @@ int cmake::LoadCache() bool cmake::LoadCache(const std::string& path) { - return this->CacheManager->LoadCache(path); + std::set<std::string> emptySet; + return this->LoadCache(path, true, emptySet, emptySet); } bool cmake::LoadCache(const std::string& path, bool internal, std::set<std::string>& excludes, std::set<std::string>& includes) { - return this->CacheManager->LoadCache(path, internal, excludes, includes); + bool result = this->State->LoadCache(path, internal, excludes, includes); + static const char* entries[] = {"CMAKE_CACHE_MAJOR_VERSION", + "CMAKE_CACHE_MINOR_VERSION"}; + for (const char* const* nameIt = cmArrayBegin(entries); + nameIt != cmArrayEnd(entries); ++nameIt) + { + this->UnwatchUnusedCli(*nameIt); + } + return result; } bool cmake::SaveCache(const std::string& path) { - return this->CacheManager->SaveCache(path); + bool result = this->State->SaveCache(path); + static const char* entries[] = {"CMAKE_CACHE_MAJOR_VERSION", + "CMAKE_CACHE_MINOR_VERSION", + "CMAKE_CACHE_PATCH_VERSION", + "CMAKE_CACHEFILE_DIR"}; + for (const char* const* nameIt = cmArrayBegin(entries); + nameIt != cmArrayEnd(entries); ++nameIt) + { + this->UnwatchUnusedCli(*nameIt); + } + return result; } bool cmake::DeleteCache(const std::string& path) { - return this->CacheManager->DeleteCache(path); + return this->State->DeleteCache(path); } void cmake::SetProgressCallback(ProgressCallbackType f, void *cd) @@ -1992,7 +1889,7 @@ void cmake::UpdateConversionPathTable() { // Update the path conversion table with any specified file: const char* tablepath = - this->CacheManager + this->State ->GetInitializedCacheValue("CMAKE_PATH_TRANSLATION_FILE"); if(tablepath) @@ -2061,9 +1958,9 @@ int cmake::CheckBuildSystem() cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg(gg.CreateLocalGenerator(mf.get())); if(!mf->ReadListFile(this->CheckBuildSystemArgument.c_str()) || cmSystemTools::GetErrorOccuredFlag()) { @@ -2092,6 +1989,7 @@ int cmake::CheckBuildSystem() ggd(this->CreateGlobalGenerator(genName)); if(ggd.get()) { + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmsys::auto_ptr<cmMakefile> mfd(new cmMakefile(ggd.get(), cm.GetCurrentSnapshot())); cmsys::auto_ptr<cmLocalGenerator> lgd( @@ -2596,17 +2494,20 @@ bool cmake::PrintMessagePreamble(cmake::MessageType t, std::ostream& msg) { msg << "CMake Deprecation Warning"; } - else if (t == cmake::AUTHOR_WARNING) - { - msg << "CMake Warning (dev)"; - } - else if (t == cmake::AUTHOR_ERROR) - { - msg << "CMake Error (dev)"; - } else { msg << "CMake Warning"; + if(t == cmake::AUTHOR_WARNING) + { + // Allow suppression of these warnings. + const char* suppress = this->State->GetCacheEntryValue( + "CMAKE_SUPPRESS_DEVELOPER_WARNINGS"); + if(suppress && cmSystemTools::IsOn(suppress)) + { + return false; + } + msg << " (dev)"; + } } return true; } @@ -2628,12 +2529,6 @@ void displayMessage(cmake::MessageType t, std::ostringstream& msg) msg << "This warning is for project developers. Use -Wno-dev to suppress it."; } - else if (t == cmake::AUTHOR_ERROR) - { - msg << - "This error is for project developers. Use -Wno-error=dev to suppress " - "it."; - } // Add a terminating blank line. msg << "\n"; @@ -2657,8 +2552,7 @@ void displayMessage(cmake::MessageType t, std::ostringstream& msg) // Output the message. if(t == cmake::FATAL_ERROR || t == cmake::INTERNAL_ERROR - || t == cmake::DEPRECATION_ERROR - || t == cmake::AUTHOR_ERROR) + || t == cmake::DEPRECATION_ERROR) { cmSystemTools::SetErrorOccured(); cmSystemTools::Message(msg.str().c_str(), "Error"); @@ -2855,18 +2749,3 @@ void cmake::RunCheckForUnusedVariables() } #endif } - -void cmake::SetSuppressDevWarnings(bool b) -{ - // equivalent to -Wno-dev - if (b) - { - this->WarningLevels["dev"] = IGNORE_LEVEL; - } - // equivalent to -Wdev - else - { - this->WarningLevels["dev"] = std::max(this->WarningLevels["dev"], - WARNING_LEVEL); - } -} diff --git a/Source/cmake.h b/Source/cmake.h index 8ac8897..6b0e83f 100644 --- a/Source/cmake.h +++ b/Source/cmake.h @@ -59,7 +59,6 @@ class cmake public: enum MessageType { AUTHOR_WARNING, - AUTHOR_ERROR, FATAL_ERROR, INTERNAL_ERROR, MESSAGE, @@ -69,12 +68,6 @@ class cmake DEPRECATION_WARNING }; - enum WarningLevel - { - IGNORE_LEVEL, - WARNING_LEVEL, - ERROR_LEVEL - }; /** \brief Describes the working modes of cmake */ enum WorkingMode @@ -189,6 +182,11 @@ class cmake ///! get the cmCachemManager used by this invocation of cmake cmCacheManager *GetCacheManager() { return this->CacheManager; } + const std::vector<std::string>& GetSourceExtensions() const + {return this->SourceFileExtensions;} + const std::vector<std::string>& GetHeaderExtensions() const + {return this->HeaderFileExtensions;} + /** * Given a variable name, return its value (as a string). */ @@ -278,7 +276,6 @@ class cmake void SetTrace(bool b) { this->Trace = b;} bool GetTraceExpand() { return this->TraceExpand;} void SetTraceExpand(bool b) { this->TraceExpand = b;} - void SetSuppressDevWarnings(bool b); bool GetWarnUninitialized() { return this->WarnUninitialized;} void SetWarnUninitialized(bool b) { this->WarnUninitialized = b;} bool GetWarnUnused() { return this->WarnUnused;} @@ -299,6 +296,12 @@ class cmake std::string const& GetCMakeEditCommand() const { return this->CMakeEditCommand; } + void SetSuppressDevWarnings(bool v) + { + this->SuppressDevWarnings = v; + this->DoSuppressDevWarnings = true; + } + /** Display a message to the user. */ void IssueMessage(cmake::MessageType t, std::string const& text, cmListFileBacktrace const& backtrace = cmListFileBacktrace()); @@ -341,7 +344,8 @@ protected: cmGlobalGenerator *GlobalGenerator; cmCacheManager *CacheManager; - std::map<std::string, WarningLevel> WarningLevels; + bool SuppressDevWarnings; + bool DoSuppressDevWarnings; std::string GeneratorPlatform; std::string GeneratorToolset; @@ -392,6 +396,8 @@ private: std::string CheckStampFile; std::string CheckStampList; std::string VSSolutionFile; + std::vector<std::string> SourceFileExtensions; + std::vector<std::string> HeaderFileExtensions; bool ClearBuildSystem; bool DebugTryCompile; cmFileTimeComparison* FileComparison; @@ -417,15 +423,7 @@ private: {"-T <toolset-name>", "Specify toolset name if supported by generator."}, \ {"-A <platform-name>", "Specify platform name if supported by generator."}, \ {"-Wno-dev", "Suppress developer warnings."},\ - {"-Wdev", "Enable developer warnings."},\ - {"-Werror=dev", "Make developer warnings errors."},\ - {"-Wno-error=dev", "Make developer warnings not errors."},\ - {"-Wdeprecated", "Enable deprecated macro and function warnings."},\ - {"-Wno-deprecated", "Suppress deprecated macro and function warnings."},\ - {"-Werror=deprecated", "Make deprecated macro and function warnings " \ - "errors."},\ - {"-Wno-error=deprecated", "Make deprecated macro and function warnings " \ - "not errors."} + {"-Wdev", "Enable developer warnings."} #define FOR_EACH_C_FEATURE(F) \ F(c_function_prototypes) \ diff --git a/Source/cmake.version.manifest b/Source/cmake.version.manifest new file mode 100644 index 0000000..e7010c9 --- /dev/null +++ b/Source/cmake.version.manifest @@ -0,0 +1,18 @@ +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" + manifestVersion="1.0" + xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" > + <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"> + <application> + <!-- Windows Vista --> + <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/> + <!-- Windows 7 --> + <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/> + <!-- Windows 8 --> + <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/> + <!-- Windows 8.1 --> + <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/> + <!-- Windows 10 --> + <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/> + </application> + </compatibility> +</assembly> diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx index aa70aa0..be492ed 100644 --- a/Source/cmcmd.cxx +++ b/Source/cmcmd.cxx @@ -765,15 +765,18 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) startOutDir = cmSystemTools::CollapseFullPath(startOutDir); cm.SetHomeDirectory(homeDir); cm.SetHomeOutputDirectory(homeOutDir); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); if(cmGlobalGenerator* ggd = cm.CreateGlobalGenerator(gen)) { cm.SetGlobalGenerator(ggd); cmState::Snapshot snapshot = cm.GetCurrentSnapshot(); + snapshot.GetDirectory().SetCurrentBinary + (cmSystemTools::GetCurrentWorkingDirectory()); + snapshot.GetDirectory().SetCurrentSource + (cmSystemTools::GetCurrentWorkingDirectory()); cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(ggd, snapshot)); cmsys::auto_ptr<cmLocalGenerator> lgd( ggd->CreateLocalGenerator(mf.get())); - lgd->GetMakefile()->SetCurrentSourceDirectory(startDir); - lgd->GetMakefile()->SetCurrentBinaryDirectory(startOutDir); // Actually scan dependencies. return lgd->UpdateDependencies(depInfo.c_str(), @@ -1355,6 +1358,35 @@ int cmcmd::WindowsCEEnvironment(const char* version, const std::string& name) return -1; } +class cmVSLink +{ + int Type; + bool Verbose; + bool Incremental; + bool LinkGeneratesManifest; + std::vector<std::string> LinkCommand; + std::vector<std::string> UserManifests; + std::string LinkerManifestFile; + std::string ManifestFile; + std::string ManifestFileRC; + std::string ManifestFileRes; + std::string TargetFile; +public: + cmVSLink(int type, bool verbose) + : Type(type) + , Verbose(verbose) + , Incremental(false) + , LinkGeneratesManifest(true) + {} + bool Parse(std::vector<std::string>::const_iterator argBeg, + std::vector<std::string>::const_iterator argEnd); + int Link(); +private: + int LinkIncremental(); + int LinkNonIncremental(); + int RunMT(std::string const& out, bool notify); +}; + // For visual studio 2005 and newer manifest files need to be embedded into // exe and dll's. This code does that in such a way that incremental linking // still works. @@ -1364,11 +1396,7 @@ int cmcmd::VisualStudioLink(std::vector<std::string>& args, int type) { return -1; } - bool verbose = false; - if(cmSystemTools::GetEnv("VERBOSE")) - { - verbose = true; - } + bool verbose = cmSystemTools::GetEnv("VERBOSE")? true:false; std::vector<std::string> expandedArgs; for(std::vector<std::string>::iterator i = args.begin(); i != args.end(); ++i) @@ -1389,79 +1417,19 @@ int cmcmd::VisualStudioLink(std::vector<std::string>& args, int type) expandedArgs.push_back(*i); } } - bool hasIncremental = false; - bool hasManifest = true; - for(std::vector<std::string>::iterator i = expandedArgs.begin(); - i != expandedArgs.end(); ++i) - { - if(cmSystemTools::Strucmp(i->c_str(), "/INCREMENTAL:YES") == 0) - { - hasIncremental = true; - } - if(cmSystemTools::Strucmp(i->c_str(), "/INCREMENTAL") == 0) - { - hasIncremental = true; - } - if(cmSystemTools::Strucmp(i->c_str(), "/MANIFEST:NO") == 0) - { - hasManifest = false; - } - } - if(hasIncremental && hasManifest) - { - if(verbose) - { - std::cout << "Visual Studio Incremental Link with embedded manifests\n"; - } - return cmcmd::VisualStudioLinkIncremental(expandedArgs, type, verbose); - } - if(verbose) - { - if(!hasIncremental) - { - std::cout << "Visual Studio Non-Incremental Link\n"; - } - else - { - std::cout << "Visual Studio Incremental Link without manifests\n"; - } - } - return cmcmd::VisualStudioLinkNonIncremental(expandedArgs, - type, hasManifest, verbose); -} -int cmcmd::ParseVisualStudioLinkCommand(std::vector<std::string>& args, - std::vector<std::string>& command, - std::string& targetName) -{ - std::vector<std::string>::iterator i = args.begin(); - i++; // skip -E - i++; // skip vs_link_dll or vs_link_exe - command.push_back(*i); - i++; // move past link command - for(; i != args.end(); ++i) - { - command.push_back(*i); - if(i->find("/Fe") == 0) - { - targetName = i->substr(3); - } - if(i->find("/out:") == 0) - { - targetName = i->substr(5); - } - } - if(targetName.empty() || command.empty()) + cmVSLink vsLink(type, verbose); + if (!vsLink.Parse(expandedArgs.begin()+2, expandedArgs.end())) { return -1; } - return 0; + return vsLink.Link(); } -bool cmcmd::RunCommand(const char* comment, +static bool RunCommand(const char* comment, std::vector<std::string>& command, bool verbose, - int* retCodeOut) + int* retCodeOut = 0) { if(verbose) { @@ -1503,8 +1471,134 @@ bool cmcmd::RunCommand(const char* comment, return retCode == 0; } -int cmcmd::VisualStudioLinkIncremental(std::vector<std::string>& args, - int type, bool verbose) +bool cmVSLink::Parse(std::vector<std::string>::const_iterator argBeg, + std::vector<std::string>::const_iterator argEnd) +{ + // Parse our own arguments. + std::string intDir; + std::vector<std::string>::const_iterator arg = argBeg; + while (arg != argEnd && cmHasLiteralPrefix(*arg, "-")) + { + if (*arg == "--") + { + ++arg; + break; + } + else if (*arg == "--manifests") + { + for (++arg; arg != argEnd && !cmHasLiteralPrefix(*arg, "-"); ++arg) + { + this->UserManifests.push_back(*arg); + } + } + else if (cmHasLiteralPrefix(*arg, "--intdir=")) + { + intDir = arg->substr(9); + ++arg; + } + else + { + std::cerr << "unknown argument '" << *arg << "'\n"; + return false; + } + } + if (intDir.empty()) + { + return false; + } + + // The rest of the arguments form the link command. + if (arg == argEnd) + { + return false; + } + this->LinkCommand.insert(this->LinkCommand.begin(), arg, argEnd); + + // Parse the link command to extract information we need. + for (; arg != argEnd; ++arg) + { + if (cmSystemTools::Strucmp(arg->c_str(), "/INCREMENTAL:YES") == 0) + { + this->Incremental = true; + } + else if (cmSystemTools::Strucmp(arg->c_str(), "/INCREMENTAL") == 0) + { + this->Incremental = true; + } + else if (cmSystemTools::Strucmp(arg->c_str(), "/MANIFEST:NO") == 0) + { + this->LinkGeneratesManifest = false; + } + else if (cmHasLiteralPrefix(*arg, "/Fe")) + { + this->TargetFile = arg->substr(3); + } + else if (cmHasLiteralPrefix(*arg, "/out:")) + { + this->TargetFile = arg->substr(5); + } + } + + if (this->TargetFile.empty()) + { + return false; + } + + this->ManifestFile = intDir + "/embed.manifest"; + this->LinkerManifestFile = intDir + "/intermediate.manifest"; + + if (this->Incremental) + { + // We will compile a resource containing the manifest and + // pass it to the link command. + this->ManifestFileRC = intDir + "/manifest.rc"; + this->ManifestFileRes = intDir + "/manifest.res"; + this->LinkCommand.push_back(this->ManifestFileRes); + } + else if (this->UserManifests.empty()) + { + // Prior to support for user-specified manifests CMake placed the + // linker-generated manifest next to the binary (as if it were not to be + // embedded) when not linking incrementally. Preserve this behavior. + this->ManifestFile = this->TargetFile + ".manifest"; + this->LinkerManifestFile = this->ManifestFile; + } + + if (this->LinkGeneratesManifest) + { + this->LinkCommand.push_back("/MANIFEST"); + this->LinkCommand.push_back("/MANIFESTFILE:" + this->LinkerManifestFile); + } + + return true; +} + +int cmVSLink::Link() +{ + if (this->Incremental && + (this->LinkGeneratesManifest || !this->UserManifests.empty())) + { + if (this->Verbose) + { + std::cout << "Visual Studio Incremental Link with embedded manifests\n"; + } + return LinkIncremental(); + } + if (this->Verbose) + { + if (!this->Incremental) + { + std::cout << "Visual Studio Non-Incremental Link\n"; + } + else + { + std::cout << "Visual Studio Incremental Link without manifests\n"; + } + } + return LinkNonIncremental(); +} + +int cmVSLink::LinkIncremental() { // This follows the steps listed here: // http://blogs.msdn.com/zakramer/archive/2006/05/22/603558.aspx @@ -1528,161 +1622,118 @@ int cmcmd::VisualStudioLinkIncremental(std::vector<std::string>& args, // 7. Finally, the Linker does another incremental link, but since the // only thing that has changed is the *.res file that contains the // manifest it is a short link. - std::vector<std::string> linkCommand; - std::string targetName; - if(cmcmd::ParseVisualStudioLinkCommand(args, linkCommand, targetName) == -1) - { - return -1; - } - std::string manifestArg = "/MANIFESTFILE:"; - std::vector<std::string> rcCommand; - rcCommand.push_back(cmSystemTools::FindProgram("rc.exe")); - std::vector<std::string> mtCommand; - mtCommand.push_back(cmSystemTools::FindProgram("mt.exe")); - std::string tempManifest; - tempManifest = targetName; - tempManifest += ".intermediate.manifest"; - std::string resourceInputFile = targetName; - resourceInputFile += ".resource.txt"; - if(verbose) + + // Create a resource file referencing the manifest. + std::string absManifestFile = + cmSystemTools::CollapseFullPath(this->ManifestFile); + if (this->Verbose) { - std::cout << "Create " << resourceInputFile << "\n"; + std::cout << "Create " << this->ManifestFileRC << "\n"; } - // Create input file for rc command - cmsys::ofstream fout(resourceInputFile.c_str()); - if(!fout) + { + cmsys::ofstream fout(this->ManifestFileRC.c_str()); + if (!fout) { return -1; } - std::string manifestFile = targetName; - manifestFile += ".embed.manifest"; - std::string fullPath= cmSystemTools::CollapseFullPath(manifestFile); - fout << type << " /* CREATEPROCESS_MANIFEST_RESOURCE_ID " - "*/ 24 /* RT_MANIFEST */ " << "\"" << fullPath << "\""; - fout.close(); - manifestArg += tempManifest; - // add the manifest arg to the linkCommand - linkCommand.push_back("/MANIFEST"); - linkCommand.push_back(manifestArg); - // if manifestFile is not yet created, create an - // empty one - if(!cmSystemTools::FileExists(manifestFile.c_str())) + fout << this->Type << " /* CREATEPROCESS_MANIFEST_RESOURCE_ID */ " + "24 /* RT_MANIFEST */ \"" << absManifestFile << "\""; + } + + // If we have not previously generated a manifest file, + // generate an empty one so the resource compiler succeeds. + if (!cmSystemTools::FileExists(this->ManifestFile)) { - if(verbose) + if (this->Verbose) { - std::cout << "Create empty: " << manifestFile << "\n"; + std::cout << "Create empty: " << this->ManifestFile << "\n"; } - cmsys::ofstream foutTmp(manifestFile.c_str()); + cmsys::ofstream foutTmp(this->ManifestFile.c_str()); } - std::string resourceFile = manifestFile; - resourceFile += ".res"; - // add the resource file to the end of the link command - linkCommand.push_back(resourceFile); - std::string outputOpt = "/fo"; - outputOpt += resourceFile; - rcCommand.push_back(outputOpt); - rcCommand.push_back(resourceInputFile); - // Run rc command to create resource - if(!cmcmd::RunCommand("RC Pass 1", rcCommand, verbose)) - { - return -1; - } - // Now run the link command to link and create manifest - if(!cmcmd::RunCommand("LINK Pass 1", linkCommand, verbose)) + + // Compile the resource file. + std::vector<std::string> rcCommand; + rcCommand.push_back(cmSystemTools::FindProgram("rc.exe")); + rcCommand.push_back("/fo" + this->ManifestFileRes); + rcCommand.push_back(this->ManifestFileRC); + if (!RunCommand("RC Pass 1", rcCommand, this->Verbose)) { return -1; } - // create mt command - std::string outArg("/out:"); - outArg+= manifestFile; - mtCommand.push_back("/nologo"); - mtCommand.push_back(outArg); - mtCommand.push_back("/notify_update"); - mtCommand.push_back("/manifest"); - mtCommand.push_back(tempManifest); - // now run mt.exe to create the final manifest file - int mtRet =0; - if(!cmcmd::RunCommand("MT", mtCommand, verbose, &mtRet)) + + // Run the link command (possibly generates intermediate manifest). + if (!RunCommand("LINK Pass 1", this->LinkCommand, this->Verbose)) { return -1; } - // if mt returns 0, then the manifest was not changed and - // we do not need to do another link step - if(mtRet == 0) - { - return 0; - } - // check for magic mt return value if mt returns the magic number - // 1090650113 then it means that it updated the manifest file and we need - // to do the final link. If mt has any value other than 0 or 1090650113 - // then there was some problem with the command itself and there was an - // error so return the error code back out of cmake so make can report it. - // (when hosted on a posix system the value is 187) - if(mtRet != 1090650113 && mtRet != 187) + + // Run the manifest tool to create the final manifest. + int mtRet = this->RunMT("/out:" + this->ManifestFile, true); + + // If mt returns 1090650113 (or 187 on a posix host) then it updated the + // manifest file so we need to embed it again. Otherwise we are done. + if (mtRet != 1090650113 && mtRet != 187) { return mtRet; } - // update the resource file with the new manifest from the mt command. - if(!cmcmd::RunCommand("RC Pass 2", rcCommand, verbose)) + + // Compile the resource file again. + if (!RunCommand("RC Pass 2", rcCommand, this->Verbose)) { return -1; } - // Run the final incremental link that will put the new manifest resource - // into the file incrementally. - if(!cmcmd::RunCommand("FINAL LINK", linkCommand, verbose)) + + // Link incrementally again to use the updated resource. + if (!RunCommand("FINAL LINK", this->LinkCommand, this->Verbose)) { return -1; } return 0; } -int cmcmd::VisualStudioLinkNonIncremental(std::vector<std::string>& args, - int type, - bool hasManifest, - bool verbose) +int cmVSLink::LinkNonIncremental() { - std::vector<std::string> linkCommand; - std::string targetName; - if(cmcmd::ParseVisualStudioLinkCommand(args, linkCommand, targetName) == -1) - { - return -1; - } - // Run the link command as given - if (hasManifest) - { - linkCommand.push_back("/MANIFEST"); - } - if(!cmcmd::RunCommand("LINK", linkCommand, verbose)) + // Run the link command (possibly generates intermediate manifest). + if (!RunCommand("LINK", this->LinkCommand, this->Verbose)) { return -1; } - if(!hasManifest) + + // If we have no manifest files we are done. + if (!this->LinkGeneratesManifest && this->UserManifests.empty()) { return 0; } + + // Run the manifest tool to embed the final manifest in the binary. + std::string mtOut = + "/outputresource:" + this->TargetFile + (this->Type == 1? ";#1" : ";#2"); + return this->RunMT(mtOut, false); +} + +int cmVSLink::RunMT(std::string const& out, bool notify) +{ std::vector<std::string> mtCommand; mtCommand.push_back(cmSystemTools::FindProgram("mt.exe")); mtCommand.push_back("/nologo"); mtCommand.push_back("/manifest"); - std::string manifestFile = targetName; - manifestFile += ".manifest"; - mtCommand.push_back(manifestFile); - std::string outresource = "/outputresource:"; - outresource += targetName; - outresource += ";#"; - if(type == 1) + if (this->LinkGeneratesManifest) { - outresource += "1"; + mtCommand.push_back(this->LinkerManifestFile); } - else if(type == 2) + mtCommand.insert(mtCommand.end(), + this->UserManifests.begin(), this->UserManifests.end()); + mtCommand.push_back(out); + if (notify) { - outresource += "2"; + // Add an undocumented option that enables a special return + // code to notify us when the manifest is modified. + mtCommand.push_back("/notify_update"); } - mtCommand.push_back(outresource); - // Now use the mt tool to embed the manifest into the exe or dll - if(!cmcmd::RunCommand("MT", mtCommand, verbose)) + int mtRet = 0; + if (!RunCommand("MT", mtCommand, this->Verbose, &mtRet)) { return -1; } - return 0; + return mtRet; } diff --git a/Source/cmcmd.h b/Source/cmcmd.h index 2bfbae7..64b2406 100644 --- a/Source/cmcmd.h +++ b/Source/cmcmd.h @@ -35,20 +35,6 @@ protected: static int WindowsCEEnvironment(const char* version, const std::string& name); static int VisualStudioLink(std::vector<std::string>& args, int type); - static int VisualStudioLinkIncremental(std::vector<std::string>& args, - int type, - bool verbose); - static int VisualStudioLinkNonIncremental(std::vector<std::string>& args, - int type, - bool hasManifest, - bool verbose); - static int ParseVisualStudioLinkCommand(std::vector<std::string>& args, - std::vector<std::string>& command, - std::string& targetName); - static bool RunCommand(const char* comment, - std::vector<std::string>& command, - bool verbose, - int* retCodeOut = 0); }; #endif diff --git a/Source/ctest.cxx b/Source/ctest.cxx index afcbd61..7fa6aed 100644 --- a/Source/ctest.cxx +++ b/Source/ctest.cxx @@ -46,6 +46,10 @@ static const char * cmDocumentationOptions[][2] = {"--debug", "Displaying more verbose internals of CTest."}, {"--output-on-failure", "Output anything outputted by the test program " "if the test should fail."}, + {"--test-output-size-passed <size>", "Limit the output for passed tests " + "to <size> bytes"}, + {"--test-output-size-failed <size>", "Limit the output for failed tests " + "to <size> bytes"}, {"-F", "Enable failover."}, {"-j <jobs>, --parallel <jobs>", "Run the tests in parallel using the " "given number of jobs."}, diff --git a/Source/kwsys/CMakeLists.txt b/Source/kwsys/CMakeLists.txt index c1229ff..ce7f563 100644 --- a/Source/kwsys/CMakeLists.txt +++ b/Source/kwsys/CMakeLists.txt @@ -35,15 +35,6 @@ # SET(KWSYS_HEADER_ROOT ${PROJECT_BINARY_DIR}) # INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR}) # -# KWSYS_IOS_FORCE_OLD = Force use of old non-ANSI C++ streams even if -# new streams are available. This may be used -# by projects that cannot configure their -# streams library. -# Example: -# -# SET(KWSYS_IOS_FORCE_OLD 1) -# -# # Optional settings to setup install rules are as follows: # # KWSYS_INSTALL_BIN_DIR = The installation target directories into @@ -351,110 +342,6 @@ ENDIF() # capabilities and parent project's request. Enforce 0/1 as only # possible values for configuration into Configure.hxx. -KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAVE_STD - "Checking whether STL classes are in std namespace" DIRECT) - -IF(KWSYS_IOS_FORCE_OLD) - SET(KWSYS_IOS_USE_ANSI 0) -ELSE() - KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_ANSI - "Checking whether ANSI stream headers are available" DIRECT) -ENDIF() - -IF(KWSYS_IOS_USE_ANSI) - KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAVE_STD - "Checking whether ANSI streams are in std namespace" DIRECT) - KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_SSTREAM - "Checking whether ANSI string stream is available" DIRECT) -ELSE() - SET(KWSYS_IOS_HAVE_STD 0) - SET(KWSYS_IOS_USE_SSTREAM 0) -ENDIF() - -IF(KWSYS_IOS_USE_SSTREAM) - SET(KWSYS_IOS_USE_STRSTREAM_H 0) - SET(KWSYS_IOS_USE_STRSTREA_H 0) -ELSE() - KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_STRSTREAM_H - "Checking whether strstream.h is available" DIRECT) - IF(KWSYS_IOS_USE_STRSTREAM_H) - SET(KWSYS_IOS_USE_STRSTREA_H 0) - ELSE() - KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_STRSTREA_H - "Checking whether strstrea.h is available" DIRECT) - ENDIF() -ENDIF() - -KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_CSTDDEF - "Checking whether header cstddef is available" DIRECT) - -SET(KWSYS_PLATFORM_CXX_TEST_DEFINES - -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}) -KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_NEQ_CHAR - "Checking whether stl string has operator!= for char*" DIRECT) -KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ITERATOR_TRAITS - "Checking whether stl has iterator_traits" DIRECT) -IF(KWSYS_STL_HAS_ITERATOR_TRAITS) - SET(KWSYS_STL_HAS_ITERATOR_CATEGORY 0) - SET(KWSYS_STL_HAS___ITERATOR_CATEGORY 0) -ELSE() - KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ITERATOR_CATEGORY - "Checking whether stl has old iterator_category" DIRECT) - IF(KWSYS_STL_HAS_ITERATOR_CATEGORY) - SET(KWSYS_STL_HAS___ITERATOR_CATEGORY 0) - ELSE() - KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS___ITERATOR_CATEGORY - "Checking whether stl has internal __iterator_category" DIRECT) - ENDIF() -ENDIF() -KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE - "Checking whether stl has standard template allocator" DIRECT) -IF(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE) - SET(KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE 0) - KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_REBIND - "Checking for rebind member of stl allocator" DIRECT) - KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT - "Checking for non-standard argument to stl allocator<>::max_size" DIRECT) -ELSE() - KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE - "Checking whether stl has old non-template allocator" DIRECT) - SET(KWSYS_STL_HAS_ALLOCATOR_REBIND 0) - SET(KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT 0) -ENDIF() -KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_OBJECTS - "Checking whether stl containers support allocator objects." DIRECT) -IF(KWSYS_IOS_USE_ANSI AND NOT WATCOM) - # ANSI streams always have string operators. - SET(KWSYS_STL_STRING_HAVE_OSTREAM 1) - SET(KWSYS_STL_STRING_HAVE_ISTREAM 1) -ELSE() - # There may not be string operators for old streams. - KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_OSTREAM - "Checking whether stl string has ostream operator<<" DIRECT) - KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_ISTREAM - "Checking whether stl string has istream operator>>" DIRECT) -ENDIF() -SET(KWSYS_PLATFORM_CXX_TEST_DEFINES - -DKWSYS_IOS_USE_ANSI=${KWSYS_IOS_USE_ANSI} - -DKWSYS_IOS_HAVE_STD=${KWSYS_IOS_HAVE_STD}) -KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAVE_BINARY - "Checking whether ios has binary openmode" DIRECT) -SET(KWSYS_PLATFORM_CXX_TEST_DEFINES) - -KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS - "Checking whether \"<>\" is needed for template friends" INVERT) -KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_MEMBER_TEMPLATES - "Checking for member template support" DIRECT) -KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_FULL_SPECIALIZATION - "Checking for standard template specialization syntax" DIRECT) -KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP - "Checking whether argument dependent lookup is supported" DIRECT) - -IF(UNIX) - KWSYS_PLATFORM_CXX_TEST(KWSYS_STAT_HAS_ST_MTIM - "Checking whether struct stat has st_mtim member" DIRECT) -ENDIF() - # Check existence and uniqueness of long long and __int64. KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_LONG_LONG "Checking whether C++ compiler has 'long long'" DIRECT) @@ -558,9 +445,6 @@ ENDIF() IF(KWSYS_USE_IOStream) # Determine whether iostreams support long long. - SET(KWSYS_PLATFORM_CXX_TEST_DEFINES - -DKWSYS_IOS_USE_ANSI=${KWSYS_IOS_USE_ANSI} - -DKWSYS_IOS_HAVE_STD=${KWSYS_IOS_HAVE_STD}) IF(KWSYS_CXX_HAS_LONG_LONG) KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_ISTREAM_LONG_LONG "Checking if istream supports long long" DIRECT) @@ -579,7 +463,6 @@ IF(KWSYS_USE_IOStream) SET(KWSYS_IOS_HAS_ISTREAM___INT64 0) SET(KWSYS_IOS_HAS_OSTREAM___INT64 0) ENDIF() - SET(KWSYS_PLATFORM_CXX_TEST_DEFINES) ENDIF() IF(KWSYS_NAMESPACE MATCHES "^kwsys$") @@ -623,12 +506,18 @@ IF(KWSYS_USE_SystemTools) "Checking whether CXX compiler has utimes" DIRECT) KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_UTIMENSAT "Checking whether CXX compiler has utimensat" DIRECT) + KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_STAT_HAS_ST_MTIM + "Checking whether CXX compiler struct stat has st_mtim member" DIRECT) + KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_STAT_HAS_ST_MTIMESPEC + "Checking whether CXX compiler struct stat has st_mtimespec member" DIRECT) SET_PROPERTY(SOURCE SystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS KWSYS_CXX_HAS_SETENV=${KWSYS_CXX_HAS_SETENV} KWSYS_CXX_HAS_UNSETENV=${KWSYS_CXX_HAS_UNSETENV} KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=${KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H} KWSYS_CXX_HAS_UTIMES=${KWSYS_CXX_HAS_UTIMES} KWSYS_CXX_HAS_UTIMENSAT=${KWSYS_CXX_HAS_UTIMENSAT} + KWSYS_CXX_STAT_HAS_ST_MTIM=${KWSYS_CXX_STAT_HAS_ST_MTIM} + KWSYS_CXX_STAT_HAS_ST_MTIMESPEC=${KWSYS_CXX_STAT_HAS_ST_MTIMESPEC} ) ENDIF() @@ -832,84 +721,6 @@ IF(KWSYS_INSTALL_DOC_DIR) ENDIF() #----------------------------------------------------------------------------- -# Create STL header wrappers to block warnings in the STL headers and -# give standard names by which they may be included. -SET(KWSYS_STL_HEADER_EXTRA_string 1) -FOREACH(header - algorithm - deque - exception - functional - iterator - list - map - memory - new - numeric - queue - set - stack - stdexcept - string - utility - vector - ) - # Configure the header wrapper. - SET(KWSYS_STL_HEADER "${header}") - IF(KWSYS_STL_HEADER_EXTRA_${header}) - SET(KWSYS_STL_HEADER_EXTRA - "#define ${KWSYS_NAMESPACE}_stl_${header}_including_hxx\n# include <${KWSYS_NAMESPACE}/stl/${header}.hxx>\n#undef ${KWSYS_NAMESPACE}_stl_${header}_including_hxx\n") - CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_stl_${header}.hxx.in - ${KWSYS_HEADER_DIR}/stl/${header}.hxx - @ONLY IMMEDIATE) - IF(KWSYS_INSTALL_INCLUDE_DIR) - INSTALL(FILES ${KWSYS_HEADER_DIR}/stl/${header}.hxx - DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/stl - ${KWSYS_INSTALL_INCLUDE_OPTIONS}) - ENDIF() - ELSE() - SET(KWSYS_STL_HEADER_EXTRA "") - ENDIF() - CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_stl.hxx.in - ${KWSYS_HEADER_DIR}/stl/${header} - @ONLY IMMEDIATE) - - # Create an install target for the header wrapper. - IF(KWSYS_INSTALL_INCLUDE_DIR) - INSTALL(FILES ${KWSYS_HEADER_DIR}/stl/${header} - DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/stl - ${KWSYS_INSTALL_INCLUDE_OPTIONS}) - ENDIF() -ENDFOREACH() - -# Provide cstddef header. -CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_cstddef.hxx.in - ${KWSYS_HEADER_DIR}/cstddef - @ONLY IMMEDIATE) -IF(KWSYS_INSTALL_INCLUDE_DIR) - INSTALL(FILES ${KWSYS_HEADER_DIR}/cstddef - DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE} - ${KWSYS_INSTALL_INCLUDE_OPTIONS}) -ENDIF() - -#----------------------------------------------------------------------------- -# Create streams header wrappers to give standard names by which they -# may be included. -FOREACH(header iostream fstream sstream iosfwd) - # Configure the header wrapper. - CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_ios_${header}.h.in - ${KWSYS_HEADER_DIR}/ios/${header} - @ONLY IMMEDIATE) - - # Create an install target for the header wrapper. - IF(KWSYS_INSTALL_INCLUDE_DIR) - INSTALL(FILES ${KWSYS_HEADER_DIR}/ios/${header} - DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/ios - ${KWSYS_INSTALL_INCLUDE_OPTIONS}) - ENDIF() -ENDFOREACH() - -#----------------------------------------------------------------------------- # Build a list of classes and headers we need to implement the # selected components. Initialize with required components. SET(KWSYS_CLASSES) diff --git a/Source/kwsys/CTestCustom.cmake.in b/Source/kwsys/CTestCustom.cmake.in index d6f802e..760221b 100644 --- a/Source/kwsys/CTestCustom.cmake.in +++ b/Source/kwsys/CTestCustom.cmake.in @@ -9,7 +9,6 @@ # resulting memory leaks are not logged by valgrind anyway. Therefore, we # don't have to exclude it. -set(CTEST_CUSTOM_MEMCHECK_IGNORE - ${CTEST_CUSTOM_MEMCHECK_IGNORE} +list(APPEND CTEST_CUSTOM_MEMCHECK_IGNORE kwsys.testProcess-10 ) diff --git a/Source/kwsys/CommandLineArguments.cxx b/Source/kwsys/CommandLineArguments.cxx index 9fa9802..3636836 100644 --- a/Source/kwsys/CommandLineArguments.cxx +++ b/Source/kwsys/CommandLineArguments.cxx @@ -15,22 +15,19 @@ #include KWSYS_HEADER(Configure.hxx) #include KWSYS_HEADER(String.hxx) -#include KWSYS_HEADER(stl/vector) -#include KWSYS_HEADER(stl/map) -#include KWSYS_HEADER(stl/set) -#include KWSYS_HEADER(ios/sstream) -#include KWSYS_HEADER(ios/iostream) - // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. #if 0 # include "CommandLineArguments.hxx.in" # include "Configure.hxx.in" -# include "kwsys_stl.hxx.in" -# include "kwsys_ios_sstream.h.in" -# include "kwsys_ios_iostream.h.in" #endif +#include <vector> +#include <map> +#include <set> +#include <sstream> +#include <iostream> + #include <stdio.h> #include <stdlib.h> #include <string.h> @@ -45,7 +42,7 @@ #if 0 # define CommandLineArguments_DEBUG(x) \ - kwsys_ios::cout << __LINE__ << " CLA: " << x << kwsys_ios::endl + std::cout << __LINE__ << " CLA: " << x << std::endl #else # define CommandLineArguments_DEBUG(x) #endif @@ -67,11 +64,11 @@ struct CommandLineArgumentsCallbackStructure }; class CommandLineArgumentsVectorOfStrings : - public kwsys_stl::vector<kwsys::String> {}; + public std::vector<kwsys::String> {}; class CommandLineArgumentsSetOfStrings : - public kwsys_stl::set<kwsys::String> {}; + public std::set<kwsys::String> {}; class CommandLineArgumentsMapOfStrucs : - public kwsys_stl::map<kwsys::String, + public std::map<kwsys::String, CommandLineArgumentsCallbackStructure> {}; class CommandLineArgumentsInternal @@ -152,8 +149,8 @@ void CommandLineArguments::ProcessArgument(const char* arg) //---------------------------------------------------------------------------- bool CommandLineArguments::GetMatchedArguments( - kwsys_stl::vector<kwsys_stl::string>* matches, - const kwsys_stl::string& arg) + std::vector<std::string>* matches, + const std::string& arg) { matches->clear(); CommandLineArguments::Internal::CallbacksMap::iterator it; @@ -184,15 +181,15 @@ bool CommandLineArguments::GetMatchedArguments( //---------------------------------------------------------------------------- int CommandLineArguments::Parse() { - kwsys_stl::vector<kwsys_stl::string>::size_type cc; - kwsys_stl::vector<kwsys_stl::string> matches; + std::vector<std::string>::size_type cc; + std::vector<std::string> matches; if ( this->StoreUnusedArgumentsFlag ) { this->Internals->UnusedArguments.clear(); } for ( cc = 0; cc < this->Internals->Argv.size(); cc ++ ) { - const kwsys_stl::string& arg = this->Internals->Argv[cc]; + const std::string& arg = this->Internals->Argv[cc]; CommandLineArguments_DEBUG("Process argument: " << arg); this->Internals->LastArgument = cc; if ( this->GetMatchedArguments(&matches, arg) ) @@ -214,7 +211,7 @@ int CommandLineArguments::Parse() // additional value CommandLineArgumentsCallbackStructure *cs = &this->Internals->Callbacks[matches[maxidx]]; - const kwsys_stl::string& sarg = matches[maxidx]; + const std::string& sarg = matches[maxidx]; if ( cs->Argument != sarg ) { abort(); @@ -267,7 +264,7 @@ int CommandLineArguments::Parse() CommandLineArguments_DEBUG("This is a multi argument: " << arg); for (cc++; cc < this->Internals->Argv.size(); ++ cc ) { - const kwsys_stl::string& marg = this->Internals->Argv[cc]; + const std::string& marg = this->Internals->Argv[cc]; CommandLineArguments_DEBUG(" check multi argument value: " << marg); if ( this->GetMatchedArguments(&matches, marg) ) { @@ -288,7 +285,7 @@ int CommandLineArguments::Parse() } break; default: - kwsys_ios::cerr << "Got unknown argument type: \"" << cs->ArgumentType << "\"" << kwsys_ios::endl; + std::cerr << "Got unknown argument type: \"" << cs->ArgumentType << "\"" << std::endl; this->Internals->LastArgument --; return 0; } @@ -313,7 +310,7 @@ int CommandLineArguments::Parse() } else { - kwsys_ios::cerr << "Got unknown argument: \"" << arg << "\"" << kwsys_ios::endl; + std::cerr << "Got unknown argument: \"" << arg << "\"" << std::endl; this->Internals->LastArgument --; return 0; } @@ -430,13 +427,13 @@ CommandLineArgumentsAddArgumentMacro(BOOL, bool) CommandLineArgumentsAddArgumentMacro(INT, int) CommandLineArgumentsAddArgumentMacro(DOUBLE, double) CommandLineArgumentsAddArgumentMacro(STRING, char*) -CommandLineArgumentsAddArgumentMacro(STL_STRING, kwsys_stl::string) +CommandLineArgumentsAddArgumentMacro(STL_STRING, std::string) -CommandLineArgumentsAddArgumentMacro(VECTOR_BOOL, kwsys_stl::vector<bool>) -CommandLineArgumentsAddArgumentMacro(VECTOR_INT, kwsys_stl::vector<int>) -CommandLineArgumentsAddArgumentMacro(VECTOR_DOUBLE, kwsys_stl::vector<double>) -CommandLineArgumentsAddArgumentMacro(VECTOR_STRING, kwsys_stl::vector<char*>) -CommandLineArgumentsAddArgumentMacro(VECTOR_STL_STRING, kwsys_stl::vector<kwsys_stl::string>) +CommandLineArgumentsAddArgumentMacro(VECTOR_BOOL, std::vector<bool>) +CommandLineArgumentsAddArgumentMacro(VECTOR_INT, std::vector<int>) +CommandLineArgumentsAddArgumentMacro(VECTOR_DOUBLE, std::vector<double>) +CommandLineArgumentsAddArgumentMacro(VECTOR_STRING, std::vector<char*>) +CommandLineArgumentsAddArgumentMacro(VECTOR_STL_STRING, std::vector<std::string>) //---------------------------------------------------------------------------- #define CommandLineArgumentsAddBooleanArgumentMacro(type, ctype) \ @@ -451,7 +448,7 @@ CommandLineArgumentsAddBooleanArgumentMacro(BOOL, bool) CommandLineArgumentsAddBooleanArgumentMacro(INT, int) CommandLineArgumentsAddBooleanArgumentMacro(DOUBLE, double) CommandLineArgumentsAddBooleanArgumentMacro(STRING, char*) -CommandLineArgumentsAddBooleanArgumentMacro(STL_STRING, kwsys_stl::string) +CommandLineArgumentsAddBooleanArgumentMacro(STL_STRING, std::string) //---------------------------------------------------------------------------- void CommandLineArguments::SetClientData(void* client_data) @@ -518,12 +515,12 @@ unsigned int CommandLineArguments::GetLastArgument() //---------------------------------------------------------------------------- void CommandLineArguments::GenerateHelp() { - kwsys_ios::ostringstream str; + std::ostringstream str; // Collapse all arguments into the map of vectors of all arguments that do // the same thing. CommandLineArguments::Internal::CallbacksMap::iterator it; - typedef kwsys_stl::map<CommandLineArguments::Internal::String, + typedef std::map<CommandLineArguments::Internal::String, CommandLineArguments::Internal::SetOfStrings > MapArgs; MapArgs mp; MapArgs::iterator mpit, smpit; @@ -604,7 +601,7 @@ void CommandLineArguments::GenerateHelp() CommandLineArguments::Internal::SetOfStrings::iterator sit; for ( sit = mpit->second.begin(); sit != mpit->second.end(); sit++ ) { - str << kwsys_ios::endl; + str << std::endl; char argument[100]; sprintf(argument, "%s", sit->c_str()); switch ( this->Internals->Callbacks[*sit].ArgumentType ) @@ -658,8 +655,8 @@ void CommandLineArguments::GenerateHelp() skip = cc; } } - str.write(ptr, static_cast<kwsys_ios::streamsize>(skip)); - str << kwsys_ios::endl; + str.write(ptr, static_cast<std::streamsize>(skip)); + str << std::endl; ptr += skip; len -= skip; cnt ++; @@ -680,7 +677,7 @@ void CommandLineArguments::GenerateHelp() //---------------------------------------------------------------------------- void CommandLineArguments::PopulateVariable( - bool* variable, const kwsys_stl::string& value) + bool* variable, const std::string& value) { if ( value == "1" || value == "ON" || value == "on" || value == "On" || value == "TRUE" || value == "true" || value == "True" || @@ -696,7 +693,7 @@ void CommandLineArguments::PopulateVariable( //---------------------------------------------------------------------------- void CommandLineArguments::PopulateVariable( - int* variable, const kwsys_stl::string& value) + int* variable, const std::string& value) { char* res = 0; *variable = static_cast<int>(strtol(value.c_str(), &res, 10)); @@ -708,7 +705,7 @@ void CommandLineArguments::PopulateVariable( //---------------------------------------------------------------------------- void CommandLineArguments::PopulateVariable( - double* variable, const kwsys_stl::string& value) + double* variable, const std::string& value) { char* res = 0; *variable = strtod(value.c_str(), &res); @@ -720,7 +717,7 @@ void CommandLineArguments::PopulateVariable( //---------------------------------------------------------------------------- void CommandLineArguments::PopulateVariable( - char** variable, const kwsys_stl::string& value) + char** variable, const std::string& value) { if ( *variable ) { @@ -733,14 +730,14 @@ void CommandLineArguments::PopulateVariable( //---------------------------------------------------------------------------- void CommandLineArguments::PopulateVariable( - kwsys_stl::string* variable, const kwsys_stl::string& value) + std::string* variable, const std::string& value) { *variable = value; } //---------------------------------------------------------------------------- void CommandLineArguments::PopulateVariable( - kwsys_stl::vector<bool>* variable, const kwsys_stl::string& value) + std::vector<bool>* variable, const std::string& value) { bool val = false; if ( value == "1" || value == "ON" || value == "on" || value == "On" || @@ -754,7 +751,7 @@ void CommandLineArguments::PopulateVariable( //---------------------------------------------------------------------------- void CommandLineArguments::PopulateVariable( - kwsys_stl::vector<int>* variable, const kwsys_stl::string& value) + std::vector<int>* variable, const std::string& value) { char* res = 0; variable->push_back(static_cast<int>(strtol(value.c_str(), &res, 10))); @@ -766,7 +763,7 @@ void CommandLineArguments::PopulateVariable( //---------------------------------------------------------------------------- void CommandLineArguments::PopulateVariable( - kwsys_stl::vector<double>* variable, const kwsys_stl::string& value) + std::vector<double>* variable, const std::string& value) { char* res = 0; variable->push_back(strtod(value.c_str(), &res)); @@ -778,7 +775,7 @@ void CommandLineArguments::PopulateVariable( //---------------------------------------------------------------------------- void CommandLineArguments::PopulateVariable( - kwsys_stl::vector<char*>* variable, const kwsys_stl::string& value) + std::vector<char*>* variable, const std::string& value) { char* var = new char[ value.size() + 1 ]; strcpy(var, value.c_str()); @@ -787,8 +784,8 @@ void CommandLineArguments::PopulateVariable( //---------------------------------------------------------------------------- void CommandLineArguments::PopulateVariable( - kwsys_stl::vector<kwsys_stl::string>* variable, - const kwsys_stl::string& value) + std::vector<std::string>* variable, + const std::string& value) { variable->push_back(value); } @@ -809,7 +806,7 @@ bool CommandLineArguments::PopulateVariable(CommandLineArgumentsCallbackStructur CommandLineArguments_DEBUG("Set argument: " << cs->Argument << " to " << value); if ( cs->Variable ) { - kwsys_stl::string var = "1"; + std::string var = "1"; if ( value ) { var = value; @@ -826,28 +823,28 @@ bool CommandLineArguments::PopulateVariable(CommandLineArgumentsCallbackStructur this->PopulateVariable(static_cast<char**>(cs->Variable), var); break; case CommandLineArguments::STL_STRING_TYPE: - this->PopulateVariable(static_cast<kwsys_stl::string*>(cs->Variable), var); + this->PopulateVariable(static_cast<std::string*>(cs->Variable), var); break; case CommandLineArguments::BOOL_TYPE: this->PopulateVariable(static_cast<bool*>(cs->Variable), var); break; case CommandLineArguments::VECTOR_BOOL_TYPE: - this->PopulateVariable(static_cast<kwsys_stl::vector<bool>*>(cs->Variable), var); + this->PopulateVariable(static_cast<std::vector<bool>*>(cs->Variable), var); break; case CommandLineArguments::VECTOR_INT_TYPE: - this->PopulateVariable(static_cast<kwsys_stl::vector<int>*>(cs->Variable), var); + this->PopulateVariable(static_cast<std::vector<int>*>(cs->Variable), var); break; case CommandLineArguments::VECTOR_DOUBLE_TYPE: - this->PopulateVariable(static_cast<kwsys_stl::vector<double>*>(cs->Variable), var); + this->PopulateVariable(static_cast<std::vector<double>*>(cs->Variable), var); break; case CommandLineArguments::VECTOR_STRING_TYPE: - this->PopulateVariable(static_cast<kwsys_stl::vector<char*>*>(cs->Variable), var); + this->PopulateVariable(static_cast<std::vector<char*>*>(cs->Variable), var); break; case CommandLineArguments::VECTOR_STL_STRING_TYPE: - this->PopulateVariable(static_cast<kwsys_stl::vector<kwsys_stl::string>*>(cs->Variable), var); + this->PopulateVariable(static_cast<std::vector<std::string>*>(cs->Variable), var); break; default: - kwsys_ios::cerr << "Got unknown variable type: \"" << cs->VariableType << "\"" << kwsys_ios::endl; + std::cerr << "Got unknown variable type: \"" << cs->VariableType << "\"" << std::endl; this->Internals->LastArgument --; return 0; } diff --git a/Source/kwsys/CommandLineArguments.hxx.in b/Source/kwsys/CommandLineArguments.hxx.in index cbf6ee3..e4f6d02 100644 --- a/Source/kwsys/CommandLineArguments.hxx.in +++ b/Source/kwsys/CommandLineArguments.hxx.in @@ -15,13 +15,8 @@ #include <@KWSYS_NAMESPACE@/Configure.h> #include <@KWSYS_NAMESPACE@/Configure.hxx> -#include <@KWSYS_NAMESPACE@/stl/string> -#include <@KWSYS_NAMESPACE@/stl/vector> - -/* Define this macro temporarily to keep the code readable. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define kwsys_stl @KWSYS_NAMESPACE@_stl -#endif +#include <string> +#include <vector> namespace @KWSYS_NAMESPACE@ { @@ -64,7 +59,7 @@ struct CommandLineArgumentsCallbackStructure; * "This is help string for --something"); * if ( !arg.Parse() ) * { - * kwsys_ios::cerr << "Problem parsing arguments" << kwsys_ios::endl; + * std::cerr << "Problem parsing arguments" << std::endl; * res = 1; * } * @@ -155,7 +150,7 @@ public: void AddArgument(const char* argument, ArgumentTypeEnum type, char** variable, const char* help); void AddArgument(const char* argument, ArgumentTypeEnum type, - kwsys_stl::string* variable, const char* help); + std::string* variable, const char* help); /** * Add handler for argument which is going to set the variable to the @@ -163,15 +158,15 @@ public: * appropriate type. This will handle the multi argument values. */ void AddArgument(const char* argument, ArgumentTypeEnum type, - kwsys_stl::vector<bool>* variable, const char* help); + std::vector<bool>* variable, const char* help); void AddArgument(const char* argument, ArgumentTypeEnum type, - kwsys_stl::vector<int>* variable, const char* help); + std::vector<int>* variable, const char* help); void AddArgument(const char* argument, ArgumentTypeEnum type, - kwsys_stl::vector<double>* variable, const char* help); + std::vector<double>* variable, const char* help); void AddArgument(const char* argument, ArgumentTypeEnum type, - kwsys_stl::vector<char*>* variable, const char* help); + std::vector<char*>* variable, const char* help); void AddArgument(const char* argument, ArgumentTypeEnum type, - kwsys_stl::vector<kwsys_stl::string>* variable, const char* help); + std::vector<std::string>* variable, const char* help); /** * Add handler for boolean argument. The argument does not take any option @@ -187,7 +182,7 @@ public: void AddBooleanArgument(const char* argument, char** variable, const char* help); void AddBooleanArgument(const char* argument, - kwsys_stl::string* variable, const char* help); + std::string* variable, const char* help); /** * Set the callbacks for error handling. @@ -243,28 +238,28 @@ protected: void AddArgument(const char* argument, ArgumentTypeEnum type, VariableTypeEnum vtype, void* variable, const char* help); - bool GetMatchedArguments(kwsys_stl::vector<kwsys_stl::string>* matches, - const kwsys_stl::string& arg); + bool GetMatchedArguments(std::vector<std::string>* matches, + const std::string& arg); //! Populate individual variables bool PopulateVariable(CommandLineArgumentsCallbackStructure* cs, const char* value); //! Populate individual variables of type ... - void PopulateVariable(bool* variable, const kwsys_stl::string& value); - void PopulateVariable(int* variable, const kwsys_stl::string& value); - void PopulateVariable(double* variable, const kwsys_stl::string& value); - void PopulateVariable(char** variable, const kwsys_stl::string& value); - void PopulateVariable(kwsys_stl::string* variable, const kwsys_stl::string& value); - void PopulateVariable(kwsys_stl::vector<bool>* variable, const kwsys_stl::string& value); - void PopulateVariable(kwsys_stl::vector<int>* variable, const kwsys_stl::string& value); - void PopulateVariable(kwsys_stl::vector<double>* variable, const kwsys_stl::string& value); - void PopulateVariable(kwsys_stl::vector<char*>* variable, const kwsys_stl::string& value); - void PopulateVariable(kwsys_stl::vector<kwsys_stl::string>* variable, const kwsys_stl::string& value); + void PopulateVariable(bool* variable, const std::string& value); + void PopulateVariable(int* variable, const std::string& value); + void PopulateVariable(double* variable, const std::string& value); + void PopulateVariable(char** variable, const std::string& value); + void PopulateVariable(std::string* variable, const std::string& value); + void PopulateVariable(std::vector<bool>* variable, const std::string& value); + void PopulateVariable(std::vector<int>* variable, const std::string& value); + void PopulateVariable(std::vector<double>* variable, const std::string& value); + void PopulateVariable(std::vector<char*>* variable, const std::string& value); + void PopulateVariable(std::vector<std::string>* variable, const std::string& value); typedef CommandLineArgumentsInternal Internal; Internal* Internals; - kwsys_stl::string Help; + std::string Help; unsigned int LineLength; @@ -273,11 +268,6 @@ protected: } // namespace @KWSYS_NAMESPACE@ -/* Undefine temporary macro. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# undef kwsys_stl -#endif - #endif diff --git a/Source/kwsys/Configure.hxx.in b/Source/kwsys/Configure.hxx.in index 8f5ace2..ff8e49d 100644 --- a/Source/kwsys/Configure.hxx.in +++ b/Source/kwsys/Configure.hxx.in @@ -15,164 +15,16 @@ /* Include C configuration. */ #include <@KWSYS_NAMESPACE@/Configure.h> -/* Whether ANSI C++ stream headers are to be used. */ -#define @KWSYS_NAMESPACE@_IOS_USE_ANSI @KWSYS_IOS_USE_ANSI@ - -/* Whether ANSI C++ streams are in std namespace. */ -#define @KWSYS_NAMESPACE@_IOS_HAVE_STD @KWSYS_IOS_HAVE_STD@ - -/* Whether ANSI C++ <sstream> header is to be used. */ -#define @KWSYS_NAMESPACE@_IOS_USE_SSTREAM @KWSYS_IOS_USE_SSTREAM@ - -/* Whether old C++ <strstream.h> header is to be used. */ -#define @KWSYS_NAMESPACE@_IOS_USE_STRSTREAM_H @KWSYS_IOS_USE_STRSTREAM_H@ - -/* Whether old C++ <strstrea.h> header is to be used. */ -#define @KWSYS_NAMESPACE@_IOS_USE_STRSTREA_H @KWSYS_IOS_USE_STRSTREA_H@ - -/* Whether C++ streams support the ios::binary openmode. */ -#define @KWSYS_NAMESPACE@_IOS_HAVE_BINARY @KWSYS_IOS_HAVE_BINARY@ - -/* Whether STL is in std namespace. */ -#define @KWSYS_NAMESPACE@_STL_HAVE_STD @KWSYS_STL_HAVE_STD@ - /* Whether wstring is available. */ #define @KWSYS_NAMESPACE@_STL_HAS_WSTRING @KWSYS_STL_HAS_WSTRING@ -/* Whether the STL string has operator<< for ostream. */ -#define @KWSYS_NAMESPACE@_STL_STRING_HAVE_OSTREAM @KWSYS_STL_STRING_HAVE_OSTREAM@ - -/* Whether the STL string has operator>> for istream. */ -#define @KWSYS_NAMESPACE@_STL_STRING_HAVE_ISTREAM @KWSYS_STL_STRING_HAVE_ISTREAM@ - -/* Whether the STL string has operator!= for char*. */ -#define @KWSYS_NAMESPACE@_STL_STRING_HAVE_NEQ_CHAR @KWSYS_STL_STRING_HAVE_NEQ_CHAR@ - -/* Define the stl namespace macro. */ -#if @KWSYS_NAMESPACE@_STL_HAVE_STD -# define @KWSYS_NAMESPACE@_stl std -#else -# define @KWSYS_NAMESPACE@_stl -#endif - -/* Define the ios namespace macro. */ -#if @KWSYS_NAMESPACE@_IOS_HAVE_STD -# define @KWSYS_NAMESPACE@_ios_namespace std -#else -# define @KWSYS_NAMESPACE@_ios_namespace -#endif -#if @KWSYS_NAMESPACE@_IOS_USE_SSTREAM -# define @KWSYS_NAMESPACE@_ios @KWSYS_NAMESPACE@_ios_namespace -#else -# define @KWSYS_NAMESPACE@_ios @KWSYS_NAMESPACE@_ios -#endif - -/* Define the ios::binary openmode macro. */ -#if @KWSYS_NAMESPACE@_IOS_HAVE_BINARY -# define @KWSYS_NAMESPACE@_ios_binary @KWSYS_NAMESPACE@_ios::ios::binary -#else -# define @KWSYS_NAMESPACE@_ios_binary 0 -#endif - -/* Whether the cstddef header is available. */ -#define @KWSYS_NAMESPACE@_CXX_HAS_CSTDDEF @KWSYS_CXX_HAS_CSTDDEF@ - -/* Whether the compiler supports null template arguments. */ -#define @KWSYS_NAMESPACE@_CXX_HAS_NULL_TEMPLATE_ARGS @KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS@ - -/* Define the null template arguments macro. */ -#if @KWSYS_NAMESPACE@_CXX_HAS_NULL_TEMPLATE_ARGS -# define @KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS <> -#else -# define @KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS -#endif - -/* Whether the compiler supports member templates. */ -#define @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES @KWSYS_CXX_HAS_MEMBER_TEMPLATES@ - -/* Whether the compiler supports argument dependent lookup. */ -#define @KWSYS_NAMESPACE@_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP @KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP@ - -/* Whether the compiler supports standard full specialization syntax. */ -#define @KWSYS_NAMESPACE@_CXX_HAS_FULL_SPECIALIZATION @KWSYS_CXX_HAS_FULL_SPECIALIZATION@ - -/* Define the specialization definition macro. */ -#if @KWSYS_NAMESPACE@_CXX_HAS_FULL_SPECIALIZATION -# define @KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION template <> -#else -# define @KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION -#endif - -/* Define typename keyword macro for use in declarations. */ -#if defined(_MSC_VER) && _MSC_VER < 1300 -# define @KWSYS_NAMESPACE@_CXX_DECL_TYPENAME -#else -# define @KWSYS_NAMESPACE@_CXX_DECL_TYPENAME typename -#endif - -/* Whether the stl has iterator_traits. */ -#define @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_TRAITS @KWSYS_STL_HAS_ITERATOR_TRAITS@ - -/* Whether the stl has iterator_category. */ -#define @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_CATEGORY @KWSYS_STL_HAS_ITERATOR_CATEGORY@ - -/* Whether the stl has __iterator_category. */ -#define @KWSYS_NAMESPACE@_STL_HAS___ITERATOR_CATEGORY @KWSYS_STL_HAS___ITERATOR_CATEGORY@ - -/* Whether the stl allocator is the standard template. */ -#define @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_TEMPLATE @KWSYS_STL_HAS_ALLOCATOR_TEMPLATE@ - -/* Whether the stl allocator is not a template. */ -#define @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_NONTEMPLATE @KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE@ - -/* Whether the stl allocator has rebind. */ -#define @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_REBIND @KWSYS_STL_HAS_ALLOCATOR_REBIND@ - -/* Whether the stl allocator has a size argument for max_size. */ -#define @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT @KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT@ - -/* Whether the stl containers support allocator objects. */ -#define @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_OBJECTS @KWSYS_STL_HAS_ALLOCATOR_OBJECTS@ - -/* Whether struct stat has the st_mtim member for high resolution times. */ -#define @KWSYS_NAMESPACE@_STAT_HAS_ST_MTIM @KWSYS_STAT_HAS_ST_MTIM@ - /* If building a C++ file in kwsys itself, give the source file access to the macros without a configured namespace. */ #if defined(KWSYS_NAMESPACE) # if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define kwsys_stl @KWSYS_NAMESPACE@_stl -# define kwsys_ios @KWSYS_NAMESPACE@_ios # define kwsys @KWSYS_NAMESPACE@ -# define kwsys_ios_binary @KWSYS_NAMESPACE@_ios_binary # endif # define KWSYS_NAME_IS_KWSYS @KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define KWSYS_STL_HAVE_STD @KWSYS_NAMESPACE@_STL_HAVE_STD -# define KWSYS_IOS_HAVE_STD @KWSYS_NAMESPACE@_IOS_HAVE_STD -# define KWSYS_IOS_USE_ANSI @KWSYS_NAMESPACE@_IOS_USE_ANSI -# define KWSYS_IOS_USE_SSTREAM @KWSYS_NAMESPACE@_IOS_USE_SSTREAM -# define KWSYS_IOS_USE_STRSTREAM_H @KWSYS_NAMESPACE@_IOS_USE_STRSTREAM_H -# define KWSYS_IOS_USE_STRSTREA_H @KWSYS_NAMESPACE@_IOS_USE_STRSTREA_H -# define KWSYS_IOS_HAVE_BINARY @KWSYS_NAMESPACE@_IOS_HAVE_BINARY -# define KWSYS_STAT_HAS_ST_MTIM @KWSYS_NAMESPACE@_STAT_HAS_ST_MTIM -# define KWSYS_CXX_HAS_CSTDDEF @KWSYS_NAMESPACE@_CXX_HAS_CSTDDEF -# define KWSYS_STL_STRING_HAVE_OSTREAM @KWSYS_NAMESPACE@_STL_STRING_HAVE_OSTREAM -# define KWSYS_STL_STRING_HAVE_ISTREAM @KWSYS_NAMESPACE@_STL_STRING_HAVE_ISTREAM -# define KWSYS_STL_STRING_HAVE_NEQ_CHAR @KWSYS_NAMESPACE@_STL_STRING_HAVE_NEQ_CHAR -# define KWSYS_CXX_NULL_TEMPLATE_ARGS @KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS -# define KWSYS_CXX_HAS_MEMBER_TEMPLATES @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES -# define KWSYS_CXX_HAS_FULL_SPECIALIZATION @KWSYS_NAMESPACE@_CXX_HAS_FULL_SPECIALIZATION -# define KWSYS_CXX_DEFINE_SPECIALIZATION @KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION -# define KWSYS_CXX_DECL_TYPENAME @KWSYS_NAMESPACE@_CXX_DECL_TYPENAME -# define KWSYS_STL_HAS_ALLOCATOR_REBIND @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_REBIND -# define KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT -# define KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP @KWSYS_NAMESPACE@_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP -# define KWSYS_STL_HAS_ITERATOR_TRAITS @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_TRAITS -# define KWSYS_STL_HAS_ITERATOR_CATEGORY @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_CATEGORY -# define KWSYS_STL_HAS___ITERATOR_CATEGORY @KWSYS_NAMESPACE@_STL_HAS___ITERATOR_CATEGORY -# define KWSYS_STL_HAS_ALLOCATOR_TEMPLATE @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_TEMPLATE -# define KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_NONTEMPLATE -# define KWSYS_STL_HAS_ALLOCATOR_OBJECTS @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_OBJECTS # define KWSYS_STL_HAS_WSTRING @KWSYS_NAMESPACE@_STL_HAS_WSTRING #endif diff --git a/Source/kwsys/Directory.cxx b/Source/kwsys/Directory.cxx index 58cea63..c549792 100644 --- a/Source/kwsys/Directory.cxx +++ b/Source/kwsys/Directory.cxx @@ -16,20 +16,17 @@ #include KWSYS_HEADER(Encoding.hxx) -#include KWSYS_HEADER(stl/string) -#include KWSYS_HEADER(stl/vector) - // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. #if 0 # include "Directory.hxx.in" # include "Configure.hxx.in" # include "Encoding.hxx.in" -# include "kwsys_stl.hxx.in" -# include "kwsys_stl_string.hxx.in" -# include "kwsys_stl_vector.hxx.in" #endif +#include <string> +#include <vector> + namespace KWSYS_NAMESPACE { @@ -38,10 +35,10 @@ class DirectoryInternals { public: // Array of Files - kwsys_stl::vector<kwsys_stl::string> Files; + std::vector<std::string> Files; // Path to Open'ed directory - kwsys_stl::string Path; + std::string Path; }; //---------------------------------------------------------------------------- @@ -103,7 +100,7 @@ void Directory::Clear() namespace KWSYS_NAMESPACE { -bool Directory::Load(const kwsys_stl::string& name) +bool Directory::Load(const std::string& name) { this->Clear(); #if _MSC_VER < 1300 @@ -153,7 +150,7 @@ bool Directory::Load(const kwsys_stl::string& name) return _findclose(srchHandle) != -1; } -unsigned long Directory::GetNumberOfFilesInDirectory(const kwsys_stl::string& name) +unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name) { #if _MSC_VER < 1300 long srchHandle; @@ -220,7 +217,7 @@ unsigned long Directory::GetNumberOfFilesInDirectory(const kwsys_stl::string& na namespace KWSYS_NAMESPACE { -bool Directory::Load(const kwsys_stl::string& name) +bool Directory::Load(const std::string& name) { this->Clear(); @@ -240,7 +237,7 @@ bool Directory::Load(const kwsys_stl::string& name) return 1; } -unsigned long Directory::GetNumberOfFilesInDirectory(const kwsys_stl::string& name) +unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name) { DIR* dir = opendir(name.c_str()); diff --git a/Source/kwsys/Directory.hxx.in b/Source/kwsys/Directory.hxx.in index 1bcf90e..e68f337 100644 --- a/Source/kwsys/Directory.hxx.in +++ b/Source/kwsys/Directory.hxx.in @@ -13,12 +13,7 @@ #define @KWSYS_NAMESPACE@_Directory_hxx #include <@KWSYS_NAMESPACE@/Configure.h> -#include <@KWSYS_NAMESPACE@/stl/string> - -/* Define these macros temporarily to keep the code readable. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define kwsys_stl @KWSYS_NAMESPACE@_stl -#endif +#include <string> namespace @KWSYS_NAMESPACE@ { @@ -44,7 +39,7 @@ public: * in that directory. 0 is returned if the directory can not be * opened, 1 if it is opened. */ - bool Load(const kwsys_stl::string&); + bool Load(const std::string&); /** * Return the number of files in the current directory. @@ -55,7 +50,7 @@ public: * Return the number of files in the specified directory. * A higher performance static method. */ - static unsigned long GetNumberOfFilesInDirectory(const kwsys_stl::string&); + static unsigned long GetNumberOfFilesInDirectory(const std::string&); /** * Return the file at the given index, the indexing is 0 based @@ -83,9 +78,4 @@ private: } // namespace @KWSYS_NAMESPACE@ -/* Undefine temporary macros. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# undef kwsys_stl -#endif - #endif diff --git a/Source/kwsys/DynamicLoader.cxx b/Source/kwsys/DynamicLoader.cxx index a776f97..1941d96 100644 --- a/Source/kwsys/DynamicLoader.cxx +++ b/Source/kwsys/DynamicLoader.cxx @@ -40,7 +40,7 @@ namespace KWSYS_NAMESPACE { //---------------------------------------------------------------------------- -DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname ) +DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname ) { return shl_load(libname.c_str(), BIND_DEFERRED | DYNAMIC_PATH, 0L); } @@ -57,7 +57,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib) //---------------------------------------------------------------------------- DynamicLoader::SymbolPointer -DynamicLoader::GetSymbolAddress(DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym) +DynamicLoader::GetSymbolAddress(DynamicLoader::LibraryHandle lib, const std::string& sym) { void* addr; int status; @@ -115,7 +115,7 @@ namespace KWSYS_NAMESPACE { //---------------------------------------------------------------------------- -DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname ) +DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname ) { NSObjectFileImageReturnCode rc; NSObjectFileImage image = 0; @@ -146,7 +146,7 @@ int DynamicLoader::CloseLibrary( DynamicLoader::LibraryHandle lib) //---------------------------------------------------------------------------- DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress( - DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym) + DynamicLoader::LibraryHandle lib, const std::string& sym) { void *result=0; // Need to prepend symbols with '_' on Apple-gcc compilers @@ -187,7 +187,7 @@ namespace KWSYS_NAMESPACE { //---------------------------------------------------------------------------- -DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname) +DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname) { DynamicLoader::LibraryHandle lh; int length = MultiByteToWideChar(CP_UTF8, 0, libname.c_str(), -1, NULL, 0); @@ -207,7 +207,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib) //---------------------------------------------------------------------------- DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress( - DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym) + DynamicLoader::LibraryHandle lib, const std::string& sym) { // TODO: The calling convention affects the name of the symbol. We // should have a tool to help get the symbol with the desired @@ -302,7 +302,7 @@ namespace KWSYS_NAMESPACE static image_id last_dynamic_err = B_OK; //---------------------------------------------------------------------------- -DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname ) +DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname ) { // image_id's are integers, errors are negative. Add one just in case we // get a valid image_id of zero (is that even possible?). @@ -340,7 +340,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib) //---------------------------------------------------------------------------- DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress( - DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym) + DynamicLoader::LibraryHandle lib, const std::string& sym) { // Hack to cast pointer-to-data to pointer-to-function. union @@ -393,7 +393,7 @@ namespace KWSYS_NAMESPACE { //---------------------------------------------------------------------------- -DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname ) +DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname ) { return 0; } @@ -411,7 +411,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib) //---------------------------------------------------------------------------- DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress( - DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym) + DynamicLoader::LibraryHandle lib, const std::string& sym) { return 0; } @@ -437,7 +437,7 @@ namespace KWSYS_NAMESPACE { //---------------------------------------------------------------------------- -DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname ) +DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname ) { char *name = (char *)calloc(1, libname.size() + 1); dld_init(program_invocation_name); @@ -456,7 +456,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib) //---------------------------------------------------------------------------- DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress( - DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym) + DynamicLoader::LibraryHandle lib, const std::string& sym) { // Hack to cast pointer-to-data to pointer-to-function. union @@ -489,7 +489,7 @@ namespace KWSYS_NAMESPACE { //---------------------------------------------------------------------------- -DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname ) +DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname ) { return dlopen(libname.c_str(), RTLD_LAZY); } @@ -508,7 +508,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib) //---------------------------------------------------------------------------- DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress( - DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym) + DynamicLoader::LibraryHandle lib, const std::string& sym) { // Hack to cast pointer-to-data to pointer-to-function. union diff --git a/Source/kwsys/DynamicLoader.hxx.in b/Source/kwsys/DynamicLoader.hxx.in index 75811ab..1e4a912 100644 --- a/Source/kwsys/DynamicLoader.hxx.in +++ b/Source/kwsys/DynamicLoader.hxx.in @@ -12,8 +12,8 @@ #ifndef @KWSYS_NAMESPACE@_DynamicLoader_hxx #define @KWSYS_NAMESPACE@_DynamicLoader_hxx -#include <@KWSYS_NAMESPACE@/Configure.h> -#include <@KWSYS_NAMESPACE@/stl/string> +#include <@KWSYS_NAMESPACE@/Configure.hxx> +#include <string> #if defined(__hpux) #include <dl.h> @@ -28,11 +28,6 @@ #include <be/kernel/image.h> #endif -/* Define these macros temporarily to keep the code readable. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define kwsys_stl @KWSYS_NAMESPACE@_stl -#endif - namespace @KWSYS_NAMESPACE@ { /** \class DynamicLoader @@ -83,14 +78,14 @@ public: /** Load a dynamic library into the current process. * The returned LibraryHandle can be used to access the symbols in the * library. */ - static LibraryHandle OpenLibrary(const kwsys_stl::string&); + static LibraryHandle OpenLibrary(const std::string&); /** Attempt to detach a dynamic library from the * process. A value of true is returned if it is sucessful. */ static int CloseLibrary(LibraryHandle); /** Find the address of the symbol in the given library. */ - static SymbolPointer GetSymbolAddress(LibraryHandle, const kwsys_stl::string&); + static SymbolPointer GetSymbolAddress(LibraryHandle, const std::string&); /** Return the default module prefix for the current platform. */ static const char* LibPrefix() { return "@KWSYS_DynamicLoader_PREFIX@"; } @@ -104,9 +99,4 @@ public: } // namespace @KWSYS_NAMESPACE@ -/* Undefine temporary macros. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# undef kwsys_stl -#endif - #endif diff --git a/Source/kwsys/Encoding.hxx.in b/Source/kwsys/Encoding.hxx.in index aba4175..87b1c21 100644 --- a/Source/kwsys/Encoding.hxx.in +++ b/Source/kwsys/Encoding.hxx.in @@ -13,13 +13,8 @@ #define @KWSYS_NAMESPACE@_Encoding_hxx #include <@KWSYS_NAMESPACE@/Configure.hxx> -#include <@KWSYS_NAMESPACE@/stl/string> -#include <@KWSYS_NAMESPACE@/stl/vector> - -/* Define these macros temporarily to keep the code readable. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define kwsys_stl @KWSYS_NAMESPACE@_stl -#endif +#include <string> +#include <vector> namespace @KWSYS_NAMESPACE@ { @@ -65,23 +60,18 @@ public: // Convert a narrow string to a wide string. // On Windows, UTF-8 is assumed, and on other platforms, // the current locale is assumed. - static kwsys_stl::wstring ToWide(const kwsys_stl::string& str); - static kwsys_stl::wstring ToWide(const char* str); + static std::wstring ToWide(const std::string& str); + static std::wstring ToWide(const char* str); // Convert a wide string to a narrow string. // On Windows, UTF-8 is assumed, and on other platforms, // the current locale is assumed. - static kwsys_stl::string ToNarrow(const kwsys_stl::wstring& str); - static kwsys_stl::string ToNarrow(const wchar_t* str); + static std::string ToNarrow(const std::wstring& str); + static std::string ToNarrow(const wchar_t* str); #endif // @KWSYS_NAMESPACE@_STL_HAS_WSTRING }; // class Encoding } // namespace @KWSYS_NAMESPACE@ -/* Undefine temporary macros. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# undef kwsys_stl -#endif - #endif diff --git a/Source/kwsys/EncodingCXX.cxx b/Source/kwsys/EncodingCXX.cxx index 251a56d..597d4bd 100644 --- a/Source/kwsys/EncodingCXX.cxx +++ b/Source/kwsys/EncodingCXX.cxx @@ -19,7 +19,6 @@ #include "kwsysPrivate.h" #include KWSYS_HEADER(Encoding.hxx) #include KWSYS_HEADER(Encoding.h) -#include KWSYS_HEADER(stl/vector) // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. @@ -28,6 +27,7 @@ # include "Encoding.h.in" #endif +#include <vector> #include <stdlib.h> #include <string.h> @@ -38,6 +38,7 @@ // Windows API. #if defined(_WIN32) # include <windows.h> +# include <shellapi.h> #endif namespace KWSYS_NAMESPACE @@ -140,23 +141,23 @@ char const* const* Encoding::CommandLineArguments::argv() const #if KWSYS_STL_HAS_WSTRING -kwsys_stl::wstring Encoding::ToWide(const kwsys_stl::string& str) +std::wstring Encoding::ToWide(const std::string& str) { return ToWide(str.c_str()); } -kwsys_stl::string Encoding::ToNarrow(const kwsys_stl::wstring& str) +std::string Encoding::ToNarrow(const std::wstring& str) { return ToNarrow(str.c_str()); } -kwsys_stl::wstring Encoding::ToWide(const char* cstr) +std::wstring Encoding::ToWide(const char* cstr) { - kwsys_stl::wstring wstr; + std::wstring wstr; size_t length = kwsysEncoding_mbstowcs(0, cstr, 0) + 1; if(length > 0) { - kwsys_stl::vector<wchar_t> wchars(length); + std::vector<wchar_t> wchars(length); if(kwsysEncoding_mbstowcs(&wchars[0], cstr, length) > 0) { wstr = &wchars[0]; @@ -165,9 +166,9 @@ kwsys_stl::wstring Encoding::ToWide(const char* cstr) return wstr; } -kwsys_stl::string Encoding::ToNarrow(const wchar_t* wcstr) +std::string Encoding::ToNarrow(const wchar_t* wcstr) { - kwsys_stl::string str; + std::string str; size_t length = kwsysEncoding_wcstombs(0, wcstr, 0) + 1; if(length > 0) { diff --git a/Source/kwsys/FStream.hxx.in b/Source/kwsys/FStream.hxx.in index 37055d6..681e4d8 100644 --- a/Source/kwsys/FStream.hxx.in +++ b/Source/kwsys/FStream.hxx.in @@ -12,8 +12,8 @@ #ifndef @KWSYS_NAMESPACE@_FStream_hxx #define @KWSYS_NAMESPACE@_FStream_hxx -#include <@KWSYS_NAMESPACE@/ios/fstream> #include <@KWSYS_NAMESPACE@/Encoding.hxx> +#include <fstream> namespace @KWSYS_NAMESPACE@ { @@ -167,8 +167,8 @@ class basic_ofstream : public std::basic_ostream<CharType,Traits> # undef @KWSYS_NAMESPACE@_FStream_NOEXCEPT #else - using @KWSYS_NAMESPACE@_ios_namespace::ofstream; - using @KWSYS_NAMESPACE@_ios_namespace::ifstream; + using std::ofstream; + using std::ifstream; #endif namespace FStream diff --git a/Source/kwsys/Glob.cxx b/Source/kwsys/Glob.cxx index 11bfd16..9d63459 100644 --- a/Source/kwsys/Glob.cxx +++ b/Source/kwsys/Glob.cxx @@ -17,9 +17,6 @@ #include KWSYS_HEADER(RegularExpression.hxx) #include KWSYS_HEADER(SystemTools.hxx) #include KWSYS_HEADER(Directory.hxx) -#include KWSYS_HEADER(stl/string) -#include KWSYS_HEADER(stl/vector) -#include KWSYS_HEADER(stl/algorithm) // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. @@ -29,12 +26,12 @@ # include "Configure.hxx.in" # include "RegularExpression.hxx.in" # include "SystemTools.hxx.in" -# include "kwsys_stl.hxx.in" -# include "kwsys_stl_string.hxx.in" -# include "kwsys_stl_vector.hxx.in" -# include "kwsys_stl_algorithm.hxx.in" #endif +#include <string> +#include <vector> +#include <algorithm> + #include <ctype.h> #include <stdio.h> #include <string.h> @@ -54,8 +51,8 @@ namespace KWSYS_NAMESPACE class GlobInternals { public: - kwsys_stl::vector<kwsys_stl::string> Files; - kwsys_stl::vector<kwsys::RegularExpression> Expressions; + std::vector<std::string> Files; + std::vector<kwsys::RegularExpression> Expressions; }; //---------------------------------------------------------------------------- @@ -82,21 +79,21 @@ Glob::~Glob() } //---------------------------------------------------------------------------- -kwsys_stl::vector<kwsys_stl::string>& Glob::GetFiles() +std::vector<std::string>& Glob::GetFiles() { return this->Internals->Files; } //---------------------------------------------------------------------------- -kwsys_stl::string Glob::PatternToRegex(const kwsys_stl::string& pattern, +std::string Glob::PatternToRegex(const std::string& pattern, bool require_whole_string, bool preserve_case) { // Incrementally build the regular expression from the pattern. - kwsys_stl::string regex = require_whole_string? "^" : ""; - kwsys_stl::string::const_iterator pattern_first = pattern.begin(); - kwsys_stl::string::const_iterator pattern_last = pattern.end(); - for(kwsys_stl::string::const_iterator i = pattern_first; + std::string regex = require_whole_string? "^" : ""; + std::string::const_iterator pattern_first = pattern.begin(); + std::string::const_iterator pattern_last = pattern.end(); + for(std::string::const_iterator i = pattern_first; i != pattern_last; ++i) { int c = *i; @@ -120,8 +117,8 @@ kwsys_stl::string Glob::PatternToRegex(const kwsys_stl::string& pattern, { // Parse out the bracket expression. It begins just after the // opening character. - kwsys_stl::string::const_iterator bracket_first = i+1; - kwsys_stl::string::const_iterator bracket_last = bracket_first; + std::string::const_iterator bracket_first = i+1; + std::string::const_iterator bracket_last = bracket_first; // The first character may be complementation '!' or '^'. if(bracket_last != pattern_last && @@ -153,7 +150,7 @@ kwsys_stl::string Glob::PatternToRegex(const kwsys_stl::string& pattern, else { // Convert the bracket string to its regex equivalent. - kwsys_stl::string::const_iterator k = bracket_first; + std::string::const_iterator k = bracket_first; // Open the regex block. regex += "["; @@ -221,8 +218,8 @@ kwsys_stl::string Glob::PatternToRegex(const kwsys_stl::string& pattern, } //---------------------------------------------------------------------------- -bool Glob::RecurseDirectory(kwsys_stl::string::size_type start, - const kwsys_stl::string& dir, GlobMessages* messages) +bool Glob::RecurseDirectory(std::string::size_type start, + const std::string& dir, GlobMessages* messages) { kwsys::Directory d; if ( !d.Load(dir) ) @@ -230,8 +227,8 @@ bool Glob::RecurseDirectory(kwsys_stl::string::size_type start, return true; } unsigned long cc; - kwsys_stl::string realname; - kwsys_stl::string fname; + std::string realname; + std::string fname; for ( cc = 0; cc < d.GetNumberOfFiles(); cc ++ ) { fname = d.GetFile(cc); @@ -262,8 +259,8 @@ bool Glob::RecurseDirectory(kwsys_stl::string::size_type start, if (isSymLink) { ++this->FollowedSymlinkCount; - kwsys_stl::string realPathErrorMessage; - kwsys_stl::string canonicalPath(SystemTools::GetRealPath(dir, + std::string realPathErrorMessage; + std::string canonicalPath(SystemTools::GetRealPath(dir, &realPathErrorMessage)); if(!realPathErrorMessage.empty()) @@ -277,7 +274,7 @@ bool Glob::RecurseDirectory(kwsys_stl::string::size_type start, return false; } - if(kwsys_stl::find(this->VisitedSymlinks.begin(), + if(std::find(this->VisitedSymlinks.begin(), this->VisitedSymlinks.end(), canonicalPath) == this->VisitedSymlinks.end()) { @@ -299,9 +296,9 @@ bool Glob::RecurseDirectory(kwsys_stl::string::size_type start, // else we have already visited this symlink - prevent cyclic recursion else if(messages) { - kwsys_stl::string message; - for(kwsys_stl::vector<kwsys_stl::string>::const_iterator - pathIt = kwsys_stl::find(this->VisitedSymlinks.begin(), + std::string message; + for(std::vector<std::string>::const_iterator + pathIt = std::find(this->VisitedSymlinks.begin(), this->VisitedSymlinks.end(), canonicalPath); pathIt != this->VisitedSymlinks.end(); ++pathIt) @@ -338,10 +335,10 @@ bool Glob::RecurseDirectory(kwsys_stl::string::size_type start, } //---------------------------------------------------------------------------- -void Glob::ProcessDirectory(kwsys_stl::string::size_type start, - const kwsys_stl::string& dir, GlobMessages* messages) +void Glob::ProcessDirectory(std::string::size_type start, + const std::string& dir, GlobMessages* messages) { - //kwsys_ios::cout << "ProcessDirectory: " << dir << kwsys_ios::endl; + //std::cout << "ProcessDirectory: " << dir << std::endl; bool last = ( start == this->Internals->Expressions.size()-1 ); if ( last && this->Recurse ) { @@ -360,8 +357,8 @@ void Glob::ProcessDirectory(kwsys_stl::string::size_type start, return; } unsigned long cc; - kwsys_stl::string realname; - kwsys_stl::string fname; + std::string realname; + std::string fname; for ( cc = 0; cc < d.GetNumberOfFiles(); cc ++ ) { fname = d.GetFile(cc); @@ -384,10 +381,10 @@ void Glob::ProcessDirectory(kwsys_stl::string::size_type start, fname = kwsys::SystemTools::LowerCase(fname); #endif - //kwsys_ios::cout << "Look at file: " << fname << kwsys_ios::endl; - //kwsys_ios::cout << "Match: " - // << this->Internals->TextExpressions[start].c_str() << kwsys_ios::endl; - //kwsys_ios::cout << "Real name: " << realname << kwsys_ios::endl; + //std::cout << "Look at file: " << fname << std::endl; + //std::cout << "Match: " + // << this->Internals->TextExpressions[start].c_str() << std::endl; + //std::cout << "Real name: " << realname << std::endl; if( (!last && !kwsys::SystemTools::FileIsDirectory(realname)) || (!this->ListDirs && last && @@ -411,11 +408,11 @@ void Glob::ProcessDirectory(kwsys_stl::string::size_type start, } //---------------------------------------------------------------------------- -bool Glob::FindFiles(const kwsys_stl::string& inexpr, GlobMessages* messages) +bool Glob::FindFiles(const std::string& inexpr, GlobMessages* messages) { - kwsys_stl::string cexpr; - kwsys_stl::string::size_type cc; - kwsys_stl::string expr = inexpr; + std::string cexpr; + std::string::size_type cc; + std::string expr = inexpr; this->Internals->Expressions.clear(); this->Internals->Files.clear(); @@ -425,10 +422,10 @@ bool Glob::FindFiles(const kwsys_stl::string& inexpr, GlobMessages* messages) expr = kwsys::SystemTools::GetCurrentWorkingDirectory(); expr += "/" + inexpr; } - kwsys_stl::string fexpr = expr; + std::string fexpr = expr; - kwsys_stl::string::size_type skip = 0; - kwsys_stl::string::size_type last_slash = 0; + std::string::size_type skip = 0; + std::string::size_type last_slash = 0; for ( cc = 0; cc < expr.size(); cc ++ ) { if ( cc > 0 && expr[cc] == '/' && expr[cc-1] != '\\' ) @@ -444,8 +441,8 @@ bool Glob::FindFiles(const kwsys_stl::string& inexpr, GlobMessages* messages) } if ( last_slash > 0 ) { - //kwsys_ios::cout << "I can skip: " << fexpr.substr(0, last_slash) - // << kwsys_ios::endl; + //std::cout << "I can skip: " << fexpr.substr(0, last_slash) + // << std::endl; skip = last_slash; } if ( skip == 0 ) @@ -517,7 +514,7 @@ bool Glob::FindFiles(const kwsys_stl::string& inexpr, GlobMessages* messages) } //---------------------------------------------------------------------------- -void Glob::AddExpression(const kwsys_stl::string& expr) +void Glob::AddExpression(const std::string& expr) { this->Internals->Expressions.push_back( kwsys::RegularExpression( @@ -546,7 +543,7 @@ const char* Glob::GetRelative() } //---------------------------------------------------------------------------- -void Glob::AddFile(kwsys_stl::vector<kwsys_stl::string>& files, const kwsys_stl::string& file) +void Glob::AddFile(std::vector<std::string>& files, const std::string& file) { if ( !this->Relative.empty() ) { diff --git a/Source/kwsys/Glob.hxx.in b/Source/kwsys/Glob.hxx.in index 5239ccd..ffee9ca 100644 --- a/Source/kwsys/Glob.hxx.in +++ b/Source/kwsys/Glob.hxx.in @@ -15,13 +15,8 @@ #include <@KWSYS_NAMESPACE@/Configure.h> #include <@KWSYS_NAMESPACE@/Configure.hxx> -#include <@KWSYS_NAMESPACE@/stl/string> -#include <@KWSYS_NAMESPACE@/stl/vector> - -/* Define this macro temporarily to keep the code readable. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define kwsys_stl @KWSYS_NAMESPACE@_stl -#endif +#include <string> +#include <vector> namespace @KWSYS_NAMESPACE@ { @@ -49,9 +44,9 @@ public: struct Message { MessageType type; - kwsys_stl::string content; + std::string content; - Message(MessageType t, const kwsys_stl::string& c) : + Message(MessageType t, const std::string& c) : type(t), content(c) {} @@ -67,18 +62,18 @@ public: } }; - typedef kwsys_stl::vector<Message> GlobMessages; - typedef kwsys_stl::vector<Message>::iterator GlobMessagesIterator; + typedef std::vector<Message> GlobMessages; + typedef std::vector<Message>::iterator GlobMessagesIterator; public: Glob(); ~Glob(); //! Find all files that match the pattern. - bool FindFiles(const kwsys_stl::string& inexpr, + bool FindFiles(const std::string& inexpr, GlobMessages* messages = 0); //! Return the list of files that matched. - kwsys_stl::vector<kwsys_stl::string>& GetFiles(); + std::vector<std::string>& GetFiles(); //! Set recurse to true to match subdirectories. void RecurseOn() { this->SetRecurse(true); } @@ -107,7 +102,7 @@ public: string. This is on by default because patterns always match whole strings, but may be disabled to support concatenating expressions more easily (regex1|regex2|etc). */ - static kwsys_stl::string PatternToRegex(const kwsys_stl::string& pattern, + static std::string PatternToRegex(const std::string& pattern, bool require_whole_string = true, bool preserve_case = false); @@ -122,28 +117,28 @@ public: protected: //! Process directory - void ProcessDirectory(kwsys_stl::string::size_type start, - const kwsys_stl::string& dir, + void ProcessDirectory(std::string::size_type start, + const std::string& dir, GlobMessages* messages); //! Process last directory, but only when recurse flags is on. That is // effectively like saying: /path/to/file/**/file - bool RecurseDirectory(kwsys_stl::string::size_type start, - const kwsys_stl::string& dir, + bool RecurseDirectory(std::string::size_type start, + const std::string& dir, GlobMessages* messages); //! Add regular expression - void AddExpression(const kwsys_stl::string& expr); + void AddExpression(const std::string& expr); //! Add a file to the list - void AddFile(kwsys_stl::vector<kwsys_stl::string>& files, const kwsys_stl::string& file); + void AddFile(std::vector<std::string>& files, const std::string& file); GlobInternals* Internals; bool Recurse; - kwsys_stl::string Relative; + std::string Relative; bool RecurseThroughSymlinks; unsigned int FollowedSymlinkCount; - kwsys_stl::vector<kwsys_stl::string> VisitedSymlinks; + std::vector<std::string> VisitedSymlinks; bool ListDirs; bool RecurseListDirs; @@ -154,9 +149,4 @@ private: } // namespace @KWSYS_NAMESPACE@ -/* Undefine temporary macro. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# undef kwsys_stl -#endif - #endif diff --git a/Source/kwsys/IOStream.cxx b/Source/kwsys/IOStream.cxx index a31f8c8..81c6a73 100644 --- a/Source/kwsys/IOStream.cxx +++ b/Source/kwsys/IOStream.cxx @@ -12,25 +12,14 @@ #include "kwsysPrivate.h" #include KWSYS_HEADER(Configure.hxx) -// Configure the implementation for the current streams library. -#if !KWSYS_IOS_USE_ANSI -# define ios_base ios -# if defined(__HP_aCC) -# define protected public -# include <iostream.h> // Hack access to some private stream methods. -# undef protected -# endif -#endif - // Include the streams library. -#include KWSYS_HEADER(ios/iostream) +#include <iostream> #include KWSYS_HEADER(IOStream.hxx) // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. #if 0 # include "Configure.hxx.in" -# include "kwsys_ios_iostream.hxx.in" # include "IOStream.hxx.in" #endif @@ -50,7 +39,7 @@ namespace KWSYS_NAMESPACE { // Scan an input stream for an integer value. -static int IOStreamScanStream(kwsys_ios::istream& is, char* buffer) +static int IOStreamScanStream(std::istream& is, char* buffer) { // Prepare to write to buffer. char* out = buffer; @@ -64,10 +53,10 @@ static int IOStreamScanStream(kwsys_ios::istream& is, char* buffer) // detect it from the input. A leading 0x means hex, and a leading // 0 alone means octal. int base = 0; - int flags = is.flags() & kwsys_ios::ios_base::basefield; - if(flags == kwsys_ios::ios_base::oct) { base = 8; } - else if(flags == kwsys_ios::ios_base::dec) { base = 10; } - else if(flags == kwsys_ios::ios_base::hex) { base = 16; } + int flags = is.flags() & std::ios_base::basefield; + if(flags == std::ios_base::oct) { base = 8; } + else if(flags == std::ios_base::dec) { base = 10; } + else if(flags == std::ios_base::hex) { base = 16; } bool foundDigit = false; bool foundNonZero = false; if(is.peek() == '0') @@ -134,24 +123,17 @@ static int IOStreamScanStream(kwsys_ios::istream& is, char* buffer) // Read an integer value from an input stream. template <class T> -kwsys_ios::istream& -IOStreamScanTemplate(kwsys_ios::istream& is, T& value, char type) +std::istream& +IOStreamScanTemplate(std::istream& is, T& value, char type) { - int state = kwsys_ios::ios_base::goodbit; + int state = std::ios_base::goodbit; // Skip leading whitespace. -# if KWSYS_IOS_USE_ANSI - kwsys_ios::istream::sentry okay(is); -# else - is.eatwhite(); - kwsys_ios::istream& okay = is; -# endif + std::istream::sentry okay(is); if(okay) { -# if KWSYS_IOS_USE_ANSI try { -# endif // Copy the string to a buffer and construct the format string. char buffer[KWSYS_IOS_INT64_MAX_DIG]; # if defined(_MSC_VER) @@ -174,52 +156,40 @@ IOStreamScanTemplate(kwsys_ios::istream& is, T& value, char type) int success = (sscanf(buffer, format, &result) == 1)?1:0; // Set flags for resulting state. - if(is.peek() == EOF) { state |= kwsys_ios::ios_base::eofbit; } - if(!success) { state |= kwsys_ios::ios_base::failbit; } + if(is.peek() == EOF) { state |= std::ios_base::eofbit; } + if(!success) { state |= std::ios_base::failbit; } else { value = result; } -# if KWSYS_IOS_USE_ANSI - } catch(...) { state |= kwsys_ios::ios_base::badbit; } -# endif + } catch(...) { state |= std::ios_base::badbit; } } -# if KWSYS_IOS_USE_ANSI - is.setstate(kwsys_ios::ios_base::iostate(state)); -# else - is.clear(state); -# endif + is.setstate(std::ios_base::iostate(state)); return is; } // Print an integer value to an output stream. template <class T> -kwsys_ios::ostream& -IOStreamPrintTemplate(kwsys_ios::ostream& os, T value, char type) +std::ostream& +IOStreamPrintTemplate(std::ostream& os, T value, char type) { -# if KWSYS_IOS_USE_ANSI - kwsys_ios::ostream::sentry okay(os); -# else - kwsys_ios::ostream& okay = os; -# endif + std::ostream::sentry okay(os); if(okay) { -# if KWSYS_IOS_USE_ANSI try { -# endif // Construct the format string. char format[8]; char* f = format; *f++ = '%'; - if(os.flags() & kwsys_ios::ios_base::showpos) { *f++ = '+'; } - if(os.flags() & kwsys_ios::ios_base::showbase) { *f++ = '#'; } + if(os.flags() & std::ios_base::showpos) { *f++ = '+'; } + if(os.flags() & std::ios_base::showbase) { *f++ = '#'; } # if defined(_MSC_VER) *f++ = 'I'; *f++ = '6'; *f++ = '4'; # else *f++ = 'l'; *f++ = 'l'; # endif - long bflags = os.flags() & kwsys_ios::ios_base::basefield; - if(bflags == kwsys_ios::ios_base::oct) { *f++ = 'o'; } - else if(bflags != kwsys_ios::ios_base::hex) { *f++ = type; } - else if(os.flags() & kwsys_ios::ios_base::uppercase) { *f++ = 'X'; } + long bflags = os.flags() & std::ios_base::basefield; + if(bflags == std::ios_base::oct) { *f++ = 'o'; } + else if(bflags != std::ios_base::hex) { *f++ = type; } + else if(os.flags() & std::ios_base::uppercase) { *f++ = 'X'; } else { *f++ = 'x'; } *f = '\0'; @@ -228,22 +198,20 @@ IOStreamPrintTemplate(kwsys_ios::ostream& os, T value, char type) char buffer[2*KWSYS_IOS_INT64_MAX_DIG]; sprintf(buffer, format, value); os << buffer; -# if KWSYS_IOS_USE_ANSI - } catch(...) { os.clear(os.rdstate() | kwsys_ios::ios_base::badbit); } -# endif + } catch(...) { os.clear(os.rdstate() | std::ios_base::badbit); } } return os; } # if !KWSYS_IOS_HAS_ISTREAM_LONG_LONG // Implement input stream operator for IOStreamSLL. -kwsys_ios::istream& IOStreamScan(kwsys_ios::istream& is, IOStreamSLL& value) +std::istream& IOStreamScan(std::istream& is, IOStreamSLL& value) { return IOStreamScanTemplate(is, value, 'd'); } // Implement input stream operator for IOStreamULL. -kwsys_ios::istream& IOStreamScan(kwsys_ios::istream& is, IOStreamULL& value) +std::istream& IOStreamScan(std::istream& is, IOStreamULL& value) { return IOStreamScanTemplate(is, value, 'u'); } @@ -251,13 +219,13 @@ kwsys_ios::istream& IOStreamScan(kwsys_ios::istream& is, IOStreamULL& value) # if !KWSYS_IOS_HAS_OSTREAM_LONG_LONG // Implement output stream operator for IOStreamSLL. -kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream& os, IOStreamSLL value) +std::ostream& IOStreamPrint(std::ostream& os, IOStreamSLL value) { return IOStreamPrintTemplate(os, value, 'd'); } // Implement output stream operator for IOStreamULL. -kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream& os, IOStreamULL value) +std::ostream& IOStreamPrint(std::ostream& os, IOStreamULL value) { return IOStreamPrintTemplate(os, value, 'u'); } diff --git a/Source/kwsys/IOStream.hxx.in b/Source/kwsys/IOStream.hxx.in index 2eeedf2..c101909 100644 --- a/Source/kwsys/IOStream.hxx.in +++ b/Source/kwsys/IOStream.hxx.in @@ -12,12 +12,11 @@ #ifndef @KWSYS_NAMESPACE@_IOStream_hxx #define @KWSYS_NAMESPACE@_IOStream_hxx -#include <@KWSYS_NAMESPACE@/ios/iosfwd> +#include <iosfwd> /* Define these macros temporarily to keep the code readable. */ #if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS # define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT -# define kwsys_ios @KWSYS_NAMESPACE@_ios #endif /* Whether istream supports long long. */ @@ -56,10 +55,8 @@ /* Input stream operator implementation functions. */ namespace @KWSYS_NAMESPACE@ { -kwsysEXPORT kwsys_ios::istream& IOStreamScan(kwsys_ios::istream&, - IOStreamSLL&); -kwsysEXPORT kwsys_ios::istream& IOStreamScan(kwsys_ios::istream&, - IOStreamULL&); +kwsysEXPORT std::istream& IOStreamScan(std::istream&, IOStreamSLL&); +kwsysEXPORT std::istream& IOStreamScan(std::istream&, IOStreamULL&); } /* Provide input stream operator for long long. */ @@ -67,8 +64,8 @@ kwsysEXPORT kwsys_ios::istream& IOStreamScan(kwsys_ios::istream&, !defined(KWSYS_IOS_ISTREAM_LONG_LONG_DEFINED) # define KWSYS_IOS_ISTREAM_LONG_LONG_DEFINED # define @KWSYS_NAMESPACE@_IOS_ISTREAM_LONG_LONG_DEFINED -inline kwsys_ios::istream& -operator>>(kwsys_ios::istream& is, @KWSYS_NAMESPACE@::IOStreamSLL& value) +inline std::istream& +operator>>(std::istream& is, @KWSYS_NAMESPACE@::IOStreamSLL& value) { return @KWSYS_NAMESPACE@::IOStreamScan(is, value); } @@ -79,8 +76,8 @@ operator>>(kwsys_ios::istream& is, @KWSYS_NAMESPACE@::IOStreamSLL& value) !defined(KWSYS_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED) # define KWSYS_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED # define @KWSYS_NAMESPACE@_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED -inline kwsys_ios::istream& -operator>>(kwsys_ios::istream& is, @KWSYS_NAMESPACE@::IOStreamULL& value) +inline std::istream& +operator>>(std::istream& is, @KWSYS_NAMESPACE@::IOStreamULL& value) { return @KWSYS_NAMESPACE@::IOStreamScan(is, value); } @@ -92,10 +89,8 @@ operator>>(kwsys_ios::istream& is, @KWSYS_NAMESPACE@::IOStreamULL& value) /* Output stream operator implementation functions. */ namespace @KWSYS_NAMESPACE@ { -kwsysEXPORT kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream&, - IOStreamSLL); -kwsysEXPORT kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream&, - IOStreamULL); +kwsysEXPORT std::ostream& IOStreamPrint(std::ostream&, IOStreamSLL); +kwsysEXPORT std::ostream& IOStreamPrint(std::ostream&, IOStreamULL); } /* Provide output stream operator for long long. */ @@ -103,8 +98,8 @@ kwsysEXPORT kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream&, !defined(KWSYS_IOS_OSTREAM_LONG_LONG_DEFINED) # define KWSYS_IOS_OSTREAM_LONG_LONG_DEFINED # define @KWSYS_NAMESPACE@_IOS_OSTREAM_LONG_LONG_DEFINED -inline kwsys_ios::ostream& -operator<<(kwsys_ios::ostream& os, @KWSYS_NAMESPACE@::IOStreamSLL value) +inline std::ostream& +operator<<(std::ostream& os, @KWSYS_NAMESPACE@::IOStreamSLL value) { return @KWSYS_NAMESPACE@::IOStreamPrint(os, value); } @@ -115,8 +110,8 @@ operator<<(kwsys_ios::ostream& os, @KWSYS_NAMESPACE@::IOStreamSLL value) !defined(KWSYS_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED) # define KWSYS_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED # define @KWSYS_NAMESPACE@_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED -inline kwsys_ios::ostream& -operator<<(kwsys_ios::ostream& os, @KWSYS_NAMESPACE@::IOStreamULL value) +inline std::ostream& +operator<<(std::ostream& os, @KWSYS_NAMESPACE@::IOStreamULL value) { return @KWSYS_NAMESPACE@::IOStreamPrint(os, value); } @@ -127,7 +122,6 @@ operator<<(kwsys_ios::ostream& os, @KWSYS_NAMESPACE@::IOStreamULL value) /* Undefine temporary macros. */ #if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS # undef kwsysEXPORT -# undef kwsys_ios #endif /* If building a C++ file in kwsys itself, give the source file diff --git a/Source/kwsys/RegularExpression.hxx.in b/Source/kwsys/RegularExpression.hxx.in index 502fbe2..d0235d8 100644 --- a/Source/kwsys/RegularExpression.hxx.in +++ b/Source/kwsys/RegularExpression.hxx.in @@ -33,12 +33,7 @@ #include <@KWSYS_NAMESPACE@/Configure.h> #include <@KWSYS_NAMESPACE@/Configure.hxx> -#include <@KWSYS_NAMESPACE@/stl/string> - -/* Define this macro temporarily to keep the code readable. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define kwsys_stl @KWSYS_NAMESPACE@_stl -#endif +#include <string> /* Disable useless Borland warnings. KWSys tries not to force things on its includers, but there is no choice here. */ @@ -207,7 +202,7 @@ public: /** * Instantiate RegularExpression with compiled string. */ - inline RegularExpression (kwsys_stl::string const&); + inline RegularExpression (std::string const&); /** * Destructor. @@ -224,7 +219,7 @@ public: * Compile a regular expression into internal code * for later pattern matching. */ - inline bool compile (kwsys_stl::string const&); + inline bool compile (std::string const&); /** * Matches the regular expression to the given string. @@ -236,17 +231,17 @@ public: * Matches the regular expression to the given std string. * Returns true if found, and sets start and end indexes accordingly. */ - inline bool find (kwsys_stl::string const&); + inline bool find (std::string const&); /** * Index to start of first find. */ - inline kwsys_stl::string::size_type start() const; + inline std::string::size_type start() const; /** * Index to end of first find. */ - inline kwsys_stl::string::size_type end() const; + inline std::string::size_type end() const; /** * Copy the given regular expression. @@ -285,9 +280,9 @@ public: * Destructor. */ // awf added - kwsys_stl::string::size_type start(int n) const; - kwsys_stl::string::size_type end(int n) const; - kwsys_stl::string match(int n) const; + std::string::size_type start(int n) const; + std::string::size_type end(int n) const; + std::string match(int n) const; enum { NSUBEXP = 10 }; private: @@ -296,7 +291,7 @@ private: char regstart; // Internal use only char reganch; // Internal use only const char* regmust; // Internal use only - kwsys_stl::string::size_type regmlen; // Internal use only + std::string::size_type regmlen; // Internal use only char* program; int progsize; const char* searchstring; @@ -327,7 +322,7 @@ inline RegularExpression::RegularExpression (const char* s) * Creates a regular expression from string s, and * compiles s. */ -inline RegularExpression::RegularExpression (const kwsys_stl::string& s) +inline RegularExpression::RegularExpression (const std::string& s) { this->program = 0; this->compile(s); @@ -347,7 +342,7 @@ inline RegularExpression::~RegularExpression () * Compile a regular expression into internal code * for later pattern matching. */ -inline bool RegularExpression::compile (kwsys_stl::string const& s) +inline bool RegularExpression::compile (std::string const& s) { return this->compile(s.c_str()); } @@ -356,7 +351,7 @@ inline bool RegularExpression::compile (kwsys_stl::string const& s) * Matches the regular expression to the given std string. * Returns true if found, and sets start and end indexes accordingly. */ -inline bool RegularExpression::find (kwsys_stl::string const& s) +inline bool RegularExpression::find (std::string const& s) { return this->find(s.c_str()); } @@ -364,9 +359,9 @@ inline bool RegularExpression::find (kwsys_stl::string const& s) /** * Set the start position for the regular expression. */ -inline kwsys_stl::string::size_type RegularExpression::start () const +inline std::string::size_type RegularExpression::start () const { - return static_cast<kwsys_stl::string::size_type>( + return static_cast<std::string::size_type>( this->startp[0] - searchstring); } @@ -374,9 +369,9 @@ inline kwsys_stl::string::size_type RegularExpression::start () const /** * Returns the start/end index of the last item found. */ -inline kwsys_stl::string::size_type RegularExpression::end () const +inline std::string::size_type RegularExpression::end () const { - return static_cast<kwsys_stl::string::size_type>( + return static_cast<std::string::size_type>( this->endp[0] - searchstring); } @@ -410,9 +405,9 @@ inline void RegularExpression::set_invalid () /** * Return start index of nth submatch. start(0) is the start of the full match. */ -inline kwsys_stl::string::size_type RegularExpression::start(int n) const +inline std::string::size_type RegularExpression::start(int n) const { - return static_cast<kwsys_stl::string::size_type>( + return static_cast<std::string::size_type>( this->startp[n] - searchstring); } @@ -420,34 +415,29 @@ inline kwsys_stl::string::size_type RegularExpression::start(int n) const /** * Return end index of nth submatch. end(0) is the end of the full match. */ -inline kwsys_stl::string::size_type RegularExpression::end(int n) const +inline std::string::size_type RegularExpression::end(int n) const { - return static_cast<kwsys_stl::string::size_type>( + return static_cast<std::string::size_type>( this->endp[n] - searchstring); } /** * Return nth submatch as a string. */ -inline kwsys_stl::string RegularExpression::match(int n) const +inline std::string RegularExpression::match(int n) const { if (this->startp[n]==0) { - return kwsys_stl::string(""); + return std::string(""); } else { - return kwsys_stl::string(this->startp[n], - static_cast<kwsys_stl::string::size_type>( + return std::string(this->startp[n], + static_cast<std::string::size_type>( this->endp[n] - this->startp[n])); } } } // namespace @KWSYS_NAMESPACE@ -/* Undefine temporary macro. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# undef kwsys_stl -#endif - #endif diff --git a/Source/kwsys/String.hxx.in b/Source/kwsys/String.hxx.in index 4386c9e..2e9aedb 100644 --- a/Source/kwsys/String.hxx.in +++ b/Source/kwsys/String.hxx.in @@ -12,7 +12,7 @@ #ifndef @KWSYS_NAMESPACE@_String_hxx #define @KWSYS_NAMESPACE@_String_hxx -#include <@KWSYS_NAMESPACE@/stl/string> +#include <string> namespace @KWSYS_NAMESPACE@ { @@ -25,10 +25,10 @@ namespace @KWSYS_NAMESPACE@ * simply a subclass of this type with the same interface so that the * name is shorter in debugging symbols and error messages. */ -class String: public @KWSYS_NAMESPACE@_stl::string +class String: public std::string { /** The original string type. */ - typedef @KWSYS_NAMESPACE@_stl::string stl_string; + typedef std::string stl_string; public: @@ -55,8 +55,8 @@ public: #if defined(__WATCOMC__) inline bool operator<(String const& l, String const& r) { - return (static_cast<@KWSYS_NAMESPACE@_stl::string const&>(l) < - static_cast<@KWSYS_NAMESPACE@_stl::string const&>(r)); + return (static_cast<std::string const&>(l) < + static_cast<std::string const&>(r)); } #endif diff --git a/Source/kwsys/SystemInformation.cxx b/Source/kwsys/SystemInformation.cxx index 6e81b0b..cddcc8d 100644 --- a/Source/kwsys/SystemInformation.cxx +++ b/Source/kwsys/SystemInformation.cxx @@ -35,14 +35,8 @@ // http://msdn.microsoft.com/en-us/library/ms683219(VS.85).aspx #include "kwsysPrivate.h" -#include KWSYS_HEADER(stl/string) -#include KWSYS_HEADER(stl/vector) -#include KWSYS_HEADER(ios/iosfwd) #include KWSYS_HEADER(SystemInformation.hxx) #include KWSYS_HEADER(Process.h) -#include KWSYS_HEADER(ios/iostream) -#include KWSYS_HEADER(ios/sstream) -#include KWSYS_HEADER(ios/fstream) // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. @@ -50,14 +44,14 @@ # include "SystemInformation.hxx.in" # include "Process.h.in" # include "Configure.hxx.in" -# include "kwsys_stl.hxx.in" -# include "kwsys_stl_vector.in" -# include "kwsys_stl_iosfwd.in" -# include "kwsys_ios_sstream.h.in" -# include "kwsys_ios_iostream.h.in" -# include "kwsys_ios_fstream.h.in" #endif +#include <iostream> +#include <sstream> +#include <fstream> +#include <string> +#include <vector> + #if defined(_WIN32) # include <windows.h> # if defined(_MSC_VER) && _MSC_VER >= 1800 @@ -325,11 +319,11 @@ public: const char * GetVendorString(); const char * GetVendorID(); - kwsys_stl::string GetTypeID(); - kwsys_stl::string GetFamilyID(); - kwsys_stl::string GetModelID(); - kwsys_stl::string GetModelName(); - kwsys_stl::string GetSteppingCode(); + std::string GetTypeID(); + std::string GetFamilyID(); + std::string GetModelID(); + std::string GetModelName(); + std::string GetSteppingCode(); const char * GetExtendedProcessorName(); const char * GetProcessorSerialNumber(); int GetProcessorCacheSize(); @@ -341,7 +335,7 @@ public: const char * GetOSName(); const char * GetHostname(); - int GetFullyQualifiedDomainName(kwsys_stl::string &fqdn); + int GetFullyQualifiedDomainName(std::string &fqdn); const char * GetOSRelease(); const char * GetOSVersion(); const char * GetOSPlatform(); @@ -379,7 +373,7 @@ public: // get current stack static - kwsys_stl::string GetProgramStack(int firstFrame, int wholePath); + std::string GetProgramStack(int firstFrame, int wholePath); /** Run the different checks */ void RunCPUCheck(); @@ -395,10 +389,10 @@ public: int Revision; int ExtendedFamily; int ExtendedModel; - kwsys_stl::string ProcessorName; - kwsys_stl::string Vendor; - kwsys_stl::string SerialNumber; - kwsys_stl::string ModelName; + std::string ProcessorName; + std::string Vendor; + std::string SerialNumber; + std::string ModelName; } ID; typedef struct tagCPUPowerManagement @@ -480,7 +474,7 @@ protected: // For Linux and Cygwin, /proc/cpuinfo formats are slightly different bool RetreiveInformationFromCpuInfoFile(); - kwsys_stl::string ExtractValueFromCpuInfoFile(kwsys_stl::string buffer, + std::string ExtractValueFromCpuInfoFile(std::string buffer, const char* word, size_t init=0); bool QueryLinuxMemory(); @@ -489,20 +483,20 @@ protected: static void Delay (unsigned int); static void DelayOverhead (unsigned int); - void FindManufacturer(const kwsys_stl::string &family = ""); + void FindManufacturer(const std::string &family = ""); // For Mac bool ParseSysCtl(); - int CallSwVers(const char *arg, kwsys_stl::string &ver); - void TrimNewline(kwsys_stl::string&); - kwsys_stl::string ExtractValueFromSysCtl(const char* word); - kwsys_stl::string SysCtlBuffer; + int CallSwVers(const char *arg, std::string &ver); + void TrimNewline(std::string&); + std::string ExtractValueFromSysCtl(const char* word); + std::string SysCtlBuffer; // For Solaris bool QuerySolarisMemory(); bool QuerySolarisProcessor(); - kwsys_stl::string ParseValueFromKStat(const char* arguments); - kwsys_stl::string RunProcess(kwsys_stl::vector<const char*> args); + std::string ParseValueFromKStat(const char* arguments); + std::string RunProcess(std::vector<const char*> args); //For Haiku OS bool QueryHaikuInfo(); @@ -540,11 +534,11 @@ protected: // Operating System information bool QueryOSInformation(); - kwsys_stl::string OSName; - kwsys_stl::string Hostname; - kwsys_stl::string OSRelease; - kwsys_stl::string OSVersion; - kwsys_stl::string OSPlatform; + std::string OSName; + std::string Hostname; + std::string OSRelease; + std::string OSVersion; + std::string OSPlatform; }; @@ -568,27 +562,27 @@ const char * SystemInformation::GetVendorID() return this->Implementation->GetVendorID(); } -kwsys_stl::string SystemInformation::GetTypeID() +std::string SystemInformation::GetTypeID() { return this->Implementation->GetTypeID(); } -kwsys_stl::string SystemInformation::GetFamilyID() +std::string SystemInformation::GetFamilyID() { return this->Implementation->GetFamilyID(); } -kwsys_stl::string SystemInformation::GetModelID() +std::string SystemInformation::GetModelID() { return this->Implementation->GetModelID(); } -kwsys_stl::string SystemInformation::GetModelName() +std::string SystemInformation::GetModelName() { return this->Implementation->GetModelName(); } -kwsys_stl::string SystemInformation::GetSteppingCode() +std::string SystemInformation::GetSteppingCode() { return this->Implementation->GetSteppingCode(); } @@ -633,9 +627,9 @@ bool SystemInformation::DoesCPUSupportFeature(long int i) return this->Implementation->DoesCPUSupportFeature(i); } -kwsys_stl::string SystemInformation::GetCPUDescription() +std::string SystemInformation::GetCPUDescription() { - kwsys_ios::ostringstream oss; + std::ostringstream oss; oss << this->GetNumberOfPhysicalCPU() << " core "; @@ -654,9 +648,9 @@ kwsys_stl::string SystemInformation::GetCPUDescription() } // remove extra spaces - kwsys_stl::string tmp=oss.str(); + std::string tmp=oss.str(); size_t pos; - while( (pos=tmp.find(" "))!=kwsys_stl::string::npos) + while( (pos=tmp.find(" "))!=std::string::npos) { tmp.replace(pos,2," "); } @@ -674,9 +668,9 @@ const char * SystemInformation::GetHostname() return this->Implementation->GetHostname(); } -kwsys_stl::string SystemInformation::GetFullyQualifiedDomainName() +std::string SystemInformation::GetFullyQualifiedDomainName() { - kwsys_stl::string fqdn; + std::string fqdn; this->Implementation->GetFullyQualifiedDomainName(fqdn); return fqdn; } @@ -723,9 +717,9 @@ int SystemInformation::GetOSIsApple() #endif } -kwsys_stl::string SystemInformation::GetOSDescription() +std::string SystemInformation::GetOSDescription() { - kwsys_ios::ostringstream oss; + std::ostringstream oss; oss << this->GetOSName() << " " @@ -777,11 +771,11 @@ size_t SystemInformation::GetAvailablePhysicalMemory() return this->Implementation->GetAvailablePhysicalMemory(); } -kwsys_stl::string SystemInformation::GetMemoryDescription( +std::string SystemInformation::GetMemoryDescription( const char *hostLimitEnvVarName, const char *procLimitEnvVarName) { - kwsys_ios::ostringstream oss; + std::ostringstream oss; oss << "Host Total: " << iostreamLongLong(this->GetHostMemoryTotal()) @@ -842,7 +836,7 @@ void SystemInformation::SetStackTraceOnError(int enable) SystemInformationImplementation::SetStackTraceOnError(enable); } -kwsys_stl::string SystemInformation::GetProgramStack(int firstFrame, int wholePath) +std::string SystemInformation::GetProgramStack(int firstFrame, int wholePath) { return SystemInformationImplementation::GetProgramStack(firstFrame, wholePath); } @@ -926,7 +920,7 @@ namespace { #if defined(__linux) || defined(__APPLE__) int LoadLines( FILE *file, - kwsys_stl::vector<kwsys_stl::string> &lines) + std::vector<std::string> &lines) { // Load each line in the given file into a the vector. int nRead=0; @@ -963,7 +957,7 @@ int LoadLines( // ***************************************************************************** int LoadLines( const char *fileName, - kwsys_stl::vector<kwsys_stl::string> &lines) + std::vector<std::string> &lines) { FILE *file=fopen(fileName,"r"); if (file==0) @@ -979,18 +973,18 @@ int LoadLines( // **************************************************************************** template<typename T> int NameValue( - kwsys_stl::vector<kwsys_stl::string> &lines, - kwsys_stl::string name, T &value) + std::vector<std::string> &lines, + std::string name, T &value) { size_t nLines=lines.size(); for (size_t i=0; i<nLines; ++i) { size_t at=lines[i].find(name); - if (at==kwsys_stl::string::npos) + if (at==std::string::npos) { continue; } - kwsys_ios::istringstream is(lines[i].substr(at+name.size())); + std::istringstream is(lines[i].substr(at+name.size())); is >> value; return 0; } @@ -1006,7 +1000,7 @@ int GetFieldsFromFile( const char **fieldNames, T *values) { - kwsys_stl::vector<kwsys_stl::string> fields; + std::vector<std::string> fields; if (!LoadLines(fileName,fields)) { return -1; @@ -1056,7 +1050,7 @@ int GetFieldsFromCommand( { return -1; } - kwsys_stl::vector<kwsys_stl::string> fields; + std::vector<std::string> fields; int nl=LoadLines(file,fields); pclose(file); if (nl==0) @@ -1085,10 +1079,10 @@ void StacktraceSignalHandler( void * /*sigContext*/) { #if defined(__linux) || defined(__APPLE__) - kwsys_ios::ostringstream oss; + std::ostringstream oss; oss - << kwsys_ios::endl - << "=========================================================" << kwsys_ios::endl + << std::endl + << "=========================================================" << std::endl << "Process id " << getpid() << " "; switch (sigNo) { @@ -1281,11 +1275,11 @@ void StacktraceSignalHandler( break; } oss - << kwsys_ios::endl - << "Program Stack:" << kwsys_ios::endl + << std::endl + << "Program Stack:" << std::endl << SystemInformationImplementation::GetProgramStack(2,0) - << "=========================================================" << kwsys_ios::endl; - kwsys_ios::cerr << oss.str() << kwsys_ios::endl; + << "=========================================================" << std::endl; + std::cerr << oss.str() << std::endl; // restore the previously registered handlers // and abort @@ -1330,7 +1324,7 @@ public: void SetBinary(const char *binary) { this->Binary=safes(binary); } - kwsys_stl::string GetBinary() const; + std::string GetBinary() const; // Description: // Set the name of the function that the symbol is found in. @@ -1338,7 +1332,7 @@ public: void SetFunction(const char *function) { this->Function=this->Demangle(function); } - kwsys_stl::string GetFunction() const + std::string GetFunction() const { return this->Function; } // Description: @@ -1347,7 +1341,7 @@ public: void SetSourceFile(const char *sourcefile) { this->SourceFile=safes(sourcefile); } - kwsys_stl::string GetSourceFile() const + std::string GetSourceFile() const { return this->GetFileName(this->SourceFile); } // Description: @@ -1365,31 +1359,31 @@ private: void *GetRealAddress() const { return (void*)((char*)this->Address-(char*)this->BinaryBaseAddress); } - kwsys_stl::string GetFileName(const kwsys_stl::string &path) const; - kwsys_stl::string Demangle(const char *symbol) const; + std::string GetFileName(const std::string &path) const; + std::string Demangle(const char *symbol) const; private: - kwsys_stl::string Binary; + std::string Binary; void *BinaryBaseAddress; void *Address; - kwsys_stl::string SourceFile; - kwsys_stl::string Function; + std::string SourceFile; + std::string Function; long LineNumber; int ReportPath; }; // -------------------------------------------------------------------------- -kwsys_ios::ostream &operator<<( - kwsys_ios::ostream &os, +std::ostream &operator<<( + std::ostream &os, const SymbolProperties &sp) { #if defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP) os - << kwsys_ios::hex << sp.GetAddress() << " : " + << std::hex << sp.GetAddress() << " : " << sp.GetFunction() << " [(" << sp.GetBinary() << ") " << sp.GetSourceFile() << ":" - << kwsys_ios::dec << sp.GetLineNumber() << "]"; + << std::dec << sp.GetLineNumber() << "]"; #elif defined(KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE) void *addr = sp.GetAddress(); char **syminfo = backtrace_symbols(&addr,1); @@ -1422,28 +1416,28 @@ SymbolProperties::SymbolProperties() } // -------------------------------------------------------------------------- -kwsys_stl::string SymbolProperties::GetFileName(const kwsys_stl::string &path) const +std::string SymbolProperties::GetFileName(const std::string &path) const { - kwsys_stl::string file(path); + std::string file(path); if (!this->ReportPath) { size_t at = file.rfind("/"); - if (at!=kwsys_stl::string::npos) + if (at!=std::string::npos) { - file = file.substr(at+1,kwsys_stl::string::npos); + file = file.substr(at+1,std::string::npos); } } return file; } // -------------------------------------------------------------------------- -kwsys_stl::string SymbolProperties::GetBinary() const +std::string SymbolProperties::GetBinary() const { // only linux has proc fs #if defined(__linux__) if (this->Binary=="/proc/self/exe") { - kwsys_stl::string binary; + std::string binary; char buf[1024]={'\0'}; ssize_t ll=0; if ((ll=readlink("/proc/self/exe",buf,1024))>0) @@ -1462,9 +1456,9 @@ kwsys_stl::string SymbolProperties::GetBinary() const } // -------------------------------------------------------------------------- -kwsys_stl::string SymbolProperties::Demangle(const char *symbol) const +std::string SymbolProperties::Demangle(const char *symbol) const { - kwsys_stl::string result = safes(symbol); + std::string result = safes(symbol); #if defined(KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE) int status = 0; size_t bufferLen = 1024; @@ -1729,7 +1723,7 @@ const char* SystemInformationImplementation::GetHostname() /** Get the FQDN */ int SystemInformationImplementation::GetFullyQualifiedDomainName( - kwsys_stl::string &fqdn) + std::string &fqdn) { // in the event of absolute failure return localhost. fqdn="localhost"; @@ -1820,8 +1814,8 @@ int SystemInformationImplementation::GetFullyQualifiedDomainName( continue; } - kwsys_stl::string candidate=host; - if ((candidate.find(base)!=kwsys_stl::string::npos) && baseSize<candidate.size()) + std::string candidate=host; + if ((candidate.find(base)!=std::string::npos) && baseSize<candidate.size()) { // success, stop now. ierr=0; @@ -1897,39 +1891,39 @@ const char * SystemInformationImplementation::GetVendorID() } /** Return the type ID of the CPU */ -kwsys_stl::string SystemInformationImplementation::GetTypeID() +std::string SystemInformationImplementation::GetTypeID() { - kwsys_ios::ostringstream str; + std::ostringstream str; str << this->ChipID.Type; return str.str(); } /** Return the family of the CPU present */ -kwsys_stl::string SystemInformationImplementation::GetFamilyID() +std::string SystemInformationImplementation::GetFamilyID() { - kwsys_ios::ostringstream str; + std::ostringstream str; str << this->ChipID.Family; return str.str(); } // Return the model of CPU present */ -kwsys_stl::string SystemInformationImplementation::GetModelID() +std::string SystemInformationImplementation::GetModelID() { - kwsys_ios::ostringstream str; + std::ostringstream str; str << this->ChipID.Model; return str.str(); } // Return the model name of CPU present */ -kwsys_stl::string SystemInformationImplementation::GetModelName() +std::string SystemInformationImplementation::GetModelName() { return this->ChipID.ModelName; } /** Return the stepping code of the CPU present. */ -kwsys_stl::string SystemInformationImplementation::GetSteppingCode() +std::string SystemInformationImplementation::GetSteppingCode() { - kwsys_ios::ostringstream str; + std::ostringstream str; str << this->ChipID.Revision; return str.str(); } @@ -2180,7 +2174,7 @@ bool SystemInformationImplementation::RetrieveCPUFeatures() /** Find the manufacturer given the vendor id */ -void SystemInformationImplementation::FindManufacturer(const kwsys_stl::string& family) +void SystemInformationImplementation::FindManufacturer(const std::string& family) { if (this->ChipID.Vendor == "GenuineIntel") this->ChipManufacturer = Intel; // Intel Corp. else if (this->ChipID.Vendor == "UMC UMC UMC ") this->ChipManufacturer = UMC; // United Microelectronics Corp. @@ -2799,11 +2793,11 @@ bool SystemInformationImplementation::RetrieveCPUPowerManagement() #if USE_CPUID // Used only in USE_CPUID implementation below. -static void SystemInformationStripLeadingSpace(kwsys_stl::string& str) +static void SystemInformationStripLeadingSpace(std::string& str) { // Because some manufacturers have leading white space - we have to post-process the name. - kwsys_stl::string::size_type pos = str.find_first_not_of(" "); - if(pos != kwsys_stl::string::npos) + std::string::size_type pos = str.find_first_not_of(" "); + if(pos != std::string::npos) { str = str.substr(pos); } @@ -3148,7 +3142,7 @@ bool SystemInformationImplementation::RetrieveClassicalCPUIdentity() /** Extract a value from the CPUInfo file */ -kwsys_stl::string SystemInformationImplementation::ExtractValueFromCpuInfoFile(kwsys_stl::string buffer,const char* word,size_t init) +std::string SystemInformationImplementation::ExtractValueFromCpuInfoFile(std::string buffer,const char* word,size_t init) { size_t pos = buffer.find(word,init); if(pos != buffer.npos) @@ -3180,12 +3174,12 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() { this->NumberOfLogicalCPU = 0; this->NumberOfPhysicalCPU = 0; - kwsys_stl::string buffer; + std::string buffer; FILE *fd = fopen("/proc/cpuinfo", "r" ); if ( !fd ) { - kwsys_ios::cout << "Problem opening /proc/cpuinfo" << kwsys_ios::endl; + std::cout << "Problem opening /proc/cpuinfo" << std::endl; return false; } @@ -3209,7 +3203,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() #ifdef __linux // Find the largest physical id. int maxId = -1; - kwsys_stl::string idc = + std::string idc = this->ExtractValueFromCpuInfoFile(buffer,"physical id"); while(this->CurrentPositionInFile != buffer.npos) { @@ -3224,7 +3218,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() // Physical ids returned by Linux don't distinguish cores. // We want to record the total number of cores in this->NumberOfPhysicalCPU // (checking only the first proc) - kwsys_stl::string cores = + std::string cores = this->ExtractValueFromCpuInfoFile(buffer,"cpu cores"); int numberOfCoresPerCPU=atoi(cores.c_str()); if (maxId > 0) @@ -3242,7 +3236,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() #else // __CYGWIN__ // does not have "physical id" entries, neither "cpu cores" // this has to be fixed for hyper-threading. - kwsys_stl::string cpucount = + std::string cpucount = this->ExtractValueFromCpuInfoFile(buffer,"cpu count"); this->NumberOfPhysicalCPU= this->NumberOfLogicalCPU = atoi(cpucount.c_str()); @@ -3258,7 +3252,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() this->NumberOfLogicalCPU/this->NumberOfPhysicalCPU; // CPU speed (checking only the first processor) - kwsys_stl::string CPUSpeed = this->ExtractValueFromCpuInfoFile(buffer,"cpu MHz"); + std::string CPUSpeed = this->ExtractValueFromCpuInfoFile(buffer,"cpu MHz"); if(!CPUSpeed.empty()) { this->CPUSpeedInMHz = static_cast<float>(atof(CPUSpeed.c_str())); @@ -3274,7 +3268,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() #endif // Chip family - kwsys_stl::string familyStr = + std::string familyStr = this->ExtractValueFromCpuInfoFile(buffer,"cpu family"); if(familyStr.empty()) { @@ -3304,7 +3298,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() { // Some platforms (e.g. PA-RISC) tell us their CPU name here. // Note: x86 does not. - kwsys_stl::string cpuname = this->ExtractValueFromCpuInfoFile(buffer,"cpu"); + std::string cpuname = this->ExtractValueFromCpuInfoFile(buffer,"cpu"); if(!cpuname.empty()) { this->ChipID.ProcessorName = cpuname; @@ -3312,7 +3306,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() } // Chip revision - kwsys_stl::string cpurev = this->ExtractValueFromCpuInfoFile(buffer,"stepping"); + std::string cpurev = this->ExtractValueFromCpuInfoFile(buffer,"stepping"); if(cpurev.empty()) { cpurev = this->ExtractValueFromCpuInfoFile(buffer,"CPU revision"); @@ -3325,7 +3319,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() // L1 Cache size // Different architectures may show different names for the caches. // Sum up everything we find. - kwsys_stl::vector<const char*> cachename; + std::vector<const char*> cachename; cachename.clear(); cachename.push_back("cache size"); // e.g. x86 @@ -3335,7 +3329,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() this->Features.L1CacheSize = 0; for (size_t index = 0; index < cachename.size(); index ++) { - kwsys_stl::string cacheSize = this->ExtractValueFromCpuInfoFile(buffer,cachename[index]); + std::string cacheSize = this->ExtractValueFromCpuInfoFile(buffer,cachename[index]); if (!cacheSize.empty()) { pos = cacheSize.find(" KB"); @@ -3348,48 +3342,48 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile() } // processor feature flags (probably x86 specific) - kwsys_stl::string cpuflags = this->ExtractValueFromCpuInfoFile(buffer,"flags"); + std::string cpuflags = this->ExtractValueFromCpuInfoFile(buffer,"flags"); if(!cpurev.empty()) { // now we can match every flags as space + flag + space cpuflags = " " + cpuflags + " "; - if ((cpuflags.find(" fpu ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" fpu ")!=std::string::npos)) { this->Features.HasFPU = true; } - if ((cpuflags.find(" tsc ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" tsc ")!=std::string::npos)) { this->Features.HasTSC = true; } - if ((cpuflags.find(" mmx ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" mmx ")!=std::string::npos)) { this->Features.HasMMX = true; } - if ((cpuflags.find(" sse ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" sse ")!=std::string::npos)) { this->Features.HasSSE = true; } - if ((cpuflags.find(" sse2 ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" sse2 ")!=std::string::npos)) { this->Features.HasSSE2 = true; } - if ((cpuflags.find(" apic ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" apic ")!=std::string::npos)) { this->Features.HasAPIC = true; } - if ((cpuflags.find(" cmov ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" cmov ")!=std::string::npos)) { this->Features.HasCMOV = true; } - if ((cpuflags.find(" mtrr ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" mtrr ")!=std::string::npos)) { this->Features.HasMTRR = true; } - if ((cpuflags.find(" acpi ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" acpi ")!=std::string::npos)) { this->Features.HasACPI = true; } - if ((cpuflags.find(" 3dnow ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" 3dnow ")!=std::string::npos)) { this->Features.ExtendedFeatures.Has3DNow = true; } @@ -3645,7 +3639,7 @@ SystemInformationImplementation::GetProcMemoryUsed() #elif defined(__APPLE__) SystemInformation::LongLong memUsed=0; pid_t pid=getpid(); - kwsys_ios::ostringstream oss; + std::ostringstream oss; oss << "ps -o rss= -p " << pid; FILE *file=popen(oss.str().c_str(),"r"); if (file==0) @@ -3670,7 +3664,7 @@ SystemInformationImplementation::GetProcMemoryUsed() { return -2; } - kwsys_ios::istringstream iss(oss.str()); + std::istringstream iss(oss.str()); iss >> memUsed; return memUsed; #else @@ -3729,11 +3723,11 @@ SystemInformationImplementation::GetProcessId() return current program stack in a string demangle cxx symbols if possible. */ -kwsys_stl::string SystemInformationImplementation::GetProgramStack( +std::string SystemInformationImplementation::GetProgramStack( int firstFrame, int wholePath) { - kwsys_stl::string programStack = "" + std::string programStack = "" #if !defined(KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE) "WARNING: The stack could not be examined " "because backtrace is not supported.\n" @@ -3752,7 +3746,7 @@ kwsys_stl::string SystemInformationImplementation::GetProgramStack( #endif ; - kwsys_ios::ostringstream oss; + std::ostringstream oss; #if defined(KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE) void *stackSymbols[256]; int nFrames=backtrace(stackSymbols,256); @@ -3761,7 +3755,7 @@ kwsys_stl::string SystemInformationImplementation::GetProgramStack( SymbolProperties symProps; symProps.SetReportPath(wholePath); symProps.Initialize(stackSymbols[i]); - oss << symProps << kwsys_ios::endl; + oss << symProps << std::endl; } #else (void)firstFrame; @@ -3892,7 +3886,7 @@ bool SystemInformationImplementation::QueryLinuxMemory() int errorFlag = uname(&unameInfo); if( errorFlag!=0 ) { - kwsys_ios::cout << "Problem calling uname(): " << strerror(errno) << kwsys_ios::endl; + std::cout << "Problem calling uname(): " << strerror(errno) << std::endl; return false; } @@ -3916,7 +3910,7 @@ bool SystemInformationImplementation::QueryLinuxMemory() FILE *fd = fopen("/proc/meminfo", "r" ); if ( !fd ) { - kwsys_ios::cout << "Problem opening /proc/meminfo" << kwsys_ios::endl; + std::cout << "Problem opening /proc/meminfo" << std::endl; return false; } @@ -3954,7 +3948,7 @@ bool SystemInformationImplementation::QueryLinuxMemory() } else { - kwsys_ios::cout << "Problem parsing /proc/meminfo" << kwsys_ios::endl; + std::cout << "Problem parsing /proc/meminfo" << std::endl; fclose(fd); return false; } @@ -3987,7 +3981,7 @@ bool SystemInformationImplementation::QueryLinuxMemory() } else { - kwsys_ios::cout << "Problem parsing /proc/meminfo" << kwsys_ios::endl; + std::cout << "Problem parsing /proc/meminfo" << std::endl; fclose(fd); return false; } @@ -4464,8 +4458,8 @@ bool SystemInformationImplementation::ParseSysCtl() ::memset(retBuf, 0, 128); len = 32; err = sysctlbyname("hw.machine", &retBuf, &len, NULL, 0); - kwsys_stl::string machineBuf(retBuf); - if (machineBuf.find_first_of("Power") != kwsys_stl::string::npos) + std::string machineBuf(retBuf); + if (machineBuf.find_first_of("Power") != std::string::npos) { this->ChipID.Vendor = "IBM"; len = sizeof(this->ChipID.Family); @@ -4527,41 +4521,41 @@ bool SystemInformationImplementation::ParseSysCtl() { // now we can match every flags as space + flag + space buf[len + 1] = ' '; - kwsys_stl::string cpuflags(buf, len + 2); + std::string cpuflags(buf, len + 2); - if ((cpuflags.find(" FPU ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" FPU ")!=std::string::npos)) { this->Features.HasFPU = true; } - if ((cpuflags.find(" TSC ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" TSC ")!=std::string::npos)) { this->Features.HasTSC = true; } - if ((cpuflags.find(" MMX ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" MMX ")!=std::string::npos)) { this->Features.HasMMX = true; } - if ((cpuflags.find(" SSE ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" SSE ")!=std::string::npos)) { this->Features.HasSSE = true; } - if ((cpuflags.find(" SSE2 ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" SSE2 ")!=std::string::npos)) { this->Features.HasSSE2 = true; } - if ((cpuflags.find(" APIC ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" APIC ")!=std::string::npos)) { this->Features.HasAPIC = true; } - if ((cpuflags.find(" CMOV ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" CMOV ")!=std::string::npos)) { this->Features.HasCMOV = true; } - if ((cpuflags.find(" MTRR ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" MTRR ")!=std::string::npos)) { this->Features.HasMTRR = true; } - if ((cpuflags.find(" ACPI ")!=kwsys_stl::string::npos)) + if ((cpuflags.find(" ACPI ")!=std::string::npos)) { this->Features.HasACPI = true; } @@ -4595,7 +4589,7 @@ bool SystemInformationImplementation::ParseSysCtl() /** Extract a value from sysctl command */ -kwsys_stl::string SystemInformationImplementation::ExtractValueFromSysCtl(const char* word) +std::string SystemInformationImplementation::ExtractValueFromSysCtl(const char* word) { size_t pos = this->SysCtlBuffer.find(word); if(pos != this->SysCtlBuffer.npos) @@ -4612,9 +4606,9 @@ kwsys_stl::string SystemInformationImplementation::ExtractValueFromSysCtl(const /** Run a given process */ -kwsys_stl::string SystemInformationImplementation::RunProcess(kwsys_stl::vector<const char*> args) +std::string SystemInformationImplementation::RunProcess(std::vector<const char*> args) { - kwsys_stl::string buffer = ""; + std::string buffer = ""; // Run the application kwsysProcess* gp = kwsysProcess_New(); @@ -4644,12 +4638,12 @@ kwsys_stl::string SystemInformationImplementation::RunProcess(kwsys_stl::vector< } break; case kwsysProcess_State_Error: { - kwsys_ios::cerr << "Error: Could not run " << args[0] << ":\n"; - kwsys_ios::cerr << kwsysProcess_GetErrorString(gp) << "\n"; + std::cerr << "Error: Could not run " << args[0] << ":\n"; + std::cerr << kwsysProcess_GetErrorString(gp) << "\n"; } break; case kwsysProcess_State_Exception: { - kwsys_ios::cerr << "Error: " << args[0] + std::cerr << "Error: " << args[0] << " terminated with an exception: " << kwsysProcess_GetExceptionString(gp) << "\n"; } break; @@ -4659,27 +4653,27 @@ kwsys_stl::string SystemInformationImplementation::RunProcess(kwsys_stl::vector< case kwsysProcess_State_Killed: { // Should not get here. - kwsys_ios::cerr << "Unexpected ending state after running " << args[0] - << kwsys_ios::endl; + std::cerr << "Unexpected ending state after running " << args[0] + << std::endl; } break; } kwsysProcess_Delete(gp); if(result) { - kwsys_ios::cerr << "Error " << args[0] << " returned :" << result << "\n"; + std::cerr << "Error " << args[0] << " returned :" << result << "\n"; } return buffer; } -kwsys_stl::string SystemInformationImplementation::ParseValueFromKStat(const char* arguments) +std::string SystemInformationImplementation::ParseValueFromKStat(const char* arguments) { - kwsys_stl::vector<const char*> args; + std::vector<const char*> args; args.clear(); args.push_back("kstat"); args.push_back("-p"); - kwsys_stl::string command = arguments; + std::string command = arguments; size_t start = command.npos; size_t pos = command.find(' ',0); while(pos!=command.npos) @@ -4701,7 +4695,7 @@ kwsys_stl::string SystemInformationImplementation::ParseValueFromKStat(const cha if(!inQuotes) { - kwsys_stl::string arg = command.substr(start+1,pos-start-1); + std::string arg = command.substr(start+1,pos-start-1); // Remove the quotes if any size_t quotes = arg.find('"'); @@ -4715,14 +4709,14 @@ kwsys_stl::string SystemInformationImplementation::ParseValueFromKStat(const cha } pos = command.find(' ',pos+1); } - kwsys_stl::string lastArg = command.substr(start+1,command.size()-start-1); + std::string lastArg = command.substr(start+1,command.size()-start-1); args.push_back(lastArg.c_str()); args.push_back(0); - kwsys_stl::string buffer = this->RunProcess(args); + std::string buffer = this->RunProcess(args); - kwsys_stl::string value = ""; + std::string value = ""; for(size_t i=buffer.size()-1;i>0;i--) { if(buffer[i] == ' ' || buffer[i] == '\t') @@ -4731,7 +4725,7 @@ kwsys_stl::string SystemInformationImplementation::ParseValueFromKStat(const cha } if(buffer[i] != '\n' && buffer[i] != '\r') { - kwsys_stl::string val = value; + std::string val = value; value = buffer[i]; value += val; } @@ -4885,8 +4879,8 @@ bool SystemInformationImplementation::QueryHaikuInfo() bool SystemInformationImplementation::QueryQNXMemory() { #if defined(__QNX__) - kwsys_stl::string buffer; - kwsys_stl::vector<const char*> args; + std::string buffer; + std::vector<const char*> args; args.clear(); args.push_back("showmem"); @@ -4943,8 +4937,8 @@ bool SystemInformationImplementation::QueryQNXProcessor() #if defined(__QNX__) // the output on my QNX 6.4.1 looks like this: // Processor1: 686 Pentium II Stepping 3 2175MHz FPU - kwsys_stl::string buffer; - kwsys_stl::vector<const char*> args; + std::string buffer; + std::vector<const char*> args; args.clear(); args.push_back("pidin"); @@ -5440,10 +5434,10 @@ bool SystemInformationImplementation::QueryOSInformation() int SystemInformationImplementation::CallSwVers( const char *arg, - kwsys_stl::string &ver) + std::string &ver) { #ifdef __APPLE__ - kwsys_stl::vector<const char*> args; + std::vector<const char*> args; args.push_back("sw_vers"); args.push_back(arg); args.push_back(0); @@ -5457,18 +5451,18 @@ int SystemInformationImplementation::CallSwVers( return 0; } -void SystemInformationImplementation::TrimNewline(kwsys_stl::string& output) +void SystemInformationImplementation::TrimNewline(std::string& output) { // remove \r - kwsys_stl::string::size_type pos=0; - while((pos = output.find("\r", pos)) != kwsys_stl::string::npos) + std::string::size_type pos=0; + while((pos = output.find("\r", pos)) != std::string::npos) { output.erase(pos); } // remove \n pos = 0; - while((pos = output.find("\n", pos)) != kwsys_stl::string::npos) + while((pos = output.find("\n", pos)) != std::string::npos) { output.erase(pos); } diff --git a/Source/kwsys/SystemInformation.hxx.in b/Source/kwsys/SystemInformation.hxx.in index 4acdc4f..7c45388 100644 --- a/Source/kwsys/SystemInformation.hxx.in +++ b/Source/kwsys/SystemInformation.hxx.in @@ -12,14 +12,9 @@ #ifndef @KWSYS_NAMESPACE@_SystemInformation_h #define @KWSYS_NAMESPACE@_SystemInformation_h - -/* Define these macros temporarily to keep the code readable. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define kwsys_stl @KWSYS_NAMESPACE@_stl -# define kwsys_ios @KWSYS_NAMESPACE@_ios -#endif -#include <@KWSYS_NAMESPACE@/stl/string> +#include <@KWSYS_NAMESPACE@/Configure.hxx> #include <stddef.h> /* size_t */ +#include <string> namespace @KWSYS_NAMESPACE@ { @@ -45,11 +40,11 @@ public: const char * GetVendorString(); const char * GetVendorID(); - kwsys_stl::string GetTypeID(); - kwsys_stl::string GetFamilyID(); - kwsys_stl::string GetModelID(); - kwsys_stl::string GetModelName(); - kwsys_stl::string GetSteppingCode(); + std::string GetTypeID(); + std::string GetFamilyID(); + std::string GetModelID(); + std::string GetModelName(); + std::string GetSteppingCode(); const char * GetExtendedProcessorName(); const char * GetProcessorSerialNumber(); int GetProcessorCacheSize(); @@ -61,10 +56,10 @@ public: // returns an informative general description of the cpu // on this system. - kwsys_stl::string GetCPUDescription(); + std::string GetCPUDescription(); const char * GetHostname(); - kwsys_stl::string GetFullyQualifiedDomainName(); + std::string GetFullyQualifiedDomainName(); const char * GetOSName(); const char * GetOSRelease(); @@ -77,7 +72,7 @@ public: // returns an informative general description of the os // on this system. - kwsys_stl::string GetOSDescription(); + std::string GetOSDescription(); bool Is64Bits(); @@ -98,7 +93,7 @@ public: // returns an informative general description if the installed and // available ram on this system. See the GetHostMmeoryTotal, and // Get{Host,Proc}MemoryAvailable methods for more information. - kwsys_stl::string GetMemoryDescription( + std::string GetMemoryDescription( const char *hostLimitEnvVarName=NULL, const char *procLimitEnvVarName=NULL); @@ -144,7 +139,7 @@ public: // order to produce an informative stack trace the application // should be dynamically linked and compiled with debug symbols. static - kwsys_stl::string GetProgramStack(int firstFrame, int wholePath); + std::string GetProgramStack(int firstFrame, int wholePath); /** Run the different checks */ void RunCPUCheck(); @@ -154,10 +149,4 @@ public: } // namespace @KWSYS_NAMESPACE@ -/* Undefine temporary macros. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# undef kwsys_stl -# undef kwsys_ios -#endif - #endif diff --git a/Source/kwsys/SystemTools.cxx b/Source/kwsys/SystemTools.cxx index f12a06c..da34eb9 100644 --- a/Source/kwsys/SystemTools.cxx +++ b/Source/kwsys/SystemTools.cxx @@ -31,11 +31,10 @@ #include KWSYS_HEADER(FStream.hxx) #include KWSYS_HEADER(Encoding.hxx) -#include KWSYS_HEADER(ios/iostream) -#include KWSYS_HEADER(ios/fstream) -#include KWSYS_HEADER(ios/sstream) - -#include KWSYS_HEADER(stl/set) +#include <iostream> +#include <fstream> +#include <sstream> +#include <set> // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. @@ -44,9 +43,6 @@ # include "Directory.hxx.in" # include "FStream.hxx.in" # include "Encoding.hxx.in" -# include "kwsys_ios_iostream.h.in" -# include "kwsys_ios_fstream.h.in" -# include "kwsys_ios_sstream.h.in" #endif #ifdef _MSC_VER @@ -220,12 +216,12 @@ static time_t windows_filetime_to_posix_time(const FILETIME& ft) #ifdef KWSYS_WINDOWS_DIRS #include <wctype.h> -inline int Mkdir(const kwsys_stl::string& dir) +inline int Mkdir(const std::string& dir) { return _wmkdir( KWSYS_NAMESPACE::SystemTools::ConvertToWindowsExtendedPath(dir).c_str()); } -inline int Rmdir(const kwsys_stl::string& dir) +inline int Rmdir(const std::string& dir) { return _wrmdir( KWSYS_NAMESPACE::SystemTools::ConvertToWindowsExtendedPath(dir).c_str()); @@ -246,7 +242,7 @@ inline const char* Getcwd(char* buf, unsigned int len) } return 0; } -inline int Chdir(const kwsys_stl::string& dir) +inline int Chdir(const std::string& dir) { #if defined(__BORLANDC__) return chdir(dir.c_str()); @@ -254,11 +250,11 @@ inline int Chdir(const kwsys_stl::string& dir) return _wchdir(KWSYS_NAMESPACE::Encoding::ToWide(dir).c_str()); #endif } -inline void Realpath(const kwsys_stl::string& path, - kwsys_stl::string& resolved_path, - kwsys_stl::string* errorMessage = 0) +inline void Realpath(const std::string& path, + std::string& resolved_path, + std::string* errorMessage = 0) { - kwsys_stl::wstring tmp = KWSYS_NAMESPACE::Encoding::ToWide(path); + std::wstring tmp = KWSYS_NAMESPACE::Encoding::ToWide(path); wchar_t *ptemp; wchar_t fullpath[MAX_PATH]; DWORD bufferLen = GetFullPathNameW(tmp.c_str(), @@ -303,11 +299,11 @@ inline void Realpath(const kwsys_stl::string& path, #include <sys/types.h> #include <fcntl.h> #include <unistd.h> -inline int Mkdir(const kwsys_stl::string& dir) +inline int Mkdir(const std::string& dir) { return mkdir(dir.c_str(), 00777); } -inline int Rmdir(const kwsys_stl::string& dir) +inline int Rmdir(const std::string& dir) { return rmdir(dir.c_str()); } @@ -316,13 +312,13 @@ inline const char* Getcwd(char* buf, unsigned int len) return getcwd(buf, len); } -inline int Chdir(const kwsys_stl::string& dir) +inline int Chdir(const std::string& dir) { return chdir(dir.c_str()); } -inline void Realpath(const kwsys_stl::string& path, - kwsys_stl::string& resolved_path, - kwsys_stl::string* errorMessage = 0) +inline void Realpath(const std::string& path, + std::string& resolved_path, + std::string* errorMessage = 0) { char resolved_name[KWSYS_SYSTEMTOOLS_MAXPATH]; @@ -385,14 +381,14 @@ double SystemTools::GetTime(void) } class SystemToolsTranslationMap : - public kwsys_stl::map<kwsys_stl::string,kwsys_stl::string> + public std::map<std::string,std::string> { }; #ifdef _WIN32 struct SystemToolsPathCaseCmp { - bool operator()(kwsys_stl::string const& l, kwsys_stl::string const& r) const + bool operator()(std::string const& l, std::string const& r) const { # ifdef _MSC_VER return _stricmp(l.c_str(), r.c_str()) < 0; @@ -405,13 +401,14 @@ struct SystemToolsPathCaseCmp }; class SystemToolsPathCaseMap: - public kwsys_stl::map<kwsys_stl::string, kwsys_stl::string, + public std::map<std::string, std::string, SystemToolsPathCaseCmp> {}; #endif // adds the elements of the env variable path to the arg passed in -void SystemTools::GetPath(kwsys_stl::vector<kwsys_stl::string>& path, const char* env) +void SystemTools::GetPath(std::vector<std::string>& path, const char* env) { + size_t const old_size = path.size(); #if defined(_WIN32) && !defined(__CYGWIN__) const char pathSep = ';'; #else @@ -427,19 +424,19 @@ void SystemTools::GetPath(kwsys_stl::vector<kwsys_stl::string>& path, const char return; } - kwsys_stl::string pathEnv = cpathEnv; + std::string pathEnv = cpathEnv; // A hack to make the below algorithm work. if(!pathEnv.empty() && *pathEnv.rbegin() != pathSep) { pathEnv += pathSep; } - kwsys_stl::string::size_type start =0; + std::string::size_type start =0; bool done = false; while(!done) { - kwsys_stl::string::size_type endpos = pathEnv.find(pathSep, start); - if(endpos != kwsys_stl::string::npos) + std::string::size_type endpos = pathEnv.find(pathSep, start); + if(endpos != std::string::npos) { path.push_back(pathEnv.substr(start, endpos-start)); start = endpos+1; @@ -449,7 +446,7 @@ void SystemTools::GetPath(kwsys_stl::vector<kwsys_stl::string>& path, const char done = true; } } - for(kwsys_stl::vector<kwsys_stl::string>::iterator i = path.begin(); + for(std::vector<std::string>::iterator i = path.begin() + old_size; i != path.end(); ++i) { SystemTools::ConvertToUnixSlashes(*i); @@ -461,12 +458,12 @@ const char* SystemTools::GetEnv(const char* key) return getenv(key); } -const char* SystemTools::GetEnv(const kwsys_stl::string& key) +const char* SystemTools::GetEnv(const std::string& key) { return SystemTools::GetEnv(key.c_str()); } -bool SystemTools::GetEnv(const char* key, kwsys_stl::string& result) +bool SystemTools::GetEnv(const char* key, std::string& result) { const char* v = getenv(key); if(v) @@ -480,7 +477,7 @@ bool SystemTools::GetEnv(const char* key, kwsys_stl::string& result) } } -bool SystemTools::GetEnv(const kwsys_stl::string& key, kwsys_stl::string& result) +bool SystemTools::GetEnv(const std::string& key, std::string& result) { return SystemTools::GetEnv(key.c_str(), result); } @@ -496,7 +493,7 @@ bool SystemTools::GetEnv(const kwsys_stl::string& key, kwsys_stl::string& result #if KWSYS_CXX_HAS_UNSETENV /* unsetenv("A") removes A from the environment. On older platforms it returns void instead of int. */ -static int kwsysUnPutEnv(const kwsys_stl::string& env) +static int kwsysUnPutEnv(const std::string& env) { size_t pos = env.find('='); if(pos != env.npos) @@ -513,7 +510,7 @@ static int kwsysUnPutEnv(const kwsys_stl::string& env) #elif defined(KWSYS_PUTENV_EMPTY) || defined(KWSYS_PUTENV_NAME) /* putenv("A=") or putenv("A") removes A from the environment. */ -static int kwsysUnPutEnv(const kwsys_stl::string& env) +static int kwsysUnPutEnv(const std::string& env) { int err = 0; size_t pos = env.find('='); @@ -558,7 +555,7 @@ static int kwsysUnPutEnv(const kwsys_stl::string& env) #else /* Manipulate the "environ" global directly. */ -static int kwsysUnPutEnv(const kwsys_stl::string& env) +static int kwsysUnPutEnv(const std::string& env) { size_t pos = env.find('='); size_t const len = pos == env.npos ? env.size() : pos; @@ -591,7 +588,7 @@ static int kwsysUnPutEnv(const kwsys_stl::string& env) /* setenv("A", "B", 1) will set A=B in the environment and makes its own copies of the strings. */ -bool SystemTools::PutEnv(const kwsys_stl::string& env) +bool SystemTools::PutEnv(const std::string& env) { size_t pos = env.find('='); if(pos != env.npos) @@ -605,7 +602,7 @@ bool SystemTools::PutEnv(const kwsys_stl::string& env) } } -bool SystemTools::UnPutEnv(const kwsys_stl::string& env) +bool SystemTools::UnPutEnv(const std::string& env) { return kwsysUnPutEnv(env) == 0; } @@ -643,7 +640,7 @@ struct kwsysEnvCompare } }; -class kwsysEnv: public kwsys_stl::set<const char*, kwsysEnvCompare> +class kwsysEnv: public std::set<const char*, kwsysEnvCompare> { class Free { @@ -653,7 +650,7 @@ class kwsysEnv: public kwsys_stl::set<const char*, kwsysEnvCompare> ~Free() { free(const_cast<char*>(this->Env)); } }; public: - typedef kwsys_stl::set<const char*, kwsysEnvCompare> derived; + typedef std::set<const char*, kwsysEnvCompare> derived; ~kwsysEnv() { for(derived::iterator i = this->begin(); i != this->end(); ++i) @@ -691,12 +688,12 @@ public: static kwsysEnv kwsysEnvInstance; -bool SystemTools::PutEnv(const kwsys_stl::string& env) +bool SystemTools::PutEnv(const std::string& env) { return kwsysEnvInstance.Put(env.c_str()); } -bool SystemTools::UnPutEnv(const kwsys_stl::string& env) +bool SystemTools::UnPutEnv(const std::string& env) { return kwsysEnvInstance.UnPut(env.c_str()); } @@ -714,7 +711,7 @@ const char* SystemTools::GetExecutableExtension() #endif } -FILE* SystemTools::Fopen(const kwsys_stl::string& file, const char* mode) +FILE* SystemTools::Fopen(const std::string& file, const char* mode) { #ifdef _WIN32 return _wfopen(SystemTools::ConvertToWindowsExtendedPath(file).c_str(), @@ -730,10 +727,10 @@ bool SystemTools::MakeDirectory(const char* path) { return false; } - return SystemTools::MakeDirectory(kwsys_stl::string(path)); + return SystemTools::MakeDirectory(std::string(path)); } -bool SystemTools::MakeDirectory(const kwsys_stl::string& path) +bool SystemTools::MakeDirectory(const std::string& path) { if(SystemTools::FileExists(path)) { @@ -743,12 +740,12 @@ bool SystemTools::MakeDirectory(const kwsys_stl::string& path) { return false; } - kwsys_stl::string dir = path; + std::string dir = path; SystemTools::ConvertToUnixSlashes(dir); - kwsys_stl::string::size_type pos = 0; - kwsys_stl::string topdir; - while((pos = dir.find('/', pos)) != kwsys_stl::string::npos) + std::string::size_type pos = 0; + std::string topdir; + while((pos = dir.find('/', pos)) != std::string::npos) { topdir = dir.substr(0, pos); Mkdir(topdir); @@ -776,9 +773,9 @@ bool SystemTools::MakeDirectory(const kwsys_stl::string& path) // replace replace with with as many times as it shows up in source. // write the result into source. -void SystemTools::ReplaceString(kwsys_stl::string& source, - const kwsys_stl::string& replace, - const kwsys_stl::string& with) +void SystemTools::ReplaceString(std::string& source, + const std::string& replace, + const std::string& with) { // do while hangs if replaceSize is 0 if (replace.empty()) @@ -789,7 +786,7 @@ void SystemTools::ReplaceString(kwsys_stl::string& source, SystemTools::ReplaceString(source, replace.c_str(), replace.size(), with); } -void SystemTools::ReplaceString(kwsys_stl::string& source, +void SystemTools::ReplaceString(std::string& source, const char* replace, const char* with) { @@ -802,10 +799,10 @@ void SystemTools::ReplaceString(kwsys_stl::string& source, SystemTools::ReplaceString(source, replace, strlen(replace), with ? with : ""); } -void SystemTools::ReplaceString(kwsys_stl::string& source, +void SystemTools::ReplaceString(std::string& source, const char* replace, size_t replaceSize, - const kwsys_stl::string& with) + const std::string& with) { const char *src = source.c_str(); char *searchPos = const_cast<char *>(strstr(src,replace)); @@ -848,21 +845,21 @@ void SystemTools::ReplaceString(kwsys_stl::string& source, #endif #if defined(_WIN32) && !defined(__CYGWIN__) -static bool SystemToolsParseRegistryKey(const kwsys_stl::string& key, +static bool SystemToolsParseRegistryKey(const std::string& key, HKEY& primaryKey, - kwsys_stl::string& second, - kwsys_stl::string& valuename) + std::string& second, + std::string& valuename) { - kwsys_stl::string primary = key; + std::string primary = key; size_t start = primary.find('\\'); - if (start == kwsys_stl::string::npos) + if (start == std::string::npos) { return false; } size_t valuenamepos = primary.find(';'); - if (valuenamepos != kwsys_stl::string::npos) + if (valuenamepos != std::string::npos) { valuename = primary.substr(valuenamepos+1); } @@ -919,13 +916,13 @@ static DWORD SystemToolsMakeRegistryMode(DWORD mode, #if defined(_WIN32) && !defined(__CYGWIN__) bool -SystemTools::GetRegistrySubKeys(const kwsys_stl::string& key, - kwsys_stl::vector<kwsys_stl::string>& subkeys, +SystemTools::GetRegistrySubKeys(const std::string& key, + std::vector<std::string>& subkeys, KeyWOW64 view) { HKEY primaryKey = HKEY_CURRENT_USER; - kwsys_stl::string second; - kwsys_stl::string valuename; + std::string second; + std::string valuename; if (!SystemToolsParseRegistryKey(key, primaryKey, second, valuename)) { return false; @@ -958,8 +955,8 @@ SystemTools::GetRegistrySubKeys(const kwsys_stl::string& key, return true; } #else -bool SystemTools::GetRegistrySubKeys(const kwsys_stl::string&, - kwsys_stl::vector<kwsys_stl::string>&, +bool SystemTools::GetRegistrySubKeys(const std::string&, + std::vector<std::string>&, KeyWOW64) { return false; @@ -974,13 +971,13 @@ bool SystemTools::GetRegistrySubKeys(const kwsys_stl::string&, // => will return the data of the "Root" value of the key #if defined(_WIN32) && !defined(__CYGWIN__) -bool SystemTools::ReadRegistryValue(const kwsys_stl::string& key, kwsys_stl::string &value, +bool SystemTools::ReadRegistryValue(const std::string& key, std::string &value, KeyWOW64 view) { bool valueset = false; HKEY primaryKey = HKEY_CURRENT_USER; - kwsys_stl::string second; - kwsys_stl::string valuename; + std::string second; + std::string valuename; if (!SystemToolsParseRegistryKey(key, primaryKey, second, valuename)) { return false; @@ -1031,7 +1028,7 @@ bool SystemTools::ReadRegistryValue(const kwsys_stl::string& key, kwsys_stl::str return valueset; } #else -bool SystemTools::ReadRegistryValue(const kwsys_stl::string&, kwsys_stl::string &, +bool SystemTools::ReadRegistryValue(const std::string&, std::string &, KeyWOW64) { return false; @@ -1047,13 +1044,13 @@ bool SystemTools::ReadRegistryValue(const kwsys_stl::string&, kwsys_stl::string // => will set the data of the "Root" value of the key #if defined(_WIN32) && !defined(__CYGWIN__) -bool SystemTools::WriteRegistryValue(const kwsys_stl::string& key, - const kwsys_stl::string& value, +bool SystemTools::WriteRegistryValue(const std::string& key, + const std::string& value, KeyWOW64 view) { HKEY primaryKey = HKEY_CURRENT_USER; - kwsys_stl::string second; - kwsys_stl::string valuename; + std::string second; + std::string valuename; if (!SystemToolsParseRegistryKey(key, primaryKey, second, valuename)) { return false; @@ -1088,7 +1085,7 @@ bool SystemTools::WriteRegistryValue(const kwsys_stl::string& key, return false; } #else -bool SystemTools::WriteRegistryValue(const kwsys_stl::string&, const kwsys_stl::string&, KeyWOW64) +bool SystemTools::WriteRegistryValue(const std::string&, const std::string&, KeyWOW64) { return false; } @@ -1102,11 +1099,11 @@ bool SystemTools::WriteRegistryValue(const kwsys_stl::string&, const kwsys_stl:: // => will delete the data of the "Root" value of the key #if defined(_WIN32) && !defined(__CYGWIN__) -bool SystemTools::DeleteRegistryValue(const kwsys_stl::string& key, KeyWOW64 view) +bool SystemTools::DeleteRegistryValue(const std::string& key, KeyWOW64 view) { HKEY primaryKey = HKEY_CURRENT_USER; - kwsys_stl::string second; - kwsys_stl::string valuename; + std::string second; + std::string valuename; if (!SystemToolsParseRegistryKey(key, primaryKey, second, valuename)) { return false; @@ -1133,13 +1130,13 @@ bool SystemTools::DeleteRegistryValue(const kwsys_stl::string& key, KeyWOW64 vie return false; } #else -bool SystemTools::DeleteRegistryValue(const kwsys_stl::string&, KeyWOW64) +bool SystemTools::DeleteRegistryValue(const std::string&, KeyWOW64) { return false; } #endif -bool SystemTools::SameFile(const kwsys_stl::string& file1, const kwsys_stl::string& file2) +bool SystemTools::SameFile(const std::string& file1, const std::string& file2) { #ifdef _WIN32 HANDLE hFile1, hFile2; @@ -1207,11 +1204,11 @@ bool SystemTools::FileExists(const char* filename) { return false; } - return SystemTools::FileExists(kwsys_stl::string(filename)); + return SystemTools::FileExists(std::string(filename)); } //---------------------------------------------------------------------------- -bool SystemTools::FileExists(const kwsys_stl::string& filename) +bool SystemTools::FileExists(const std::string& filename) { if(filename.empty()) { @@ -1241,11 +1238,11 @@ bool SystemTools::FileExists(const char* filename, bool isFile) { return false; } - return SystemTools::FileExists(kwsys_stl::string(filename), isFile); + return SystemTools::FileExists(std::string(filename), isFile); } //---------------------------------------------------------------------------- -bool SystemTools::FileExists(const kwsys_stl::string& filename, bool isFile) +bool SystemTools::FileExists(const std::string& filename, bool isFile) { if(SystemTools::FileExists(filename)) { @@ -1264,12 +1261,12 @@ bool SystemTools::TestFileAccess(const char* filename, { return false; } - return SystemTools::TestFileAccess(kwsys_stl::string(filename), + return SystemTools::TestFileAccess(std::string(filename), permissions); } //---------------------------------------------------------------------------- -bool SystemTools::TestFileAccess(const kwsys_stl::string& filename, +bool SystemTools::TestFileAccess(const std::string& filename, TestFilePermissions permissions) { if(filename.empty()) @@ -1317,7 +1314,7 @@ bool SystemTools::PathCygwinToWin32(const char *path, char *win32_path) } #endif -bool SystemTools::Touch(const kwsys_stl::string& filename, bool create) +bool SystemTools::Touch(const std::string& filename, bool create) { if (!SystemTools::FileExists(filename)) { @@ -1369,15 +1366,18 @@ bool SystemTools::Touch(const kwsys_stl::string& filename, bool create) struct timeval mtime; gettimeofday(&mtime, 0); # if KWSYS_CXX_HAS_UTIMES - struct timeval times[2] = - { -# if KWSYS_STAT_HAS_ST_MTIM - {st.st_atim.tv_sec, st.st_atim.tv_nsec/1000}, /* tv_sec, tv_usec */ + struct timeval atime; +# if KWSYS_CXX_STAT_HAS_ST_MTIM + atime.tv_sec = st.st_atim.tv_sec; + atime.tv_usec = st.st_atim.tv_nsec/1000; +# elif KWSYS_CXX_STAT_HAS_ST_MTIMESPEC + atime.tv_sec = st.st_atimespec.tv_sec; + atime.tv_usec = st.st_atimespec.tv_nsec/1000; # else - {st.st_atime, 0}, + atime.tv_sec = st.st_atime; + atime.tv_usec = 0; # endif - mtime - }; + struct timeval times[2] = { atime, mtime }; if(utimes(filename.c_str(), times) < 0) { return false; @@ -1393,8 +1393,8 @@ bool SystemTools::Touch(const kwsys_stl::string& filename, bool create) return true; } -bool SystemTools::FileTimeCompare(const kwsys_stl::string& f1, - const kwsys_stl::string& f2, +bool SystemTools::FileTimeCompare(const std::string& f1, + const std::string& f2, int* result) { // Default to same time. @@ -1411,7 +1411,7 @@ bool SystemTools::FileTimeCompare(const kwsys_stl::string& f1, { return false; } -# if KWSYS_STAT_HAS_ST_MTIM +# if KWSYS_CXX_STAT_HAS_ST_MTIM // Compare using nanosecond resolution. if(s1.st_mtim.tv_sec < s2.st_mtim.tv_sec) { @@ -1429,6 +1429,24 @@ bool SystemTools::FileTimeCompare(const kwsys_stl::string& f1, { *result = 1; } +# elif KWSYS_CXX_STAT_HAS_ST_MTIMESPEC + // Compare using nanosecond resolution. + if(s1.st_mtimespec.tv_sec < s2.st_mtimespec.tv_sec) + { + *result = -1; + } + else if(s1.st_mtimespec.tv_sec > s2.st_mtimespec.tv_sec) + { + *result = 1; + } + else if(s1.st_mtimespec.tv_nsec < s2.st_mtimespec.tv_nsec) + { + *result = -1; + } + else if(s1.st_mtimespec.tv_nsec > s2.st_mtimespec.tv_nsec) + { + *result = 1; + } # else // Compare using 1 second resolution. if(s1.st_mtime < s2.st_mtime) @@ -1466,26 +1484,26 @@ bool SystemTools::FileTimeCompare(const kwsys_stl::string& f1, // Return a capitalized string (i.e the first letter is uppercased, all other // are lowercased) -kwsys_stl::string SystemTools::Capitalized(const kwsys_stl::string& s) +std::string SystemTools::Capitalized(const std::string& s) { - kwsys_stl::string n; + std::string n; if(s.empty()) { return n; } n.resize(s.size()); - n[0] = static_cast<kwsys_stl::string::value_type>(toupper(s[0])); + n[0] = static_cast<std::string::value_type>(toupper(s[0])); for (size_t i = 1; i < s.size(); i++) { - n[i] = static_cast<kwsys_stl::string::value_type>(tolower(s[i])); + n[i] = static_cast<std::string::value_type>(tolower(s[i])); } return n; } // Return capitalized words -kwsys_stl::string SystemTools::CapitalizedWords(const kwsys_stl::string& s) +std::string SystemTools::CapitalizedWords(const std::string& s) { - kwsys_stl::string n(s); + std::string n(s); for (size_t i = 0; i < s.size(); i++) { #if defined(_MSC_VER) && defined (_MT) && defined (_DEBUG) @@ -1497,16 +1515,16 @@ kwsys_stl::string SystemTools::CapitalizedWords(const kwsys_stl::string& s) if (isalpha(s[i]) && (i == 0 || isspace(s[i - 1]))) #endif { - n[i] = static_cast<kwsys_stl::string::value_type>(toupper(s[i])); + n[i] = static_cast<std::string::value_type>(toupper(s[i])); } } return n; } // Return uncapitalized words -kwsys_stl::string SystemTools::UnCapitalizedWords(const kwsys_stl::string& s) +std::string SystemTools::UnCapitalizedWords(const std::string& s) { - kwsys_stl::string n(s); + std::string n(s); for (size_t i = 0; i < s.size(); i++) { #if defined(_MSC_VER) && defined (_MT) && defined (_DEBUG) @@ -1518,17 +1536,17 @@ kwsys_stl::string SystemTools::UnCapitalizedWords(const kwsys_stl::string& s) if (isalpha(s[i]) && (i == 0 || isspace(s[i - 1]))) #endif { - n[i] = static_cast<kwsys_stl::string::value_type>(tolower(s[i])); + n[i] = static_cast<std::string::value_type>(tolower(s[i])); } } return n; } // only works for words with at least two letters -kwsys_stl::string SystemTools::AddSpaceBetweenCapitalizedWords( - const kwsys_stl::string& s) +std::string SystemTools::AddSpaceBetweenCapitalizedWords( + const std::string& s) { - kwsys_stl::string n; + std::string n; if (!s.empty()) { n.reserve(s.size()); @@ -1595,25 +1613,25 @@ char* SystemTools::AppendStrings( } // Return a lower case string -kwsys_stl::string SystemTools::LowerCase(const kwsys_stl::string& s) +std::string SystemTools::LowerCase(const std::string& s) { - kwsys_stl::string n; + std::string n; n.resize(s.size()); for (size_t i = 0; i < s.size(); i++) { - n[i] = static_cast<kwsys_stl::string::value_type>(tolower(s[i])); + n[i] = static_cast<std::string::value_type>(tolower(s[i])); } return n; } // Return a lower case string -kwsys_stl::string SystemTools::UpperCase(const kwsys_stl::string& s) +std::string SystemTools::UpperCase(const std::string& s) { - kwsys_stl::string n; + std::string n; n.resize(s.size()); for (size_t i = 0; i < s.size(); i++) { - n[i] = static_cast<kwsys_stl::string::value_type>(toupper(s[i])); + n[i] = static_cast<std::string::value_type>(toupper(s[i])); } return n; } @@ -1719,7 +1737,7 @@ bool SystemTools::StringStartsWith(const char* str1, const char* str2) } // Returns if string starts with another string -bool SystemTools::StringStartsWith(const kwsys_stl::string& str1, const char* str2) +bool SystemTools::StringStartsWith(const std::string& str1, const char* str2) { if (!str2) { @@ -1741,7 +1759,7 @@ bool SystemTools::StringEndsWith(const char* str1, const char* str2) } // Returns if string ends with another string -bool SystemTools::StringEndsWith(const kwsys_stl::string& str1, const char* str2) +bool SystemTools::StringEndsWith(const std::string& str1, const char* str2) { if (!str2) { @@ -1787,7 +1805,7 @@ char* SystemTools::DuplicateString(const char* str) } // Return a cropped string -kwsys_stl::string SystemTools::CropString(const kwsys_stl::string& s, +std::string SystemTools::CropString(const std::string& s, size_t max_len) { if (!s.size() || max_len == 0 || max_len >= s.size()) @@ -1795,13 +1813,13 @@ kwsys_stl::string SystemTools::CropString(const kwsys_stl::string& s, return s; } - kwsys_stl::string n; + std::string n; n.reserve(max_len); size_t middle = max_len / 2; n += s.substr(0, middle); - n += s.substr(s.size() - (max_len - middle), kwsys_stl::string::npos); + n += s.substr(s.size() - (max_len - middle), std::string::npos); if (max_len > 2) { @@ -1820,10 +1838,10 @@ kwsys_stl::string SystemTools::CropString(const kwsys_stl::string& s, } //---------------------------------------------------------------------------- -kwsys_stl::vector<kwsys::String> SystemTools::SplitString(const kwsys_stl::string& p, char sep, bool isPath) +std::vector<kwsys::String> SystemTools::SplitString(const std::string& p, char sep, bool isPath) { - kwsys_stl::string path = p; - kwsys_stl::vector<kwsys::String> paths; + std::string path = p; + std::vector<kwsys::String> paths; if(path.empty()) { return paths; @@ -1833,9 +1851,9 @@ kwsys_stl::vector<kwsys::String> SystemTools::SplitString(const kwsys_stl::strin path.erase(path.begin()); paths.push_back("/"); } - kwsys_stl::string::size_type pos1 = 0; - kwsys_stl::string::size_type pos2 = path.find(sep, pos1+1); - while(pos2 != kwsys_stl::string::npos) + std::string::size_type pos1 = 0; + std::string::size_type pos2 = path.find(sep, pos1+1); + while(pos2 != std::string::npos) { paths.push_back(path.substr(pos1, pos2-pos1)); pos1 = pos2+1; @@ -1915,12 +1933,12 @@ int SystemTools::EstimateFormatLength(const char *format, va_list ap) return static_cast<int>(length); } -kwsys_stl::string SystemTools::EscapeChars( +std::string SystemTools::EscapeChars( const char *str, const char *chars_to_escape, char escape_char) { - kwsys_stl::string n; + std::string n; if (str) { if (!chars_to_escape || !*chars_to_escape) @@ -1951,17 +1969,17 @@ kwsys_stl::string SystemTools::EscapeChars( } #ifdef __VMS -static void ConvertVMSToUnix(kwsys_stl::string& path) +static void ConvertVMSToUnix(std::string& path) { - kwsys_stl::string::size_type rootEnd = path.find(":["); - kwsys_stl::string::size_type pathEnd = path.find("]"); + std::string::size_type rootEnd = path.find(":["); + std::string::size_type pathEnd = path.find("]"); if(rootEnd != path.npos) { - kwsys_stl::string root = path.substr(0, rootEnd); - kwsys_stl::string pathPart = path.substr(rootEnd+2, pathEnd - rootEnd-2); + std::string root = path.substr(0, rootEnd); + std::string pathPart = path.substr(rootEnd+2, pathEnd - rootEnd-2); const char* pathCString = pathPart.c_str(); const char* pos0 = pathCString; - for (kwsys_stl::string::size_type pos = 0; *pos0; ++ pos ) + for (std::string::size_type pos = 0; *pos0; ++ pos ) { if ( *pos0 == '.' ) { @@ -1975,7 +1993,7 @@ static void ConvertVMSToUnix(kwsys_stl::string& path) #endif // convert windows slashes to unix slashes -void SystemTools::ConvertToUnixSlashes(kwsys_stl::string& path) +void SystemTools::ConvertToUnixSlashes(std::string& path) { const char* pathCString = path.c_str(); bool hasDoubleSlash = false; @@ -1984,7 +2002,7 @@ void SystemTools::ConvertToUnixSlashes(kwsys_stl::string& path) #else const char* pos0 = pathCString; const char* pos1 = pathCString+1; - for (kwsys_stl::string::size_type pos = 0; *pos0; ++ pos ) + for (std::string::size_type pos = 0; *pos0; ++ pos ) { // make sure we don't convert an escaped space to a unix slash if ( *pos0 == '\\' && *pos1 != ' ' ) @@ -2032,8 +2050,8 @@ void SystemTools::ConvertToUnixSlashes(kwsys_stl::string& path) #ifdef HAVE_GETPWNAM else if(pathCString[0] == '~') { - kwsys_stl::string::size_type idx = path.find_first_of("/\0"); - kwsys_stl::string user = path.substr(1, idx-1); + std::string::size_type idx = path.find_first_of("/\0"); + std::string user = path.substr(1, idx-1); passwd* pw = getpwnam(user.c_str()); if(pw) { @@ -2058,10 +2076,10 @@ void SystemTools::ConvertToUnixSlashes(kwsys_stl::string& path) #ifdef _WIN32 // Convert local paths to UNC style paths -kwsys_stl::wstring -SystemTools::ConvertToWindowsExtendedPath(const kwsys_stl::string &source) +std::wstring +SystemTools::ConvertToWindowsExtendedPath(const std::string &source) { - kwsys_stl::wstring wsource = Encoding::ToWide(source); + std::wstring wsource = Encoding::ToWide(source); // Resolve any relative paths DWORD wfull_len; @@ -2069,7 +2087,7 @@ SystemTools::ConvertToWindowsExtendedPath(const kwsys_stl::string &source) /* The +3 is a workaround for a bug in some versions of GetFullPathNameW that * won't return a large enough buffer size if the input is too small */ wfull_len = GetFullPathNameW(wsource.c_str(), 0, NULL, NULL) + 3; - kwsys_stl::vector<wchar_t> wfull(wfull_len); + std::vector<wchar_t> wfull(wfull_len); GetFullPathNameW(wsource.c_str(), wfull_len, &wfull[0], NULL); /* This should get the correct size without any extra padding from the @@ -2078,7 +2096,7 @@ SystemTools::ConvertToWindowsExtendedPath(const kwsys_stl::string &source) if(wfull_len >= 2 && isalpha(wfull[0]) && wfull[1] == L':') { /* C:\Foo\bar\FooBar.txt */ - return L"\\\\?\\" + kwsys_stl::wstring(&wfull[0]); + return L"\\\\?\\" + std::wstring(&wfull[0]); } else if(wfull_len >= 2 && wfull[0] == L'\\' && wfull[1] == L'\\') { /* Starts with \\ */ @@ -2087,31 +2105,31 @@ SystemTools::ConvertToWindowsExtendedPath(const kwsys_stl::string &source) if(wfull_len >= 8 && wfull[4] == L'U' && wfull[5] == L'N' && wfull[6] == L'C' && wfull[7] == L'\\') { /* \\?\UNC\Foo\bar\FooBar.txt */ - return kwsys_stl::wstring(&wfull[0]); + return std::wstring(&wfull[0]); } else if(wfull_len >= 6 && isalpha(wfull[4]) && wfull[5] == L':') { /* \\?\C:\Foo\bar\FooBar.txt */ - return kwsys_stl::wstring(&wfull[0]); + return std::wstring(&wfull[0]); } else if(wfull_len >= 5) { /* \\?\Foo\bar\FooBar.txt */ - return L"\\\\?\\UNC\\" + kwsys_stl::wstring(&wfull[4]); + return L"\\\\?\\UNC\\" + std::wstring(&wfull[4]); } } else if(wfull_len >= 4 && wfull[2] == L'.' && wfull[3] == L'\\') { /* Starts with \\.\ a device name */ if(wfull_len >= 6 && isalpha(wfull[4]) && wfull[5] == L':') { /* \\.\C:\Foo\bar\FooBar.txt */ - return L"\\\\?\\" + kwsys_stl::wstring(&wfull[4]); + return L"\\\\?\\" + std::wstring(&wfull[4]); } else if(wfull_len >= 5) { /* \\.\Foo\bar\ Device name is left unchanged */ - return kwsys_stl::wstring(&wfull[0]); + return std::wstring(&wfull[0]); } } else if(wfull_len >= 3) { /* \\Foo\bar\FooBar.txt */ - return L"\\\\?\\UNC\\" + kwsys_stl::wstring(&wfull[2]); + return L"\\\\?\\UNC\\" + std::wstring(&wfull[2]); } } @@ -2122,20 +2140,20 @@ SystemTools::ConvertToWindowsExtendedPath(const kwsys_stl::string &source) #endif // change // to /, and escape any spaces in the path -kwsys_stl::string SystemTools::ConvertToUnixOutputPath(const kwsys_stl::string& path) +std::string SystemTools::ConvertToUnixOutputPath(const std::string& path) { - kwsys_stl::string ret = path; + std::string ret = path; // remove // except at the beginning might be a cygwin drive - kwsys_stl::string::size_type pos=1; - while((pos = ret.find("//", pos)) != kwsys_stl::string::npos) + std::string::size_type pos=1; + while((pos = ret.find("//", pos)) != std::string::npos) { ret.erase(pos, 1); } // escape spaces and () in the path - if(ret.find_first_of(" ") != kwsys_stl::string::npos) + if(ret.find_first_of(" ") != std::string::npos) { - kwsys_stl::string result = ""; + std::string result = ""; char lastch = 1; for(const char* ch = ret.c_str(); *ch != '\0'; ++ch) { @@ -2152,7 +2170,7 @@ kwsys_stl::string SystemTools::ConvertToUnixOutputPath(const kwsys_stl::string& return ret; } -kwsys_stl::string SystemTools::ConvertToOutputPath(const kwsys_stl::string& path) +std::string SystemTools::ConvertToOutputPath(const std::string& path) { #if defined(_WIN32) && !defined(__CYGWIN__) return SystemTools::ConvertToWindowsOutputPath(path); @@ -2162,16 +2180,16 @@ kwsys_stl::string SystemTools::ConvertToOutputPath(const kwsys_stl::string& path } // remove double slashes not at the start -kwsys_stl::string SystemTools::ConvertToWindowsOutputPath(const kwsys_stl::string& path) +std::string SystemTools::ConvertToWindowsOutputPath(const std::string& path) { - kwsys_stl::string ret; + std::string ret; // make it big enough for all of path and double quotes ret.reserve(path.size()+3); // put path into the string ret = path; - kwsys_stl::string::size_type pos = 0; + std::string::size_type pos = 0; // first convert all of the slashes - while((pos = ret.find('/', pos)) != kwsys_stl::string::npos) + while((pos = ret.find('/', pos)) != std::string::npos) { ret[pos] = '\\'; pos++; @@ -2193,33 +2211,33 @@ kwsys_stl::string SystemTools::ConvertToWindowsOutputPath(const kwsys_stl::strin return ret; } } - while((pos = ret.find("\\\\", pos)) != kwsys_stl::string::npos) + while((pos = ret.find("\\\\", pos)) != std::string::npos) { ret.erase(pos, 1); } // now double quote the path if it has spaces in it // and is not already double quoted - if(ret.find(' ') != kwsys_stl::string::npos + if(ret.find(' ') != std::string::npos && ret[0] != '\"') { - ret.insert(static_cast<kwsys_stl::string::size_type>(0), - static_cast<kwsys_stl::string::size_type>(1), '\"'); + ret.insert(static_cast<std::string::size_type>(0), + static_cast<std::string::size_type>(1), '\"'); ret.append(1, '\"'); } return ret; } -bool SystemTools::CopyFileIfDifferent(const kwsys_stl::string& source, - const kwsys_stl::string& destination) +bool SystemTools::CopyFileIfDifferent(const std::string& source, + const std::string& destination) { // special check for a destination that is a directory // FilesDiffer does not handle file to directory compare if(SystemTools::FileIsDirectory(destination)) { - kwsys_stl::string new_destination = destination; + std::string new_destination = destination; SystemTools::ConvertToUnixSlashes(new_destination); new_destination += '/'; - kwsys_stl::string source_name = source; + std::string source_name = source; new_destination += SystemTools::GetFilenameName(source_name); if(SystemTools::FilesDiffer(source, new_destination)) { @@ -2244,8 +2262,8 @@ bool SystemTools::CopyFileIfDifferent(const kwsys_stl::string& source, #define KWSYS_ST_BUFFER 4096 -bool SystemTools::FilesDiffer(const kwsys_stl::string& source, - const kwsys_stl::string& destination) +bool SystemTools::FilesDiffer(const std::string& source, + const std::string& destination) { #if defined(_WIN32) @@ -2308,11 +2326,11 @@ bool SystemTools::FilesDiffer(const kwsys_stl::string& source, #if defined(_WIN32) kwsys::ifstream finSource(source.c_str(), - (kwsys_ios::ios::binary | - kwsys_ios::ios::in)); + (std::ios::binary | + std::ios::in)); kwsys::ifstream finDestination(destination.c_str(), - (kwsys_ios::ios::binary | - kwsys_ios::ios::in)); + (std::ios::binary | + std::ios::in)); #else kwsys::ifstream finSource(source.c_str()); kwsys::ifstream finDestination(destination.c_str()); @@ -2328,13 +2346,13 @@ bool SystemTools::FilesDiffer(const kwsys_stl::string& source, while(nleft > 0) { // Read a block from each file. - kwsys_ios::streamsize nnext = (nleft > KWSYS_ST_BUFFER)? KWSYS_ST_BUFFER : static_cast<kwsys_ios::streamsize>(nleft); + std::streamsize nnext = (nleft > KWSYS_ST_BUFFER)? KWSYS_ST_BUFFER : static_cast<std::streamsize>(nleft); finSource.read(source_buf, nnext); finDestination.read(dest_buf, nnext); // If either failed to read assume they are different. - if(static_cast<kwsys_ios::streamsize>(finSource.gcount()) != nnext || - static_cast<kwsys_ios::streamsize>(finDestination.gcount()) != nnext) + if(static_cast<std::streamsize>(finSource.gcount()) != nnext || + static_cast<std::streamsize>(finDestination.gcount()) != nnext) { return true; } @@ -2360,7 +2378,7 @@ bool SystemTools::FilesDiffer(const kwsys_stl::string& source, /** * Copy a file named by "source" to the file named by "destination". */ -bool SystemTools::CopyFileAlways(const kwsys_stl::string& source, const kwsys_stl::string& destination) +bool SystemTools::CopyFileAlways(const std::string& source, const std::string& destination) { // If files are the same do not copy if ( SystemTools::SameFile(source, destination) ) @@ -2369,95 +2387,102 @@ bool SystemTools::CopyFileAlways(const kwsys_stl::string& source, const kwsys_st } mode_t perm = 0; bool perms = SystemTools::GetPermissions(source, perm); + std::string real_destination = destination; - const int bufferSize = 4096; - char buffer[bufferSize]; - - // If destination is a directory, try to create a file with the same - // name as the source in that directory. - - kwsys_stl::string real_destination = destination; - kwsys_stl::string destination_dir; - if(SystemTools::FileExists(destination) && - SystemTools::FileIsDirectory(destination)) + if(SystemTools::FileIsDirectory(source)) { - destination_dir = real_destination; - SystemTools::ConvertToUnixSlashes(real_destination); - real_destination += '/'; - kwsys_stl::string source_name = source; - real_destination += SystemTools::GetFilenameName(source_name); + SystemTools::MakeDirectory(destination); } else { - destination_dir = SystemTools::GetFilenamePath(destination); - } + const int bufferSize = 4096; + char buffer[bufferSize]; - // Create destination directory + // If destination is a directory, try to create a file with the same + // name as the source in that directory. - SystemTools::MakeDirectory(destination_dir); + std::string destination_dir; + if(SystemTools::FileExists(destination) && + SystemTools::FileIsDirectory(destination)) + { + destination_dir = real_destination; + SystemTools::ConvertToUnixSlashes(real_destination); + real_destination += '/'; + std::string source_name = source; + real_destination += SystemTools::GetFilenameName(source_name); + } + else + { + destination_dir = SystemTools::GetFilenamePath(destination); + } - // Open files + // Create destination directory + + SystemTools::MakeDirectory(destination_dir); + + // Open files #if defined(_WIN32) - kwsys::ifstream fin(Encoding::ToNarrow( - SystemTools::ConvertToWindowsExtendedPath(source)).c_str(), - kwsys_ios::ios::in | kwsys_ios_binary); + kwsys::ifstream fin(Encoding::ToNarrow( + SystemTools::ConvertToWindowsExtendedPath(source)).c_str(), + std::ios::in | std::ios::binary); #else - kwsys::ifstream fin(source.c_str(), - kwsys_ios::ios::in | kwsys_ios_binary); + kwsys::ifstream fin(source.c_str(), + std::ios::in | std::ios::binary); #endif - if(!fin) - { - return false; - } + if(!fin) + { + return false; + } - // try and remove the destination file so that read only destination files - // can be written to. - // If the remove fails continue so that files in read only directories - // that do not allow file removal can be modified. - SystemTools::RemoveFile(real_destination); + // try and remove the destination file so that read only destination files + // can be written to. + // If the remove fails continue so that files in read only directories + // that do not allow file removal can be modified. + SystemTools::RemoveFile(real_destination); #if defined(_WIN32) - kwsys::ofstream fout(Encoding::ToNarrow( - SystemTools::ConvertToWindowsExtendedPath(real_destination)).c_str(), - kwsys_ios::ios::out | kwsys_ios::ios::trunc | kwsys_ios_binary); + kwsys::ofstream fout(Encoding::ToNarrow( + SystemTools::ConvertToWindowsExtendedPath(real_destination)).c_str(), + std::ios::out | std::ios::trunc | std::ios::binary); #else - kwsys::ofstream fout(real_destination.c_str(), - kwsys_ios::ios::out | kwsys_ios::ios::trunc | kwsys_ios_binary); + kwsys::ofstream fout(real_destination.c_str(), + std::ios::out | std::ios::trunc | std::ios::binary); #endif - if(!fout) - { - return false; - } - - // This copy loop is very sensitive on certain platforms with - // slightly broken stream libraries (like HPUX). Normally, it is - // incorrect to not check the error condition on the fin.read() - // before using the data, but the fin.gcount() will be zero if an - // error occurred. Therefore, the loop should be safe everywhere. - while(fin) - { - fin.read(buffer, bufferSize); - if(fin.gcount()) + if(!fout) { - fout.write(buffer, fin.gcount()); + return false; } - else + + // This copy loop is very sensitive on certain platforms with + // slightly broken stream libraries (like HPUX). Normally, it is + // incorrect to not check the error condition on the fin.read() + // before using the data, but the fin.gcount() will be zero if an + // error occurred. Therefore, the loop should be safe everywhere. + while(fin) { - break; + fin.read(buffer, bufferSize); + if(fin.gcount()) + { + fout.write(buffer, fin.gcount()); + } + else + { + break; + } } - } - // Make sure the operating system has finished writing the file - // before closing it. This will ensure the file is finished before - // the check below. - fout.flush(); + // Make sure the operating system has finished writing the file + // before closing it. This will ensure the file is finished before + // the check below. + fout.flush(); - fin.close(); - fout.close(); + fin.close(); + fout.close(); - if(!fout) - { - return false; + if(!fout) + { + return false; + } } if ( perms ) { @@ -2470,7 +2495,7 @@ bool SystemTools::CopyFileAlways(const kwsys_stl::string& source, const kwsys_st } //---------------------------------------------------------------------------- -bool SystemTools::CopyAFile(const kwsys_stl::string& source, const kwsys_stl::string& destination, +bool SystemTools::CopyAFile(const std::string& source, const std::string& destination, bool always) { if(always) @@ -2487,7 +2512,7 @@ bool SystemTools::CopyAFile(const kwsys_stl::string& source, const kwsys_stl::st * Copy a directory content from "source" directory to the directory named by * "destination". */ -bool SystemTools::CopyADirectory(const kwsys_stl::string& source, const kwsys_stl::string& destination, +bool SystemTools::CopyADirectory(const std::string& source, const std::string& destination, bool always) { Directory dir; @@ -2507,12 +2532,12 @@ bool SystemTools::CopyADirectory(const kwsys_stl::string& source, const kwsys_st if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".") && strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),"..")) { - kwsys_stl::string fullPath = source; + std::string fullPath = source; fullPath += "/"; fullPath += dir.GetFile(static_cast<unsigned long>(fileNum)); if(SystemTools::FileIsDirectory(fullPath)) { - kwsys_stl::string fullDestPath = destination; + std::string fullDestPath = destination; fullDestPath += "/"; fullDestPath += dir.GetFile(static_cast<unsigned long>(fileNum)); if (!SystemTools::CopyADirectory(fullPath, @@ -2537,7 +2562,7 @@ bool SystemTools::CopyADirectory(const kwsys_stl::string& source, const kwsys_st // return size of file; also returns zero if no file exists -unsigned long SystemTools::FileLength(const kwsys_stl::string& filename) +unsigned long SystemTools::FileLength(const std::string& filename) { unsigned long length = 0; #ifdef _WIN32 @@ -2577,7 +2602,7 @@ int SystemTools::Strucmp(const char *s1, const char *s2) } // return file's modified time -long int SystemTools::ModifiedTime(const kwsys_stl::string& filename) +long int SystemTools::ModifiedTime(const std::string& filename) { long int mt = 0; #ifdef _WIN32 @@ -2600,7 +2625,7 @@ long int SystemTools::ModifiedTime(const kwsys_stl::string& filename) } // return file's creation time -long int SystemTools::CreationTime(const kwsys_stl::string& filename) +long int SystemTools::CreationTime(const std::string& filename) { long int ct = 0; #ifdef _WIN32 @@ -2724,16 +2749,16 @@ bool SystemTools::ConvertTimeStampMacroString(const char *str, time_t *tmt) return true; } -kwsys_stl::string SystemTools::GetLastSystemError() +std::string SystemTools::GetLastSystemError() { int e = errno; return strerror(e); } -bool SystemTools::RemoveFile(const kwsys_stl::string& source) +bool SystemTools::RemoveFile(const std::string& source) { #ifdef _WIN32 - kwsys_stl::wstring const& ws = + std::wstring const& ws = SystemTools::ConvertToWindowsExtendedPath(source); if (DeleteFileW(ws.c_str())) { @@ -2772,7 +2797,7 @@ bool SystemTools::RemoveFile(const kwsys_stl::string& source) #endif } -bool SystemTools::RemoveADirectory(const kwsys_stl::string& source) +bool SystemTools::RemoveADirectory(const std::string& source) { // Add write permission to the directory so we can modify its // content to remove files and directories from it. @@ -2800,7 +2825,7 @@ bool SystemTools::RemoveADirectory(const kwsys_stl::string& source) if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".") && strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),"..")) { - kwsys_stl::string fullPath = source; + std::string fullPath = source; fullPath += "/"; fullPath += dir.GetFile(static_cast<unsigned long>(fileNum)); if(SystemTools::FileIsDirectory(fullPath) && @@ -2836,13 +2861,13 @@ size_t SystemTools::GetMaximumFilePathLength() * the system search path. Returns the full path to the file if it is * found. Otherwise, the empty string is returned. */ -kwsys_stl::string SystemTools -::FindName(const kwsys_stl::string& name, - const kwsys_stl::vector<kwsys_stl::string>& userPaths, +std::string SystemTools +::FindName(const std::string& name, + const std::vector<std::string>& userPaths, bool no_system_path) { // Add the system search path to our path first - kwsys_stl::vector<kwsys_stl::string> path; + std::vector<std::string> path; if (!no_system_path) { SystemTools::GetPath(path, "CMAKE_FILE_PATH"); @@ -2850,7 +2875,7 @@ kwsys_stl::string SystemTools } // now add the additional paths { - for(kwsys_stl::vector<kwsys_stl::string>::const_iterator i = userPaths.begin(); + for(std::vector<std::string>::const_iterator i = userPaths.begin(); i != userPaths.end(); ++i) { path.push_back(*i); @@ -2858,10 +2883,10 @@ kwsys_stl::string SystemTools } // Add a trailing slash to all paths to aid the search process. { - for(kwsys_stl::vector<kwsys_stl::string>::iterator i = path.begin(); + for(std::vector<std::string>::iterator i = path.begin(); i != path.end(); ++i) { - kwsys_stl::string& p = *i; + std::string& p = *i; if(p.empty() || *p.rbegin() != '/') { p += "/"; @@ -2869,8 +2894,8 @@ kwsys_stl::string SystemTools } } // now look for the file - kwsys_stl::string tryPath; - for(kwsys_stl::vector<kwsys_stl::string>::const_iterator p = path.begin(); + std::string tryPath; + for(std::vector<std::string>::const_iterator p = path.begin(); p != path.end(); ++p) { tryPath = *p; @@ -2889,12 +2914,12 @@ kwsys_stl::string SystemTools * the system search path. Returns the full path to the file if it is * found. Otherwise, the empty string is returned. */ -kwsys_stl::string SystemTools -::FindFile(const kwsys_stl::string& name, - const kwsys_stl::vector<kwsys_stl::string>& userPaths, +std::string SystemTools +::FindFile(const std::string& name, + const std::vector<std::string>& userPaths, bool no_system_path) { - kwsys_stl::string tryPath = SystemTools::FindName(name, userPaths, no_system_path); + std::string tryPath = SystemTools::FindName(name, userPaths, no_system_path); if(!tryPath.empty() && !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); @@ -2908,12 +2933,12 @@ kwsys_stl::string SystemTools * the system search path. Returns the full path to the directory if it is * found. Otherwise, the empty string is returned. */ -kwsys_stl::string SystemTools -::FindDirectory(const kwsys_stl::string& name, - const kwsys_stl::vector<kwsys_stl::string>& userPaths, +std::string SystemTools +::FindDirectory(const std::string& name, + const std::vector<std::string>& userPaths, bool no_system_path) { - kwsys_stl::string tryPath = SystemTools::FindName(name, userPaths, no_system_path); + std::string tryPath = SystemTools::FindName(name, userPaths, no_system_path); if(!tryPath.empty() && SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); @@ -2927,24 +2952,24 @@ kwsys_stl::string SystemTools * the system search path. Returns the full path to the executable if it is * found. Otherwise, the empty string is returned. */ -kwsys_stl::string SystemTools::FindProgram( +std::string SystemTools::FindProgram( const char* nameIn, - const kwsys_stl::vector<kwsys_stl::string>& userPaths, + const std::vector<std::string>& userPaths, bool no_system_path) { if(!nameIn || !*nameIn) { return ""; } - return SystemTools::FindProgram(kwsys_stl::string(nameIn), userPaths, no_system_path); + return SystemTools::FindProgram(std::string(nameIn), userPaths, no_system_path); } -kwsys_stl::string SystemTools::FindProgram( - const kwsys_stl::string& name, - const kwsys_stl::vector<kwsys_stl::string>& userPaths, +std::string SystemTools::FindProgram( + const std::string& name, + const std::vector<std::string>& userPaths, bool no_system_path) { - kwsys_stl::vector<kwsys_stl::string> extensions; + std::vector<std::string> extensions; #if defined (_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) bool hasExtension = false; // check to see if the name already has a .xxx at @@ -2960,10 +2985,10 @@ kwsys_stl::string SystemTools::FindProgram( extensions.push_back(".exe"); } #endif - kwsys_stl::string tryPath; + std::string tryPath; // first try with extensions if the os supports them - for(kwsys_stl::vector<kwsys_stl::string>::iterator i = + for(std::vector<std::string>::iterator i = extensions.begin(); i != extensions.end(); ++i) { tryPath = name; @@ -2982,7 +3007,7 @@ kwsys_stl::string SystemTools::FindProgram( return SystemTools::CollapseFullPath(tryPath); } // now construct the path - kwsys_stl::vector<kwsys_stl::string> path; + std::vector<std::string> path; // Add the system search path to our path. if (!no_system_path) { @@ -2990,7 +3015,7 @@ kwsys_stl::string SystemTools::FindProgram( } // now add the additional paths { - for(kwsys_stl::vector<kwsys_stl::string>::const_iterator i = + for(std::vector<std::string>::const_iterator i = userPaths.begin(); i != userPaths.end(); ++i) { path.push_back(*i); @@ -2998,10 +3023,10 @@ kwsys_stl::string SystemTools::FindProgram( } // Add a trailing slash to all paths to aid the search process. { - for(kwsys_stl::vector<kwsys_stl::string>::iterator i = path.begin(); + for(std::vector<std::string>::iterator i = path.begin(); i != path.end(); ++i) { - kwsys_stl::string& p = *i; + std::string& p = *i; if(p.empty() || *p.rbegin() != '/') { p += "/"; @@ -3009,7 +3034,7 @@ kwsys_stl::string SystemTools::FindProgram( } } // Try each path - for(kwsys_stl::vector<kwsys_stl::string>::iterator p = path.begin(); + for(std::vector<std::string>::iterator p = path.begin(); p != path.end(); ++p) { #ifdef _WIN32 @@ -3017,7 +3042,7 @@ kwsys_stl::string SystemTools::FindProgram( SystemTools::ReplaceString(*p, "\"", ""); #endif // first try with extensions - for(kwsys_stl::vector<kwsys_stl::string>::iterator ext + for(std::vector<std::string>::iterator ext = extensions.begin(); ext != extensions.end(); ++ext) { tryPath = *p; @@ -3042,16 +3067,16 @@ kwsys_stl::string SystemTools::FindProgram( return ""; } -kwsys_stl::string SystemTools::FindProgram( - const kwsys_stl::vector<kwsys_stl::string>& names, - const kwsys_stl::vector<kwsys_stl::string>& path, +std::string SystemTools::FindProgram( + const std::vector<std::string>& names, + const std::vector<std::string>& path, bool noSystemPath) { - for(kwsys_stl::vector<kwsys_stl::string>::const_iterator it = names.begin(); + for(std::vector<std::string>::const_iterator it = names.begin(); it != names.end() ; ++it) { // Try to find the program. - kwsys_stl::string result = SystemTools::FindProgram(*it, + std::string result = SystemTools::FindProgram(*it, path, noSystemPath); if ( !result.empty() ) @@ -3067,9 +3092,9 @@ kwsys_stl::string SystemTools::FindProgram( * the system search path. Returns the full path to the library if it is * found. Otherwise, the empty string is returned. */ -kwsys_stl::string SystemTools -::FindLibrary(const kwsys_stl::string& name, - const kwsys_stl::vector<kwsys_stl::string>& userPaths) +std::string SystemTools +::FindLibrary(const std::string& name, + const std::vector<std::string>& userPaths) { // See if the executable exists as written. if(SystemTools::FileExists(name) && @@ -3079,11 +3104,11 @@ kwsys_stl::string SystemTools } // Add the system search path to our path. - kwsys_stl::vector<kwsys_stl::string> path; + std::vector<std::string> path; SystemTools::GetPath(path); // now add the additional paths { - for(kwsys_stl::vector<kwsys_stl::string>::const_iterator i = userPaths.begin(); + for(std::vector<std::string>::const_iterator i = userPaths.begin(); i != userPaths.end(); ++i) { path.push_back(*i); @@ -3091,18 +3116,18 @@ kwsys_stl::string SystemTools } // Add a trailing slash to all paths to aid the search process. { - for(kwsys_stl::vector<kwsys_stl::string>::iterator i = path.begin(); + for(std::vector<std::string>::iterator i = path.begin(); i != path.end(); ++i) { - kwsys_stl::string& p = *i; + std::string& p = *i; if(p.empty() || *p.rbegin() != '/') { p += "/"; } } } - kwsys_stl::string tryPath; - for(kwsys_stl::vector<kwsys_stl::string>::const_iterator p = path.begin(); + std::string tryPath; + for(std::vector<std::string>::const_iterator p = path.begin(); p != path.end(); ++p) { #if defined(__APPLE__) @@ -3177,15 +3202,15 @@ kwsys_stl::string SystemTools return ""; } -kwsys_stl::string SystemTools::GetRealPath(const kwsys_stl::string& path, - kwsys_stl::string* errorMessage) +std::string SystemTools::GetRealPath(const std::string& path, + std::string* errorMessage) { - kwsys_stl::string ret; + std::string ret; Realpath(path, ret, errorMessage); return ret; } -bool SystemTools::FileIsDirectory(const kwsys_stl::string& inName) +bool SystemTools::FileIsDirectory(const std::string& inName) { if (inName.empty()) { @@ -3234,7 +3259,7 @@ bool SystemTools::FileIsDirectory(const kwsys_stl::string& inName) } } -bool SystemTools::FileIsSymlink(const kwsys_stl::string& name) +bool SystemTools::FileIsSymlink(const std::string& name) { #if defined( _WIN32 ) DWORD attr = GetFileAttributesW( @@ -3261,25 +3286,25 @@ bool SystemTools::FileIsSymlink(const kwsys_stl::string& name) } #if defined(_WIN32) && !defined(__CYGWIN__) -bool SystemTools::CreateSymlink(const kwsys_stl::string&, const kwsys_stl::string&) +bool SystemTools::CreateSymlink(const std::string&, const std::string&) { return false; } #else -bool SystemTools::CreateSymlink(const kwsys_stl::string& origName, const kwsys_stl::string& newName) +bool SystemTools::CreateSymlink(const std::string& origName, const std::string& newName) { return symlink(origName.c_str(), newName.c_str()) >= 0; } #endif #if defined(_WIN32) && !defined(__CYGWIN__) -bool SystemTools::ReadSymlink(const kwsys_stl::string&, kwsys_stl::string&) +bool SystemTools::ReadSymlink(const std::string&, std::string&) { return false; } #else -bool SystemTools::ReadSymlink(const kwsys_stl::string& newName, - kwsys_stl::string& origName) +bool SystemTools::ReadSymlink(const std::string& newName, + std::string& origName) { char buf[KWSYS_SYSTEMTOOLS_MAXPATH+1]; int count = @@ -3298,16 +3323,16 @@ bool SystemTools::ReadSymlink(const kwsys_stl::string& newName, } #endif -int SystemTools::ChangeDirectory(const kwsys_stl::string& dir) +int SystemTools::ChangeDirectory(const std::string& dir) { return Chdir(dir); } -kwsys_stl::string SystemTools::GetCurrentWorkingDirectory(bool collapse) +std::string SystemTools::GetCurrentWorkingDirectory(bool collapse) { char buf[2048]; const char* cwd = Getcwd(buf, 2048); - kwsys_stl::string path; + std::string path; if ( cwd ) { path = cwd; @@ -3319,16 +3344,16 @@ kwsys_stl::string SystemTools::GetCurrentWorkingDirectory(bool collapse) return path; } -kwsys_stl::string SystemTools::GetProgramPath(const kwsys_stl::string& in_name) +std::string SystemTools::GetProgramPath(const std::string& in_name) { - kwsys_stl::string dir, file; + std::string dir, file; SystemTools::SplitProgramPath(in_name, dir, file); return dir; } -bool SystemTools::SplitProgramPath(const kwsys_stl::string& in_name, - kwsys_stl::string& dir, - kwsys_stl::string& file, +bool SystemTools::SplitProgramPath(const std::string& in_name, + std::string& dir, + std::string& file, bool) { dir = in_name; @@ -3337,8 +3362,8 @@ bool SystemTools::SplitProgramPath(const kwsys_stl::string& in_name, if(!SystemTools::FileIsDirectory(dir)) { - kwsys_stl::string::size_type slashPos = dir.rfind("/"); - if(slashPos != kwsys_stl::string::npos) + std::string::size_type slashPos = dir.rfind("/"); + if(slashPos != std::string::npos) { file = dir.substr(slashPos+1); dir = dir.substr(0, slashPos); @@ -3351,7 +3376,7 @@ bool SystemTools::SplitProgramPath(const kwsys_stl::string& in_name, } if(!(dir.empty()) && !SystemTools::FileIsDirectory(dir)) { - kwsys_stl::string oldDir = in_name; + std::string oldDir = in_name; SystemTools::ConvertToUnixSlashes(oldDir); dir = in_name; return false; @@ -3360,14 +3385,14 @@ bool SystemTools::SplitProgramPath(const kwsys_stl::string& in_name, } bool SystemTools::FindProgramPath(const char* argv0, - kwsys_stl::string& pathOut, - kwsys_stl::string& errorMsg, + std::string& pathOut, + std::string& errorMsg, const char* exeName, const char* buildDir, const char* installPrefix ) { - kwsys_stl::vector<kwsys_stl::string> failures; - kwsys_stl::string self = argv0 ? argv0 : ""; + std::vector<std::string> failures; + std::string self = argv0 ? argv0 : ""; failures.push_back(self); SystemTools::ConvertToUnixSlashes(self); self = SystemTools::FindProgram(self); @@ -3375,7 +3400,7 @@ bool SystemTools::FindProgramPath(const char* argv0, { if(buildDir) { - kwsys_stl::string intdir = "."; + std::string intdir = "."; #ifdef CMAKE_INTDIR intdir = CMAKE_INTDIR; #endif @@ -3400,7 +3425,7 @@ bool SystemTools::FindProgramPath(const char* argv0, if(!SystemTools::FileExists(self)) { failures.push_back(self); - kwsys_ios::ostringstream msg; + std::ostringstream msg; msg << "Can not find the command line program "; if (exeName) { @@ -3412,7 +3437,7 @@ bool SystemTools::FindProgramPath(const char* argv0, msg << " argv[0] = \"" << argv0 << "\"\n"; } msg << " Attempted paths:\n"; - kwsys_stl::vector<kwsys_stl::string>::iterator i; + std::vector<std::string>::iterator i; for(i=failures.begin(); i != failures.end(); ++i) { msg << " \"" << *i << "\"\n"; @@ -3425,15 +3450,15 @@ bool SystemTools::FindProgramPath(const char* argv0, } -kwsys_stl::string SystemTools::CollapseFullPath(const kwsys_stl::string& in_relative) +std::string SystemTools::CollapseFullPath(const std::string& in_relative) { return SystemTools::CollapseFullPath(in_relative, 0); } -void SystemTools::AddTranslationPath(const kwsys_stl::string& a, const kwsys_stl::string& b) +void SystemTools::AddTranslationPath(const std::string& a, const std::string& b) { - kwsys_stl::string path_a = a; - kwsys_stl::string path_b = b; + std::string path_a = a; + std::string path_b = b; SystemTools::ConvertToUnixSlashes(path_a); SystemTools::ConvertToUnixSlashes(path_b); // First check this is a directory path, since we don't want the table to @@ -3444,7 +3469,7 @@ void SystemTools::AddTranslationPath(const kwsys_stl::string& a, const kwsys_stl // Ken--the following code is incorrect. .. can be in a valid path // for example /home/martink/MyHubba...Hubba/Src if( SystemTools::FileIsFullPath(path_b) && path_b.find("..") - == kwsys_stl::string::npos ) + == std::string::npos ) { // Before inserting make sure path ends with '/' if(!path_a.empty() && *path_a.rbegin() != '/') @@ -3464,14 +3489,14 @@ void SystemTools::AddTranslationPath(const kwsys_stl::string& a, const kwsys_stl } } -void SystemTools::AddKeepPath(const kwsys_stl::string& dir) +void SystemTools::AddKeepPath(const std::string& dir) { - kwsys_stl::string cdir; + std::string cdir; Realpath(SystemTools::CollapseFullPath(dir).c_str(), cdir); SystemTools::AddTranslationPath(cdir, dir); } -void SystemTools::CheckTranslationPath(kwsys_stl::string & path) +void SystemTools::CheckTranslationPath(std::string & path) { // Do not translate paths that are too short to have meaningful // translations. @@ -3487,7 +3512,7 @@ void SystemTools::CheckTranslationPath(kwsys_stl::string & path) // In case a file was specified we still have to go through this: // Now convert any path found in the table back to the one desired: - kwsys_stl::map<kwsys_stl::string,kwsys_stl::string>::const_iterator it; + std::map<std::string,std::string>::const_iterator it; for(it = SystemTools::TranslationMap->begin(); it != SystemTools::TranslationMap->end(); ++it ) @@ -3505,13 +3530,13 @@ void SystemTools::CheckTranslationPath(kwsys_stl::string & path) static void SystemToolsAppendComponents( - kwsys_stl::vector<kwsys_stl::string>& out_components, - kwsys_stl::vector<kwsys_stl::string>::const_iterator first, - kwsys_stl::vector<kwsys_stl::string>::const_iterator last) + std::vector<std::string>& out_components, + std::vector<std::string>::const_iterator first, + std::vector<std::string>::const_iterator last) { - static const kwsys_stl::string up = ".."; - static const kwsys_stl::string cur = "."; - for(kwsys_stl::vector<kwsys_stl::string>::const_iterator i = first; + static const std::string up = ".."; + static const std::string cur = "."; + for(std::vector<std::string>::const_iterator i = first; i != last; ++i) { if(*i == up) @@ -3528,20 +3553,20 @@ SystemToolsAppendComponents( } } -kwsys_stl::string SystemTools::CollapseFullPath(const kwsys_stl::string& in_path, +std::string SystemTools::CollapseFullPath(const std::string& in_path, const char* in_base) { // Collect the output path components. - kwsys_stl::vector<kwsys_stl::string> out_components; + std::vector<std::string> out_components; // Split the input path components. - kwsys_stl::vector<kwsys_stl::string> path_components; + std::vector<std::string> path_components; SystemTools::SplitPath(in_path, path_components); // If the input path is relative, start with a base path. if(path_components[0].length() == 0) { - kwsys_stl::vector<kwsys_stl::string> base_components; + std::vector<std::string> base_components; if(in_base) { // Use the given base path. @@ -3574,7 +3599,7 @@ kwsys_stl::string SystemTools::CollapseFullPath(const kwsys_stl::string& in_path path_components.end()); // Transform the path back to a string. - kwsys_stl::string newPath = SystemTools::JoinPath(out_components); + std::string newPath = SystemTools::JoinPath(out_components); // Update the translation table with this potentially new path. I am not // sure why this line is here, it seems really questionable, but yet I @@ -3599,20 +3624,20 @@ kwsys_stl::string SystemTools::CollapseFullPath(const kwsys_stl::string& in_path return newPath; } -kwsys_stl::string SystemTools::CollapseFullPath(const kwsys_stl::string& in_path, - const kwsys_stl::string& in_base) +std::string SystemTools::CollapseFullPath(const std::string& in_path, + const std::string& in_base) { // Collect the output path components. - kwsys_stl::vector<kwsys_stl::string> out_components; + std::vector<std::string> out_components; // Split the input path components. - kwsys_stl::vector<kwsys_stl::string> path_components; + std::vector<std::string> path_components; SystemTools::SplitPath(in_path, path_components); // If the input path is relative, start with a base path. if(path_components[0].length() == 0) { - kwsys_stl::vector<kwsys_stl::string> base_components; + std::vector<std::string> base_components; // Use the given base path. SystemTools::SplitPath(in_base, base_components); @@ -3629,7 +3654,7 @@ kwsys_stl::string SystemTools::CollapseFullPath(const kwsys_stl::string& in_path path_components.end()); // Transform the path back to a string. - kwsys_stl::string newPath = SystemTools::JoinPath(out_components); + std::string newPath = SystemTools::JoinPath(out_components); // Update the translation table with this potentially new path. I am not // sure why this line is here, it seems really questionable, but yet I @@ -3655,7 +3680,7 @@ kwsys_stl::string SystemTools::CollapseFullPath(const kwsys_stl::string& in_path } // compute the relative path from here to there -kwsys_stl::string SystemTools::RelativePath(const kwsys_stl::string& local, const kwsys_stl::string& remote) +std::string SystemTools::RelativePath(const std::string& local, const std::string& remote) { if(!SystemTools::FileIsFullPath(local)) { @@ -3666,14 +3691,14 @@ kwsys_stl::string SystemTools::RelativePath(const kwsys_stl::string& local, cons return ""; } - kwsys_stl::string l = SystemTools::CollapseFullPath(local); - kwsys_stl::string r = SystemTools::CollapseFullPath(remote); + std::string l = SystemTools::CollapseFullPath(local); + std::string r = SystemTools::CollapseFullPath(remote); // split up both paths into arrays of strings using / as a separator - kwsys_stl::vector<kwsys::String> localSplit = SystemTools::SplitString(l, '/', true); - kwsys_stl::vector<kwsys::String> remoteSplit = SystemTools::SplitString(r, '/', true); - kwsys_stl::vector<kwsys::String> commonPath; // store shared parts of path in this array - kwsys_stl::vector<kwsys::String> finalPath; // store the final relative path here + std::vector<kwsys::String> localSplit = SystemTools::SplitString(l, '/', true); + std::vector<kwsys::String> remoteSplit = SystemTools::SplitString(r, '/', true); + std::vector<kwsys::String> commonPath; // store shared parts of path in this array + std::vector<kwsys::String> finalPath; // store the final relative path here // count up how many matching directory names there are from the start unsigned int sameCount = 0; while( @@ -3718,7 +3743,7 @@ kwsys_stl::string SystemTools::RelativePath(const kwsys_stl::string& local, cons } // for each entry that is not common in the remote path add it // to the final path. - for(kwsys_stl::vector<String>::iterator vit = remoteSplit.begin(); + for(std::vector<String>::iterator vit = remoteSplit.begin(); vit != remoteSplit.end(); ++vit) { if(!vit->empty()) @@ -3726,10 +3751,10 @@ kwsys_stl::string SystemTools::RelativePath(const kwsys_stl::string& local, cons finalPath.push_back(*vit); } } - kwsys_stl::string relativePath; // result string + std::string relativePath; // result string // now turn the array of directories into a unix path by puttint / // between each entry that does not already have one - for(kwsys_stl::vector<String>::iterator vit1 = finalPath.begin(); + for(std::vector<String>::iterator vit1 = finalPath.begin(); vit1 != finalPath.end(); ++vit1) { if(!relativePath.empty() && *relativePath.rbegin() != '/') @@ -3742,10 +3767,10 @@ kwsys_stl::string SystemTools::RelativePath(const kwsys_stl::string& local, cons } #ifdef _WIN32 -static int GetCasePathName(const kwsys_stl::string & pathIn, - kwsys_stl::string & casePath) +static int GetCasePathName(const std::string & pathIn, + std::string & casePath) { - kwsys_stl::vector<kwsys_stl::string> path_components; + std::vector<std::string> path_components; SystemTools::SplitPath(pathIn, path_components); if(path_components[0].empty()) // First component always exists. { @@ -3755,7 +3780,7 @@ static int GetCasePathName(const kwsys_stl::string & pathIn, } // Start with root component. - kwsys_stl::vector<kwsys_stl::string>::size_type idx = 0; + std::vector<std::string>::size_type idx = 0; casePath = path_components[idx++]; // make sure drive letter is always upper case if(casePath.size() > 1 && casePath[1] == ':') @@ -3779,14 +3804,14 @@ static int GetCasePathName(const kwsys_stl::string & pathIn, { casePath += sep; sep = "/"; - kwsys_stl::string test_str = casePath; + std::string test_str = casePath; test_str += path_components[idx]; // If path component contains wildcards, we skip matching // because these filenames are not allowed on windows, // and we do not want to match a different file. - if(path_components[idx].find('*') != kwsys_stl::string::npos || - path_components[idx].find('?') != kwsys_stl::string::npos) + if(path_components[idx].find('*') != std::string::npos || + path_components[idx].find('?') != std::string::npos) { casePath = ""; return 0; @@ -3812,7 +3837,7 @@ static int GetCasePathName(const kwsys_stl::string & pathIn, //---------------------------------------------------------------------------- -kwsys_stl::string SystemTools::GetActualCaseForPath(const kwsys_stl::string& p) +std::string SystemTools::GetActualCaseForPath(const std::string& p) { #ifndef _WIN32 return p; @@ -3825,7 +3850,7 @@ kwsys_stl::string SystemTools::GetActualCaseForPath(const kwsys_stl::string& p) { return i->second; } - kwsys_stl::string casePath; + std::string casePath; int len = GetCasePathName(p, casePath); if(len == 0 || len > MAX_PATH+1) { @@ -3838,7 +3863,7 @@ kwsys_stl::string SystemTools::GetActualCaseForPath(const kwsys_stl::string& p) //---------------------------------------------------------------------------- const char* SystemTools::SplitPathRootComponent(const std::string& p, - kwsys_stl::string* root) + std::string* root) { // Identify the root component. const char* c = p.c_str(); @@ -3924,7 +3949,7 @@ const char* SystemTools::SplitPathRootComponent(const std::string& p, //---------------------------------------------------------------------------- void SystemTools::SplitPath(const std::string& p, - kwsys_stl::vector<kwsys_stl::string>& components, + std::vector<std::string>& components, bool expand_home_dir) { const char* c; @@ -3932,13 +3957,13 @@ void SystemTools::SplitPath(const std::string& p, // Identify the root component. { - kwsys_stl::string root; + std::string root; c = SystemTools::SplitPathRootComponent(p, &root); // Expand home directory references if requested. if(expand_home_dir && !root.empty() && root[0] == '~') { - kwsys_stl::string homedir; + std::string homedir; root = root.substr(0, root.size()-1); if(root.size() == 1) { @@ -3984,7 +4009,7 @@ void SystemTools::SplitPath(const std::string& p, if(*last == '/' || *last == '\\') { // End of a component. Save it. - components.push_back(kwsys_stl::string(first, last)); + components.push_back(std::string(first, last)); first = last+1; } } @@ -3992,27 +4017,27 @@ void SystemTools::SplitPath(const std::string& p, // Save the last component unless there were no components. if(last != c) { - components.push_back(kwsys_stl::string(first, last)); + components.push_back(std::string(first, last)); } } //---------------------------------------------------------------------------- -kwsys_stl::string -SystemTools::JoinPath(const kwsys_stl::vector<kwsys_stl::string>& components) +std::string +SystemTools::JoinPath(const std::vector<std::string>& components) { return SystemTools::JoinPath(components.begin(), components.end()); } //---------------------------------------------------------------------------- -kwsys_stl::string +std::string SystemTools -::JoinPath(kwsys_stl::vector<kwsys_stl::string>::const_iterator first, - kwsys_stl::vector<kwsys_stl::string>::const_iterator last) +::JoinPath(std::vector<std::string>::const_iterator first, + std::vector<std::string>::const_iterator last) { // Construct result in a single string. - kwsys_stl::string result; + std::string result; size_t len = 0; - kwsys_stl::vector<kwsys_stl::string>::const_iterator i; + std::vector<std::string>::const_iterator i; for(i = first; i != last; ++i) { len += 1 + i->size(); @@ -4041,7 +4066,7 @@ SystemTools } //---------------------------------------------------------------------------- -bool SystemTools::ComparePath(const kwsys_stl::string& c1, const kwsys_stl::string& c2) +bool SystemTools::ComparePath(const std::string& c1, const std::string& c2) { #if defined(_WIN32) || defined(__APPLE__) # ifdef _MSC_VER @@ -4057,14 +4082,14 @@ bool SystemTools::ComparePath(const kwsys_stl::string& c1, const kwsys_stl::stri } //---------------------------------------------------------------------------- -bool SystemTools::Split(const kwsys_stl::string& str, kwsys_stl::vector<kwsys_stl::string>& lines, char separator) +bool SystemTools::Split(const std::string& str, std::vector<std::string>& lines, char separator) { - kwsys_stl::string data(str); - kwsys_stl::string::size_type lpos = 0; + std::string data(str); + std::string::size_type lpos = 0; while(lpos < data.length()) { - kwsys_stl::string::size_type rpos = data.find_first_of(separator, lpos); - if(rpos == kwsys_stl::string::npos) + std::string::size_type rpos = data.find_first_of(separator, lpos); + if(rpos == std::string::npos) { // Line ends at end of string without a newline. lines.push_back(data.substr(lpos)); @@ -4081,14 +4106,14 @@ bool SystemTools::Split(const kwsys_stl::string& str, kwsys_stl::vector<kwsys_st } //---------------------------------------------------------------------------- -bool SystemTools::Split(const kwsys_stl::string& str, kwsys_stl::vector<kwsys_stl::string>& lines) +bool SystemTools::Split(const std::string& str, std::vector<std::string>& lines) { - kwsys_stl::string data(str); - kwsys_stl::string::size_type lpos = 0; + std::string data(str); + std::string::size_type lpos = 0; while(lpos < data.length()) { - kwsys_stl::string::size_type rpos = data.find_first_of("\n", lpos); - if(rpos == kwsys_stl::string::npos) + std::string::size_type rpos = data.find_first_of("\n", lpos); + if(rpos == std::string::npos) { // Line ends at end of string without a newline. lines.push_back(data.substr(lpos)); @@ -4113,15 +4138,15 @@ bool SystemTools::Split(const kwsys_stl::string& str, kwsys_stl::vector<kwsys_st * Return path of a full filename (no trailing slashes). * Warning: returned path is converted to Unix slashes format. */ -kwsys_stl::string SystemTools::GetFilenamePath(const kwsys_stl::string& filename) +std::string SystemTools::GetFilenamePath(const std::string& filename) { - kwsys_stl::string fn = filename; + std::string fn = filename; SystemTools::ConvertToUnixSlashes(fn); - kwsys_stl::string::size_type slash_pos = fn.rfind("/"); - if(slash_pos != kwsys_stl::string::npos) + std::string::size_type slash_pos = fn.rfind("/"); + if(slash_pos != std::string::npos) { - kwsys_stl::string ret = fn.substr(0, slash_pos); + std::string ret = fn.substr(0, slash_pos); if(ret.size() == 2 && ret[1] == ':') { return ret + '/'; @@ -4142,14 +4167,14 @@ kwsys_stl::string SystemTools::GetFilenamePath(const kwsys_stl::string& filename /** * Return file name of a full filename (i.e. file name without path). */ -kwsys_stl::string SystemTools::GetFilenameName(const kwsys_stl::string& filename) +std::string SystemTools::GetFilenameName(const std::string& filename) { #if defined(_WIN32) - kwsys_stl::string::size_type slash_pos = filename.find_last_of("/\\"); + std::string::size_type slash_pos = filename.find_last_of("/\\"); #else - kwsys_stl::string::size_type slash_pos = filename.rfind('/'); + std::string::size_type slash_pos = filename.rfind('/'); #endif - if(slash_pos != kwsys_stl::string::npos) + if(slash_pos != std::string::npos) { return filename.substr(slash_pos + 1); } @@ -4164,11 +4189,11 @@ kwsys_stl::string SystemTools::GetFilenameName(const kwsys_stl::string& filename * Return file extension of a full filename (dot included). * Warning: this is the longest extension (for example: .tar.gz) */ -kwsys_stl::string SystemTools::GetFilenameExtension(const kwsys_stl::string& filename) +std::string SystemTools::GetFilenameExtension(const std::string& filename) { - kwsys_stl::string name = SystemTools::GetFilenameName(filename); - kwsys_stl::string::size_type dot_pos = name.find('.'); - if(dot_pos != kwsys_stl::string::npos) + std::string name = SystemTools::GetFilenameName(filename); + std::string::size_type dot_pos = name.find('.'); + if(dot_pos != std::string::npos) { return name.substr(dot_pos); } @@ -4182,11 +4207,11 @@ kwsys_stl::string SystemTools::GetFilenameExtension(const kwsys_stl::string& fil * Return file extension of a full filename (dot included). * Warning: this is the shortest extension (for example: .gz of .tar.gz) */ -kwsys_stl::string SystemTools::GetFilenameLastExtension(const kwsys_stl::string& filename) +std::string SystemTools::GetFilenameLastExtension(const std::string& filename) { - kwsys_stl::string name = SystemTools::GetFilenameName(filename); - kwsys_stl::string::size_type dot_pos = name.rfind('.'); - if(dot_pos != kwsys_stl::string::npos) + std::string name = SystemTools::GetFilenameName(filename); + std::string::size_type dot_pos = name.rfind('.'); + if(dot_pos != std::string::npos) { return name.substr(dot_pos); } @@ -4200,11 +4225,11 @@ kwsys_stl::string SystemTools::GetFilenameLastExtension(const kwsys_stl::string& * Return file name without extension of a full filename (i.e. without path). * Warning: it considers the longest extension (for example: .tar.gz) */ -kwsys_stl::string SystemTools::GetFilenameWithoutExtension(const kwsys_stl::string& filename) +std::string SystemTools::GetFilenameWithoutExtension(const std::string& filename) { - kwsys_stl::string name = SystemTools::GetFilenameName(filename); - kwsys_stl::string::size_type dot_pos = name.find('.'); - if(dot_pos != kwsys_stl::string::npos) + std::string name = SystemTools::GetFilenameName(filename); + std::string::size_type dot_pos = name.find('.'); + if(dot_pos != std::string::npos) { return name.substr(0, dot_pos); } @@ -4220,12 +4245,12 @@ kwsys_stl::string SystemTools::GetFilenameWithoutExtension(const kwsys_stl::stri * Warning: it considers the last extension (for example: removes .gz * from .tar.gz) */ -kwsys_stl::string -SystemTools::GetFilenameWithoutLastExtension(const kwsys_stl::string& filename) +std::string +SystemTools::GetFilenameWithoutLastExtension(const std::string& filename) { - kwsys_stl::string name = SystemTools::GetFilenameName(filename); - kwsys_stl::string::size_type dot_pos = name.rfind('.'); - if(dot_pos != kwsys_stl::string::npos) + std::string name = SystemTools::GetFilenameName(filename); + std::string::size_type dot_pos = name.rfind('.'); + if(dot_pos != std::string::npos) { return name.substr(0, dot_pos); } @@ -4334,7 +4359,7 @@ SystemTools::DetectFileType(const char *filename, bool SystemTools::LocateFileInDir(const char *filename, const char *dir, - kwsys_stl::string& filename_found, + std::string& filename_found, int try_filename_dirs) { if (!filename || !dir) @@ -4344,12 +4369,12 @@ bool SystemTools::LocateFileInDir(const char *filename, // Get the basename of 'filename' - kwsys_stl::string filename_base = SystemTools::GetFilenameName(filename); + std::string filename_base = SystemTools::GetFilenameName(filename); // Check if 'dir' is really a directory // If win32 and matches something like C:, accept it as a dir - kwsys_stl::string real_dir; + std::string real_dir; if (!SystemTools::FileIsDirectory(dir)) { #if defined( _WIN32 ) @@ -4373,7 +4398,7 @@ bool SystemTools::LocateFileInDir(const char *filename, int need_slash = (dir_len && dir[dir_len - 1] != '/' && dir[dir_len - 1] != '\\'); - kwsys_stl::string temp = dir; + std::string temp = dir; if (need_slash) { temp += "/"; @@ -4393,9 +4418,9 @@ bool SystemTools::LocateFileInDir(const char *filename, else if (try_filename_dirs) { - kwsys_stl::string filename_dir(filename); - kwsys_stl::string filename_dir_base; - kwsys_stl::string filename_dir_bases; + std::string filename_dir(filename); + std::string filename_dir_base; + std::string filename_dir_bases; do { filename_dir = SystemTools::GetFilenamePath(filename_dir); @@ -4429,7 +4454,7 @@ bool SystemTools::LocateFileInDir(const char *filename, return res; } -bool SystemTools::FileIsFullPath(const kwsys_stl::string& in_name) +bool SystemTools::FileIsFullPath(const std::string& in_name) { return SystemTools::FileIsFullPath(in_name.c_str(), in_name.size()); } @@ -4478,7 +4503,7 @@ bool SystemTools::FileIsFullPath(const char* in_name, size_t len) return false; } -bool SystemTools::GetShortPath(const kwsys_stl::string& path, kwsys_stl::string& shortPath) +bool SystemTools::GetShortPath(const std::string& path, std::string& shortPath) { #if defined(_WIN32) && !defined(__CYGWIN__) const int size = int(path.size()) +1; // size of return @@ -4496,8 +4521,8 @@ bool SystemTools::GetShortPath(const kwsys_stl::string& path, kwsys_stl::string& strcpy(tempPath,path.c_str()); } - kwsys_stl::wstring wtempPath = Encoding::ToWide(tempPath); - kwsys_stl::vector<wchar_t> buffer(wtempPath.size()+1); + std::wstring wtempPath = Encoding::ToWide(tempPath); + std::vector<wchar_t> buffer(wtempPath.size()+1); buffer[0] = 0; ret = GetShortPathNameW(wtempPath.c_str(), &buffer[0], static_cast<DWORD>(wtempPath.size())); @@ -4519,8 +4544,8 @@ bool SystemTools::GetShortPath(const kwsys_stl::string& path, kwsys_stl::string& #endif } -void SystemTools::SplitProgramFromArgs(const kwsys_stl::string& path, - kwsys_stl::string& program, kwsys_stl::string& args) +void SystemTools::SplitProgramFromArgs(const std::string& path, + std::string& program, std::string& args) { // see if this is a full path to a program // if so then set program to path and args to nothing @@ -4532,8 +4557,8 @@ void SystemTools::SplitProgramFromArgs(const kwsys_stl::string& path, } // Try to find the program in the path, note the program // may have spaces in its name so we have to look for it - kwsys_stl::vector<kwsys_stl::string> e; - kwsys_stl::string findProg = SystemTools::FindProgram(path, e); + std::vector<std::string> e; + std::string findProg = SystemTools::FindProgram(path, e); if(!findProg.empty()) { program = findProg; @@ -4543,17 +4568,17 @@ void SystemTools::SplitProgramFromArgs(const kwsys_stl::string& path, // Now try and peel off space separated chunks from the end of the string // so the largest path possible is found allowing for spaces in the path - kwsys_stl::string dir = path; - kwsys_stl::string::size_type spacePos = dir.rfind(' '); - while(spacePos != kwsys_stl::string::npos) + std::string dir = path; + std::string::size_type spacePos = dir.rfind(' '); + while(spacePos != std::string::npos) { - kwsys_stl::string tryProg = dir.substr(0, spacePos); + std::string tryProg = dir.substr(0, spacePos); // See if the file exists if(SystemTools::FileExists(tryProg)) { program = tryProg; // remove trailing spaces from program - kwsys_stl::string::size_type pos = program.size()-1; + std::string::size_type pos = program.size()-1; while(program[pos] == ' ') { program.erase(pos); @@ -4568,7 +4593,7 @@ void SystemTools::SplitProgramFromArgs(const kwsys_stl::string& path, { program = findProg; // remove trailing spaces from program - kwsys_stl::string::size_type pos = program.size()-1; + std::string::size_type pos = program.size()-1; while(program[pos] == ' ') { program.erase(pos); @@ -4586,29 +4611,29 @@ void SystemTools::SplitProgramFromArgs(const kwsys_stl::string& path, args = ""; } -kwsys_stl::string SystemTools::GetCurrentDateTime(const char* format) +std::string SystemTools::GetCurrentDateTime(const char* format) { char buf[1024]; time_t t; time(&t); strftime(buf, sizeof(buf), format, localtime(&t)); - return kwsys_stl::string(buf); + return std::string(buf); } -kwsys_stl::string SystemTools::MakeCidentifier(const kwsys_stl::string& s) +std::string SystemTools::MakeCidentifier(const std::string& s) { - kwsys_stl::string str(s); + std::string str(s); if (str.find_first_of("0123456789") == 0) { str = "_" + str; } - kwsys_stl::string permited_chars("_" + std::string permited_chars("_" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789"); - kwsys_stl::string::size_type pos = 0; - while ((pos = str.find_first_not_of(permited_chars, pos)) != kwsys_stl::string::npos) + std::string::size_type pos = 0; + while ((pos = str.find_first_not_of(permited_chars, pos)) != std::string::npos) { str[pos] = '_'; } @@ -4618,8 +4643,8 @@ kwsys_stl::string SystemTools::MakeCidentifier(const kwsys_stl::string& s) // Due to a buggy stream library on the HP and another on Mac OS X, we // need this very carefully written version of getline. Returns true // if any data were read before the end-of-file was reached. -bool SystemTools::GetLineFromStream(kwsys_ios::istream& is, - kwsys_stl::string& line, +bool SystemTools::GetLineFromStream(std::istream& is, + std::string& line, bool* has_newline /* = 0 */, long sizeLimit /* = -1 */) { @@ -4650,7 +4675,7 @@ bool SystemTools::GetLineFromStream(kwsys_ios::istream& is, // been reached. Clear the fail bit just before reading. while(!haveNewline && leftToRead != 0 && - (is.clear(is.rdstate() & ~kwsys_ios::ios::failbit), + (is.clear(is.rdstate() & ~std::ios::failbit), is.getline(buffer, bufferSize), is.gcount() > 0)) { // We have read at least one byte. @@ -4735,10 +4760,10 @@ bool SystemTools::GetPermissions(const char* file, mode_t& mode) { return false; } - return SystemTools::GetPermissions(kwsys_stl::string(file), mode); + return SystemTools::GetPermissions(std::string(file), mode); } -bool SystemTools::GetPermissions(const kwsys_stl::string& file, mode_t& mode) +bool SystemTools::GetPermissions(const std::string& file, mode_t& mode) { #if defined(_WIN32) DWORD attr = GetFileAttributesW( @@ -4793,10 +4818,10 @@ bool SystemTools::SetPermissions(const char* file, return false; } return SystemTools::SetPermissions( - kwsys_stl::string(file), mode, honor_umask); + std::string(file), mode, honor_umask); } -bool SystemTools::SetPermissions(const kwsys_stl::string& file, +bool SystemTools::SetPermissions(const std::string& file, mode_t mode, bool honor_umask) { @@ -4826,19 +4851,19 @@ bool SystemTools::SetPermissions(const kwsys_stl::string& file, return true; } -kwsys_stl::string SystemTools::GetParentDirectory(const kwsys_stl::string& fileOrDir) +std::string SystemTools::GetParentDirectory(const std::string& fileOrDir) { return SystemTools::GetFilenamePath(fileOrDir); } -bool SystemTools::IsSubDirectory(const kwsys_stl::string& cSubdir, const kwsys_stl::string& cDir) +bool SystemTools::IsSubDirectory(const std::string& cSubdir, const std::string& cDir) { if(cDir.empty()) { return false; } - kwsys_stl::string subdir = cSubdir; - kwsys_stl::string dir = cDir; + std::string subdir = cSubdir; + std::string dir = cDir; SystemTools::ConvertToUnixSlashes(subdir); SystemTools::ConvertToUnixSlashes(dir); if(subdir.size() > dir.size() && subdir[dir.size()] == '/') @@ -4873,9 +4898,9 @@ void SystemTools::Delay(unsigned int msec) #endif } -kwsys_stl::string SystemTools::GetOperatingSystemNameAndVersion() +std::string SystemTools::GetOperatingSystemNameAndVersion() { - kwsys_stl::string res; + std::string res; #ifdef _WIN32 char buffer[256]; @@ -4883,11 +4908,8 @@ kwsys_stl::string SystemTools::GetOperatingSystemNameAndVersion() OSVERSIONINFOEXA osvi; BOOL bOsVersionInfoEx; - // Try calling GetVersionEx using the OSVERSIONINFOEX structure. - // If that fails, try using the OSVERSIONINFO structure. - - ZeroMemory(&osvi, sizeof(OSVERSIONINFOEXA)); - osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA); + ZeroMemory(&osvi, sizeof(osvi)); + osvi.dwOSVersionInfoSize = sizeof(osvi); #ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx # pragma warning (push) @@ -4897,14 +4919,10 @@ kwsys_stl::string SystemTools::GetOperatingSystemNameAndVersion() # pragma warning (disable:4996) # endif #endif - bOsVersionInfoEx = GetVersionEx((OSVERSIONINFO *)&osvi); + bOsVersionInfoEx = GetVersionExA((OSVERSIONINFOA *)&osvi); if (!bOsVersionInfoEx) { - osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); - if (!GetVersionEx((OSVERSIONINFO *)&osvi)) - { - return 0; - } + return 0; } #ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx # pragma warning (pop) @@ -4917,10 +4935,56 @@ kwsys_stl::string SystemTools::GetOperatingSystemNameAndVersion() case VER_PLATFORM_WIN32_NT: // Test for the specific product family. + if (osvi.dwMajorVersion == 10 && osvi.dwMinorVersion == 0) + { + if (osvi.wProductType == VER_NT_WORKSTATION) + { + res += "Microsoft Windows 10"; + } + else + { + res += "Microsoft Windows Server 2016 family"; + } + } + + if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 3) + { + if (osvi.wProductType == VER_NT_WORKSTATION) + { + res += "Microsoft Windows 8.1"; + } + else + { + res += "Microsoft Windows Server 2012 R2 family"; + } + } + + if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 2) + { + if (osvi.wProductType == VER_NT_WORKSTATION) + { + res += "Microsoft Windows 8"; + } + else + { + res += "Microsoft Windows Server 2012 family"; + } + } + + if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 1) + { + if (osvi.wProductType == VER_NT_WORKSTATION) + { + res += "Microsoft Windows 7"; + } + else + { + res += "Microsoft Windows Server 2008 R2 family"; + } + } if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 0) { -#if (_MSC_VER >= 1300) if (osvi.wProductType == VER_NT_WORKSTATION) { res += "Microsoft Windows Vista"; @@ -4929,9 +4993,6 @@ kwsys_stl::string SystemTools::GetOperatingSystemNameAndVersion() { res += "Microsoft Windows Server 2008 family"; } -#else - res += "Microsoft Windows Vista or Windows Server 2008"; -#endif } if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2) @@ -4960,7 +5021,6 @@ kwsys_stl::string SystemTools::GetOperatingSystemNameAndVersion() { // Test for the workstation type. -#if (_MSC_VER >= 1300) if (osvi.wProductType == VER_NT_WORKSTATION) { if (osvi.dwMajorVersion == 4) @@ -5032,7 +5092,6 @@ kwsys_stl::string SystemTools::GetOperatingSystemNameAndVersion() } } } -#endif // Visual Studio 7 and up } // Test for specific product on Windows NT 4.0 SP5 and earlier @@ -5170,9 +5229,9 @@ kwsys_stl::string SystemTools::GetOperatingSystemNameAndVersion() } // ---------------------------------------------------------------------- -bool SystemTools::ParseURLProtocol( const kwsys_stl::string& URL, - kwsys_stl::string& protocol, - kwsys_stl::string& dataglom ) +bool SystemTools::ParseURLProtocol( const std::string& URL, + std::string& protocol, + std::string& dataglom ) { // match 0 entire url // match 1 protocol @@ -5188,13 +5247,13 @@ bool SystemTools::ParseURLProtocol( const kwsys_stl::string& URL, } // ---------------------------------------------------------------------- -bool SystemTools::ParseURL( const kwsys_stl::string& URL, - kwsys_stl::string& protocol, - kwsys_stl::string& username, - kwsys_stl::string& password, - kwsys_stl::string& hostname, - kwsys_stl::string& dataport, - kwsys_stl::string& database ) +bool SystemTools::ParseURL( const std::string& URL, + std::string& protocol, + std::string& username, + std::string& password, + std::string& hostname, + std::string& dataport, + std::string& database ) { kwsys::RegularExpression urlRe( VTK_URL_REGEX ); if ( ! urlRe.find( URL ) ) return false; @@ -5299,13 +5358,13 @@ void SystemTools::ClassInitialize() // The current working directory may be a logical path. Find // the shortest logical path that still produces the correct // physical path. - kwsys_stl::string cwd_changed; - kwsys_stl::string pwd_changed; + std::string cwd_changed; + std::string pwd_changed; // Test progressively shorter logical-to-physical mappings. - kwsys_stl::string pwd_str = pwd; - kwsys_stl::string cwd_str = cwd; - kwsys_stl::string pwd_path; + std::string pwd_str = pwd; + std::string cwd_str = cwd; + std::string pwd_path; Realpath(pwd, pwd_path); while(cwd_str == pwd_path && cwd_str != pwd_str) { diff --git a/Source/kwsys/SystemTools.hxx.in b/Source/kwsys/SystemTools.hxx.in index 164c5e0..bba5a5c 100644 --- a/Source/kwsys/SystemTools.hxx.in +++ b/Source/kwsys/SystemTools.hxx.in @@ -12,12 +12,13 @@ #ifndef @KWSYS_NAMESPACE@_SystemTools_hxx #define @KWSYS_NAMESPACE@_SystemTools_hxx -#include <@KWSYS_NAMESPACE@/ios/iosfwd> -#include <@KWSYS_NAMESPACE@/stl/string> -#include <@KWSYS_NAMESPACE@/stl/vector> -#include <@KWSYS_NAMESPACE@/stl/map> +#include <@KWSYS_NAMESPACE@/Configure.hxx> + +#include <iosfwd> +#include <string> +#include <vector> +#include <map> -#include <@KWSYS_NAMESPACE@/Configure.h> #include <@KWSYS_NAMESPACE@/String.hxx> #include <sys/types.h> @@ -29,7 +30,7 @@ #include <stdarg.h> // Required for FILE* #include <stdio.h> -#if @KWSYS_NAMESPACE@_STL_HAVE_STD && !defined(va_list) +#if !defined(va_list) // Some compilers move va_list into the std namespace and there is no way to // tell that this has been done. Playing with things being included before or // after stdarg.h does not solve things because we do not have control over @@ -47,12 +48,6 @@ namespace @KWSYS_NAMESPACE@ } #endif // va_list -/* Define these macros temporarily to keep the code readable. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define kwsys_stl @KWSYS_NAMESPACE@_stl -# define kwsys_ios @KWSYS_NAMESPACE@_ios -#endif - namespace @KWSYS_NAMESPACE@ { @@ -112,9 +107,9 @@ public: * then an underscore is prepended. Note that this can produce * identifiers that the standard reserves (_[A-Z].* and __.*). */ - static kwsys_stl::string MakeCidentifier(const kwsys_stl::string& s); + static std::string MakeCidentifier(const std::string& s); - static kwsys_stl::string MakeCindentifier(const kwsys_stl::string& s) + static std::string MakeCindentifier(const std::string& s) { return MakeCidentifier(s); } @@ -122,40 +117,40 @@ public: /** * Replace replace all occurences of the string in the source string. */ - static void ReplaceString(kwsys_stl::string& source, + static void ReplaceString(std::string& source, const char* replace, const char* with); - static void ReplaceString(kwsys_stl::string& source, - const kwsys_stl::string& replace, - const kwsys_stl::string& with); + static void ReplaceString(std::string& source, + const std::string& replace, + const std::string& with); /** * Return a capitalized string (i.e the first letter is uppercased, * all other are lowercased). */ - static kwsys_stl::string Capitalized(const kwsys_stl::string&); + static std::string Capitalized(const std::string&); /** * Return a 'capitalized words' string (i.e the first letter of each word * is uppercased all other are left untouched though). */ - static kwsys_stl::string CapitalizedWords(const kwsys_stl::string&); + static std::string CapitalizedWords(const std::string&); /** * Return a 'uncapitalized words' string (i.e the first letter of each word * is lowercased all other are left untouched though). */ - static kwsys_stl::string UnCapitalizedWords(const kwsys_stl::string&); + static std::string UnCapitalizedWords(const std::string&); /** * Return a lower case string */ - static kwsys_stl::string LowerCase(const kwsys_stl::string&); + static std::string LowerCase(const std::string&); /** * Return a lower case string */ - static kwsys_stl::string UpperCase(const kwsys_stl::string&); + static std::string UpperCase(const std::string&); /** * Count char in string @@ -184,9 +179,9 @@ public: * Returns true if str1 starts (respectively ends) with str2 */ static bool StringStartsWith(const char* str1, const char* str2); - static bool StringStartsWith(const kwsys_stl::string& str1, const char* str2); + static bool StringStartsWith(const std::string& str1, const char* str2); static bool StringEndsWith(const char* str1, const char* str2); - static bool StringEndsWith(const kwsys_stl::string& str1, const char* str2); + static bool StringEndsWith(const std::string& str1, const char* str2); /** * Returns a pointer to the last occurence of str2 in str1 @@ -204,14 +199,14 @@ public: * Return the string cropped to a given length by removing chars in the * center of the string and replacing them with an ellipsis (...) */ - static kwsys_stl::string CropString(const kwsys_stl::string&,size_t max_len); + static std::string CropString(const std::string&,size_t max_len); /** split a path by separator into an array of strings, default is /. If isPath is true then the string is treated like a path and if s starts with a / then the first element of the returned array will be /, so /foo/bar will be [/, foo, bar] */ - static kwsys_stl::vector<String> SplitString(const kwsys_stl::string& s, char separator = '/', + static std::vector<String> SplitString(const std::string& s, char separator = '/', bool isPath = false); /** * Perform a case-independent string comparison @@ -229,16 +224,16 @@ public: * Split a string on its newlines into multiple lines * Return false only if the last line stored had no newline */ - static bool Split(const kwsys_stl::string& s, kwsys_stl::vector<kwsys_stl::string>& l); - static bool Split(const kwsys_stl::string& s, kwsys_stl::vector<kwsys_stl::string>& l, char separator); + static bool Split(const std::string& s, std::vector<std::string>& l); + static bool Split(const std::string& s, std::vector<std::string>& l, char separator); /** * Return string with space added between capitalized words * (i.e. EatMyShorts becomes Eat My Shorts ) * (note that IEatShorts becomes IEat Shorts) */ - static kwsys_stl::string AddSpaceBetweenCapitalizedWords( - const kwsys_stl::string&); + static std::string AddSpaceBetweenCapitalizedWords( + const std::string&); /** * Append two or more strings and produce new one. @@ -265,7 +260,7 @@ public: /** * Escape specific characters in 'str'. */ - static kwsys_stl::string EscapeChars( + static std::string EscapeChars( const char *str, const char *chars_to_escape, char escape_char = '\\'); /** ----------------------------------------------------------------- @@ -276,7 +271,7 @@ public: /** * Replace Windows file system slashes with Unix-style slashes. */ - static void ConvertToUnixSlashes(kwsys_stl::string& path); + static void ConvertToUnixSlashes(std::string& path); #ifdef _WIN32 /** @@ -286,20 +281,20 @@ public: * will be prefixed with \\?\UNC\. All output will also be converted to * absolute paths with Windows-style backslashes. **/ - static kwsys_stl::wstring ConvertToWindowsExtendedPath(const kwsys_stl::string&); + static std::wstring ConvertToWindowsExtendedPath(const std::string&); #endif /** * For windows this calls ConvertToWindowsOutputPath and for unix * it calls ConvertToUnixOutputPath */ - static kwsys_stl::string ConvertToOutputPath(const kwsys_stl::string&); + static std::string ConvertToOutputPath(const std::string&); /** * Convert the path to a string that can be used in a unix makefile. * double slashes are removed, and spaces are escaped. */ - static kwsys_stl::string ConvertToUnixOutputPath(const kwsys_stl::string&); + static std::string ConvertToUnixOutputPath(const std::string&); /** * Convert the path to string that can be used in a windows project or @@ -307,7 +302,7 @@ public: * the string, the slashes are converted to windows style backslashes, and * if there are spaces in the string it is double quoted. */ - static kwsys_stl::string ConvertToWindowsOutputPath(const kwsys_stl::string&); + static std::string ConvertToWindowsOutputPath(const std::string&); /** * Return true if a file exists in the current directory. @@ -318,9 +313,9 @@ public: * for read access is only done on POSIX systems.) */ static bool FileExists(const char* filename, bool isFile); - static bool FileExists(const kwsys_stl::string& filename, bool isFile); + static bool FileExists(const std::string& filename, bool isFile); static bool FileExists(const char* filename); - static bool FileExists(const kwsys_stl::string& filename); + static bool FileExists(const std::string& filename); /** * Test if a file exists and can be accessed with the requested @@ -334,7 +329,7 @@ public: */ static bool TestFileAccess(const char* filename, TestFilePermissions permissions); - static bool TestFileAccess(const kwsys_stl::string& filename, + static bool TestFileAccess(const std::string& filename, TestFilePermissions permissions); /** @@ -349,12 +344,12 @@ public: /** * Return file length */ - static unsigned long FileLength(const kwsys_stl::string& filename); + static unsigned long FileLength(const std::string& filename); /** Change the modification time or create a file */ - static bool Touch(const kwsys_stl::string& filename, bool create); + static bool Touch(const std::string& filename, bool create); /** * Compare file modification times. @@ -362,8 +357,8 @@ public: * When true is returned, result has -1, 0, +1 for * f1 older, same, or newer than f2. */ - static bool FileTimeCompare(const kwsys_stl::string& f1, - const kwsys_stl::string& f2, + static bool FileTimeCompare(const std::string& f1, + const std::string& f2, int* result); /** @@ -378,17 +373,17 @@ public: * does not exist path is returned unchanged. This does nothing * on unix but return path. */ - static kwsys_stl::string GetActualCaseForPath(const kwsys_stl::string& path); + static std::string GetActualCaseForPath(const std::string& path); /** * Given the path to a program executable, get the directory part of * the path with the file stripped off. If there is no directory * part, the empty string is returned. */ - static kwsys_stl::string GetProgramPath(const kwsys_stl::string&); - static bool SplitProgramPath(const kwsys_stl::string& in_name, - kwsys_stl::string& dir, - kwsys_stl::string& file, + static std::string GetProgramPath(const std::string&); + static bool SplitProgramPath(const std::string& in_name, + std::string& dir, + std::string& file, bool errorReport = true); /** @@ -404,8 +399,8 @@ public: * installPrefix is a possibly null pointer to the install directory. */ static bool FindProgramPath(const char* argv0, - kwsys_stl::string& pathOut, - kwsys_stl::string& errorMsg, + std::string& pathOut, + std::string& errorMsg, const char* exeName = 0, const char* buildDir = 0, const char* installPrefix = 0); @@ -416,11 +411,11 @@ public: * (which defaults to the current working directory). The full path * is returned. */ - static kwsys_stl::string CollapseFullPath(const kwsys_stl::string& in_relative); - static kwsys_stl::string CollapseFullPath(const kwsys_stl::string& in_relative, + static std::string CollapseFullPath(const std::string& in_relative); + static std::string CollapseFullPath(const std::string& in_relative, const char* in_base); - static kwsys_stl::string CollapseFullPath(const kwsys_stl::string& in_relative, - const kwsys_stl::string& in_base); + static std::string CollapseFullPath(const std::string& in_relative, + const std::string& in_base); /** * Get the real path for a given path, removing all symlinks. In @@ -429,8 +424,8 @@ public: * NULL. Otherwise empty string is returned and errorMessage * contains error description. */ - static kwsys_stl::string GetRealPath(const kwsys_stl::string& path, - kwsys_stl::string* errorMessage = 0); + static std::string GetRealPath(const std::string& path, + std::string* errorMessage = 0); /** * Split a path name into its root component and the rest of the @@ -448,7 +443,7 @@ public: * given. */ static const char* SplitPathRootComponent(const std::string& p, - kwsys_stl::string* root=0); + std::string* root=0); /** * Split a path name into its basic components. The first component @@ -461,76 +456,76 @@ public: * platform supports them. */ static void SplitPath(const std::string& p, - kwsys_stl::vector<kwsys_stl::string>& components, + std::vector<std::string>& components, bool expand_home_dir = true); /** * Join components of a path name into a single string. See * SplitPath for the format of the components. */ - static kwsys_stl::string JoinPath( - const kwsys_stl::vector<kwsys_stl::string>& components); - static kwsys_stl::string JoinPath( - kwsys_stl::vector<kwsys_stl::string>::const_iterator first, - kwsys_stl::vector<kwsys_stl::string>::const_iterator last); + static std::string JoinPath( + const std::vector<std::string>& components); + static std::string JoinPath( + std::vector<std::string>::const_iterator first, + std::vector<std::string>::const_iterator last); /** * Compare a path or components of a path. */ - static bool ComparePath(const kwsys_stl::string& c1, const kwsys_stl::string& c2); + static bool ComparePath(const std::string& c1, const std::string& c2); /** * Return path of a full filename (no trailing slashes) */ - static kwsys_stl::string GetFilenamePath(const kwsys_stl::string&); + static std::string GetFilenamePath(const std::string&); /** * Return file name of a full filename (i.e. file name without path) */ - static kwsys_stl::string GetFilenameName(const kwsys_stl::string&); + static std::string GetFilenameName(const std::string&); /** * Split a program from its arguments and handle spaces in the paths */ static void SplitProgramFromArgs( - const kwsys_stl::string& path, - kwsys_stl::string& program, kwsys_stl::string& args); + const std::string& path, + std::string& program, std::string& args); /** * Return longest file extension of a full filename (dot included) */ - static kwsys_stl::string GetFilenameExtension(const kwsys_stl::string&); + static std::string GetFilenameExtension(const std::string&); /** * Return shortest file extension of a full filename (dot included) */ - static kwsys_stl::string GetFilenameLastExtension( - const kwsys_stl::string& filename); + static std::string GetFilenameLastExtension( + const std::string& filename); /** * Return file name without extension of a full filename */ - static kwsys_stl::string GetFilenameWithoutExtension( - const kwsys_stl::string&); + static std::string GetFilenameWithoutExtension( + const std::string&); /** * Return file name without its last (shortest) extension */ - static kwsys_stl::string GetFilenameWithoutLastExtension( - const kwsys_stl::string&); + static std::string GetFilenameWithoutLastExtension( + const std::string&); /** * Return whether the path represents a full path (not relative) */ - static bool FileIsFullPath(const kwsys_stl::string&); + static bool FileIsFullPath(const std::string&); static bool FileIsFullPath(const char*); /** * For windows return the short path for the given path, * Unix just a pass through */ - static bool GetShortPath(const kwsys_stl::string& path, kwsys_stl::string& result); + static bool GetShortPath(const std::string& path, std::string& result); /** * Read line from file. Make sure to get everything. Due to a buggy stream @@ -539,20 +534,20 @@ public: * end-of-file was reached. If the has_newline argument is specified, it will * be true when the line read had a newline character. */ - static bool GetLineFromStream(kwsys_ios::istream& istr, - kwsys_stl::string& line, + static bool GetLineFromStream(std::istream& istr, + std::string& line, bool* has_newline=0, long sizeLimit=-1); /** * Get the parent directory of the directory or file */ - static kwsys_stl::string GetParentDirectory(const kwsys_stl::string& fileOrDir); + static std::string GetParentDirectory(const std::string& fileOrDir); /** * Check if the given file or directory is in subdirectory of dir */ - static bool IsSubDirectory(const kwsys_stl::string& fileOrDir, const kwsys_stl::string& dir); + static bool IsSubDirectory(const std::string& fileOrDir, const std::string& dir); /** ----------------------------------------------------------------- * File Manipulation Routines @@ -562,7 +557,7 @@ public: /** * Open a file considering unicode. */ - static FILE* Fopen(const kwsys_stl::string& file, const char* mode); + static FILE* Fopen(const std::string& file, const char* mode); /** * Make a new directory if it is not there. This function @@ -570,36 +565,36 @@ public: * prior to calling this function. */ static bool MakeDirectory(const char* path); - static bool MakeDirectory(const kwsys_stl::string& path); + static bool MakeDirectory(const std::string& path); /** * Copy the source file to the destination file only * if the two files differ. */ - static bool CopyFileIfDifferent(const kwsys_stl::string& source, - const kwsys_stl::string& destination); + static bool CopyFileIfDifferent(const std::string& source, + const std::string& destination); /** * Compare the contents of two files. Return true if different */ - static bool FilesDiffer(const kwsys_stl::string& source, const kwsys_stl::string& destination); + static bool FilesDiffer(const std::string& source, const std::string& destination); /** * Return true if the two files are the same file */ - static bool SameFile(const kwsys_stl::string& file1, const kwsys_stl::string& file2); + static bool SameFile(const std::string& file1, const std::string& file2); /** * Copy a file. */ - static bool CopyFileAlways(const kwsys_stl::string& source, const kwsys_stl::string& destination); + static bool CopyFileAlways(const std::string& source, const std::string& destination); /** * Copy a file. If the "always" argument is true the file is always * copied. If it is false, the file is copied only if it is new or * has changed. */ - static bool CopyAFile(const kwsys_stl::string& source, const kwsys_stl::string& destination, + static bool CopyAFile(const std::string& source, const std::string& destination, bool always = true); /** @@ -608,18 +603,18 @@ public: * always copied. If it is false, only files that have changed or * are new are copied. */ - static bool CopyADirectory(const kwsys_stl::string& source, const kwsys_stl::string& destination, + static bool CopyADirectory(const std::string& source, const std::string& destination, bool always = true); /** * Remove a file */ - static bool RemoveFile(const kwsys_stl::string& source); + static bool RemoveFile(const std::string& source); /** * Remove a directory */ - static bool RemoveADirectory(const kwsys_stl::string& source); + static bool RemoveADirectory(const std::string& source); /** * Get the maximum full file path length @@ -629,56 +624,56 @@ public: /** * Find a file in the system PATH, with optional extra paths */ - static kwsys_stl::string FindFile( - const kwsys_stl::string& name, - const kwsys_stl::vector<kwsys_stl::string>& path = - kwsys_stl::vector<kwsys_stl::string>(), + static std::string FindFile( + const std::string& name, + const std::vector<std::string>& path = + std::vector<std::string>(), bool no_system_path = false); /** * Find a directory in the system PATH, with optional extra paths */ - static kwsys_stl::string FindDirectory( - const kwsys_stl::string& name, - const kwsys_stl::vector<kwsys_stl::string>& path = - kwsys_stl::vector<kwsys_stl::string>(), + static std::string FindDirectory( + const std::string& name, + const std::vector<std::string>& path = + std::vector<std::string>(), bool no_system_path = false); /** * Find an executable in the system PATH, with optional extra paths */ - static kwsys_stl::string FindProgram( + static std::string FindProgram( const char* name, - const kwsys_stl::vector<kwsys_stl::string>& path = - kwsys_stl::vector<kwsys_stl::string>(), + const std::vector<std::string>& path = + std::vector<std::string>(), bool no_system_path = false); - static kwsys_stl::string FindProgram( - const kwsys_stl::string& name, - const kwsys_stl::vector<kwsys_stl::string>& path = - kwsys_stl::vector<kwsys_stl::string>(), + static std::string FindProgram( + const std::string& name, + const std::vector<std::string>& path = + std::vector<std::string>(), bool no_system_path = false); - static kwsys_stl::string FindProgram( - const kwsys_stl::vector<kwsys_stl::string>& names, - const kwsys_stl::vector<kwsys_stl::string>& path = - kwsys_stl::vector<kwsys_stl::string>(), + static std::string FindProgram( + const std::vector<std::string>& names, + const std::vector<std::string>& path = + std::vector<std::string>(), bool no_system_path = false); /** * Find a library in the system PATH, with optional extra paths */ - static kwsys_stl::string FindLibrary( - const kwsys_stl::string& name, - const kwsys_stl::vector<kwsys_stl::string>& path); + static std::string FindLibrary( + const std::string& name, + const std::vector<std::string>& path); /** * Return true if the file is a directory */ - static bool FileIsDirectory(const kwsys_stl::string& name); + static bool FileIsDirectory(const std::string& name); /** * Return true if the file is a symlink */ - static bool FileIsSymlink(const kwsys_stl::string& name); + static bool FileIsSymlink(const std::string& name); /** * Return true if the file has a given signature (first set of bytes) @@ -708,15 +703,15 @@ public: /** * Create a symbolic link if the platform supports it. Returns whether - * creation succeded. + * creation succeeded. */ - static bool CreateSymlink(const kwsys_stl::string& origName, const kwsys_stl::string& newName); + static bool CreateSymlink(const std::string& origName, const std::string& newName); /** * Read the contents of a symbolic link. Returns whether reading - * succeded. + * succeeded. */ - static bool ReadSymlink(const kwsys_stl::string& newName, kwsys_stl::string& origName); + static bool ReadSymlink(const std::string& newName, std::string& origName); /** * Try to locate the file 'filename' in the directory 'dir'. @@ -735,7 +730,7 @@ public: */ static bool LocateFileInDir(const char *filename, const char *dir, - kwsys_stl::string& filename_found, + std::string& filename_found, int try_filename_dirs = 0); /** compute the relative path from local to remote. local must @@ -746,17 +741,17 @@ public: /a/b/c/d to /a/b/c1/d1 -> ../../c1/d1 from /usr/src to /usr/src/test/blah/foo.cpp -> test/blah/foo.cpp */ - static kwsys_stl::string RelativePath(const kwsys_stl::string& local, const kwsys_stl::string& remote); + static std::string RelativePath(const std::string& local, const std::string& remote); /** * Return file's modified time */ - static long int ModifiedTime(const kwsys_stl::string& filename); + static long int ModifiedTime(const std::string& filename); /** * Return file's creation time (Win32: works only for NTFS, not FAT) */ - static long int CreationTime(const kwsys_stl::string& filename); + static long int CreationTime(const std::string& filename); /** * Visual C++ does not define mode_t (note that Borland does, however). @@ -774,11 +769,9 @@ public: * if a honor_umask parameter is set to true. */ static bool GetPermissions(const char* file, mode_t& mode); - static bool GetPermissions(const kwsys_stl::string& file, mode_t& mode); - static bool SetPermissions( - const char* file, mode_t mode, bool honor_umask = false); - static bool SetPermissions( - const kwsys_stl::string& file, mode_t mode, bool honor_umask = false); + static bool GetPermissions(const std::string& file, mode_t& mode); + static bool SetPermissions(const char* file, mode_t mode, bool honor_umask = false); + static bool SetPermissions(const std::string& file, mode_t mode, bool honor_umask = false); /** ----------------------------------------------------------------- * Time Manipulation Routines @@ -791,7 +784,7 @@ public: /** * Get current date/time */ - static kwsys_stl::string GetCurrentDateTime(const char* format); + static std::string GetCurrentDateTime(const char* format); /** ----------------------------------------------------------------- * Registry Manipulation Routines @@ -808,26 +801,26 @@ public: /** * Get a list of subkeys. */ - static bool GetRegistrySubKeys(const kwsys_stl::string& key, - kwsys_stl::vector<kwsys_stl::string>& subkeys, + static bool GetRegistrySubKeys(const std::string& key, + std::vector<std::string>& subkeys, KeyWOW64 view = KeyWOW64_Default); /** * Read a registry value */ - static bool ReadRegistryValue(const kwsys_stl::string& key, kwsys_stl::string &value, + static bool ReadRegistryValue(const std::string& key, std::string &value, KeyWOW64 view = KeyWOW64_Default); /** * Write a registry value */ - static bool WriteRegistryValue(const kwsys_stl::string& key, const kwsys_stl::string& value, + static bool WriteRegistryValue(const std::string& key, const std::string& value, KeyWOW64 view = KeyWOW64_Default); /** * Delete a registry value */ - static bool DeleteRegistryValue(const kwsys_stl::string& key, + static bool DeleteRegistryValue(const std::string& key, KeyWOW64 view = KeyWOW64_Default); /** ----------------------------------------------------------------- @@ -840,39 +833,39 @@ public: * string vector passed in. If env is set then the value * of env will be used instead of PATH. */ - static void GetPath(kwsys_stl::vector<kwsys_stl::string>& path, + static void GetPath(std::vector<std::string>& path, const char* env=0); /** * Read an environment variable */ static const char* GetEnv(const char* key); - static const char* GetEnv(const kwsys_stl::string& key); - static bool GetEnv(const char* key, kwsys_stl::string& result); - static bool GetEnv(const kwsys_stl::string& key, kwsys_stl::string& result); + static const char* GetEnv(const std::string& key); + static bool GetEnv(const char* key, std::string& result); + static bool GetEnv(const std::string& key, std::string& result); /** Put a string into the environment of the form var=value */ - static bool PutEnv(const kwsys_stl::string& env); + static bool PutEnv(const std::string& env); /** Remove a string from the environment. Input is of the form "var" or "var=value" (value is ignored). */ - static bool UnPutEnv(const kwsys_stl::string& env); + static bool UnPutEnv(const std::string& env); /** * Get current working directory CWD */ - static kwsys_stl::string GetCurrentWorkingDirectory(bool collapse =true); + static std::string GetCurrentWorkingDirectory(bool collapse =true); /** * Change directory to the directory specified */ - static int ChangeDirectory(const kwsys_stl::string& dir); + static int ChangeDirectory(const std::string& dir); /** * Get the result of strerror(errno) */ - static kwsys_stl::string GetLastSystemError(); + static std::string GetLastSystemError(); /** * When building DEBUG with MSVC, this enables a hook that prevents @@ -891,18 +884,18 @@ public: /** * Add an entry in the path translation table. */ - static void AddTranslationPath(const kwsys_stl::string& dir, const kwsys_stl::string& refdir); + static void AddTranslationPath(const std::string& dir, const std::string& refdir); /** * If dir is different after CollapseFullPath is called, * Then insert it into the path translation table */ - static void AddKeepPath(const kwsys_stl::string& dir); + static void AddKeepPath(const std::string& dir); /** * Update path by going through the Path Translation table; */ - static void CheckTranslationPath(kwsys_stl::string & path); + static void CheckTranslationPath(std::string & path); /** * Delay the execution for a specified amount of time specified @@ -914,7 +907,7 @@ public: * Get the operating system name and version * This is implemented for Win32 only for the moment */ - static kwsys_stl::string GetOperatingSystemNameAndVersion(); + static std::string GetOperatingSystemNameAndVersion(); /** ----------------------------------------------------------------- * URL Manipulation Routines @@ -927,9 +920,9 @@ public: * and fill protocol as appropriate. * Return false if the URL does not have the required form, true otherwise. */ - static bool ParseURLProtocol( const kwsys_stl::string& URL, - kwsys_stl::string& protocol, - kwsys_stl::string& dataglom ); + static bool ParseURLProtocol( const std::string& URL, + std::string& protocol, + std::string& dataglom ); /** * Parse a string (a URL without protocol prefix) with the form: @@ -938,13 +931,13 @@ public: * when values are found. * Return true if the string matches the format; false otherwise. */ - static bool ParseURL( const kwsys_stl::string& URL, - kwsys_stl::string& protocol, - kwsys_stl::string& username, - kwsys_stl::string& password, - kwsys_stl::string& hostname, - kwsys_stl::string& dataport, - kwsys_stl::string& datapath ); + static bool ParseURL( const std::string& URL, + std::string& protocol, + std::string& username, + std::string& password, + std::string& hostname, + std::string& dataport, + std::string& datapath ); private: /** @@ -968,10 +961,10 @@ private: /** * Actual implementation of ReplaceString. */ - static void ReplaceString(kwsys_stl::string& source, + static void ReplaceString(std::string& source, const char* replace, size_t replaceSize, - const kwsys_stl::string& with); + const std::string& with); /** * Actual implementation of FileIsFullPath. @@ -982,10 +975,10 @@ private: * Find a filename (file or directory) in the system PATH, with * optional extra paths. */ - static kwsys_stl::string FindName( - const kwsys_stl::string& name, - const kwsys_stl::vector<kwsys_stl::string>& path = - kwsys_stl::vector<kwsys_stl::string>(), + static std::string FindName( + const std::string& name, + const std::vector<std::string>& path = + std::vector<std::string>(), bool no_system_path = false); @@ -1005,10 +998,4 @@ private: } // namespace @KWSYS_NAMESPACE@ -/* Undefine temporary macros. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# undef kwsys_stl -# undef kwsys_ios -#endif - #endif diff --git a/Source/kwsys/Terminal.c b/Source/kwsys/Terminal.c index d13f79a..a8abb6c 100644 --- a/Source/kwsys/Terminal.c +++ b/Source/kwsys/Terminal.c @@ -184,14 +184,25 @@ static const char* kwsysTerminalVT100Names[] = static int kwsysTerminalStreamIsVT100(FILE* stream, int default_vt100, int default_tty) { + /* Force color according to http://bixense.com/clicolors/ convention. */ + { + const char* clicolor_force = getenv("CLICOLOR_FORCE"); + if (clicolor_force && *clicolor_force && strcmp(clicolor_force, "0") != 0) + { + return 1; + } + } + /* If running inside emacs the terminal is not VT100. Some emacs seem to claim the TERM is xterm even though they do not support VT100 escapes. */ + { const char* emacs = getenv("EMACS"); if(emacs && *emacs == 't') { return 0; } + } /* Check for a valid terminal. */ if(!default_vt100) diff --git a/Source/kwsys/hash_fun.hxx.in b/Source/kwsys/hash_fun.hxx.in index 6f787dd..4872b51 100644 --- a/Source/kwsys/hash_fun.hxx.in +++ b/Source/kwsys/hash_fun.hxx.in @@ -38,8 +38,8 @@ #define @KWSYS_NAMESPACE@_hash_fun_hxx #include <@KWSYS_NAMESPACE@/Configure.hxx> -#include <@KWSYS_NAMESPACE@/cstddef> // size_t -#include <@KWSYS_NAMESPACE@/stl/string> // string +#include <stddef.h> // size_t +#include <string> namespace @KWSYS_NAMESPACE@ { @@ -55,90 +55,90 @@ inline size_t _stl_hash_string(const char* __s) return size_t(__h); } -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<char*> { size_t operator()(const char* __s) const { return _stl_hash_string(__s); } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<const char*> { size_t operator()(const char* __s) const { return _stl_hash_string(__s); } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION - struct hash<@KWSYS_NAMESPACE@_stl::string> { - size_t operator()(const @KWSYS_NAMESPACE@_stl::string & __s) const { return _stl_hash_string(__s.c_str()); } +template <> + struct hash<std::string> { + size_t operator()(const std::string & __s) const { return _stl_hash_string(__s.c_str()); } }; #if !defined(__BORLANDC__) -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION - struct hash<const @KWSYS_NAMESPACE@_stl::string> { - size_t operator()(const @KWSYS_NAMESPACE@_stl::string & __s) const { return _stl_hash_string(__s.c_str()); } +template <> + struct hash<const std::string> { + size_t operator()(const std::string & __s) const { return _stl_hash_string(__s.c_str()); } }; #endif -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<char> { size_t operator()(char __x) const { return __x; } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<unsigned char> { size_t operator()(unsigned char __x) const { return __x; } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<signed char> { size_t operator()(unsigned char __x) const { return __x; } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<short> { size_t operator()(short __x) const { return __x; } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<unsigned short> { size_t operator()(unsigned short __x) const { return __x; } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<int> { size_t operator()(int __x) const { return __x; } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<unsigned int> { size_t operator()(unsigned int __x) const { return __x; } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<long> { size_t operator()(long __x) const { return __x; } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<unsigned long> { size_t operator()(unsigned long __x) const { return __x; } }; // use long long or __int64 #if @KWSYS_USE_LONG_LONG@ -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<long long> { size_t operator()(long long __x) const { return __x; } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<unsigned long long> { size_t operator()(unsigned long long __x) const { return __x; } }; #elif @KWSYS_USE___INT64@ -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<__int64> { size_t operator()(__int64 __x) const { return __x; } }; -@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION +template <> struct hash<unsigned __int64> { size_t operator()(unsigned __int64 __x) const { return __x; } }; diff --git a/Source/kwsys/hash_map.hxx.in b/Source/kwsys/hash_map.hxx.in index 6d4379d..60c7086 100644 --- a/Source/kwsys/hash_map.hxx.in +++ b/Source/kwsys/hash_map.hxx.in @@ -39,7 +39,7 @@ #include <@KWSYS_NAMESPACE@/hashtable.hxx> #include <@KWSYS_NAMESPACE@/hash_fun.hxx> -#include <@KWSYS_NAMESPACE@/stl/functional> // equal_to +#include <functional> // equal_to #if defined(_MSC_VER) # pragma warning (push) @@ -58,9 +58,9 @@ namespace @KWSYS_NAMESPACE@ // select1st is an extension: it is not part of the standard. template <class T1, class T2> struct hash_select1st: - public @KWSYS_NAMESPACE@_stl::unary_function<@KWSYS_NAMESPACE@_stl::pair<T1, T2>, T1> + public std::unary_function<std::pair<T1, T2>, T1> { - const T1& operator()(const @KWSYS_NAMESPACE@_stl::pair<T1, T2>& __x) const + const T1& operator()(const std::pair<T1, T2>& __x) const { return __x.first; } }; @@ -68,8 +68,8 @@ struct hash_select1st: template <class _Key, class _Tp, class _HashFcn = hash<_Key>, - class _EqualKey = @KWSYS_NAMESPACE@_stl::equal_to<_Key>, - class _Alloc = @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(char) > + class _EqualKey = std::equal_to<_Key>, + class _Alloc = std::allocator<char> > class hash_map; template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc> @@ -81,7 +81,7 @@ template <class _Key, class _Tp, class _HashFcn, class _EqualKey, class hash_map { private: - typedef hashtable<@KWSYS_NAMESPACE@_stl::pair<const _Key,_Tp>,_Key,_HashFcn, + typedef hashtable<std::pair<const _Key,_Tp>,_Key,_HashFcn, hash_select1st<const _Key,_Tp>,_EqualKey,_Alloc> _Ht; _Ht _M_ht; @@ -119,7 +119,6 @@ public: const allocator_type& __a = allocator_type()) : _M_ht(__n, __hf, __eql, __a) {} -#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES template <class _InputIterator> hash_map(_InputIterator __f, _InputIterator __l) : _M_ht(100, hasher(), key_equal(), allocator_type()) @@ -140,48 +139,14 @@ public: : _M_ht(__n, __hf, __eql, __a) { _M_ht.insert_unique(__f, __l); } -#else - hash_map(const value_type* __f, const value_type* __l) - : _M_ht(100, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_map(const value_type* __f, const value_type* __l, size_type __n) - : _M_ht(__n, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_map(const value_type* __f, const value_type* __l, size_type __n, - const hasher& __hf) - : _M_ht(__n, __hf, key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_map(const value_type* __f, const value_type* __l, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _M_ht(__n, __hf, __eql, __a) - { _M_ht.insert_unique(__f, __l); } - - hash_map(const_iterator __f, const_iterator __l) - : _M_ht(100, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_map(const_iterator __f, const_iterator __l, size_type __n) - : _M_ht(__n, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_map(const_iterator __f, const_iterator __l, size_type __n, - const hasher& __hf) - : _M_ht(__n, __hf, key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_map(const_iterator __f, const_iterator __l, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _M_ht(__n, __hf, __eql, __a) - { _M_ht.insert_unique(__f, __l); } -#endif - public: size_type size() const { return _M_ht.size(); } size_type max_size() const { return _M_ht.max_size(); } bool empty() const { return _M_ht.empty(); } void swap(hash_map& __hs) { _M_ht.swap(__hs._M_ht); } - friend bool operator==@KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS(const hash_map&, - const hash_map&); + friend bool operator==<>(const hash_map&, + const hash_map&); iterator begin() { return _M_ht.begin(); } iterator end() { return _M_ht.end(); } @@ -189,20 +154,12 @@ public: const_iterator end() const { return _M_ht.end(); } public: - @KWSYS_NAMESPACE@_stl::pair<iterator,bool> insert(const value_type& __obj) + std::pair<iterator,bool> insert(const value_type& __obj) { return _M_ht.insert_unique(__obj); } -#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES template <class _InputIterator> void insert(_InputIterator __f, _InputIterator __l) { _M_ht.insert_unique(__f,__l); } -#else - void insert(const value_type* __f, const value_type* __l) { - _M_ht.insert_unique(__f,__l); - } - void insert(const_iterator __f, const_iterator __l) - { _M_ht.insert_unique(__f, __l); } -#endif - @KWSYS_NAMESPACE@_stl::pair<iterator,bool> insert_noresize(const value_type& __obj) + std::pair<iterator,bool> insert_noresize(const value_type& __obj) { return _M_ht.insert_unique_noresize(__obj); } iterator find(const key_type& __key) { return _M_ht.find(__key); } @@ -215,9 +172,9 @@ public: size_type count(const key_type& __key) const { return _M_ht.count(__key); } - @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> equal_range(const key_type& __key) + std::pair<iterator, iterator> equal_range(const key_type& __key) { return _M_ht.equal_range(__key); } - @KWSYS_NAMESPACE@_stl::pair<const_iterator, const_iterator> + std::pair<const_iterator, const_iterator> equal_range(const key_type& __key) const { return _M_ht.equal_range(__key); } @@ -260,8 +217,8 @@ swap(hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1, template <class _Key, class _Tp, class _HashFcn = hash<_Key>, - class _EqualKey = @KWSYS_NAMESPACE@_stl::equal_to<_Key>, - class _Alloc = @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(char) > + class _EqualKey = std::equal_to<_Key>, + class _Alloc = std::allocator<char> > class hash_multimap; template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc> @@ -274,7 +231,7 @@ template <class _Key, class _Tp, class _HashFcn, class _EqualKey, class hash_multimap { private: - typedef hashtable<@KWSYS_NAMESPACE@_stl::pair<const _Key, _Tp>, _Key, _HashFcn, + typedef hashtable<std::pair<const _Key, _Tp>, _Key, _HashFcn, hash_select1st<const _Key, _Tp>, _EqualKey, _Alloc> _Ht; _Ht _M_ht; @@ -313,7 +270,6 @@ public: const allocator_type& __a = allocator_type()) : _M_ht(__n, __hf, __eql, __a) {} -#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES template <class _InputIterator> hash_multimap(_InputIterator __f, _InputIterator __l) : _M_ht(100, hasher(), key_equal(), allocator_type()) @@ -334,48 +290,14 @@ public: : _M_ht(__n, __hf, __eql, __a) { _M_ht.insert_equal(__f, __l); } -#else - hash_multimap(const value_type* __f, const value_type* __l) - : _M_ht(100, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multimap(const value_type* __f, const value_type* __l, size_type __n) - : _M_ht(__n, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multimap(const value_type* __f, const value_type* __l, size_type __n, - const hasher& __hf) - : _M_ht(__n, __hf, key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multimap(const value_type* __f, const value_type* __l, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _M_ht(__n, __hf, __eql, __a) - { _M_ht.insert_equal(__f, __l); } - - hash_multimap(const_iterator __f, const_iterator __l) - : _M_ht(100, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multimap(const_iterator __f, const_iterator __l, size_type __n) - : _M_ht(__n, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multimap(const_iterator __f, const_iterator __l, size_type __n, - const hasher& __hf) - : _M_ht(__n, __hf, key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multimap(const_iterator __f, const_iterator __l, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _M_ht(__n, __hf, __eql, __a) - { _M_ht.insert_equal(__f, __l); } -#endif - public: size_type size() const { return _M_ht.size(); } size_type max_size() const { return _M_ht.max_size(); } bool empty() const { return _M_ht.empty(); } void swap(hash_multimap& __hs) { _M_ht.swap(__hs._M_ht); } - friend bool operator==@KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS(const hash_multimap&, - const hash_multimap&); + friend bool operator==<>(const hash_multimap&, + const hash_multimap&); iterator begin() { return _M_ht.begin(); } iterator end() { return _M_ht.end(); } @@ -385,17 +307,9 @@ public: public: iterator insert(const value_type& __obj) { return _M_ht.insert_equal(__obj); } -#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES template <class _InputIterator> void insert(_InputIterator __f, _InputIterator __l) { _M_ht.insert_equal(__f,__l); } -#else - void insert(const value_type* __f, const value_type* __l) { - _M_ht.insert_equal(__f,__l); - } - void insert(const_iterator __f, const_iterator __l) - { _M_ht.insert_equal(__f, __l); } -#endif iterator insert_noresize(const value_type& __obj) { return _M_ht.insert_equal_noresize(__obj); } @@ -405,9 +319,9 @@ public: size_type count(const key_type& __key) const { return _M_ht.count(__key); } - @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> equal_range(const key_type& __key) + std::pair<iterator, iterator> equal_range(const key_type& __key) { return _M_ht.equal_range(__key); } - @KWSYS_NAMESPACE@_stl::pair<const_iterator, const_iterator> + std::pair<const_iterator, const_iterator> equal_range(const key_type& __key) const { return _M_ht.equal_range(__key); } diff --git a/Source/kwsys/hash_set.hxx.in b/Source/kwsys/hash_set.hxx.in index 5ee01a5..c314979 100644 --- a/Source/kwsys/hash_set.hxx.in +++ b/Source/kwsys/hash_set.hxx.in @@ -39,7 +39,7 @@ #include <@KWSYS_NAMESPACE@/hashtable.hxx> #include <@KWSYS_NAMESPACE@/hash_fun.hxx> -#include <@KWSYS_NAMESPACE@/stl/functional> // equal_to +#include <functional> // equal_to #if defined(_MSC_VER) # pragma warning (push) @@ -57,7 +57,7 @@ namespace @KWSYS_NAMESPACE@ // identity is an extension: it is not part of the standard. template <class _Tp> -struct _Identity : public @KWSYS_NAMESPACE@_stl::unary_function<_Tp,_Tp> +struct _Identity : public std::unary_function<_Tp,_Tp> { const _Tp& operator()(const _Tp& __x) const { return __x; } }; @@ -66,8 +66,8 @@ struct _Identity : public @KWSYS_NAMESPACE@_stl::unary_function<_Tp,_Tp> template <class _Value, class _HashFcn = hash<_Value>, - class _EqualKey = @KWSYS_NAMESPACE@_stl::equal_to<_Value>, - class _Alloc = @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(char) > + class _EqualKey = std::equal_to<_Value>, + class _Alloc = std::allocator<char> > class hash_set; template <class _Value, class _HashFcn, class _EqualKey, class _Alloc> @@ -116,7 +116,6 @@ public: const allocator_type& __a = allocator_type()) : _M_ht(__n, __hf, __eql, __a) {} -#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES template <class _InputIterator> hash_set(_InputIterator __f, _InputIterator __l) : _M_ht(100, hasher(), key_equal(), allocator_type()) @@ -136,40 +135,6 @@ public: const allocator_type& __a = allocator_type()) : _M_ht(__n, __hf, __eql, __a) { _M_ht.insert_unique(__f, __l); } -#else - - hash_set(const value_type* __f, const value_type* __l) - : _M_ht(100, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_set(const value_type* __f, const value_type* __l, size_type __n) - : _M_ht(__n, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_set(const value_type* __f, const value_type* __l, size_type __n, - const hasher& __hf) - : _M_ht(__n, __hf, key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_set(const value_type* __f, const value_type* __l, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _M_ht(__n, __hf, __eql, __a) - { _M_ht.insert_unique(__f, __l); } - - hash_set(const_iterator __f, const_iterator __l) - : _M_ht(100, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_set(const_iterator __f, const_iterator __l, size_type __n) - : _M_ht(__n, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_set(const_iterator __f, const_iterator __l, size_type __n, - const hasher& __hf) - : _M_ht(__n, __hf, key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } - hash_set(const_iterator __f, const_iterator __l, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _M_ht(__n, __hf, __eql, __a) - { _M_ht.insert_unique(__f, __l); } -#endif public: size_type size() const { return _M_ht.size(); } @@ -177,43 +142,35 @@ public: bool empty() const { return _M_ht.empty(); } void swap(hash_set& __hs) { _M_ht.swap(__hs._M_ht); } - friend bool operator==@KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS(const hash_set&, - const hash_set&); + friend bool operator==<>(const hash_set&, + const hash_set&); iterator begin() const { return _M_ht.begin(); } iterator end() const { return _M_ht.end(); } public: - @KWSYS_NAMESPACE@_stl::pair<iterator, bool> insert(const value_type& __obj) + std::pair<iterator, bool> insert(const value_type& __obj) { typedef typename _Ht::iterator _Ht_iterator; - @KWSYS_NAMESPACE@_stl::pair<_Ht_iterator, bool> __p = _M_ht.insert_unique(__obj); - return @KWSYS_NAMESPACE@_stl::pair<iterator,bool>(__p.first, __p.second); + std::pair<_Ht_iterator, bool> __p = _M_ht.insert_unique(__obj); + return std::pair<iterator,bool>(__p.first, __p.second); } -#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES template <class _InputIterator> void insert(_InputIterator __f, _InputIterator __l) { _M_ht.insert_unique(__f,__l); } -#else - void insert(const value_type* __f, const value_type* __l) { - _M_ht.insert_unique(__f,__l); - } - void insert(const_iterator __f, const_iterator __l) - {_M_ht.insert_unique(__f, __l); } -#endif - @KWSYS_NAMESPACE@_stl::pair<iterator, bool> insert_noresize(const value_type& __obj) + std::pair<iterator, bool> insert_noresize(const value_type& __obj) { typedef typename _Ht::iterator _Ht_iterator; - @KWSYS_NAMESPACE@_stl::pair<_Ht_iterator, bool> __p = + std::pair<_Ht_iterator, bool> __p = _M_ht.insert_unique_noresize(__obj); - return @KWSYS_NAMESPACE@_stl::pair<iterator, bool>(__p.first, __p.second); + return std::pair<iterator, bool>(__p.first, __p.second); } iterator find(const key_type& __key) const { return _M_ht.find(__key); } size_type count(const key_type& __key) const { return _M_ht.count(__key); } - @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> equal_range(const key_type& __key) const + std::pair<iterator, iterator> equal_range(const key_type& __key) const { return _M_ht.equal_range(__key); } size_type erase(const key_type& __key) {return _M_ht.erase(__key); } @@ -254,8 +211,8 @@ swap(hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1, template <class _Value, class _HashFcn = hash<_Value>, - class _EqualKey = @KWSYS_NAMESPACE@_stl::equal_to<_Value>, - class _Alloc = @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(char) > + class _EqualKey = std::equal_to<_Value>, + class _Alloc = std::allocator<char> > class hash_multiset; template <class _Val, class _HashFcn, class _EqualKey, class _Alloc> @@ -305,7 +262,6 @@ public: const allocator_type& __a = allocator_type()) : _M_ht(__n, __hf, __eql, __a) {} -#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES template <class _InputIterator> hash_multiset(_InputIterator __f, _InputIterator __l) : _M_ht(100, hasher(), key_equal(), allocator_type()) @@ -325,40 +281,6 @@ public: const allocator_type& __a = allocator_type()) : _M_ht(__n, __hf, __eql, __a) { _M_ht.insert_equal(__f, __l); } -#else - - hash_multiset(const value_type* __f, const value_type* __l) - : _M_ht(100, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multiset(const value_type* __f, const value_type* __l, size_type __n) - : _M_ht(__n, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multiset(const value_type* __f, const value_type* __l, size_type __n, - const hasher& __hf) - : _M_ht(__n, __hf, key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multiset(const value_type* __f, const value_type* __l, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _M_ht(__n, __hf, __eql, __a) - { _M_ht.insert_equal(__f, __l); } - - hash_multiset(const_iterator __f, const_iterator __l) - : _M_ht(100, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multiset(const_iterator __f, const_iterator __l, size_type __n) - : _M_ht(__n, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multiset(const_iterator __f, const_iterator __l, size_type __n, - const hasher& __hf) - : _M_ht(__n, __hf, key_equal(), allocator_type()) - { _M_ht.insert_equal(__f, __l); } - hash_multiset(const_iterator __f, const_iterator __l, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _M_ht(__n, __hf, __eql, __a) - { _M_ht.insert_equal(__f, __l); } -#endif public: size_type size() const { return _M_ht.size(); } @@ -366,8 +288,8 @@ public: bool empty() const { return _M_ht.empty(); } void swap(hash_multiset& hs) { _M_ht.swap(hs._M_ht); } - friend bool operator==@KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS(const hash_multiset&, - const hash_multiset&); + friend bool operator==<>(const hash_multiset&, + const hash_multiset&); iterator begin() const { return _M_ht.begin(); } iterator end() const { return _M_ht.end(); } @@ -375,17 +297,9 @@ public: public: iterator insert(const value_type& __obj) { return _M_ht.insert_equal(__obj); } -#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES template <class _InputIterator> void insert(_InputIterator __f, _InputIterator __l) { _M_ht.insert_equal(__f,__l); } -#else - void insert(const value_type* __f, const value_type* __l) { - _M_ht.insert_equal(__f,__l); - } - void insert(const_iterator __f, const_iterator __l) - { _M_ht.insert_equal(__f, __l); } -#endif iterator insert_noresize(const value_type& __obj) { return _M_ht.insert_equal_noresize(__obj); } @@ -393,7 +307,7 @@ public: size_type count(const key_type& __key) const { return _M_ht.count(__key); } - @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> equal_range(const key_type& __key) const + std::pair<iterator, iterator> equal_range(const key_type& __key) const { return _M_ht.equal_range(__key); } size_type erase(const key_type& __key) {return _M_ht.erase(__key); } diff --git a/Source/kwsys/hashtable.hxx.in b/Source/kwsys/hashtable.hxx.in index 7e7dc42..9a20226 100644 --- a/Source/kwsys/hashtable.hxx.in +++ b/Source/kwsys/hashtable.hxx.in @@ -44,13 +44,13 @@ #include <@KWSYS_NAMESPACE@/Configure.hxx> -#include <@KWSYS_NAMESPACE@/cstddef> // size_t -#include <@KWSYS_NAMESPACE@/stl/algorithm> // lower_bound -#include <@KWSYS_NAMESPACE@/stl/functional> // unary_function -#include <@KWSYS_NAMESPACE@/stl/iterator> // iterator_traits -#include <@KWSYS_NAMESPACE@/stl/memory> // allocator -#include <@KWSYS_NAMESPACE@/stl/utility> // pair -#include <@KWSYS_NAMESPACE@/stl/vector> // vector +#include <stddef.h> // size_t +#include <algorithm> // lower_bound +#include <functional> // unary_function +#include <iterator> // iterator_traits +#include <memory> // allocator +#include <utility> // pair +#include <vector> // vector #if defined(_MSC_VER) # pragma warning (push) @@ -73,238 +73,9 @@ # endif #endif -#if @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_TEMPLATE -# define @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(T) @KWSYS_NAMESPACE@_stl::allocator< T > -#elif @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_NONTEMPLATE -# define @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(T) @KWSYS_NAMESPACE@_stl::allocator -#else -# define @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(T) @KWSYS_NAMESPACE@_stl::alloc -#endif - -#if @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_OBJECTS -# define @KWSYS_NAMESPACE@_HASH_BUCKETS_INIT(__a) _M_buckets(__a) -# define @KWSYS_NAMESPACE@_HASH_BUCKETS_GET_ALLOCATOR(__b) , __b.get_allocator() -#else -# define @KWSYS_NAMESPACE@_HASH_BUCKETS_INIT(__a) _M_buckets() -# define @KWSYS_NAMESPACE@_HASH_BUCKETS_GET_ALLOCATOR(__b) -#endif - namespace @KWSYS_NAMESPACE@ { -//---------------------------------------------------------------------------- -// Define an allocator adaptor for platforms that do not provide an -// allocator with the rebind member. -#if !@KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_REBIND - -// Utility functions to convert item counts. -inline size_t hash_sizeof(void*) { return sizeof(char); } -inline size_t hash_sizeof(const void*) { return sizeof(char); } -template <class TPtr> inline size_t hash_sizeof(TPtr p) -{ - static_cast<void>(p); - return sizeof(*p); -} -template <class POut, class PIn, class TSize> -inline TSize hash_allocator_n(POut out, PIn in, TSize n) -{ - return n*(hash_sizeof(out)/hash_sizeof(in) + - (hash_sizeof(out)%hash_sizeof(in)>0)); -} - -// Define an allocation method to use the native allocator with -// the proper signature. The following signatures of the allocate -// method are used on various STL implementations: -// pointer allocate(size_type, const void* hint) -// pointer allocate(size_type) -// static pointer allocate(size_type, const void* hint) -// static pointer allocate(size_type) -// Where pointer might be a real type or void*. -// This set of overloads decodes the signature for a particular STL. -// The extra three int/long arguments will favor certain signatures -// over others in the case that multiple are present to avoid -// ambiguity errors. -template <class TAlloc, class PIn, class TSize, class THint, class POut> -inline void hash_allocate(TAlloc* a, PIn (TAlloc::*allocate)(TSize, THint), - TSize n_out, const void* hint, POut& out, - int, int, int) -{ - TSize n_in = hash_allocator_n(POut(), PIn(), n_out); - void* vout = (a->*allocate)(n_in, const_cast<THint>(hint)); - out = static_cast<POut>(vout); -} - -template <class TAlloc, class PIn, class TSize, class POut> -inline void hash_allocate(TAlloc* a, PIn (TAlloc::*allocate)(TSize), - TSize n_out, const void*, POut& out, - int, int, long) -{ - TSize n_in = hash_allocator_n(POut(), PIn(), n_out); - void* vout = (a->*allocate)(n_in); - out = static_cast<POut>(vout); -} - -template <class PIn, class TSize, class THint, class POut> -inline void hash_allocate(void*, PIn (*allocate)(TSize, THint), - TSize n_out, const void* hint, POut& out, - int, long, long) -{ - TSize n_in = hash_allocator_n(POut(), PIn(), n_out); - void* vout = allocate(n_in, const_cast<THint>(hint)); - out = static_cast<POut>(vout); -} - -template <class PIn, class TSize, class POut> -inline void hash_allocate(void*, PIn (*allocate)(TSize), - TSize n_out, const void*, POut& out, - long, long, long) -{ - TSize n_in = hash_allocator_n(POut(), PIn(), n_out); - void* vout = allocate(n_in); - out = static_cast<POut>(vout); -} - -// Define a deallocation method to use the native allocator with -// the proper signature. The following signatures of the deallocate -// method are used on various STL implementations: -// void deallocate(pointer, size_type) -// void deallocate(pointer) -// static void deallocate(pointer, size_type) -// static void deallocate(pointer) -// Where pointer might be a real type or void*. -// This set of overloads decodes the signature for a particular STL. -// The extra three int/long arguments will favor certain signatures -// over others in the case that multiple are present to avoid -// ambiguity errors. -template <class TAlloc, class PIn, class TSize, class PInReal, class POut> -inline void hash_deallocate(TAlloc* a, void (TAlloc::*deallocate)(PIn, TSize), - PInReal, POut p, TSize n_out, int, int, int) -{ - TSize n_in = hash_allocator_n(POut(), PInReal(), n_out); - void* vout = p; - (a->*deallocate)(static_cast<PIn>(vout), n_in); -} - -template <class TAlloc, class PIn, class TSize, class PInReal, class POut> -inline void hash_deallocate(TAlloc* a, void (TAlloc::*deallocate)(PIn), - PInReal, POut p, TSize, int, int, long) -{ - void* vout = p; - (a->*deallocate)(static_cast<PIn>(vout)); -} - -template <class PIn, class TSize, class PInReal, class POut> -inline void hash_deallocate(void*, void (*deallocate)(PIn, TSize), - PInReal, POut p, TSize n_out, int, long, long) -{ - TSize n_in = hash_allocator_n(POut(), PInReal(), n_out); - void* vout = p; - deallocate(static_cast<PIn>(vout), n_in); -} - -template <class PIn, class TSize, class PInReal, class POut> -inline void hash_deallocate(void*, void (*deallocate)(PIn), - PInReal, POut p, TSize, long, long, long) -{ - void* vout = p; - deallocate(static_cast<PIn>(vout)); -} - -// Use the same four overloads as hash_allocate to decode the type -// really used for allocation. This is passed as PInReal to the -// deallocate functions so that hash_allocator_n has the proper size. -template <class TAlloc, class PIn, class TSize, class THint> -inline PIn hash_allocate_type(PIn (TAlloc::*)(TSize, THint), - int, int, int) { return 0; } -template <class TAlloc, class PIn, class TSize> -inline PIn hash_allocate_type(PIn (TAlloc::*)(TSize), - int, int, long) { return 0; } -template <class PIn, class TSize, class THint> -inline PIn hash_allocate_type(PIn (*)(TSize, THint), - int, long, long) { return 0; } -template <class PIn, class TSize> -inline PIn hash_allocate_type(PIn (*)(TSize), - long, long, long) { return 0; } - -// Define the comparison operators in terms of a base type to avoid -// needing templated versions. -class hash_allocator_base {}; -inline bool operator==(const hash_allocator_base&, - const hash_allocator_base&) throw() { return true; } -inline bool operator!=(const hash_allocator_base&, - const hash_allocator_base&) throw() { return false; } - -// Define the allocator template. -template <class T, class Alloc> -class hash_allocator: public hash_allocator_base -{ -private: - // Store the real allocator privately. - typedef Alloc alloc_type; - alloc_type alloc_; - -public: - // Standard allocator interface. - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef T* pointer; - typedef const T* const_pointer; - typedef T& reference; - typedef const T& const_reference; - typedef T value_type; - - hash_allocator() throw(): alloc_() {} - hash_allocator(const hash_allocator_base&) throw() : alloc_() {} - hash_allocator(const hash_allocator& a) throw() : alloc_(a.alloc_) {} - hash_allocator(const alloc_type& a) throw() : alloc_(a) {} - ~hash_allocator() throw() {} -# if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES - template <class U> - struct rebind { typedef hash_allocator<U, alloc_type> other; }; -# endif - pointer address(reference x) const { return &x; } - const_pointer address(const_reference x) const { return &x; } - typedef void* void_pointer; - typedef const void* const_void_pointer; - pointer allocate(size_type n=1, const_void_pointer hint = 0) - { - if(n) - { - pointer p; - hash_allocate(&alloc_, &alloc_type::allocate, n, hint, p, 1, 1, 1); - return p; - } - else - { - return 0; - } - } - void deallocate(pointer p, size_type n=1) - { - if(n) - { - hash_deallocate(&alloc_, &alloc_type::deallocate, - hash_allocate_type(&alloc_type::allocate, 1, 1, 1), - p, n, 1, 1, 1); - } - } -#if @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT - size_type max_size(size_type s) const throw() - { - return alloc_.max_size(s); - } -#else - size_type max_size() const throw() - { - size_type n = alloc_.max_size() / sizeof(value_type); - return n>0? n:1; - } -#endif - void construct(pointer p, const value_type& val) { new (p) value_type(val); } - void destroy(pointer p) { (void)p; p->~value_type(); } -}; -#endif - template <class _Val> struct _Hashtable_node { @@ -317,7 +88,7 @@ private: template <class _Val, class _Key, class _HashFcn, class _ExtractKey, class _EqualKey, - class _Alloc = @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(char) > + class _Alloc = std::allocator<char> > class hashtable; template <class _Val, class _Key, class _HashFcn, @@ -341,7 +112,7 @@ struct _Hashtable_iterator { const_iterator; typedef _Hashtable_node<_Val> _Node; - typedef @KWSYS_NAMESPACE@_stl::forward_iterator_tag iterator_category; + typedef std::forward_iterator_tag iterator_category; typedef _Val value_type; typedef ptrdiff_t difference_type; typedef size_t size_type; @@ -378,7 +149,7 @@ struct _Hashtable_const_iterator { const_iterator; typedef _Hashtable_node<_Val> _Node; - typedef @KWSYS_NAMESPACE@_stl::forward_iterator_tag iterator_category; + typedef std::forward_iterator_tag iterator_category; typedef _Val value_type; typedef ptrdiff_t difference_type; typedef size_t size_type; @@ -427,7 +198,7 @@ static inline size_t _stl_next_prime(size_t __n) { const unsigned long* __first = get_stl_prime_list(); const unsigned long* __last = get_stl_prime_list() + (int)_stl_num_primes; - const unsigned long* pos = @KWSYS_NAMESPACE@_stl::lower_bound(__first, __last, __n); + const unsigned long* pos = std::lower_bound(__first, __last, __n); return pos == __last ? *(__last - 1) : *pos; } @@ -470,27 +241,13 @@ public: private: typedef _Hashtable_node<_Val> _Node; -#if @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_REBIND public: typedef typename _Alloc::template rebind<_Val>::other allocator_type; allocator_type get_allocator() const { return _M_node_allocator; } private: typedef typename _Alloc::template rebind<_Node>::other _M_node_allocator_type; typedef typename _Alloc::template rebind<_Node*>::other _M_node_ptr_allocator_type; - typedef @KWSYS_NAMESPACE@_stl::vector<_Node*,_M_node_ptr_allocator_type> _M_buckets_type; -#else -public: - typedef hash_allocator<_Val, _Alloc> allocator_type; - allocator_type get_allocator() const { return allocator_type(); } -private: - typedef hash_allocator<_Node, _Alloc> _M_node_allocator_type; -# if @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_OBJECTS - typedef hash_allocator<_Node*, _Alloc> _M_node_ptr_allocator_type; -# else - typedef _Alloc _M_node_ptr_allocator_type; -# endif - typedef @KWSYS_NAMESPACE@_stl::vector<_Node*,_M_node_ptr_allocator_type> _M_buckets_type; -#endif + typedef std::vector<_Node*,_M_node_ptr_allocator_type> _M_buckets_type; private: _M_node_allocator_type _M_node_allocator; @@ -525,7 +282,7 @@ public: _M_hash(__hf), _M_equals(__eql), _M_get_key(__ext), - @KWSYS_NAMESPACE@_HASH_BUCKETS_INIT(__a), + _M_buckets(__a), _M_num_elements(0) { _M_initialize_buckets(__n); @@ -539,7 +296,7 @@ public: _M_hash(__hf), _M_equals(__eql), _M_get_key(_ExtractKey()), - @KWSYS_NAMESPACE@_HASH_BUCKETS_INIT(__a), + _M_buckets(__a), _M_num_elements(0) { _M_initialize_buckets(__n); @@ -550,7 +307,7 @@ public: _M_hash(__ht._M_hash), _M_equals(__ht._M_equals), _M_get_key(__ht._M_get_key), - @KWSYS_NAMESPACE@_HASH_BUCKETS_INIT(__ht.get_allocator()), + _M_buckets(__ht.get_allocator()), _M_num_elements(0) { _M_copy_from(__ht); @@ -576,11 +333,11 @@ public: void swap(hashtable& __ht) { - @KWSYS_NAMESPACE@_stl::swap(_M_hash, __ht._M_hash); - @KWSYS_NAMESPACE@_stl::swap(_M_equals, __ht._M_equals); - @KWSYS_NAMESPACE@_stl::swap(_M_get_key, __ht._M_get_key); + std::swap(_M_hash, __ht._M_hash); + std::swap(_M_equals, __ht._M_equals); + std::swap(_M_get_key, __ht._M_get_key); _M_buckets.swap(__ht._M_buckets); - @KWSYS_NAMESPACE@_stl::swap(_M_num_elements, __ht._M_num_elements); + std::swap(_M_num_elements, __ht._M_num_elements); } iterator begin() @@ -603,8 +360,8 @@ public: const_iterator end() const { return const_iterator(0, this); } - friend bool operator==@KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS(const hashtable&, - const hashtable&); + friend bool operator==<>(const hashtable&, + const hashtable&); public: @@ -621,7 +378,7 @@ public: return __result; } - @KWSYS_NAMESPACE@_stl::pair<iterator, bool> insert_unique(const value_type& __obj) + std::pair<iterator, bool> insert_unique(const value_type& __obj) { resize(_M_num_elements + 1); return insert_unique_noresize(__obj); @@ -633,38 +390,26 @@ public: return insert_equal_noresize(__obj); } - @KWSYS_NAMESPACE@_stl::pair<iterator, bool> insert_unique_noresize(const value_type& __obj); + std::pair<iterator, bool> insert_unique_noresize(const value_type& __obj); iterator insert_equal_noresize(const value_type& __obj); -#if @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_TRAITS -# define @KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY(T,I) \ - typename @KWSYS_NAMESPACE@_stl::iterator_traits< T >::iterator_category() -#elif @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_CATEGORY -# define @KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY(T,I) \ - @KWSYS_NAMESPACE@_stl::iterator_category( I ) -#elif @KWSYS_NAMESPACE@_STL_HAS___ITERATOR_CATEGORY -# define @KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY(T,I) \ - @KWSYS_NAMESPACE@_stl::__iterator_category( I ) -#endif - -#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES && defined(@KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY) template <class _InputIterator> void insert_unique(_InputIterator __f, _InputIterator __l) { insert_unique(__f, __l, - @KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY(_InputIterator, __f)); + typename std::iterator_traits<_InputIterator>::iterator_category()); } template <class _InputIterator> void insert_equal(_InputIterator __f, _InputIterator __l) { insert_equal(__f, __l, - @KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY(_InputIterator, __f)); + typename std::iterator_traits<_InputIterator>::iterator_category()); } template <class _InputIterator> void insert_unique(_InputIterator __f, _InputIterator __l, - @KWSYS_NAMESPACE@_stl::input_iterator_tag) + std::input_iterator_tag) { for ( ; __f != __l; ++__f) insert_unique(*__f); @@ -672,7 +417,7 @@ public: template <class _InputIterator> void insert_equal(_InputIterator __f, _InputIterator __l, - @KWSYS_NAMESPACE@_stl::input_iterator_tag) + std::input_iterator_tag) { for ( ; __f != __l; ++__f) insert_equal(*__f); @@ -680,10 +425,10 @@ public: template <class _ForwardIterator> void insert_unique(_ForwardIterator __f, _ForwardIterator __l, - @KWSYS_NAMESPACE@_stl::forward_iterator_tag) + std::forward_iterator_tag) { size_type __n = 0; - @KWSYS_NAMESPACE@_stl::distance(__f, __l, __n); + std::distance(__f, __l, __n); resize(_M_num_elements + __n); for ( ; __n > 0; --__n, ++__f) insert_unique_noresize(*__f); @@ -691,51 +436,15 @@ public: template <class _ForwardIterator> void insert_equal(_ForwardIterator __f, _ForwardIterator __l, - @KWSYS_NAMESPACE@_stl::forward_iterator_tag) + std::forward_iterator_tag) { size_type __n = 0; - @KWSYS_NAMESPACE@_stl::distance(__f, __l, __n); + std::distance(__f, __l, __n); resize(_M_num_elements + __n); for ( ; __n > 0; --__n, ++__f) insert_equal_noresize(*__f); } -#else - void insert_unique(const value_type* __f, const value_type* __l) - { - size_type __n = __l - __f; - resize(_M_num_elements + __n); - for ( ; __n > 0; --__n, ++__f) - insert_unique_noresize(*__f); - } - - void insert_equal(const value_type* __f, const value_type* __l) - { - size_type __n = __l - __f; - resize(_M_num_elements + __n); - for ( ; __n > 0; --__n, ++__f) - insert_equal_noresize(*__f); - } - - void insert_unique(const_iterator __f, const_iterator __l) - { - size_type __n = 0; - @KWSYS_NAMESPACE@_stl::distance(__f, __l, __n); - resize(_M_num_elements + __n); - for ( ; __n > 0; --__n, ++__f) - insert_unique_noresize(*__f); - } - - void insert_equal(const_iterator __f, const_iterator __l) - { - size_type __n = 0; - @KWSYS_NAMESPACE@_stl::distance(__f, __l, __n); - resize(_M_num_elements + __n); - for ( ; __n > 0; --__n, ++__f) - insert_equal_noresize(*__f); - } -#endif - reference find_or_insert(const value_type& __obj); iterator find(const key_type& __key) @@ -771,10 +480,10 @@ public: return __result; } - @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> + std::pair<iterator, iterator> equal_range(const key_type& __key); - @KWSYS_NAMESPACE@_stl::pair<const_iterator, const_iterator> + std::pair<const_iterator, const_iterator> equal_range(const key_type& __key) const; size_type erase(const key_type& __key); @@ -936,7 +645,7 @@ inline void swap(hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht1, } template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All> -@KWSYS_NAMESPACE@_stl::pair<@KWSYS_NAMESPACE@_CXX_DECL_TYPENAME hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator, bool> +std::pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator, bool> hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> ::insert_unique_noresize(const value_type& __obj) { @@ -945,13 +654,13 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) - return @KWSYS_NAMESPACE@_stl::pair<iterator, bool>(iterator(__cur, this), false); + return std::pair<iterator, bool>(iterator(__cur, this), false); _Node* __tmp = _M_new_node(__obj); __tmp->_M_next = __first; _M_buckets[__n] = __tmp; ++_M_num_elements; - return @KWSYS_NAMESPACE@_stl::pair<iterator, bool>(iterator(__tmp, this), true); + return std::pair<iterator, bool>(iterator(__tmp, this), true); } template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All> @@ -999,11 +708,11 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::find_or_insert(const value_type& __obj) } template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All> -@KWSYS_NAMESPACE@_stl::pair<@KWSYS_NAMESPACE@_CXX_DECL_TYPENAME hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator, - @KWSYS_NAMESPACE@_CXX_DECL_TYPENAME hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator> +std::pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator, + typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator> hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::equal_range(const key_type& __key) { - typedef @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> _Pii; + typedef std::pair<iterator, iterator> _Pii; const size_type __n = _M_bkt_num_key(__key); for (_Node* __first = _M_buckets[__n]; __first; __first = __first->_M_next) @@ -1021,12 +730,12 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::equal_range(const key_type& __key) } template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All> -@KWSYS_NAMESPACE@_stl::pair<@KWSYS_NAMESPACE@_CXX_DECL_TYPENAME hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator, - @KWSYS_NAMESPACE@_CXX_DECL_TYPENAME hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator> +std::pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator, + typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator> hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> ::equal_range(const key_type& __key) const { - typedef @KWSYS_NAMESPACE@_stl::pair<const_iterator, const_iterator> _Pii; + typedef std::pair<const_iterator, const_iterator> _Pii; const size_type __n = _M_bkt_num_key(__key); for (const _Node* __first = _M_buckets[__n] ; @@ -1164,8 +873,8 @@ void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> const size_type __n = _M_next_size(__num_elements_hint); if (__n > __old_n) { _M_buckets_type __tmp( - __n, (_Node*)(0) - @KWSYS_NAMESPACE@_HASH_BUCKETS_GET_ALLOCATOR(_M_buckets)); + __n, (_Node*)(0), + _M_buckets.get_allocator()); try { for (size_type __bucket = 0; __bucket < __old_n; ++__bucket) { _Node* __first = _M_buckets[__bucket]; @@ -1274,14 +983,6 @@ void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> } // namespace @KWSYS_NAMESPACE@ -// Normally the comparison operators should be found in the @KWSYS_NAMESPACE@ -// namespace by argument dependent lookup. For compilers that do not -// support it we must bring them into the global namespace now. -#if !@KWSYS_NAMESPACE@_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP -using @KWSYS_NAMESPACE@::operator==; -using @KWSYS_NAMESPACE@::operator!=; -#endif - // Undo warning suppression. #if defined(__clang__) && defined(__has_warning) # if __has_warning("-Wdeprecated") diff --git a/Source/kwsys/kwsysPlatformTestsCXX.cxx b/Source/kwsys/kwsysPlatformTestsCXX.cxx index 1596fe4..9626937 100644 --- a/Source/kwsys/kwsysPlatformTestsCXX.cxx +++ b/Source/kwsys/kwsysPlatformTestsCXX.cxx @@ -9,110 +9,11 @@ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the License for more information. ============================================================================*/ -// Setup for tests that use result of stl namespace test. -#if defined(KWSYS_STL_HAVE_STD) -# if KWSYS_STL_HAVE_STD -# define kwsys_stl std -# else -# define kwsys_stl -# endif -#endif - -// Setup for tests that use iostreams. -#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD) -# if defined(_MSC_VER) -# pragma warning (push,1) -# endif -# if KWSYS_IOS_USE_ANSI -# include <iostream> -# else -# include <iostream.h> -# endif -# if defined(_MSC_VER) -# pragma warning (pop) -# endif -# if KWSYS_IOS_HAVE_STD -# define kwsys_ios std -# else -# define kwsys_ios -# endif -#endif - -#ifdef TEST_KWSYS_STL_HAVE_STD -#include <list> -void f(std ::list<int>*) {} -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_IOS_USE_ANSI -#include <iosfwd> -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_IOS_HAVE_STD -#include <iosfwd> -void f(std ::ostream*) {} -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_IOS_USE_SSTREAM -#include <sstream> -#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96 -# error "GCC 2.96 stringstream is buggy" -#endif -int main() -{ - std ::ostringstream ostr; - ostr << "hello"; - if(ostr.str().size() == 5) - { - return 0; - } - return -1; -} -#endif - -#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H -#include <strstream.h> -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H -#include <strstrea.h> -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM -# include <iostream.h> -# include <string> -void f(ostream& os, const kwsys_stl::string& s) { os << s; } -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM -# include <iostream.h> -# include <string> -void f(istream& is, kwsys_stl::string& s) { is >> s; } -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR -# include <string> -bool f(const kwsys_stl::string& s) { return s != ""; } -int main() { return 0; } -#endif - #ifdef TEST_KWSYS_CXX_HAS_CSTDIO #include <cstdio> int main() { return 0; } #endif -#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF -#include <cstddef> -void f(size_t) {} -int main() { return 0; } -#endif - #ifdef TEST_KWSYS_CXX_HAS_LONG_LONG long long f(long long n) { return n; } int main() @@ -131,159 +32,28 @@ int main() } #endif -#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS -template <class T> class A; -template <class T> int f(A<T>&); -template <class T> class A -{ -public: - // "friend int f<>(A<T>&)" would conform - friend int f(A<T>&); -private: - int x; -}; - -template <class T> int f(A<T>& a) { return a.x = 0; } -template int f(A<int>&); - -int main() -{ - A<int> a; - return f(a); -} -#endif - -#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES -template <class U> -class A -{ -public: - U u; - A(): u(0) {} - template <class V> V m(V* p) { return *p = u; } -}; - -int main() -{ - A<short> a; - int s = 1; - return a.m(&s); -} -#endif - -#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION -template <class T> struct A {}; -template <> struct A<int*> -{ - static int f() { return 0; } -}; -int main() { return A<int*>::f(); } -#endif - -#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP -namespace N -{ - class A {}; - int f(A*) { return 0; } -} -void f(void*); -int main() -{ - N::A* a = 0; - return f(a); -} -#endif - -#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS -#include <iterator> -#include <list> -void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {} -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY -#include <iterator> -#include <list> -void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); } -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY -#include <iterator> -#include <list> -void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); } -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE -#include <memory> -template <class Alloc> -void f(const Alloc&) -{ - typedef typename Alloc::size_type alloc_size_type; -} -int main() -{ - f(kwsys_stl::allocator<char>()); - return 0; -} -#endif - -#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE -#include <memory> -void f(kwsys_stl::allocator::size_type const&) {} -int main() { return 0; } -#endif - -#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND -#include <memory> -template <class T, class Alloc> -void f(const T&, const Alloc&) -{ - typedef typename Alloc::template rebind<T>::other alloc_type; -} -int main() -{ - f(0, kwsys_stl::allocator<char>()); - return 0; -} -#endif - -#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT -#include <memory> -void f(kwsys_stl::allocator<char> const& a) -{ - a.max_size(sizeof(int)); -} -int main() -{ - f(kwsys_stl::allocator<char>()); - return 0; -} -#endif - -#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS -#include <vector> -void f(kwsys_stl::vector<int> const& v1) -{ - kwsys_stl::vector<int>(1, 1, v1.get_allocator()); -} +#ifdef TEST_KWSYS_CXX_STAT_HAS_ST_MTIM +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> int main() { - f(kwsys_stl::vector<int>()); + struct stat stat1; + (void)stat1.st_mtim.tv_sec; + (void)stat1.st_mtim.tv_nsec; return 0; } #endif -#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM +#ifdef TEST_KWSYS_CXX_STAT_HAS_ST_MTIMESPEC #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> int main() { struct stat stat1; - (void)stat1.st_mtim.tv_sec; - (void)stat1.st_mtim.tv_nsec; + (void)stat1.st_mtimespec.tv_sec; + (void)stat1.st_mtimespec.tv_nsec; return 0; } #endif @@ -323,62 +93,55 @@ int main() } #endif -#ifdef TEST_KWSYS_IOS_HAVE_BINARY -int test_binary(int, ...) -{ - return 0; -} -int main() -{ - return test_binary(1, kwsys_ios::ios::binary); -} -#endif - #ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG -int test_istream(kwsys_ios::istream& is, long long& x) +# include <iostream> +int test_istream(std::istream& is, long long& x) { return (is >> x)? 1:0; } int main() { long long x = 0; - return test_istream(kwsys_ios::cin, x); + return test_istream(std::cin, x); } #endif #ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG -int test_ostream(kwsys_ios::ostream& os, long long x) +# include <iostream> +int test_ostream(std::ostream& os, long long x) { return (os << x)? 1:0; } int main() { long long x = 0; - return test_ostream(kwsys_ios::cout, x); + return test_ostream(std::cout, x); } #endif #ifdef TEST_KWSYS_IOS_HAS_ISTREAM___INT64 -int test_istream(kwsys_ios::istream& is, __int64& x) +# include <iostream> +int test_istream(std::istream& is, __int64& x) { return (is >> x)? 1:0; } int main() { __int64 x = 0; - return test_istream(kwsys_ios::cin, x); + return test_istream(std::cin, x); } #endif #ifdef TEST_KWSYS_IOS_HAS_OSTREAM___INT64 -int test_ostream(kwsys_ios::ostream& os, __int64 x) +# include <iostream> +int test_ostream(std::ostream& os, __int64 x) { return (os << x)? 1:0; } int main() { __int64 x = 0; - return test_ostream(kwsys_ios::cout, x); + return test_ostream(std::cout, x); } #endif diff --git a/Source/kwsys/kwsys_cstddef.hxx.in b/Source/kwsys/kwsys_cstddef.hxx.in deleted file mode 100644 index 925c030..0000000 --- a/Source/kwsys/kwsys_cstddef.hxx.in +++ /dev/null @@ -1,35 +0,0 @@ -/*============================================================================ - KWSys - Kitware System Library - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ -#ifndef @KWSYS_NAMESPACE@_cstddef -#define @KWSYS_NAMESPACE@_cstddef - -#include <@KWSYS_NAMESPACE@/Configure.hxx> - -/* Avoid warnings in MSVC standard headers. */ -#ifdef _MSC_VER -# pragma warning (push, 1) -# pragma warning (disable: 4702) -# pragma warning (disable: 4786) -#endif - -/* Include the real header. */ -#if @KWSYS_NAMESPACE@_CXX_HAS_CSTDDEF -# include <cstddef> -#else -# include <stddef.h> -#endif - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -#endif diff --git a/Source/kwsys/kwsys_ios_fstream.h.in b/Source/kwsys/kwsys_ios_fstream.h.in deleted file mode 100644 index 4b1a8cf..0000000 --- a/Source/kwsys/kwsys_ios_fstream.h.in +++ /dev/null @@ -1,46 +0,0 @@ -/*============================================================================ - KWSys - Kitware System Library - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ -#ifndef @KWSYS_NAMESPACE@_ios_fstream -#define @KWSYS_NAMESPACE@_ios_fstream - -#include <@KWSYS_NAMESPACE@/Configure.hxx> - -#ifdef _MSC_VER -# pragma warning (push, 1) -# pragma warning (disable: 4702) -# pragma warning (disable: 4995) /* Old streams are deprecated. */ -#endif - -#if @KWSYS_NAMESPACE@_IOS_USE_ANSI -# include <fstream> -#else -# include <fstream.h> -#endif - -#if !@KWSYS_NAMESPACE@_IOS_USE_SSTREAM -namespace @KWSYS_NAMESPACE@_ios -{ - using @KWSYS_NAMESPACE@_ios_namespace::ostream; - using @KWSYS_NAMESPACE@_ios_namespace::istream; - using @KWSYS_NAMESPACE@_ios_namespace::ofstream; - using @KWSYS_NAMESPACE@_ios_namespace::ifstream; - using @KWSYS_NAMESPACE@_ios_namespace::ios; - using @KWSYS_NAMESPACE@_ios_namespace::endl; - using @KWSYS_NAMESPACE@_ios_namespace::flush; -} -#endif - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -#endif diff --git a/Source/kwsys/kwsys_ios_iosfwd.h.in b/Source/kwsys/kwsys_ios_iosfwd.h.in deleted file mode 100644 index f4fafeb..0000000 --- a/Source/kwsys/kwsys_ios_iosfwd.h.in +++ /dev/null @@ -1,49 +0,0 @@ -/*============================================================================ - KWSys - Kitware System Library - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ -#ifndef @KWSYS_NAMESPACE@_ios_iosfwd -#define @KWSYS_NAMESPACE@_ios_iosfwd - -#include <@KWSYS_NAMESPACE@/Configure.hxx> - -#ifdef _MSC_VER -#pragma warning (push, 1) -#pragma warning (disable: 4702) -#endif - -#if @KWSYS_NAMESPACE@_IOS_USE_ANSI -# include <iosfwd> -#else -class fstream; -class ifstream; -class ios; -class istream; -class ofstream; -class ostream; -#endif - -#if !@KWSYS_NAMESPACE@_IOS_USE_SSTREAM -namespace @KWSYS_NAMESPACE@_ios -{ - using @KWSYS_NAMESPACE@_ios_namespace::fstream; - using @KWSYS_NAMESPACE@_ios_namespace::ifstream; - using @KWSYS_NAMESPACE@_ios_namespace::ios; - using @KWSYS_NAMESPACE@_ios_namespace::istream; - using @KWSYS_NAMESPACE@_ios_namespace::ofstream; - using @KWSYS_NAMESPACE@_ios_namespace::ostream; -} -#endif - -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -#endif diff --git a/Source/kwsys/kwsys_ios_iostream.h.in b/Source/kwsys/kwsys_ios_iostream.h.in deleted file mode 100644 index 43fc4d5..0000000 --- a/Source/kwsys/kwsys_ios_iostream.h.in +++ /dev/null @@ -1,99 +0,0 @@ -/*============================================================================ - KWSys - Kitware System Library - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ -#ifndef @KWSYS_NAMESPACE@_ios_iostream -#define @KWSYS_NAMESPACE@_ios_iostream - -#include <@KWSYS_NAMESPACE@/Configure.hxx> - -#ifdef _MSC_VER -# pragma warning (push, 1) -# pragma warning (disable: 4702) -# pragma warning (disable: 4995) /* Old streams are deprecated. */ -#endif - -#if @KWSYS_NAMESPACE@_IOS_USE_ANSI -# include <iostream> -#else -# include <iostream.h> -#endif - -// The HP implementation of iostream defines cin, cout, cerr, and clog -// as macros in order to do thread-private streams. -// See /opt/aCC/include/iostream/iostream.h for details. -// This block redefines the macros in a safe way that is also compatible -// with the HP definitions and the using declarations below. - -#if !@KWSYS_NAMESPACE@_IOS_USE_SSTREAM -# if defined(__HP_aCC) && (defined(HP_THREAD_SAFE) || defined(_THREAD_SAFE)) -# if defined(cin) && !defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CIN) -# define @KWSYS_NAMESPACE@_IOS_HP_HACK_CIN -# undef cin -# define cin __tcin.ref() -# endif -# if defined(cout) && !defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_COUT) -# define @KWSYS_NAMESPACE@_IOS_HP_HACK_COUT -# undef cout -# define cout __tcout.ref() -# endif -# if defined(cerr) && !defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CERR) -# define @KWSYS_NAMESPACE@_IOS_HP_HACK_CERR -# undef cerr -# define cerr __tcerr.ref() -# endif -# if defined(clog) && !defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CLOG) -# define @KWSYS_NAMESPACE@_IOS_HP_HACK_CLOG -# undef clog -# define clog __tclog.ref() -# endif -# endif -#endif - -// If using our own sstream emulation code, put the standard -// streams in the same namespace. -#if !@KWSYS_NAMESPACE@_IOS_USE_SSTREAM -namespace @KWSYS_NAMESPACE@_ios -{ - typedef int streamsize; - typedef int streamoff; - using @KWSYS_NAMESPACE@_ios_namespace::ostream; - using @KWSYS_NAMESPACE@_ios_namespace::istream; - using @KWSYS_NAMESPACE@_ios_namespace::ios; - using @KWSYS_NAMESPACE@_ios_namespace::endl; - using @KWSYS_NAMESPACE@_ios_namespace::flush; -# if defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CIN) - using @KWSYS_NAMESPACE@_ios_namespace::__tcin; -# else - using @KWSYS_NAMESPACE@_ios_namespace::cin; -# endif -# if defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_COUT) - using @KWSYS_NAMESPACE@_ios_namespace::__tcout; -# else - using @KWSYS_NAMESPACE@_ios_namespace::cout; -# endif -# if defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CERR) - using @KWSYS_NAMESPACE@_ios_namespace::__tcerr; -# else - using @KWSYS_NAMESPACE@_ios_namespace::cerr; -# endif -# if defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CLOG) - using @KWSYS_NAMESPACE@_ios_namespace::__tclog; -# else - using @KWSYS_NAMESPACE@_ios_namespace::clog; -# endif -} -#endif - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -#endif diff --git a/Source/kwsys/kwsys_ios_sstream.h.in b/Source/kwsys/kwsys_ios_sstream.h.in deleted file mode 100644 index 29d250c..0000000 --- a/Source/kwsys/kwsys_ios_sstream.h.in +++ /dev/null @@ -1,199 +0,0 @@ -/*============================================================================ - KWSys - Kitware System Library - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ -#ifndef @KWSYS_NAMESPACE@_ios_sstream -#define @KWSYS_NAMESPACE@_ios_sstream - -#include <@KWSYS_NAMESPACE@/Configure.hxx> - -/* Define this macro temporarily to keep the code readable. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define kwsys_stl @KWSYS_NAMESPACE@_stl -#endif - -#if @KWSYS_NAMESPACE@_IOS_USE_SSTREAM -# ifdef _MSC_VER -# pragma warning (push, 1) -# pragma warning (disable: 4702) -# endif -# include <sstream> -# ifdef _MSC_VER -# pragma warning(pop) -# endif -#else -# ifdef _MSC_VER -# pragma warning (push, 1) -# pragma warning (disable: 4702) -# pragma warning (disable: 4995) /* Old streams are deprecated. */ -# endif -# if @KWSYS_NAMESPACE@_IOS_USE_ANSI -# include <strstream> -# elif @KWSYS_NAMESPACE@_IOS_USE_STRSTREAM_H -# include <strstream.h> -# elif @KWSYS_NAMESPACE@_IOS_USE_STRSTREA_H -# include <strstrea.h> -# endif -# if @KWSYS_NAMESPACE@_IOS_USE_ANSI -# include <new> // Need placement operator new. -# else -# include <new.h> // Need placement operator new. -# endif -# ifdef _MSC_VER -# pragma warning(pop) -# endif - -// Only have old std strstream classes. Wrap them to look like new -// ostringstream and istringstream classes. - -# include <@KWSYS_NAMESPACE@/stl/string> - -namespace @KWSYS_NAMESPACE@_ios -{ -using @KWSYS_NAMESPACE@_ios_namespace::streambuf; -using @KWSYS_NAMESPACE@_ios_namespace::ostream; -using @KWSYS_NAMESPACE@_ios_namespace::istream; -using @KWSYS_NAMESPACE@_ios_namespace::strstream; -using @KWSYS_NAMESPACE@_ios_namespace::istrstream; -using @KWSYS_NAMESPACE@_ios_namespace::ostrstream; -using @KWSYS_NAMESPACE@_ios_namespace::ios; -using @KWSYS_NAMESPACE@_ios_namespace::endl; -using @KWSYS_NAMESPACE@_ios_namespace::ends; -using @KWSYS_NAMESPACE@_ios_namespace::flush; - -class stringstream_cleanup -{ -public: - stringstream_cleanup(strstream& str): m_StrStream(str) {} - ~stringstream_cleanup() { m_StrStream.rdbuf()->freeze(0); } - static void IgnoreUnusedVariable(const stringstream_cleanup&) {} -protected: - strstream& m_StrStream; -private: - void operator=(stringstream_cleanup const&); -}; - -class stringstream: public strstream -{ -public: - typedef strstream Superclass; - stringstream() {} - stringstream(const kwsys_stl::string& s) { *this << s.c_str(); } - kwsys_stl::string str() - { - stringstream_cleanup cleanup(*this); - stringstream_cleanup::IgnoreUnusedVariable(cleanup); -// Visual Studio 6 has a strstream::pcount, but this is not rdbuf()->pcount() -#if (@KWSYS_NAMESPACE@_IOS_USE_STRSTREA_H) && defined(_MSC_VER) && (_MSC_VER == 1200) - int count = this->pcount(); -#elif defined(__WATCOMC__) - int count = this->rdbuf()->out_waiting(); -#else - int count = this->rdbuf()->pcount(); -#endif - const char* ptr = this->Superclass::str(); - return kwsys_stl::string(ptr?ptr:"", count); - } - void str(const kwsys_stl::string& s) - { - this->~stringstream(); - new (this) stringstream(s); - } -private: - stringstream(const stringstream&); - void operator=(const stringstream&); -}; - -class ostringstream_cleanup -{ -public: - ostringstream_cleanup(ostrstream& ostr): m_OStrStream(ostr) {} - ~ostringstream_cleanup() { m_OStrStream.rdbuf()->freeze(0); } - static void IgnoreUnusedVariable(const ostringstream_cleanup&) {} -protected: - ostrstream& m_OStrStream; -private: - void operator=(ostringstream_cleanup const&); -}; - -class ostringstream: public ostrstream -{ -public: - typedef ostrstream Superclass; - ostringstream() {} - ostringstream(const kwsys_stl::string& s) { *this << s.c_str(); } - kwsys_stl::string str() - { - ostringstream_cleanup cleanup(*this); - ostringstream_cleanup::IgnoreUnusedVariable(cleanup); - int count = this->pcount(); - const char* ptr = this->Superclass::str(); - return kwsys_stl::string(ptr?ptr:"", count); - } - void str(const kwsys_stl::string& s) - { - this->~ostringstream(); - new (this) ostringstream(s); - } -private: - ostringstream(const ostringstream&); - void operator=(const ostringstream&); -}; - -#if defined(_MSC_VER) -# pragma warning (push) -# pragma warning (disable: 4097) /* typedef-name used as synonym for class */ -#endif -#if defined(__WATCOMC__) -// W728: class modifiers for 'A' conflict with class modifiers for 'B' -# pragma warning 728 10 -#endif - -class istringstream: private kwsys_stl::string, public istrstream -{ -public: - typedef kwsys_stl::string StdString; - typedef istrstream IStrStream; - istringstream(): StdString(), - IStrStream(const_cast<char*>(StdString::c_str())) {} - istringstream(const kwsys_stl::string& s): - StdString(s), IStrStream(const_cast<char*>(StdString::c_str())) {} - kwsys_stl::string str() const { return *this; } - void str(const kwsys_stl::string& s) - { - this->~istringstream(); - new (this) istringstream(s); - } - void clear(int flags) - { - this->IStrStream::clear(flags); - } -private: - istringstream(const istringstream&); - void operator=(const istringstream&); -}; - -#if defined(__WATCOMC__) -# pragma warning 728 9 -#endif -#if defined(_MSC_VER) -# pragma warning (pop) -#endif - -} // namespace @KWSYS_NAMESPACE@_ios - -#endif - -/* Undefine temporary macro. */ -#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS -# undef kwsys_stl -#endif - -#endif diff --git a/Source/kwsys/kwsys_stl.hxx.in b/Source/kwsys/kwsys_stl.hxx.in deleted file mode 100644 index 610e6d4..0000000 --- a/Source/kwsys/kwsys_stl.hxx.in +++ /dev/null @@ -1,49 +0,0 @@ -/*============================================================================ - KWSys - Kitware System Library - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ -#ifndef @KWSYS_NAMESPACE@_stl_@KWSYS_STL_HEADER@ -#define @KWSYS_NAMESPACE@_stl_@KWSYS_STL_HEADER@ - -#include <@KWSYS_NAMESPACE@/Configure.hxx> - -/* Avoid warnings in MSVC standard headers. */ -#ifdef _MSC_VER -# pragma warning (push, 1) -# pragma warning (disable: 4702) -# pragma warning (disable: 4786) -#endif - -/* The HP standard library defines the functor "times" instead of - "multiplies" as specified by C++98 20.3.2 for backward - compatibility with earlier specifications. Defining this macro - fixes this behavior. The name "times" also conflicts with the - function declared in sys/times.h on that platform, so we must do - this as a work-around anyway. */ -#if defined(__HP_aCC) && !defined(__HPACC_USING_MULTIPLIES_IN_FUNCTIONAL) -# define __HPACC_USING_MULTIPLIES_IN_FUNCTIONAL -# define @KWSYS_NAMESPACE@_DEFINED___HPACC_USING_MULTIPLIES_IN_FUNCTIONAL -#endif - -/* Include the real header. */ -#include <@KWSYS_STL_HEADER@> - -/* Cleanup. */ -#if defined(@KWSYS_NAMESPACE@_DEFINED___HPACC_USING_MULTIPLIES_IN_FUNCTIONAL) -# undef @KWSYS_NAMESPACE@_DEFINED___HPACC_USING_MULTIPLIES_IN_FUNCTIONAL -# undef __HPACC_USING_MULTIPLIES_IN_FUNCTIONAL -#endif - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -@KWSYS_STL_HEADER_EXTRA@ -#endif diff --git a/Source/kwsys/kwsys_stl_string.hxx.in b/Source/kwsys/kwsys_stl_string.hxx.in deleted file mode 100644 index cd312cb..0000000 --- a/Source/kwsys/kwsys_stl_string.hxx.in +++ /dev/null @@ -1,123 +0,0 @@ -/*============================================================================ - KWSys - Kitware System Library - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ - -// This header is extra code for <@KWSYS_NAMESPACE@/stl/string>. -#if !defined(@KWSYS_NAMESPACE@_stl_string_including_hxx) -# error "The header <@KWSYS_NAMESPACE@/stl/string.hxx> may be included only by <@KWSYS_NAMESPACE@/stl/string>." -#endif - -// Provide the istream operator for the stl string if it is not -// provided by the system or another copy of kwsys. Allow user code -// to block this definition by defining the macro -// @KWSYS_NAMESPACE@_STL_STRING_NO_ISTREAM -// to avoid conflicts with other libraries. User code can test for -// this definition by checking the macro -// @KWSYS_NAMESPACE@_STL_STRING_ISTREAM_DEFINED -#if !@KWSYS_NAMESPACE@_STL_STRING_HAVE_ISTREAM && !defined(@KWSYS_NAMESPACE@_STL_STRING_NO_ISTREAM) && !defined(KWSYS_STL_STRING_ISTREAM_DEFINED) -# define KWSYS_STL_STRING_ISTREAM_DEFINED -# define @KWSYS_NAMESPACE@_STL_STRING_ISTREAM_DEFINED -# include <ctype.h> // isspace -# include <@KWSYS_NAMESPACE@/ios/iostream> -# if defined(__WATCOMC__) -namespace @KWSYS_NAMESPACE@ -{ -struct ios_istream_hack: public kwsys_ios::istream -{ void eatwhite() { this->@KWSYS_NAMESPACE@_ios::istream::eatwhite(); } }; -} -# endif -inline @KWSYS_NAMESPACE@_ios::istream& -operator>>(@KWSYS_NAMESPACE@_ios::istream& is, - @KWSYS_NAMESPACE@_stl::string& s) -{ - // Keep track of the resulting state. - int state = @KWSYS_NAMESPACE@_ios::ios::goodbit; - - // Save the width setting and set it back to zero. - size_t n = static_cast<size_t>(is.width(0)); - - // Clear any old contents of the output string. - s.erase(); - - // Skip leading whitespace. -#if defined(__WATCOMC__) - static_cast<@KWSYS_NAMESPACE@::ios_istream_hack&>(is).eatwhite(); -#else - is.eatwhite(); -#endif - @KWSYS_NAMESPACE@_ios::istream& okay = is; - - if(okay) - { - // Select a maximum possible length. - if(n == 0 || n >= s.max_size()) - { - n = s.max_size(); - } - - // Read until a space is found or the maximum length is reached. - bool success = false; - for(int c = is.peek(); (--n > 0 && c != EOF && !isspace(c)); c = is.peek()) - { - s += static_cast<char>(c); - success = true; - is.ignore(); - } - - // Set flags for resulting state. - if(is.peek() == EOF) { state |= @KWSYS_NAMESPACE@_ios::ios::eofbit; } - if(!success) { state |= @KWSYS_NAMESPACE@_ios::ios::failbit; } - } - - // Set the final result state. - is.clear(state); - return is; -} -#endif - -// Provide the ostream operator for the stl string if it is not -// provided by the system or another copy of kwsys. Allow user code -// to block this definition by defining the macro -// @KWSYS_NAMESPACE@_STL_STRING_NO_OSTREAM -// to avoid conflicts with other libraries. User code can test for -// this definition by checking the macro -// @KWSYS_NAMESPACE@_STL_STRING_OSTREAM_DEFINED -#if !@KWSYS_NAMESPACE@_STL_STRING_HAVE_OSTREAM && !defined(@KWSYS_NAMESPACE@_STL_STRING_NO_OSTREAM) && !defined(KWSYS_STL_STRING_OSTREAM_DEFINED) -# define KWSYS_STL_STRING_OSTREAM_DEFINED -# define @KWSYS_NAMESPACE@_STL_STRING_OSTREAM_DEFINED -# include <@KWSYS_NAMESPACE@/ios/iostream> -inline @KWSYS_NAMESPACE@_ios::ostream& -operator<<(@KWSYS_NAMESPACE@_ios::ostream& os, - @KWSYS_NAMESPACE@_stl::string const& s) -{ - return os << s.c_str(); -} -#endif - -// Provide the operator!= for the stl string and char* if it is not -// provided by the system or another copy of kwsys. Allow user code -// to block this definition by defining the macro -// @KWSYS_NAMESPACE@_STL_STRING_NO_NEQ_CHAR -// to avoid conflicts with other libraries. User code can test for -// this definition by checking the macro -// @KWSYS_NAMESPACE@_STL_STRING_NEQ_CHAR_DEFINED -#if !@KWSYS_NAMESPACE@_STL_STRING_HAVE_NEQ_CHAR && !defined(@KWSYS_NAMESPACE@_STL_STRING_NO_NEQ_CHAR) && !defined(KWSYS_STL_STRING_NEQ_CHAR_DEFINED) -# define KWSYS_STL_STRING_NEQ_CHAR_DEFINED -# define @KWSYS_NAMESPACE@_STL_STRING_NEQ_CHAR_DEFINED -inline bool operator!=(@KWSYS_NAMESPACE@_stl::string const& s, const char* c) -{ - return !(s == c); -} -inline bool operator!=(const char* c, @KWSYS_NAMESPACE@_stl::string const& s) -{ - return !(s == c); -} -#endif diff --git a/Source/kwsys/testCommandLineArguments.cxx b/Source/kwsys/testCommandLineArguments.cxx index 6a03c0f..525522d 100644 --- a/Source/kwsys/testCommandLineArguments.cxx +++ b/Source/kwsys/testCommandLineArguments.cxx @@ -11,16 +11,16 @@ ============================================================================*/ #include "kwsysPrivate.h" #include KWSYS_HEADER(CommandLineArguments.hxx) -#include KWSYS_HEADER(ios/iostream) -#include KWSYS_HEADER(stl/vector) // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. #if 0 # include "CommandLineArguments.hxx.in" -# include "kwsys_ios_iostream.h.in" #endif +#include <iostream> +#include <vector> + #include <stddef.h> /* size_t */ #include <string.h> /* strcmp */ @@ -28,10 +28,10 @@ static void* random_ptr = reinterpret_cast<void*>(0x123); static int argument(const char* arg, const char* value, void* call_data) { - kwsys_ios::cout << "Got argument: \"" << arg << "\" value: \"" << (value?value:"(null)") << "\"" << kwsys_ios::endl; + std::cout << "Got argument: \"" << arg << "\" value: \"" << (value?value:"(null)") << "\"" << std::endl; if ( call_data != random_ptr ) { - kwsys_ios::cerr << "Problem processing call_data" << kwsys_ios::endl; + std::cerr << "Problem processing call_data" << std::endl; return 0; } return 1; @@ -39,10 +39,10 @@ static int argument(const char* arg, const char* value, void* call_data) static int unknown_argument(const char* argument, void* call_data) { - kwsys_ios::cout << "Got unknown argument: \"" << argument << "\"" << kwsys_ios::endl; + std::cout << "Got unknown argument: \"" << argument << "\"" << std::endl; if ( call_data != random_ptr ) { - kwsys_ios::cerr << "Problem processing call_data" << kwsys_ios::endl; + std::cerr << "Problem processing call_data" << std::endl; return 0; } return 1; @@ -53,8 +53,8 @@ static bool CompareTwoItemsOnList(int i1, int i2) { return i1 == i2; } static bool CompareTwoItemsOnList(double i1, double i2) { return i1 == i2; } static bool CompareTwoItemsOnList(const char* i1, const char* i2) { return strcmp(i1, i2) == 0; } -static bool CompareTwoItemsOnList(const kwsys_stl::string& i1, - const kwsys_stl::string& i2) { return i1 == i2; } +static bool CompareTwoItemsOnList(const std::string& i1, + const std::string& i2) { return i1 == i2; } int testCommandLineArguments(int argc, char* argv[]) { @@ -74,26 +74,26 @@ int testCommandLineArguments(int argc, char* argv[]) int some_int_variable = 10; double some_double_variable = 10.10; char* some_string_variable = 0; - kwsys_stl::string some_stl_string_variable = ""; + std::string some_stl_string_variable = ""; bool some_bool_variable = false; bool some_bool_variable1 = false; bool bool_arg1 = false; int bool_arg2 = 0; - kwsys_stl::vector<int> numbers_argument; + std::vector<int> numbers_argument; int valid_numbers[] = { 5, 1, 8, 3, 7, 1, 3, 9, 7, 1 }; - kwsys_stl::vector<double> doubles_argument; + std::vector<double> doubles_argument; double valid_doubles[] = { 12.5, 1.31, 22 }; - kwsys_stl::vector<bool> bools_argument; + std::vector<bool> bools_argument; bool valid_bools[] = { true, true, false }; - kwsys_stl::vector<char*> strings_argument; + std::vector<char*> strings_argument; const char* valid_strings[] = { "andy", "bill", "brad", "ken" }; - kwsys_stl::vector<kwsys_stl::string> stl_strings_argument; - kwsys_stl::string valid_stl_strings[] = { "ken", "brad", "bill", "andy" }; + std::vector<std::string> stl_strings_argument; + std::string valid_stl_strings[] = { "ken", "brad", "bill", "andy" }; typedef kwsys::CommandLineArguments argT; @@ -122,47 +122,47 @@ int testCommandLineArguments(int argc, char* argv[]) if ( !arg.Parse() ) { - kwsys_ios::cerr << "Problem parsing arguments" << kwsys_ios::endl; + std::cerr << "Problem parsing arguments" << std::endl; res = 1; } - kwsys_ios::cout << "Help: " << arg.GetHelp() << kwsys_ios::endl; + std::cout << "Help: " << arg.GetHelp() << std::endl; - kwsys_ios::cout << "Some int variable was set to: " << some_int_variable << kwsys_ios::endl; - kwsys_ios::cout << "Some double variable was set to: " << some_double_variable << kwsys_ios::endl; + std::cout << "Some int variable was set to: " << some_int_variable << std::endl; + std::cout << "Some double variable was set to: " << some_double_variable << std::endl; if ( some_string_variable && strcmp(some_string_variable, "test string with space") == 0) { - kwsys_ios::cout << "Some string variable was set to: " << some_string_variable << kwsys_ios::endl; + std::cout << "Some string variable was set to: " << some_string_variable << std::endl; delete [] some_string_variable; } else { - kwsys_ios::cerr << "Problem setting string variable" << kwsys_ios::endl; + std::cerr << "Problem setting string variable" << std::endl; res = 1; } size_t cc; #define CompareTwoLists(list1, list_valid, lsize) \ if ( list1.size() != lsize ) \ { \ - kwsys_ios::cerr << "Problem setting " #list1 ". Size is: " << list1.size() \ - << " should be: " << lsize << kwsys_ios::endl; \ + std::cerr << "Problem setting " #list1 ". Size is: " << list1.size() \ + << " should be: " << lsize << std::endl; \ res = 1; \ } \ else \ { \ - kwsys_ios::cout << #list1 " argument set:"; \ + std::cout << #list1 " argument set:"; \ for ( cc =0; cc < lsize; ++ cc ) \ { \ - kwsys_ios::cout << " " << list1[cc]; \ + std::cout << " " << list1[cc]; \ if ( !CompareTwoItemsOnList(list1[cc], list_valid[cc]) ) \ { \ - kwsys_ios::cerr << "Problem setting " #list1 ". Value of " \ + std::cerr << "Problem setting " #list1 ". Value of " \ << cc << " is: [" << list1[cc] << "] <> [" \ - << list_valid[cc] << "]" << kwsys_ios::endl; \ + << list_valid[cc] << "]" << std::endl; \ res = 1; \ break; \ } \ } \ - kwsys_ios::cout << kwsys_ios::endl; \ + std::cout << std::endl; \ } CompareTwoLists(numbers_argument, valid_numbers, 10); @@ -171,12 +171,12 @@ int testCommandLineArguments(int argc, char* argv[]) CompareTwoLists(strings_argument, valid_strings, 4); CompareTwoLists(stl_strings_argument, valid_stl_strings, 4); - kwsys_ios::cout << "Some STL String variable was set to: " << some_stl_string_variable << kwsys_ios::endl; - kwsys_ios::cout << "Some bool variable was set to: " << some_bool_variable << kwsys_ios::endl; - kwsys_ios::cout << "Some bool variable was set to: " << some_bool_variable1 << kwsys_ios::endl; - kwsys_ios::cout << "bool_arg1 variable was set to: " << bool_arg1 << kwsys_ios::endl; - kwsys_ios::cout << "bool_arg2 variable was set to: " << bool_arg2 << kwsys_ios::endl; - kwsys_ios::cout << kwsys_ios::endl; + std::cout << "Some STL String variable was set to: " << some_stl_string_variable << std::endl; + std::cout << "Some bool variable was set to: " << some_bool_variable << std::endl; + std::cout << "Some bool variable was set to: " << some_bool_variable1 << std::endl; + std::cout << "bool_arg1 variable was set to: " << bool_arg1 << std::endl; + std::cout << "bool_arg2 variable was set to: " << bool_arg2 << std::endl; + std::cout << std::endl; for ( cc = 0; cc < strings_argument.size(); ++ cc ) { diff --git a/Source/kwsys/testCommandLineArguments1.cxx b/Source/kwsys/testCommandLineArguments1.cxx index b65c37f..6eb465d 100644 --- a/Source/kwsys/testCommandLineArguments1.cxx +++ b/Source/kwsys/testCommandLineArguments1.cxx @@ -11,16 +11,16 @@ ============================================================================*/ #include "kwsysPrivate.h" #include KWSYS_HEADER(CommandLineArguments.hxx) -#include KWSYS_HEADER(ios/iostream) -#include KWSYS_HEADER(stl/vector) // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. #if 0 # include "CommandLineArguments.hxx.in" -# include "kwsys_ios_iostream.h.in" #endif +#include <iostream> +#include <vector> + #include <assert.h> /* assert */ #include <string.h> /* strcmp */ @@ -31,7 +31,7 @@ int testCommandLineArguments1(int argc, char* argv[]) int n = 0; char* m = 0; - kwsys_stl::string p; + std::string p; int res = 0; typedef kwsys::CommandLineArguments argT; @@ -43,27 +43,27 @@ int testCommandLineArguments1(int argc, char* argv[]) if ( !arg.Parse() ) { - kwsys_ios::cerr << "Problem parsing arguments" << kwsys_ios::endl; + std::cerr << "Problem parsing arguments" << std::endl; res = 1; } if ( n != 24 ) { - kwsys_ios::cout << "Problem setting N. Value of N: " << n << kwsys_ios::endl; + std::cout << "Problem setting N. Value of N: " << n << std::endl; res = 1; } if ( !m || strcmp(m, "test value") != 0 ) { - kwsys_ios::cout << "Problem setting M. Value of M: " << m << kwsys_ios::endl; + std::cout << "Problem setting M. Value of M: " << m << std::endl; res = 1; } if ( p != "1" ) { - kwsys_ios::cout << "Problem setting P. Value of P: " << p << kwsys_ios::endl; + std::cout << "Problem setting P. Value of P: " << p << std::endl; res = 1; } - kwsys_ios::cout << "Value of N: " << n << kwsys_ios::endl; - kwsys_ios::cout << "Value of M: " << m << kwsys_ios::endl; - kwsys_ios::cout << "Value of P: " << p << kwsys_ios::endl; + std::cout << "Value of N: " << n << std::endl; + std::cout << "Value of M: " << m << std::endl; + std::cout << "Value of P: " << p << std::endl; if ( m ) { delete [] m; @@ -79,25 +79,25 @@ int testCommandLineArguments1(int argc, char* argv[]) }; if ( newArgc != 9 ) { - kwsys_ios::cerr << "Bad number of unused arguments: " << newArgc << kwsys_ios::endl; + std::cerr << "Bad number of unused arguments: " << newArgc << std::endl; res = 1; } for ( cc = 0; cc < newArgc; ++ cc ) { assert(newArgv[cc]); /* Quiet Clang scan-build. */ - kwsys_ios::cout << "Unused argument[" << cc << "] = [" << newArgv[cc] << "]" - << kwsys_ios::endl; + std::cout << "Unused argument[" << cc << "] = [" << newArgv[cc] << "]" + << std::endl; if ( cc >= 9 ) { - kwsys_ios::cerr << "Too many unused arguments: " << cc << kwsys_ios::endl; + std::cerr << "Too many unused arguments: " << cc << std::endl; res = 1; } else if ( valid_unused_args[cc] && strcmp(valid_unused_args[cc], newArgv[cc]) != 0 ) { - kwsys_ios::cerr << "Bad unused argument [" << cc << "] \"" + std::cerr << "Bad unused argument [" << cc << "] \"" << newArgv[cc] << "\" should be: \"" << valid_unused_args[cc] << "\"" - << kwsys_ios::endl; + << std::endl; res = 1; } } diff --git a/Source/kwsys/testDynamicLoader.cxx b/Source/kwsys/testDynamicLoader.cxx index 58adb84..695a134 100644 --- a/Source/kwsys/testDynamicLoader.cxx +++ b/Source/kwsys/testDynamicLoader.cxx @@ -12,8 +12,6 @@ #include "kwsysPrivate.h" #include KWSYS_HEADER(DynamicLoader.hxx) -#include KWSYS_HEADER(ios/iostream) -#include KWSYS_HEADER(stl/string) #if defined(__BEOS__) || defined(__HAIKU__) #include <be/kernel/OS.h> /* disable_debugger() API. */ @@ -23,18 +21,19 @@ // duplicate the above list of headers. #if 0 # include "DynamicLoader.hxx.in" -# include "kwsys_ios_iostream.h.in" -# include "kwsys_stl_string.hxx.in" #endif +#include <string> +#include <iostream> + // Include with <> instead of "" to avoid getting any in-source copy // left on disk. #include <testSystemTools.h> -static kwsys_stl::string GetLibName(const char* lname) +static std::string GetLibName(const char* lname) { // Construct proper name of lib - kwsys_stl::string slname; + std::string slname; slname = EXECUTABLE_OUTPUT_PATH; #ifdef CMAKE_INTDIR slname += "/"; @@ -56,30 +55,30 @@ static kwsys_stl::string GetLibName(const char* lname) */ int TestDynamicLoader(const char* libname, const char* symbol, int r1, int r2, int r3) { - kwsys_ios::cerr << "Testing: " << libname << kwsys_ios::endl; + std::cerr << "Testing: " << libname << std::endl; kwsys::DynamicLoader::LibraryHandle l = kwsys::DynamicLoader::OpenLibrary(libname); // If result is incompatible with expectation just fails (xor): if( (r1 && !l) || (!r1 && l) ) { - kwsys_ios::cerr - << kwsys::DynamicLoader::LastError() << kwsys_ios::endl; + std::cerr + << kwsys::DynamicLoader::LastError() << std::endl; return 1; } kwsys::DynamicLoader::SymbolPointer f = kwsys::DynamicLoader::GetSymbolAddress(l, symbol); if( (r2 && !f) || (!r2 && f) ) { - kwsys_ios::cerr - << kwsys::DynamicLoader::LastError() << kwsys_ios::endl; + std::cerr + << kwsys::DynamicLoader::LastError() << std::endl; return 1; } #ifndef __APPLE__ int s = kwsys::DynamicLoader::CloseLibrary(l); if( (r3 && !s) || (!r3 && s) ) { - kwsys_ios::cerr - << kwsys::DynamicLoader::LastError() << kwsys_ios::endl; + std::cerr + << kwsys::DynamicLoader::LastError() << std::endl; return 1; } #else @@ -118,7 +117,7 @@ int testDynamicLoader(int argc, char *argv[]) res += TestDynamicLoader("libdl.so", "TestDynamicLoader",1,0,1); #endif // Now try on the generated library - kwsys_stl::string libname = GetLibName(KWSYS_NAMESPACE_STRING "TestDynload"); + std::string libname = GetLibName(KWSYS_NAMESPACE_STRING "TestDynload"); res += TestDynamicLoader(libname.c_str(), "dummy",1,0,1); res += TestDynamicLoader(libname.c_str(), "TestDynamicLoaderSymbolPointer",1,1,1); res += TestDynamicLoader(libname.c_str(), "_TestDynamicLoaderSymbolPointer",1,0,1); diff --git a/Source/kwsys/testEncoding.cxx b/Source/kwsys/testEncoding.cxx index 094588c..842b17d 100644 --- a/Source/kwsys/testEncoding.cxx +++ b/Source/kwsys/testEncoding.cxx @@ -17,8 +17,8 @@ #include KWSYS_HEADER(Encoding.hxx) #include KWSYS_HEADER(Encoding.h) -#include KWSYS_HEADER(ios/iostream) +#include <iostream> #include <locale.h> #include <string.h> #include <stdlib.h> @@ -28,7 +28,6 @@ #if 0 # include "Encoding.hxx.in" # include "Encoding.h.in" -# include "kwsys_ios_iostream.h.in" #endif //---------------------------------------------------------------------------- diff --git a/Source/kwsys/testFStream.cxx b/Source/kwsys/testFStream.cxx index 9abfd4c..ac5220a 100644 --- a/Source/kwsys/testFStream.cxx +++ b/Source/kwsys/testFStream.cxx @@ -16,7 +16,6 @@ #endif #include KWSYS_HEADER(FStream.hxx) -#include KWSYS_HEADER(ios/iostream) #include <string.h> #ifdef __BORLANDC__ # include <mem.h> /* memcmp */ @@ -26,9 +25,9 @@ // duplicate the above list of headers. #if 0 # include "FStream.hxx.in" -# include "kwsys_ios_iostream.h.in" #endif +#include <iostream> //---------------------------------------------------------------------------- static int testNoFile() @@ -95,20 +94,20 @@ static int testBOM() kwsys::FStream::BOM bom = kwsys::FStream::ReadBOM(in); if(bom != expected_bom[i]) { - kwsys_ios::cout << "Unexpected BOM " << i << std::endl; + std::cout << "Unexpected BOM " << i << std::endl; return 1; } char data[45]; in.read(data, file_data[i][0]); if(!in.good()) { - kwsys_ios::cout << "Unable to read data " << i << std::endl; + std::cout << "Unable to read data " << i << std::endl; return 1; } if(memcmp(data, file_data[i]+1, file_data[i][0]) != 0) { - kwsys_ios::cout << "Incorrect read data " << i << std::endl; + std::cout << "Incorrect read data " << i << std::endl; return 1; } @@ -125,20 +124,20 @@ static int testBOM() kwsys::FStream::BOM bom = kwsys::FStream::ReadBOM(in); if(bom != kwsys::FStream::BOM_None) { - kwsys_ios::cout << "Unexpected BOM for none case" << std::endl; + std::cout << "Unexpected BOM for none case" << std::endl; return 1; } char data[45]; in.read(data, file_data[0][0]); if(!in.good()) { - kwsys_ios::cout << "Unable to read data for none case" << std::endl; + std::cout << "Unable to read data for none case" << std::endl; return 1; } if(memcmp(data, file_data[0]+1, file_data[0][0]) != 0) { - kwsys_ios::cout << "Incorrect read data for none case" << std::endl; + std::cout << "Incorrect read data for none case" << std::endl; return 1; } } @@ -156,20 +155,20 @@ static int testBOM() kwsys::FStream::BOM bom = kwsys::FStream::ReadBOM(in); if(bom != kwsys::FStream::BOM_UTF8) { - kwsys_ios::cout << "Unexpected BOM for utf-8 case" << std::endl; + std::cout << "Unexpected BOM for utf-8 case" << std::endl; return 1; } char data[45]; in.read(data, file_data[0][0]); if(!in.good()) { - kwsys_ios::cout << "Unable to read data for utf-8 case" << std::endl; + std::cout << "Unable to read data for utf-8 case" << std::endl; return 1; } if(memcmp(data, file_data[0]+1, file_data[0][0]) != 0) { - kwsys_ios::cout << "Incorrect read data for utf-8 case" << std::endl; + std::cout << "Incorrect read data for utf-8 case" << std::endl; return 1; } } diff --git a/Source/kwsys/testHashSTL.cxx b/Source/kwsys/testHashSTL.cxx index ac5cf74..ab1f83e 100644 --- a/Source/kwsys/testHashSTL.cxx +++ b/Source/kwsys/testHashSTL.cxx @@ -12,7 +12,6 @@ #include "kwsysPrivate.h" #include KWSYS_HEADER(hash_map.hxx) #include KWSYS_HEADER(hash_set.hxx) -#include KWSYS_HEADER(ios/iostream) // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. @@ -20,9 +19,10 @@ # include "hash_map.hxx.in" # include "hash_set.hxx.in" # include "hashtable.hxx.in" -# include "kwsys_ios_iostream.h.in" #endif +#include <iostream> + #if defined(_MSC_VER) # pragma warning (disable:4786) #endif @@ -44,8 +44,8 @@ static bool test_hash_map() int sum = 0; for(mtype::iterator mi = m.begin(); mi != m.end(); ++mi) { - kwsys_ios::cout << "Found entry [" << mi->first << "," << mi->second << "]" - << kwsys_ios::endl; + std::cout << "Found entry [" << mi->first << "," << mi->second << "]" + << std::endl; sum += mi->second; } return sum == 3; @@ -60,7 +60,7 @@ static bool test_hash_set() int sum = 0; for(stype::iterator si = s.begin(); si != s.end(); ++si) { - kwsys_ios::cout << "Found entry [" << *si << "]" << kwsys_ios::endl; + std::cout << "Found entry [" << *si << "]" << std::endl; sum += *si; } return sum == 3; diff --git a/Source/kwsys/testIOS.cxx b/Source/kwsys/testIOS.cxx index f0c7f1a..396a09d 100644 --- a/Source/kwsys/testIOS.cxx +++ b/Source/kwsys/testIOS.cxx @@ -10,158 +10,149 @@ See the License for more information. ============================================================================*/ #include "kwsysPrivate.h" -#include KWSYS_HEADER(stl/vector) -#include KWSYS_HEADER(ios/sstream) -#include KWSYS_HEADER(ios/fstream) -#include KWSYS_HEADER(ios/iostream) - -// Work-around CMake dependency scanning limitation. This must -// duplicate the above list of headers. -#if 0 -# include "kwsys_stl_string.hxx.in" -# include "kwsys_stl_vector.h.in" -# include "kwsys_ios_sstream.h.in" -# include "kwsys_ios_fstream.h.in" -# include "kwsys_ios_iostream.h.in" -#endif +#include KWSYS_HEADER(Configure.hxx) +#include <sstream> +#include <fstream> +#include <iostream> +#include <vector> #include <string.h> /* strlen */ int testIOS(int, char*[]) { - kwsys_ios::ostringstream ostr; + std::ostringstream ostr; const char hello[] = "hello"; ostr << hello; if(ostr.str() != hello) { - kwsys_ios::cerr << "failed to write hello to ostr" << kwsys_ios::endl; + std::cerr << "failed to write hello to ostr" << std::endl; return 1; } const char world[] = "world"; - kwsys_ios::ostringstream ostr2; + std::ostringstream ostr2; ostr2.write( hello, strlen(hello) ); /* I could do sizeof */ ostr2.put( '\0' ); ostr2.write( world, strlen(world) ); if(ostr2.str().size() != strlen(hello) + 1 + strlen(world) ) { - kwsys_ios::cerr << "failed to write hello to ostr2" << kwsys_ios::endl; + std::cerr << "failed to write hello to ostr2" << std::endl; return 1; } static const unsigned char array[] = { 0xff,0x4f,0xff,0x51,0x00,0x29,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x07,0x01,0x01,0xff,0x52,0x00,0x0c,0x00,0x00,0x00,0x01,0x00,0x05,0x04,0x04,0x00,0x01,0xff,0x5c,0x00,0x13,0x40,0x40,0x48,0x48,0x50,0x48,0x48,0x50,0x48,0x48,0x50,0x48,0x48,0x50,0x48,0x48,0x50,0xff,0x64,0x00,0x2c,0x00,0x00,0x43,0x72,0x65,0x61,0x74,0x65,0x64,0x20,0x62,0x79,0x20,0x49,0x54,0x4b,0x2f,0x47,0x44,0x43,0x4d,0x2f,0x4f,0x70,0x65,0x6e,0x4a,0x50,0x45,0x47,0x20,0x76,0x65,0x72,0x73,0x69,0x6f,0x6e,0x20,0x31,0x2e,0x30,0xff,0x90,0x00,0x0a,0x00,0x00,0x00,0x00,0x06,0x2c,0x00,0x01,0xff,0x93,0xcf,0xb0,0x18,0x08,0x7f,0xc6,0x99,0xbf,0xff,0xc0,0xf8,0xc1,0xc1,0xf3,0x05,0x81,0xf2,0x83,0x0a,0xa5,0xff,0x10,0x90,0xbf,0x2f,0xff,0x04,0xa8,0x7f,0xc0,0xf8,0xc4,0xc1,0xf3,0x09,0x81,0xf3,0x0c,0x19,0x34 }; const size_t narray = sizeof(array); // 180 - kwsys_ios::stringstream strstr; + std::stringstream strstr; strstr.write( (char*)array, narray ); //strstr.seekp( narray / 2 ); // set position of put pointer in mid string if(strstr.str().size() != narray ) { - kwsys_ios::cerr << "failed to write array to strstr" << kwsys_ios::endl; + std::cerr << "failed to write array to strstr" << std::endl; return 1; } - kwsys_ios::istringstream istr(" 10 20 str "); - kwsys_stl::string s; + std::istringstream istr(" 10 20 str "); + std::string s; int x; if(istr >> x) { if(x != 10) { - kwsys_ios::cerr << "x != 10" << kwsys_ios::endl; + std::cerr << "x != 10" << std::endl; return 1; } } else { - kwsys_ios::cerr << "Failed to read 10 from istr" << kwsys_ios::endl; + std::cerr << "Failed to read 10 from istr" << std::endl; return 1; } if(istr >> x) { if(x != 20) { - kwsys_ios::cerr << "x != 20" << kwsys_ios::endl; + std::cerr << "x != 20" << std::endl; return 1; } } else { - kwsys_ios::cerr << "Failed to read 20 from istr" << kwsys_ios::endl; + std::cerr << "Failed to read 20 from istr" << std::endl; return 1; } if(istr >> s) { if(s != "str") { - kwsys_ios::cerr << "s != \"str\"" << kwsys_ios::endl; + std::cerr << "s != \"str\"" << std::endl; return 1; } } else { - kwsys_ios::cerr << "Failed to read str from istr" << kwsys_ios::endl; + std::cerr << "Failed to read str from istr" << std::endl; return 1; } if(istr >> s) { - kwsys_ios::cerr << "Able to read past end of stream" << kwsys_ios::endl; + std::cerr << "Able to read past end of stream" << std::endl; return 1; } else { // Clear the failure. - istr.clear(istr.rdstate() & ~kwsys_ios::ios::eofbit); - istr.clear(istr.rdstate() & ~kwsys_ios::ios::failbit); + istr.clear(istr.rdstate() & ~std::ios::eofbit); + istr.clear(istr.rdstate() & ~std::ios::failbit); } istr.str("30"); if(istr >> x) { if(x != 30) { - kwsys_ios::cerr << "x != 30" << kwsys_ios::endl; + std::cerr << "x != 30" << std::endl; return 1; } } else { - kwsys_ios::cerr << "Failed to read 30 from istr" << kwsys_ios::endl; + std::cerr << "Failed to read 30 from istr" << std::endl; return 1; } - kwsys_ios::stringstream sstr; + std::stringstream sstr; sstr << "40 str2"; if(sstr >> x) { if(x != 40) { - kwsys_ios::cerr << "x != 40" << kwsys_ios::endl; + std::cerr << "x != 40" << std::endl; return 1; } } else { - kwsys_ios::cerr << "Failed to read 40 from sstr" << kwsys_ios::endl; + std::cerr << "Failed to read 40 from sstr" << std::endl; return 1; } if(sstr >> s) { if(s != "str2") { - kwsys_ios::cerr << "s != \"str2\"" << kwsys_ios::endl; + std::cerr << "s != \"str2\"" << std::endl; return 1; } } else { - kwsys_ios::cerr << "Failed to read str2 from sstr" << kwsys_ios::endl; + std::cerr << "Failed to read str2 from sstr" << std::endl; return 1; } // Just try to compile this. if(x == 12345) { - kwsys_ios::ifstream fin("/does_not_exist", - kwsys_ios::ios::in | kwsys_ios_binary); + std::ifstream fin("/does_not_exist", + std::ios::in | std::ios::binary); } - kwsys_ios::cout << "IOS tests passed" << kwsys_ios::endl; + std::cout << "IOS tests passed" << std::endl; return 0; } diff --git a/Source/kwsys/testSystemInformation.cxx b/Source/kwsys/testSystemInformation.cxx index fc8ea55..c96751a 100644 --- a/Source/kwsys/testSystemInformation.cxx +++ b/Source/kwsys/testSystemInformation.cxx @@ -11,15 +11,15 @@ ============================================================================*/ #include "kwsysPrivate.h" #include KWSYS_HEADER(SystemInformation.hxx) -#include KWSYS_HEADER(ios/iostream) // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. #if 0 # include "SystemInformation.hxx.in" -# include "kwsys_ios_iostream.h.in" #endif +#include <iostream> + #if defined(KWSYS_USE_LONG_LONG) # if defined(KWSYS_IOS_HAS_OSTREAM_LONG_LONG) # define iostreamLongLong(x) (x) @@ -36,18 +36,18 @@ # error "No Long Long" #endif -#define printMethod(info, m) kwsys_ios::cout << #m << ": " \ +#define printMethod(info, m) std::cout << #m << ": " \ << info.m() << "\n" -#define printMethod2(info, m, unit) kwsys_ios::cout << #m << ": " \ +#define printMethod2(info, m, unit) std::cout << #m << ": " \ << info.m() << " " << unit << "\n" -#define printMethod3(info, m, unit) kwsys_ios::cout << #m << ": " \ +#define printMethod3(info, m, unit) std::cout << #m << ": " \ << iostreamLongLong(info.m) << " " << unit << "\n" int testSystemInformation(int, char*[]) { - kwsys_ios::cout << "CTEST_FULL_OUTPUT\n"; // avoid truncation + std::cout << "CTEST_FULL_OUTPUT\n"; // avoid truncation kwsys::SystemInformation info; info.RunCPUCheck(); @@ -93,16 +93,16 @@ int testSystemInformation(int, char*[]) { if (info.DoesCPUSupportFeature(static_cast<long int>(1) << i)) { - kwsys_ios::cout << "CPU feature " << i << "\n"; + std::cout << "CPU feature " << i << "\n"; } } /* test stack trace */ - kwsys_ios::cout - << "Program Stack:" << kwsys_ios::endl - << kwsys::SystemInformation::GetProgramStack(0,0) << kwsys_ios::endl - << kwsys_ios::endl; + std::cout + << "Program Stack:" << std::endl + << kwsys::SystemInformation::GetProgramStack(0,0) << std::endl + << std::endl; /* test segv handler info.SetStackTraceOnError(1); diff --git a/Source/kwsys/testSystemTools.cxx b/Source/kwsys/testSystemTools.cxx index bc9ca5e..a0f904f 100644 --- a/Source/kwsys/testSystemTools.cxx +++ b/Source/kwsys/testSystemTools.cxx @@ -16,19 +16,19 @@ #endif #include KWSYS_HEADER(SystemTools.hxx) -#include KWSYS_HEADER(ios/iostream) // Work-around CMake dependency scanning limitation. This must // duplicate the above list of headers. #if 0 # include "SystemTools.hxx.in" -# include "kwsys_ios_iostream.h.in" #endif // Include with <> instead of "" to avoid getting any in-source copy // left on disk. #include <testSystemTools.h> +#include <iostream> +#include <sstream> #include <string.h> /* strcmp */ #if defined(_WIN32) && !defined(__CYGWIN__) # include <io.h> /* _umask (MSVC) / umask (Borland) */ @@ -63,17 +63,17 @@ static const char* toUnixPaths[][2] = {0, 0} }; -static bool CheckConvertToUnixSlashes(kwsys_stl::string input, - kwsys_stl::string output) +static bool CheckConvertToUnixSlashes(std::string input, + std::string output) { - kwsys_stl::string result = input; + std::string result = input; kwsys::SystemTools::ConvertToUnixSlashes(result); if ( result != output ) { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToUnixSlashes - input: " << input << " output: " << result << " expected: " << output - << kwsys_ios::endl; + << std::endl; return false; } return true; @@ -87,19 +87,19 @@ static const char* checkEscapeChars[][4] = {0, 0, 0, 0} }; -static bool CheckEscapeChars(kwsys_stl::string input, +static bool CheckEscapeChars(std::string input, const char *chars_to_escape, char escape_char, - kwsys_stl::string output) + std::string output) { - kwsys_stl::string result = kwsys::SystemTools::EscapeChars( + std::string result = kwsys::SystemTools::EscapeChars( input.c_str(), chars_to_escape, escape_char); if (result != output) { - kwsys_ios::cerr + std::cerr << "Problem with CheckEscapeChars - input: " << input << " output: " << result << " expected: " << output - << kwsys_ios::endl; + << std::endl; return false; } return true; @@ -109,75 +109,75 @@ static bool CheckEscapeChars(kwsys_stl::string input, static bool CheckFileOperations() { bool res = true; - const kwsys_stl::string testNonExistingFile(TEST_SYSTEMTOOLS_SOURCE_DIR + const std::string testNonExistingFile(TEST_SYSTEMTOOLS_SOURCE_DIR "/testSystemToolsNonExistingFile"); - const kwsys_stl::string testDotFile(TEST_SYSTEMTOOLS_SOURCE_DIR + const std::string testDotFile(TEST_SYSTEMTOOLS_SOURCE_DIR "/."); - const kwsys_stl::string testBinFile(TEST_SYSTEMTOOLS_SOURCE_DIR + const std::string testBinFile(TEST_SYSTEMTOOLS_SOURCE_DIR "/testSystemTools.bin"); - const kwsys_stl::string testTxtFile(TEST_SYSTEMTOOLS_SOURCE_DIR + const std::string testTxtFile(TEST_SYSTEMTOOLS_SOURCE_DIR "/testSystemTools.cxx"); - const kwsys_stl::string testNewDir(TEST_SYSTEMTOOLS_BINARY_DIR + const std::string testNewDir(TEST_SYSTEMTOOLS_BINARY_DIR "/testSystemToolsNewDir"); - const kwsys_stl::string testNewFile(testNewDir + "/testNewFile.txt"); + const std::string testNewFile(testNewDir + "/testNewFile.txt"); if (kwsys::SystemTools::DetectFileType(testNonExistingFile.c_str()) != kwsys::SystemTools::FileTypeUnknown) { - kwsys_ios::cerr + std::cerr << "Problem with DetectFileType - failed to detect type of: " - << testNonExistingFile << kwsys_ios::endl; + << testNonExistingFile << std::endl; res = false; } if (kwsys::SystemTools::DetectFileType(testDotFile.c_str()) != kwsys::SystemTools::FileTypeUnknown) { - kwsys_ios::cerr + std::cerr << "Problem with DetectFileType - failed to detect type of: " - << testDotFile << kwsys_ios::endl; + << testDotFile << std::endl; res = false; } if (kwsys::SystemTools::DetectFileType(testBinFile.c_str()) != kwsys::SystemTools::FileTypeBinary) { - kwsys_ios::cerr + std::cerr << "Problem with DetectFileType - failed to detect type of: " - << testBinFile << kwsys_ios::endl; + << testBinFile << std::endl; res = false; } if (kwsys::SystemTools::DetectFileType(testTxtFile.c_str()) != kwsys::SystemTools::FileTypeText) { - kwsys_ios::cerr + std::cerr << "Problem with DetectFileType - failed to detect type of: " - << testTxtFile << kwsys_ios::endl; + << testTxtFile << std::endl; res = false; } if (kwsys::SystemTools::FileLength(testBinFile) != 766) { - kwsys_ios::cerr + std::cerr << "Problem with FileLength - incorrect length for: " - << testBinFile << kwsys_ios::endl; + << testBinFile << std::endl; res = false; } if (!kwsys::SystemTools::MakeDirectory(testNewDir)) { - kwsys_ios::cerr + std::cerr << "Problem with MakeDirectory for: " - << testNewDir << kwsys_ios::endl; + << testNewDir << std::endl; res = false; } if (!kwsys::SystemTools::Touch(testNewFile.c_str(), true)) { - kwsys_ios::cerr + std::cerr << "Problem with Touch for: " - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } @@ -195,34 +195,34 @@ static bool CheckFileOperations() mode_t origPerm, thisPerm; if (!kwsys::SystemTools::GetPermissions(testNewFile, origPerm)) { - kwsys_ios::cerr + std::cerr << "Problem with GetPermissions (1) for: " - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } if (!kwsys::SystemTools::SetPermissions(testNewFile, 0)) { - kwsys_ios::cerr + std::cerr << "Problem with SetPermissions (1) for: " - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } if (!kwsys::SystemTools::GetPermissions(testNewFile, thisPerm)) { - kwsys_ios::cerr + std::cerr << "Problem with GetPermissions (2) for: " - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } if ((thisPerm & fullMask) != 0) { - kwsys_ios::cerr + std::cerr << "SetPermissions failed to set permissions (1) for: " << testNewFile << ": actual = " << thisPerm << "; expected = " - << 0 << kwsys_ios::endl; + << 0 << std::endl; res = false; } @@ -230,70 +230,70 @@ static bool CheckFileOperations() if (kwsys::SystemTools::TestFileAccess(testNewFile, kwsys::TEST_FILE_WRITE)) { - kwsys_ios::cerr + std::cerr << "TestFileAccess incorrectly indicated that this is a writable file:" - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } if (!kwsys::SystemTools::TestFileAccess(testNewFile, kwsys::TEST_FILE_OK)) { - kwsys_ios::cerr + std::cerr << "TestFileAccess incorrectly indicated that this file does not exist:" - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } // Test restoring/setting full permissions. if (!kwsys::SystemTools::SetPermissions(testNewFile, fullMask)) { - kwsys_ios::cerr + std::cerr << "Problem with SetPermissions (2) for: " - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } if (!kwsys::SystemTools::GetPermissions(testNewFile, thisPerm)) { - kwsys_ios::cerr + std::cerr << "Problem with GetPermissions (3) for: " - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } if ((thisPerm & fullMask) != fullMask) { - kwsys_ios::cerr + std::cerr << "SetPermissions failed to set permissions (2) for: " << testNewFile << ": actual = " << thisPerm << "; expected = " - << fullMask << kwsys_ios::endl; + << fullMask << std::endl; res = false; } // Test setting file permissions while honoring umask if (!kwsys::SystemTools::SetPermissions(testNewFile, fullMask, true)) { - kwsys_ios::cerr + std::cerr << "Problem with SetPermissions (3) for: " - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } if (!kwsys::SystemTools::GetPermissions(testNewFile, thisPerm)) { - kwsys_ios::cerr + std::cerr << "Problem with GetPermissions (4) for: " - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } if ((thisPerm & fullMask) != 0) { - kwsys_ios::cerr + std::cerr << "SetPermissions failed to honor umask for: " << testNewFile << ": actual = " << thisPerm << "; expected = " - << 0 << kwsys_ios::endl; + << 0 << std::endl; res = false; } @@ -303,35 +303,35 @@ static bool CheckFileOperations() // Restore file permissions if (!kwsys::SystemTools::SetPermissions(testNewFile, origPerm)) { - kwsys_ios::cerr + std::cerr << "Problem with SetPermissions (4) for: " - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } // Remove the test file if (!kwsys::SystemTools::RemoveFile(testNewFile)) { - kwsys_ios::cerr + std::cerr << "Problem with RemoveFile: " - << testNewFile << kwsys_ios::endl; + << testNewFile << std::endl; res = false; } - kwsys_stl::string const testFileMissing(testNewDir + "/testMissingFile.txt"); + std::string const testFileMissing(testNewDir + "/testMissingFile.txt"); if (!kwsys::SystemTools::RemoveFile(testFileMissing)) { std::string const& msg = kwsys::SystemTools::GetLastSystemError(); - kwsys_ios::cerr << + std::cerr << "RemoveFile(\"" << testFileMissing << "\") failed: " << msg << "\n"; res = false; } - kwsys_stl::string const testFileMissingDir(testNewDir + "/missing/file.txt"); + std::string const testFileMissingDir(testNewDir + "/missing/file.txt"); if (!kwsys::SystemTools::RemoveFile(testFileMissingDir)) { std::string const& msg = kwsys::SystemTools::GetLastSystemError(); - kwsys_ios::cerr << + std::cerr << "RemoveFile(\"" << testFileMissingDir << "\") failed: " << msg << "\n"; res = false; } @@ -339,9 +339,9 @@ static bool CheckFileOperations() kwsys::SystemTools::Touch(testNewFile.c_str(), true); if (!kwsys::SystemTools::RemoveADirectory(testNewDir)) { - kwsys_ios::cerr + std::cerr << "Problem with RemoveADirectory for: " - << testNewDir << kwsys_ios::endl; + << testNewDir << std::endl; res = false; } @@ -349,14 +349,14 @@ static bool CheckFileOperations() // Perform the same file and directory creation and deletion tests but // with paths > 256 characters in length. - const kwsys_stl::string testNewLongDir( + const std::string testNewLongDir( TEST_SYSTEMTOOLS_BINARY_DIR "/" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" "01234567890123"); - const kwsys_stl::string testNewLongFile(testNewLongDir + "/" + const std::string testNewLongFile(testNewLongDir + "/" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" @@ -365,34 +365,34 @@ static bool CheckFileOperations() if (!kwsys::SystemTools::MakeDirectory(testNewLongDir)) { - kwsys_ios::cerr + std::cerr << "Problem with MakeDirectory for: " - << testNewLongDir << kwsys_ios::endl; + << testNewLongDir << std::endl; res = false; } if (!kwsys::SystemTools::Touch(testNewLongFile.c_str(), true)) { - kwsys_ios::cerr + std::cerr << "Problem with Touch for: " - << testNewLongFile << kwsys_ios::endl; + << testNewLongFile << std::endl; res = false; } if (!kwsys::SystemTools::RemoveFile(testNewLongFile)) { - kwsys_ios::cerr + std::cerr << "Problem with RemoveFile: " - << testNewLongFile << kwsys_ios::endl; + << testNewLongFile << std::endl; res = false; } kwsys::SystemTools::Touch(testNewLongFile.c_str(), true); if (!kwsys::SystemTools::RemoveADirectory(testNewLongDir)) { - kwsys_ios::cerr + std::cerr << "Problem with RemoveADirectory for: " - << testNewLongDir << kwsys_ios::endl; + << testNewLongDir << std::endl; res = false; } #endif @@ -405,12 +405,12 @@ static bool CheckStringOperations() { bool res = true; - kwsys_stl::string test = "mary had a little lamb."; + std::string test = "mary had a little lamb."; if (kwsys::SystemTools::CapitalizedWords(test) != "Mary Had A Little Lamb.") { - kwsys_ios::cerr + std::cerr << "Problem with CapitalizedWords " - << '"' << test << '"' << kwsys_ios::endl; + << '"' << test << '"' << std::endl; res = false; } @@ -418,9 +418,9 @@ static bool CheckStringOperations() if (kwsys::SystemTools::UnCapitalizedWords(test) != "mary had a little lamb.") { - kwsys_ios::cerr + std::cerr << "Problem with UnCapitalizedWords " - << '"' << test << '"' << kwsys_ios::endl; + << '"' << test << '"' << std::endl; res = false; } @@ -428,9 +428,9 @@ static bool CheckStringOperations() if (kwsys::SystemTools::AddSpaceBetweenCapitalizedWords(test) != "Mary Had The Little Lamb.") { - kwsys_ios::cerr + std::cerr << "Problem with AddSpaceBetweenCapitalizedWords " - << '"' << test << '"' << kwsys_ios::endl; + << '"' << test << '"' << std::endl; res = false; } @@ -438,9 +438,9 @@ static bool CheckStringOperations() kwsys::SystemTools::AppendStrings("Mary Had A"," Little Lamb."); if (strcmp(cres,"Mary Had A Little Lamb.")) { - kwsys_ios::cerr + std::cerr << "Problem with AppendStrings " - << "\"Mary Had A\" \" Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had A\" \" Little Lamb.\"" << std::endl; res = false; } delete [] cres; @@ -449,18 +449,18 @@ static bool CheckStringOperations() kwsys::SystemTools::AppendStrings("Mary Had"," A ","Little Lamb."); if (strcmp(cres,"Mary Had A Little Lamb.")) { - kwsys_ios::cerr + std::cerr << "Problem with AppendStrings " - << "\"Mary Had\" \" A \" \"Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had\" \" A \" \"Little Lamb.\"" << std::endl; res = false; } delete [] cres; if (kwsys::SystemTools::CountChar("Mary Had A Little Lamb.",'a') != 3) { - kwsys_ios::cerr + std::cerr << "Problem with CountChar " - << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had A Little Lamb.\"" << std::endl; res = false; } @@ -468,9 +468,9 @@ static bool CheckStringOperations() kwsys::SystemTools::RemoveChars("Mary Had A Little Lamb.","aeiou"); if (strcmp(cres,"Mry Hd A Lttl Lmb.")) { - kwsys_ios::cerr + std::cerr << "Problem with RemoveChars " - << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had A Little Lamb.\"" << std::endl; res = false; } delete [] cres; @@ -479,9 +479,9 @@ static bool CheckStringOperations() kwsys::SystemTools::RemoveCharsButUpperHex("Mary Had A Little Lamb."); if (strcmp(cres,"A")) { - kwsys_ios::cerr + std::cerr << "Problem with RemoveCharsButUpperHex " - << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had A Little Lamb.\"" << std::endl; res = false; } delete [] cres; @@ -491,9 +491,9 @@ static bool CheckStringOperations() kwsys::SystemTools::ReplaceChars(cres2,"aeiou",'X'); if (strcmp(cres2,"MXry HXd A LXttlX LXmb.")) { - kwsys_ios::cerr + std::cerr << "Problem with ReplaceChars " - << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had A Little Lamb.\"" << std::endl; res = false; } delete [] cres2; @@ -501,27 +501,27 @@ static bool CheckStringOperations() if (!kwsys::SystemTools::StringStartsWith("Mary Had A Little Lamb.", "Mary ")) { - kwsys_ios::cerr + std::cerr << "Problem with StringStartsWith " - << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had A Little Lamb.\"" << std::endl; res = false; } if (!kwsys::SystemTools::StringEndsWith("Mary Had A Little Lamb.", " Lamb.")) { - kwsys_ios::cerr + std::cerr << "Problem with StringEndsWith " - << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had A Little Lamb.\"" << std::endl; res = false; } cres = kwsys::SystemTools::DuplicateString("Mary Had A Little Lamb."); if (strcmp(cres,"Mary Had A Little Lamb.")) { - kwsys_ios::cerr + std::cerr << "Problem with DuplicateString " - << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had A Little Lamb.\"" << std::endl; res = false; } delete [] cres; @@ -530,20 +530,20 @@ static bool CheckStringOperations() if (kwsys::SystemTools::CropString(test,13) != "Mary ...Lamb.") { - kwsys_ios::cerr + std::cerr << "Problem with CropString " - << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had A Little Lamb.\"" << std::endl; res = false; } - kwsys_stl::vector<kwsys_stl::string> lines; + std::vector<std::string> lines; kwsys::SystemTools::Split("Mary Had A Little Lamb.",lines,' '); if (lines[0] != "Mary" || lines[1] != "Had" || lines[2] != "A" || lines[3] != "Little" || lines[4] != "Lamb.") { - kwsys_ios::cerr + std::cerr << "Problem with Split " - << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl; + << "\"Mary Had A Little Lamb.\"" << std::endl; res = false; } @@ -552,10 +552,10 @@ static bool CheckStringOperations() ("L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") != L"\\\\?\\L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsExtendedPath " << "\"L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo\"" - << kwsys_ios::endl; + << std::endl; res = false; } @@ -563,10 +563,10 @@ static bool CheckStringOperations() ("L:/Local Mojo/Hex Power Pack/Iffy Voodoo") != L"\\\\?\\L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsExtendedPath " << "\"L:/Local Mojo/Hex Power Pack/Iffy Voodoo\"" - << kwsys_ios::endl; + << std::endl; res = false; } @@ -574,10 +574,10 @@ static bool CheckStringOperations() ("\\\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") != L"\\\\?\\UNC\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsExtendedPath " << "\"\\\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo\"" - << kwsys_ios::endl; + << std::endl; res = false; } @@ -585,70 +585,70 @@ static bool CheckStringOperations() ("//Foo/Local Mojo/Hex Power Pack/Iffy Voodoo") != L"\\\\?\\UNC\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsExtendedPath " << "\"//Foo/Local Mojo/Hex Power Pack/Iffy Voodoo\"" - << kwsys_ios::endl; + << std::endl; res = false; } if (kwsys::SystemTools::ConvertToWindowsExtendedPath("//") != L"//") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsExtendedPath " << "\"//\"" - << kwsys_ios::endl; + << std::endl; res = false; } if (kwsys::SystemTools::ConvertToWindowsExtendedPath("\\\\.\\") != L"\\\\.\\") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsExtendedPath " << "\"\\\\.\\\"" - << kwsys_ios::endl; + << std::endl; res = false; } if (kwsys::SystemTools::ConvertToWindowsExtendedPath("\\\\.\\X") != L"\\\\.\\X") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsExtendedPath " << "\"\\\\.\\X\"" - << kwsys_ios::endl; + << std::endl; res = false; } if (kwsys::SystemTools::ConvertToWindowsExtendedPath("\\\\.\\X:") != L"\\\\?\\X:") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsExtendedPath " << "\"\\\\.\\X:\"" - << kwsys_ios::endl; + << std::endl; res = false; } if (kwsys::SystemTools::ConvertToWindowsExtendedPath("\\\\.\\X:\\") != L"\\\\?\\X:\\") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsExtendedPath " << "\"\\\\.\\X:\\\"" - << kwsys_ios::endl; + << std::endl; res = false; } if (kwsys::SystemTools::ConvertToWindowsExtendedPath("NUL") != L"\\\\.\\NUL") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsExtendedPath " << "\"NUL\"" - << kwsys_ios::endl; + << std::endl; res = false; } @@ -658,10 +658,10 @@ static bool CheckStringOperations() ("L://Local Mojo/Hex Power Pack/Iffy Voodoo") != "\"L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo\"") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsOutputPath " << "\"L://Local Mojo/Hex Power Pack/Iffy Voodoo\"" - << kwsys_ios::endl; + << std::endl; res = false; } @@ -669,10 +669,10 @@ static bool CheckStringOperations() ("//grayson/Local Mojo/Hex Power Pack/Iffy Voodoo") != "\"\\\\grayson\\Local Mojo\\Hex Power Pack\\Iffy Voodoo\"") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToWindowsOutputPath " << "\"//grayson/Local Mojo/Hex Power Pack/Iffy Voodoo\"" - << kwsys_ios::endl; + << std::endl; res = false; } @@ -680,10 +680,10 @@ static bool CheckStringOperations() ("//Local Mojo/Hex Power Pack/Iffy Voodoo") != "//Local\\ Mojo/Hex\\ Power\\ Pack/Iffy\\ Voodoo") { - kwsys_ios::cerr + std::cerr << "Problem with ConvertToUnixOutputPath " << "\"//Local Mojo/Hex Power Pack/Iffy Voodoo\"" - << kwsys_ios::endl; + << std::endl; res = false; } @@ -692,20 +692,20 @@ static bool CheckStringOperations() //---------------------------------------------------------------------------- -static bool CheckPutEnv(const kwsys_stl::string& env, const char* name, const char* value) +static bool CheckPutEnv(const std::string& env, const char* name, const char* value) { if(!kwsys::SystemTools::PutEnv(env)) { - kwsys_ios::cerr << "PutEnv(\"" << env - << "\") failed!" << kwsys_ios::endl; + std::cerr << "PutEnv(\"" << env + << "\") failed!" << std::endl; return false; } const char* v = kwsys::SystemTools::GetEnv(name); v = v? v : "(null)"; if(strcmp(v, value) != 0) { - kwsys_ios::cerr << "GetEnv(\"" << name << "\") returned \"" - << v << "\", not \"" << value << "\"!" << kwsys_ios::endl; + std::cerr << "GetEnv(\"" << name << "\") returned \"" + << v << "\", not \"" << value << "\"!" << std::endl; return false; } return true; @@ -715,14 +715,14 @@ static bool CheckUnPutEnv(const char* env, const char* name) { if(!kwsys::SystemTools::UnPutEnv(env)) { - kwsys_ios::cerr << "UnPutEnv(\"" << env << "\") failed!" - << kwsys_ios::endl; + std::cerr << "UnPutEnv(\"" << env << "\") failed!" + << std::endl; return false; } if(const char* v = kwsys::SystemTools::GetEnv(name)) { - kwsys_ios::cerr << "GetEnv(\"" << name << "\") returned \"" - << v << "\", not (null)!" << kwsys_ios::endl; + std::cerr << "GetEnv(\"" << name << "\") returned \"" + << v << "\", not (null)!" << std::endl; return false; } return true; @@ -744,15 +744,15 @@ static bool CheckEnvironmentOperations() static bool CheckRelativePath( - const kwsys_stl::string& local, - const kwsys_stl::string& remote, - const kwsys_stl::string& expected) + const std::string& local, + const std::string& remote, + const std::string& expected) { - kwsys_stl::string result = kwsys::SystemTools::RelativePath(local, remote); + std::string result = kwsys::SystemTools::RelativePath(local, remote); if(expected != result) { - kwsys_ios::cerr << "RelativePath(" << local << ", " << remote - << ") yielded " << result << " instead of " << expected << kwsys_ios::endl; + std::cerr << "RelativePath(" << local << ", " << remote + << ") yielded " << result << " instead of " << expected << std::endl; return false; } return true; @@ -770,14 +770,14 @@ static bool CheckRelativePaths() } static bool CheckCollapsePath( - const kwsys_stl::string& path, - const kwsys_stl::string& expected) + const std::string& path, + const std::string& expected) { - kwsys_stl::string result = kwsys::SystemTools::CollapseFullPath(path); + std::string result = kwsys::SystemTools::CollapseFullPath(path); if(expected != result) { - kwsys_ios::cerr << "CollapseFullPath(" << path - << ") yielded " << result << " instead of " << expected << kwsys_ios::endl; + std::cerr << "CollapseFullPath(" << path + << ") yielded " << result << " instead of " << expected << std::endl; return false; } return true; @@ -791,6 +791,66 @@ static bool CheckCollapsePath() return res; } +static std::string StringVectorToString(const std::vector<std::string>& vec) +{ + std::stringstream ss; + ss << "vector("; + for (std::vector<std::string>::const_iterator i = vec.begin(); + i != vec.end(); ++i) + { + if (i != vec.begin()) + { + ss << ", "; + } + ss << *i; + } + ss << ")"; + return ss.str(); +} + +static bool CheckGetPath() +{ + const char* envName = "S"; +#ifdef _WIN32 + const char* envValue = "C:\\Somewhere\\something;D:\\Temp"; +#else + const char* envValue = "/Somewhere/something:/tmp"; +#endif + const char* registryPath = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MyApp; MyKey]"; + + std::vector<std::string> originalPathes; + originalPathes.push_back(registryPath); + + std::vector<std::string> expectedPathes; + expectedPathes.push_back(registryPath); +#ifdef _WIN32 + expectedPathes.push_back("C:/Somewhere/something"); + expectedPathes.push_back("D:/Temp"); +#else + expectedPathes.push_back("/Somewhere/something"); + expectedPathes.push_back("/tmp"); +#endif + + bool res = true; + res &= CheckPutEnv(std::string(envName) + "=" + envValue, envName, envValue); + + std::vector<std::string> pathes = originalPathes; + kwsys::SystemTools::GetPath(pathes, envName); + + if (pathes != expectedPathes) + { + std::cerr << + "GetPath(" << StringVectorToString(originalPathes) << + ", " << envName << ") yielded " << StringVectorToString(pathes) << + " instead of " << StringVectorToString(expectedPathes) << + std::endl; + res = false; + } + + res &= CheckUnPutEnv(envName, envName); + return res; +} + //---------------------------------------------------------------------------- int testSystemTools(int, char*[]) { @@ -803,7 +863,7 @@ int testSystemTools(int, char*[]) } // Special check for ~ - kwsys_stl::string output; + std::string output; if(kwsys::SystemTools::GetEnv("HOME", output)) { output += "/foo bar/lala"; @@ -826,5 +886,7 @@ int testSystemTools(int, char*[]) res &= CheckCollapsePath(); + res &= CheckGetPath(); + return res ? 0 : 1; } diff --git a/Templates/CPack.GenericDescription.txt b/Templates/CPack.GenericDescription.txt index 9ca1802..712ee14 100644 --- a/Templates/CPack.GenericDescription.txt +++ b/Templates/CPack.GenericDescription.txt @@ -1,5 +1,5 @@ DESCRIPTION =========== -This is an installer created using CPack (http://www.cmake.org). No additional installation instructions provided. +This is an installer created using CPack (https://cmake.org). No additional installation instructions provided. diff --git a/Templates/CPack.GenericLicense.txt b/Templates/CPack.GenericLicense.txt index c211bb3..09c6218 100644 --- a/Templates/CPack.GenericLicense.txt +++ b/Templates/CPack.GenericLicense.txt @@ -1,5 +1,5 @@ LICENSE ======= -This is an installer created using CPack (http://www.cmake.org). No license provided. +This is an installer created using CPack (https://cmake.org). No license provided. diff --git a/Templates/Windows/SmallLogo44x44.png b/Templates/Windows/SmallLogo44x44.png Binary files differnew file mode 100644 index 0000000..28810b7 --- /dev/null +++ b/Templates/Windows/SmallLogo44x44.png diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index 801d7e8..ae61bca 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -213,6 +213,29 @@ if(BUILD_TESTING) set(CMake_TEST_XCODE_VERSION "${CMAKE_MATCH_1}") endif() endif() + if(CMAKE_OSX_SYSROOT) + execute_process( + COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version ProductName + OUTPUT_VARIABLE _stdout + OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_VARIABLE _stderr + RESULT_VARIABLE _failed + ) + if(NOT _failed) + set(CMAKE_OSX_SDKPRODUCT "${_stdout}") + endif() + + execute_process( + COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version SDKVersion + OUTPUT_VARIABLE _stdout + OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_VARIABLE _stderr + RESULT_VARIABLE _failed + ) + if(NOT _failed) + set(CMAKE_OSX_SDKVERSION "${_stdout}") + endif() + endif() endif() # Use 1500 or CTEST_TEST_TIMEOUT for long test timeout value, @@ -253,15 +276,20 @@ if(BUILD_TESTING) if(TEST_RESOURCES) ADD_TEST_MACRO(VSResource VSResource) endif() + ADD_TEST_MACRO(MSManifest MSManifest) ADD_TEST_MACRO(Simple Simple) ADD_TEST_MACRO(PreOrder PreOrder) ADD_TEST_MACRO(MissingSourceFile MissingSourceFile) set_tests_properties(MissingSourceFile PROPERTIES PASS_REGULAR_EXPRESSION "CMake Error at CMakeLists.txt:3 \\(add_executable\\):[ \r\n]*Cannot find source file:[ \r\n]*DoesNotExist/MissingSourceFile.c") - if(CMake_TEST_XCODE_VERSION AND NOT CMake_TEST_XCODE_VERSION VERSION_LESS 6.1) - if(CMAKE_GENERATOR STREQUAL "Xcode") - ADD_TEST_MACRO(SwiftMix SwiftMix) - ADD_TEST_MACRO(SwiftOnly SwiftOnly) + if(CMake_TEST_XCODE_VERSION AND CMAKE_OSX_SDKVERSION AND CMAKE_OSX_SDKPRODUCT) + if((NOT CMake_TEST_XCODE_VERSION VERSION_LESS 6.1) AND + ((NOT CMAKE_OSX_SDKPRODUCT STREQUAL "Mac OS X") OR + (NOT CMAKE_OSX_SDKVERSION VERSION_LESS 10.10))) + if(CMAKE_GENERATOR STREQUAL "Xcode") + ADD_TEST_MACRO(SwiftMix SwiftMix) + ADD_TEST_MACRO(SwiftOnly SwiftOnly) + endif() endif() endif() if(CMAKE_Fortran_COMPILER) @@ -659,12 +687,12 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release if(CMAKE_BUILD_NIGHTLY_RELEASES) ADD_NIGHTLY_BUILD_TEST(CMakeNightlyWindows dash2win64_release.cmake) - ADD_NIGHTLY_BUILD_TEST(CMakeNightlyMac - dashmacmini2_release.cmake) - ADD_NIGHTLY_BUILD_TEST(CMakeNightlyMac64 + ADD_NIGHTLY_BUILD_TEST(CMakeNightlyOSX dashmacmini5_release.cmake) - ADD_NIGHTLY_BUILD_TEST(CMakeNightlyLinux + ADD_NIGHTLY_BUILD_TEST(CMakeNightlyLinux32 magrathea_release.cmake) + ADD_NIGHTLY_BUILD_TEST(CMakeNightlyLinux64 + linux64_release.cmake) endif() # add tests with more complex invocations @@ -1337,6 +1365,8 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release add_subdirectory(FindOpenSSL) endif() + add_subdirectory(FindThreads) + # Matlab module if(CMake_TEST_FindMatlab) ADD_TEST_MACRO(FindMatlab.basic_checks ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>) @@ -1925,13 +1955,15 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release set(reg_vs10 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0;InstallDir]") set(reg_vs11 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\11.0;InstallDir]") set(reg_vs12 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\12.0;InstallDir]") + set(reg_vs14 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots;KitsRoot10]") set(reg_ws80 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v8.0;InstallationFolder]") set(reg_ws81 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v8.1;InstallationFolder]") + set(reg_ws10_0 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\14.0\\Setup\\Build Tools for Windows 10;srcPath]") set(reg_wp80 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\WindowsPhone\\v8.0;InstallationFolder]") set(reg_wp81 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\WindowsPhone\\v8.1;InstallationFolder]") select_wince_sdk(reg_wince wince_sdk) set(reg_tegra "[HKEY_LOCAL_MACHINE\\SOFTWARE\\NVIDIA Corporation\\Nsight Tegra;sdkRoot]") - foreach(reg vs10 vs11 vs12 ws80 ws81 wp80 wp81 wince tegra) + foreach(reg vs10 vs11 vs12 vs14 ws80 ws81 ws10_0 wp80 wp81 wince tegra) get_filename_component(r "${reg_${reg}}" ABSOLUTE) if(IS_DIRECTORY "${r}") set(${reg} 1) @@ -1978,6 +2010,11 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release -DCMAKE_SYSTEM_VERSION=8.1 ) endif() + if(vs14 AND ws10_0) + add_test_VSWinStorePhone(vs14-store10_0-X86 "Visual Studio 14 2015" WindowsStore 10.0) + add_test_VSWinStorePhone(vs14-store10_0-ARM "Visual Studio 14 2015 ARM" WindowsStore 10.0) + add_test_VSWinStorePhone(vs14-store10_0-X64 "Visual Studio 14 2015 Win64" WindowsStore 10.0) + endif() if(vs11 AND wp80) add_test_VSWinStorePhone(vs11-phone80-X86 "Visual Studio 11 2012" WindowsPhone 8.0) add_test_VSWinStorePhone(vs11-phone80-ARM "Visual Studio 11 2012 ARM" WindowsPhone 8.0) @@ -2550,8 +2587,9 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release "${CMake_BINARY_DIR}/Testing/DelphiCoverage/DartConfiguration.tcl") file(COPY "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/src" DESTINATION "${CMake_BINARY_DIR}/Testing/DelphiCoverage") - file(COPY "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/UTCovTest(UTCovTest.pas).html" - DESTINATION "${CMake_BINARY_DIR}/Testing/DelphiCoverage") + configure_file( + "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/UTCovTest(UTCovTest.pas).html.in" + "${CMake_BINARY_DIR}/Testing/DelphiCoverage/UTCovTest(UTCovTest.pas).html") add_test(NAME CTestDelphiCoverage COMMAND cmake -E chdir ${CMake_BINARY_DIR}/Testing/DelphiCoverage diff --git a/Tests/CMakeTests/ImplicitLinkInfoTest.cmake.in b/Tests/CMakeTests/ImplicitLinkInfoTest.cmake.in index 055b183..da614e9 100644 --- a/Tests/CMakeTests/ImplicitLinkInfoTest.cmake.in +++ b/Tests/CMakeTests/ImplicitLinkInfoTest.cmake.in @@ -105,6 +105,13 @@ set(linux64_test2_libs "c;/opt/sun/sunstudio12/prod/lib/amd64/libc_supp.a") set(linux64_test2_dirs "/opt/sun/sunstudio12/prod/lib/amd64;/lib64;/usr/lib64") list(APPEND platforms linux64_test2) +# -specs=redhat-hardened-ld +set(linux64_test3_text "COLLECT_GCC_OPTIONS='-specs=/usr/lib/rpm/redhat/redhat-hardened-ld' '-v' '-O2' '-g' '-pipe' '-Wall' '-Werror=format-security' '-fexceptions' '-fstack-protector-strong' '--param' 'ssp-buffer-size=4' '-grecord-gcc-switches' '-specs=/usr/lib/rpm/redhat/redhat-hardened-cc1' '-m64' '-mtune=generic' '-I' '/usr/lib64/gfortran/modules' '-o' 'a.out' '-rdynamic' '-shared-libgcc' '-march=x86-64' '-pie' + /usr/libexec/gcc/x86_64-redhat-linux/5.1.1/collect2 -plugin /usr/libexec/gcc/x86_64-redhat-linux/5.1.1/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/5.1.1/lto-wrapper -plugin-opt=-fresolution=/tmp/ccNzxFD8.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lquadmath -plugin-opt=-pass-through=-lm -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -z now -pie -o a.out /usr/lib/gcc/x86_64-redhat-linux/5.1.1/../../../../lib64/Scrt1.o /usr/lib/gcc/x86_64-redhat-linux/5.1.1/../../../../lib64/crti.o /usr/lib/gcc/x86_64-redhat-linux/5.1.1/crtbeginS.o -L/usr/lib/gcc/x86_64-redhat-linux/5.1.1 -L/usr/lib/gcc/x86_64-redhat-linux/5.1.1/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/usr/lib/gcc/x86_64-redhat-linux/5.1.1/../../.. -z relro dummy.o -lgfortran -lm -lgcc_s -lgcc -lquadmath -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-redhat-linux/5.1.1/crtendS.o /usr/lib/gcc/x86_64-redhat-linux/5.1.1/../../../../lib64/crtn.o") +set(linux64_test3_libs "gfortran;m;quadmath;m;c") +set(linux64_test3_dirs "/usr/lib/gcc/x86_64-redhat-linux/5.1.1;/usr/lib64;/lib64;/usr/lib") +list(APPEND platforms linux64_test3) + #----------------------------------------------------------------------------- # Mac diff --git a/Tests/CPackComponents/CMakeLists.txt b/Tests/CPackComponents/CMakeLists.txt index 1cb8669..3c8ae35 100644 --- a/Tests/CPackComponents/CMakeLists.txt +++ b/Tests/CPackComponents/CMakeLists.txt @@ -72,7 +72,7 @@ set(CPACK_PACKAGE_INSTALL_DIRECTORY "CPack Component Example") set(CPACK_NSIS_MENU_LINKS "ftp://ftpserver" "Test Ftp Link" "ftps://ftpsserver" "Test Ftps Link" - "http://www.cmake.org" "CMake Web Site" + "https://cmake.org" "CMake Web Site" "https://github.com/" "Test Https Link" "mailto:kitware@kitware.com" "Test MailTo Link" "news://newsserver" "Test News Link" diff --git a/Tests/CPackComponentsDEB/CMakeLists.txt b/Tests/CPackComponentsDEB/CMakeLists.txt index 5c4eeab..093b23f 100644 --- a/Tests/CPackComponentsDEB/CMakeLists.txt +++ b/Tests/CPackComponentsDEB/CMakeLists.txt @@ -80,6 +80,43 @@ set(CPACK_COMPONENT_HEADERS_DESCRIPTION # depend on the libraries component. set(CPACK_COMPONENT_HEADERS_DEPENDS libraries) +# creates preinst/prerm scripts with specific permissions. Those permissions +# (especially executable) should be in the final archive +find_program(CHMOD_PROG chmod) +if(CHMOD_PROG) + file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/preinst "echo default_preinst") + file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/prerm "echo default_prerm") + + # Those should have 755 permission normally. We mess it up to see if + # CPACK_DEBIAN_APPLICATIONS_PACKAGE_CONTROL_STRICT_PERMISSION is able to fix + # it. + execute_process(COMMAND ${CHMOD_PROG} 640 ${CMAKE_CURRENT_BINARY_DIR}/preinst) + execute_process(COMMAND ${CHMOD_PROG} 640 ${CMAKE_CURRENT_BINARY_DIR}/prerm) + + set(CPACK_DEBIAN_APPLICATIONS_PACKAGE_CONTROL_EXTRA + "${CMAKE_CURRENT_BINARY_DIR}/preinst;${CMAKE_CURRENT_BINARY_DIR}/prerm") + + set(CPACK_DEBIAN_APPLICATIONS_PACKAGE_CONTROL_STRICT_PERMISSION TRUE) +endif() + +# creates a symbolic link and a directory. Those should not be hashed. +# warning: relocation of the symlink is not supported (symlinks with relative +# paths) +execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink mylibapp symtest) +install(FILES ${CPackComponentsDEB_BINARY_DIR}/symtest + DESTINATION bin + COMPONENT applications) + +if(EXISTS "./dirtest") + execute_process(COMMAND ${CMAKE_COMMAND} -E remove_directory ./dirtest) +endif() +# NOTE: directory left empty on purpose +execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory ./dirtest) +# NOTE: we should not add the trailing "/" to dirtest +install(DIRECTORY ${CPackComponentsDEB_BINARY_DIR}/dirtest + DESTINATION bin/ + COMPONENT applications) + # We may use the CPack specific config file in order # to tailor CPack behavior on a CPack generator specific way # (Behavior would be different for RPM or TGZ or DEB ...) diff --git a/Tests/CPackComponentsDEB/RunCPackVerifyResult-components-lintian-dpkgdeb-checks.cmake b/Tests/CPackComponentsDEB/RunCPackVerifyResult-components-lintian-dpkgdeb-checks.cmake index 5460b1a..ff22f8f 100644 --- a/Tests/CPackComponentsDEB/RunCPackVerifyResult-components-lintian-dpkgdeb-checks.cmake +++ b/Tests/CPackComponentsDEB/RunCPackVerifyResult-components-lintian-dpkgdeb-checks.cmake @@ -36,7 +36,7 @@ find_program(LINTIAN_EXECUTABLE lintian) if(LINTIAN_EXECUTABLE) set(lintian_output_errors_all "") foreach(_f IN LISTS actual_output) - set(STRINGS_TO_AVOID "E:([^\r\n]*)control-file-has-bad-permissions") + set(STRINGS_TO_AVOID "E:([^\r\n]*)control-file-has-bad-permissions" "E:([^\r\n]*)md5sums-lists-nonexistent-file") lintian_check_specific_errors(lintian_output_errors FILENAME "${_f}" ERROR_REGEX_STRINGS "${STRINGS_TO_AVOID}") diff --git a/Tests/CPackComponentsDEB/RunCPackVerifyResult.cmake b/Tests/CPackComponentsDEB/RunCPackVerifyResult.cmake index b96669e..bf9f81d 100644 --- a/Tests/CPackComponentsDEB/RunCPackVerifyResult.cmake +++ b/Tests/CPackComponentsDEB/RunCPackVerifyResult.cmake @@ -137,6 +137,8 @@ endfunction() # This function runs dpkg-deb on a .deb and returns its output +# the default behaviour it to run "--info" on the specified Debian package +# ACTION is one of the option accepted by dpkg-deb function(run_dpkgdeb dpkg_deb_output) set(${dpkg_deb_output} "" PARENT_SCOPE) @@ -144,7 +146,7 @@ function(run_dpkgdeb dpkg_deb_output) if(DPKGDEB_EXECUTABLE) set(options "") - set(oneValueArgs "FILENAME") + set(oneValueArgs "FILENAME" "ACTION") set(multiValueArgs "") cmake_parse_arguments(run_dpkgdeb_deb "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) @@ -153,8 +155,12 @@ function(run_dpkgdeb dpkg_deb_output) message(FATAL_ERROR "error: run_dpkgdeb needs FILENAME to be set") endif() - # run lintian - execute_process(COMMAND ${DPKGDEB_EXECUTABLE} -I ${run_dpkgdeb_deb_FILENAME} + if(NOT run_dpkgdeb_deb_ACTION) + set(run_dpkgdeb_deb_ACTION "--info") + endif() + + # run dpkg-deb + execute_process(COMMAND ${DPKGDEB_EXECUTABLE} ${run_dpkgdeb_deb_ACTION} ${run_dpkgdeb_deb_FILENAME} WORKING_DIRECTORY "${CPACK_TEMPORARY_DIRECTORY}" OUTPUT_VARIABLE DPKGDEB_OUTPUT RESULT_VARIABLE DPKGDEB_RESULT diff --git a/Tests/CPackComponentsDEB/license.txt b/Tests/CPackComponentsDEB/license.txt index ba8ba48..d829d93 100644 --- a/Tests/CPackComponentsDEB/license.txt +++ b/Tests/CPackComponentsDEB/license.txt @@ -1,3 +1,3 @@ LICENSE ------- -This is an installer created using CPack (http://www.cmake.org). No license provided. +This is an installer created using CPack (https://cmake.org). No license provided. diff --git a/Tests/CPackComponentsForAll/license.txt b/Tests/CPackComponentsForAll/license.txt index ba8ba48..d829d93 100644 --- a/Tests/CPackComponentsForAll/license.txt +++ b/Tests/CPackComponentsForAll/license.txt @@ -1,3 +1,3 @@ LICENSE ------- -This is an installer created using CPack (http://www.cmake.org). No license provided. +This is an installer created using CPack (https://cmake.org). No license provided. diff --git a/Tests/CPackWiXGenerator/CMakeLists.txt b/Tests/CPackWiXGenerator/CMakeLists.txt index 638e788..73eaf4f 100644 --- a/Tests/CPackWiXGenerator/CMakeLists.txt +++ b/Tests/CPackWiXGenerator/CMakeLists.txt @@ -64,7 +64,7 @@ set(CPACK_WIX_PATCH_FILE "${CMAKE_CURRENT_SOURCE_DIR}/patch.xml") set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/license.txt") set(CPACK_WIX_PROPERTY_ARPCOMMENTS "My Custom ARPCOMMENTS") -set(CPACK_WIX_PROPERTY_ARPHELPLINK "http://www.cmake.org") +set(CPACK_WIX_PROPERTY_ARPHELPLINK "https://cmake.org") include(CPack) diff --git a/Tests/CTestCoverageCollectGCOV/test.cmake.in b/Tests/CTestCoverageCollectGCOV/test.cmake.in index 29f7e7f..b2e6d6d 100644 --- a/Tests/CTestCoverageCollectGCOV/test.cmake.in +++ b/Tests/CTestCoverageCollectGCOV/test.cmake.in @@ -12,9 +12,9 @@ ctest_build() ctest_test() list(APPEND CTEST_CUSTOM_COVERAGE_EXCLUDE - "/foo/something" - "/3rdparty/" - "/bar/somethingelse" + "/foo/something" + "/3rdparty/" + "/bar/somethingelse" ) include(CTestCoverageCollectGCOV) diff --git a/Tests/Contracts/Trilinos/CMakeLists.txt b/Tests/Contracts/Trilinos/CMakeLists.txt index f5757b5..8d74ca5 100644 --- a/Tests/Contracts/Trilinos/CMakeLists.txt +++ b/Tests/Contracts/Trilinos/CMakeLists.txt @@ -27,7 +27,7 @@ endif() message(STATUS "HOME='${HOME}'") if(NOT DEFINED url) - set(url "http://www.cmake.org/files/contracts/trilinos-11.4.1.tar.gz") + set(url "https://cmake.org/files/contracts/trilinos-11.4.1.tar.gz") endif() message(STATUS "url='${url}'") diff --git a/Tests/DelphiCoverage/UTCovTest(UTCovTest.pas).html b/Tests/DelphiCoverage/UTCovTest(UTCovTest.pas).html.in index 9caaea3..9caaea3 100644 --- a/Tests/DelphiCoverage/UTCovTest(UTCovTest.pas).html +++ b/Tests/DelphiCoverage/UTCovTest(UTCovTest.pas).html.in diff --git a/Tests/ExportImport/Export/CMakeLists.txt b/Tests/ExportImport/Export/CMakeLists.txt index 2b9e844..aedc89b 100644 --- a/Tests/ExportImport/Export/CMakeLists.txt +++ b/Tests/ExportImport/Export/CMakeLists.txt @@ -29,14 +29,14 @@ add_custom_command(TARGET testLib1 POST_BUILD $<TARGET_FILE:testLib1>.genex ) install(FILES $<TARGET_FILE:testLib1>.genex - DESTINATION lib + DESTINATION $<1:lib>$<0:/wrong> ) set_property(TARGET testLib1 PROPERTY MY_FILES ${CMAKE_CURRENT_SOURCE_DIR}/testLib1file1.txt ${CMAKE_CURRENT_SOURCE_DIR}/testLib1file2.txt ) install(FILES $<TARGET_PROPERTY:testLib1,MY_FILES> - DESTINATION doc + DESTINATION $<1:doc>$<0:/wrong> ) # Test library with empty link interface. Link it to an implementation @@ -136,7 +136,7 @@ add_library(testLibDepends testLibDepends.c) target_link_libraries(testLibDepends LINK_PUBLIC testLibRequired) macro(add_include_lib _libName) - file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${_libName}.c" "// no content\n") + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${_libName}.c" "/* no content */\n") add_library(${_libName} "${CMAKE_CURRENT_BINARY_DIR}/${_libName}.c") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${_libName}") set_property(TARGET ${_libName} APPEND PROPERTY @@ -144,7 +144,7 @@ macro(add_include_lib _libName) "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/${_libName}>" ) if (NOT "${ARGV1}" STREQUAL "NO_HEADER") - file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${_libName}/${_libName}.h" "// no content\n") + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${_libName}/${_libName}.h" "/* no content */\n") install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${_libName}/${_libName}.h" DESTINATION include/${_libName} @@ -182,7 +182,7 @@ install(FILES ) add_include_lib(testLibIncludeRequired6) -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/testLibIncludeRequired7/testLibIncludeRequired7.h" "// No content\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/testLibIncludeRequired7/testLibIncludeRequired7.h" "/* No content */\n") install(FILES "${CMAKE_CURRENT_BINARY_DIR}/testLibIncludeRequired7/testLibIncludeRequired7.h" DESTINATION include/testLibIncludeRequired7 @@ -391,22 +391,22 @@ install(TARGETS install(EXPORT RequiredExp NAMESPACE Req:: FILE testLibRequiredTargets.cmake DESTINATION lib/cmake/testLibRequired) file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest/installIncludesTest.h" "// No content\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest/installIncludesTest.h" "/* No content */\n") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest2") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest2/installIncludesTest2.h" "// No content\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest2/installIncludesTest2.h" "/* No content */\n") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest3/testLibRequired") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest3/testLibRequired/installIncludesTest3.h" "// No content\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest3/testLibRequired/installIncludesTest3.h" "/* No content */\n") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/testLibRequired/installIncludesTest4") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/testLibRequired/installIncludesTest4/installIncludesTest4.h" "// No content\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/testLibRequired/installIncludesTest4/installIncludesTest4.h" "/* No content */\n") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest5") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest5/installIncludesTest5.h" "// No content\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest5/installIncludesTest5.h" "/* No content */\n") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest6") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest6/installIncludesTest6.h" "// No content\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest6/installIncludesTest6.h" "/* No content */\n") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest7") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest7/installIncludesTest7.h" "// No content\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest7/installIncludesTest7.h" "/* No content */\n") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest8") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest8/installIncludesTest8.h" "// No content\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest8/installIncludesTest8.h" "/* No content */\n") install(FILES "${CMAKE_CURRENT_BINARY_DIR}/installIncludesTest/installIncludesTest.h" DESTINATION installIncludesTest @@ -551,5 +551,5 @@ install( ARCHIVE DESTINATION lib INCLUDES DESTINATION include/abs ) -install(DIRECTORY include/abs DESTINATION include) +install(DIRECTORY include/abs DESTINATION $<1:include>$<0:/wrong>) install(EXPORT expAbs NAMESPACE expAbs_ DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/expAbs) diff --git a/Tests/ExternalProject/Example/CMakeLists.txt b/Tests/ExternalProject/Example/CMakeLists.txt index 69ebaaf..4c12895 100644 --- a/Tests/ExternalProject/Example/CMakeLists.txt +++ b/Tests/ExternalProject/Example/CMakeLists.txt @@ -5,7 +5,7 @@ include(ExternalProject) ExternalProject_Add( cmake281 - URL http://www.cmake.org/files/v2.8/cmake-2.8.1.tar.gz + URL https://cmake.org/files/v2.8/cmake-2.8.1.tar.gz CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR> BUILD_COMMAND "" ) diff --git a/Tests/FindGTK2/CMakeLists.txt b/Tests/FindGTK2/CMakeLists.txt index 1c5987c..0105fae 100644 --- a/Tests/FindGTK2/CMakeLists.txt +++ b/Tests/FindGTK2/CMakeLists.txt @@ -9,6 +9,7 @@ if(GTK2_GTK_FOUND) "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Components/gtk" ${build_generator_args} --build-target gtk-all-libs + --build-project gtk --build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Components/gtk" --force-new-ctest-process --test-command ${CMAKE_CTEST_COMMAND} -V @@ -22,6 +23,7 @@ if(GTK2_GTKMM_FOUND) "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Components/gtkmm" ${build_generator_args} --build-target gtkmm-all-libs + --build-project gtkmm --build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Components/gtkmm" --force-new-ctest-process --test-command ${CMAKE_CTEST_COMMAND} -V @@ -310,6 +312,7 @@ if(TARGET GTK2::gtkmm) "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gtkmm" ${build_generator_args} --build-target gtkmm-target + --build-project gtkmm --build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gtkmm" --force-new-ctest-process --test-command ${CMAKE_CTEST_COMMAND} -V diff --git a/Tests/FindPackageModeMakefileTest/Makefile.in b/Tests/FindPackageModeMakefileTest/Makefile.in index e4df9d6..8e7ff72 100644 --- a/Tests/FindPackageModeMakefileTest/Makefile.in +++ b/Tests/FindPackageModeMakefileTest/Makefile.in @@ -4,6 +4,7 @@ include cmakeExecutable.mk CMAKE_CURRENT_BINARY_DIR = "@CMAKE_CURRENT_BINARY_DIR@" CMAKE_CXX_COMPILER = "@CMAKE_CXX_COMPILER@" CMAKE_CXX_COMPILER_ID = "@CMAKE_CXX_COMPILER_ID@" +CMAKE_CXX_FLAGS = @CMAKE_CXX_FLAGS@ CMAKE_FOO = $(CMAKE) --find-package -DCMAKE_MODULE_PATH=$(CMAKE_CURRENT_BINARY_DIR) -DNAME=Foo -DLANGUAGE=CXX -DCOMPILER_ID=$(CMAKE_CXX_COMPILER_ID) @@ -14,7 +15,7 @@ all: pngtest main.o: clean main.cpp @$(CMAKE_FOO) -DMODE=COMPILE >$(tmp) @foo="`cat $(tmp)`"; \ - printf '"%s" %s %s -c main.cpp\n' $(CMAKE_CXX_COMPILER) "$(CXXFLAGS)" "$$foo" >$(tmp) + printf '"%s" %s %s -c main.cpp\n' $(CMAKE_CXX_COMPILER) "$(CMAKE_CXX_FLAGS)" "$$foo" >$(tmp) @cat $(tmp) @sh $(tmp) @rm -f $(tmp) @@ -22,7 +23,7 @@ main.o: clean main.cpp pngtest: main.o @$(CMAKE_FOO) -DMODE=LINK >$(tmp) @foo="`cat $(tmp)`"; \ - printf '"%s" %s %s -o pngtest main.o %s\n' $(CMAKE_CXX_COMPILER) "$(CXXFLAGS)" "$(LDFLAGS)" "$$foo" >$(tmp) + printf '"%s" %s %s -o pngtest main.o %s\n' $(CMAKE_CXX_COMPILER) "$(CMAKE_CXX_FLAGS)" "$(LDFLAGS)" "$$foo" >$(tmp) @cat $(tmp) @sh $(tmp) @rm -f $(tmp) diff --git a/Tests/FindThreads/C-only/CMakeLists.txt b/Tests/FindThreads/C-only/CMakeLists.txt new file mode 100644 index 0000000..ab4ca0d --- /dev/null +++ b/Tests/FindThreads/C-only/CMakeLists.txt @@ -0,0 +1,10 @@ +cmake_minimum_required(VERSION 3.3 FATAL_ERROR) +project(FindThreads_C-only C) + +set(CMAKE_THREAD_PREFER_PTHREAD On) +find_package(Threads REQUIRED) + +if (NOT WIN32) + add_executable(thr ${CMAKE_CURRENT_SOURCE_DIR}/../../../Modules/CheckForPthreads.c) + target_link_libraries(thr Threads::Threads) +endif () diff --git a/Tests/FindThreads/CMakeLists.txt b/Tests/FindThreads/CMakeLists.txt new file mode 100644 index 0000000..aa9499b --- /dev/null +++ b/Tests/FindThreads/CMakeLists.txt @@ -0,0 +1,11 @@ +foreach (_lang IN ITEMS C CXX) + add_test(NAME FindThreads.${_lang}-only COMMAND ${CMAKE_CTEST_COMMAND} + --build-and-test + "${CMake_SOURCE_DIR}/Tests/FindThreads/${_lang}-only" + "${CMake_BINARY_DIR}/Tests/FindThreads/${_lang}-only" + ${build_generator_args} + --build-project FindThreads_${_lang}-only + --build-options ${build_options} + --test-command ${CMAKE_CTEST_COMMAND} -V + ) +endforeach () diff --git a/Tests/FindThreads/CXX-only/CMakeLists.txt b/Tests/FindThreads/CXX-only/CMakeLists.txt new file mode 100644 index 0000000..9993123 --- /dev/null +++ b/Tests/FindThreads/CXX-only/CMakeLists.txt @@ -0,0 +1,13 @@ +cmake_minimum_required(VERSION 3.3 FATAL_ERROR) +project(FindThreads_CXX-only CXX) + +set(CMAKE_THREAD_PREFER_PTHREAD On) +find_package(Threads REQUIRED) + +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/../../../Modules/CheckForPthreads.c + ${CMAKE_CURRENT_BINARY_DIR}/CheckForPthreads.cxx) + +if (NOT WIN32) + add_executable(thr ${CMAKE_CURRENT_BINARY_DIR}/CheckForPthreads.cxx) + target_link_libraries(thr Threads::Threads) +endif () diff --git a/Tests/GeneratorExpression/CMakeLists.txt b/Tests/GeneratorExpression/CMakeLists.txt index 758165c..27f33a2 100644 --- a/Tests/GeneratorExpression/CMakeLists.txt +++ b/Tests/GeneratorExpression/CMakeLists.txt @@ -66,7 +66,7 @@ add_custom_target(check-part1 ALL -Dtest_colons_4=$<1:C:\\CMake> -Dtest_colons_5=$<1:C:/CMake> -P ${CMAKE_CURRENT_SOURCE_DIR}/check-part1.cmake - COMMAND ${CMAKE_COMMAND} -E echo "check done (part 1 of 3)" + COMMAND ${CMAKE_COMMAND} -E echo "check done (part 1 of 4)" VERBATIM ) @@ -137,7 +137,7 @@ add_custom_target(check-part2 ALL -Dtest_arbitrary_content_comma_9=$<1:a,,b,,> -Dtest_arbitrary_content_comma_10=$<1:,,a,,b,,> -P ${CMAKE_CURRENT_SOURCE_DIR}/check-part2.cmake - COMMAND ${CMAKE_COMMAND} -E echo "check done (part 2 of 3)" + COMMAND ${CMAKE_COMMAND} -E echo "check done (part 2 of 4)" VERBATIM ) @@ -221,7 +221,27 @@ add_custom_target(check-part3 ALL -Dequal22=$<EQUAL:10,-012> -Dequal23=$<EQUAL:-10,-012> -P ${CMAKE_CURRENT_SOURCE_DIR}/check-part3.cmake - COMMAND ${CMAKE_COMMAND} -E echo "check done (part 3 of 3)" + COMMAND ${CMAKE_COMMAND} -E echo "check done (part 3 of 4)" + VERBATIM + ) + +if(WIN32) + set(test_shell_path c:/shell/path) +else() + set(test_shell_path /shell/path) +endif() +set(path_prefix BYPASS_FURTHER_CONVERSION) + +add_custom_target(check-part4 ALL + COMMAND ${CMAKE_COMMAND} + # Prefix path to bypass its further conversion when being processed by + # CMake as command-line argument + -Dtest_shell_path=${path_prefix}$<SHELL_PATH:${test_shell_path}> + -Dpath_prefix=${path_prefix} + -DWIN32=${WIN32} + -DCMAKE_GENERATOR=${CMAKE_GENERATOR} + -P ${CMAKE_CURRENT_SOURCE_DIR}/check-part4.cmake + COMMAND ${CMAKE_COMMAND} -E echo "check done (part 4 of 4)" VERBATIM ) diff --git a/Tests/GeneratorExpression/check-common.cmake b/Tests/GeneratorExpression/check-common.cmake index 8ffebd7..faf5d4f 100644 --- a/Tests/GeneratorExpression/check-common.cmake +++ b/Tests/GeneratorExpression/check-common.cmake @@ -1,5 +1,5 @@ -macro(check var val) +function(check var val) if(NOT "${${var}}" STREQUAL "${val}") message(SEND_ERROR "${var} is \"${${var}}\", not \"${val}\"") endif() -endmacro() +endfunction() diff --git a/Tests/GeneratorExpression/check-part1.cmake b/Tests/GeneratorExpression/check-part1.cmake index 3207582..60b193f 100644 --- a/Tests/GeneratorExpression/check-part1.cmake +++ b/Tests/GeneratorExpression/check-part1.cmake @@ -55,5 +55,5 @@ check(test_semicolon ";") check(test_colons_1 ":") check(test_colons_2 "::") check(test_colons_3 "Qt5::Core") -check(test_colons_4 "C:\\\\CMake") +check(test_colons_4 [[C:\CMake]]) check(test_colons_5 "C:/CMake") diff --git a/Tests/GeneratorExpression/check-part4.cmake b/Tests/GeneratorExpression/check-part4.cmake new file mode 100644 index 0000000..9e516d5 --- /dev/null +++ b/Tests/GeneratorExpression/check-part4.cmake @@ -0,0 +1,15 @@ +include(${CMAKE_CURRENT_LIST_DIR}/check-common.cmake) + +string(REPLACE ${path_prefix} "" test_shell_path ${test_shell_path}) + +if(WIN32) + if(CMAKE_GENERATOR STREQUAL "MSYS Makefiles") + check(test_shell_path [[/c/shell/path]]) + elseif(CMAKE_GENERATOR STREQUAL "Unix Makefiles") + check(test_shell_path [[c:/shell/path]]) + else() + check(test_shell_path [[c:\shell\path]]) + endif() +else() + check(test_shell_path [[/shell/path]]) +endif() diff --git a/Tests/IncludeDirectories/TargetIncludeDirectories/CMakeLists.txt b/Tests/IncludeDirectories/TargetIncludeDirectories/CMakeLists.txt index 8e2bd0a..5b99ea7 100644 --- a/Tests/IncludeDirectories/TargetIncludeDirectories/CMakeLists.txt +++ b/Tests/IncludeDirectories/TargetIncludeDirectories/CMakeLists.txt @@ -5,7 +5,7 @@ project(TargetIncludeDirectories) macro(create_header _name) file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${_name}") - file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${_name}/${_name}.h" "//${_name}.h\n") + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${_name}/${_name}.h" "/* ${_name}.h */\n") endmacro() create_header(bar) @@ -88,7 +88,7 @@ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/bad/common.h" "#error Should not be incl file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/good") file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/good/common.h" "#include \"othergood.h\"\n") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/othergood") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/othergood/othergood.h" "// No error\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/othergood/othergood.h" "/* No error */\n") file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/libothergood.cpp" "// No content \n") add_library(libothergood "${CMAKE_CURRENT_BINARY_DIR}/libothergood.cpp") @@ -149,7 +149,7 @@ target_include_directories(lib5 ) file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/prefix_foo/prefix_bar/prefix_bat") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/prefix_foo/prefix_bar/prefix_bat/prefix_foo_bar_bat.h" "// prefix_foo_bar_bat.h\n") +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/prefix_foo/prefix_bar/prefix_bat/prefix_foo_bar_bat.h" "/* prefix_foo_bar_bat.h */\n") target_include_directories(TargetIncludeDirectories PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/prefix_$<JOIN:foo;bar;bat,/prefix_>") diff --git a/Tests/MSManifest/CMakeLists.txt b/Tests/MSManifest/CMakeLists.txt new file mode 100644 index 0000000..300cfa6 --- /dev/null +++ b/Tests/MSManifest/CMakeLists.txt @@ -0,0 +1,5 @@ +cmake_minimum_required(VERSION 3.3) +project(MSManifest C) + +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) +add_subdirectory(Subdir) diff --git a/Tests/MSManifest/Subdir/CMakeLists.txt b/Tests/MSManifest/Subdir/CMakeLists.txt new file mode 100644 index 0000000..a47cf00 --- /dev/null +++ b/Tests/MSManifest/Subdir/CMakeLists.txt @@ -0,0 +1,9 @@ +configure_file(test.manifest.in test.manifest) +add_executable(MSManifest main.c ${CMAKE_CURRENT_BINARY_DIR}/test.manifest) + +if(MSVC AND NOT MSVC_VERSION LESS 1400) + add_custom_command(TARGET MSManifest POST_BUILD VERBATIM + COMMAND ${CMAKE_COMMAND} -Dexe=$<TARGET_FILE:MSManifest> + -P ${CMAKE_CURRENT_SOURCE_DIR}/check.cmake + ) +endif() diff --git a/Tests/MSManifest/Subdir/check.cmake b/Tests/MSManifest/Subdir/check.cmake new file mode 100644 index 0000000..b7b6841 --- /dev/null +++ b/Tests/MSManifest/Subdir/check.cmake @@ -0,0 +1,6 @@ +file(STRINGS "${exe}" content REGEX "name=\"Kitware.CMake.MSManifestTest\"") +if(content) + message(STATUS "Expected manifest content found:\n ${content}") +else() + message(FATAL_ERROR "Expected manifest content not found in\n ${exe}") +endif() diff --git a/Tests/MSManifest/Subdir/main.c b/Tests/MSManifest/Subdir/main.c new file mode 100644 index 0000000..78f2de1 --- /dev/null +++ b/Tests/MSManifest/Subdir/main.c @@ -0,0 +1 @@ +int main(void) { return 0; } diff --git a/Tests/MSManifest/Subdir/test.manifest.in b/Tests/MSManifest/Subdir/test.manifest.in new file mode 100644 index 0000000..540961a --- /dev/null +++ b/Tests/MSManifest/Subdir/test.manifest.in @@ -0,0 +1,4 @@ +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> + <assemblyIdentity type="win32" version="1.0.0.0" + name="Kitware.CMake.MSManifestTest"/> +</assembly> diff --git a/Tests/OutOfBinary/CMakeLists.txt b/Tests/OutOfBinary/CMakeLists.txt index e327541..f50536e 100644 --- a/Tests/OutOfBinary/CMakeLists.txt +++ b/Tests/OutOfBinary/CMakeLists.txt @@ -1,2 +1,4 @@ add_library(outlib outlib.c) +add_executable(outexe outexe.c) +target_link_libraries(outexe subdir) diff --git a/Tests/OutOfBinary/outexe.c b/Tests/OutOfBinary/outexe.c new file mode 100644 index 0000000..6f14043 --- /dev/null +++ b/Tests/OutOfBinary/outexe.c @@ -0,0 +1,2 @@ +extern int subdir(void); +int main(void) { return subdir(); } diff --git a/Tests/OutOfSource/SubDir/CMakeLists.txt b/Tests/OutOfSource/SubDir/CMakeLists.txt index c5df36e..e18dbb9 100644 --- a/Tests/OutOfSource/SubDir/CMakeLists.txt +++ b/Tests/OutOfSource/SubDir/CMakeLists.txt @@ -6,3 +6,5 @@ add_subdirectory(${OutOfSource_SOURCE_DIR}/../OutOfBinary # subdir to a sibling dir add_subdirectory(${OutOfSource_SOURCE_DIR}/${KEN}OutOfSourceSubdir OutOfSourceSubdir ) + +add_library(subdir subdir.c) diff --git a/Tests/OutOfSource/SubDir/subdir.c b/Tests/OutOfSource/SubDir/subdir.c new file mode 100644 index 0000000..0d0d827 --- /dev/null +++ b/Tests/OutOfSource/SubDir/subdir.c @@ -0,0 +1 @@ +int subdir(void) { return 0; } diff --git a/Tests/Plugin/src/example_exe.cxx b/Tests/Plugin/src/example_exe.cxx index bc4b03e..12d9204 100644 --- a/Tests/Plugin/src/example_exe.cxx +++ b/Tests/Plugin/src/example_exe.cxx @@ -32,7 +32,7 @@ int main() if(!handle) { std::cerr << "Could not open plugin \"" - << libName << "\"!" << std::endl; + << libName.c_str() << "\"!" << std::endl; return 1; } kwsys::DynamicLoader::SymbolPointer sym = diff --git a/Tests/QtAutogen/CMakeLists.txt b/Tests/QtAutogen/CMakeLists.txt index ebcfc0f..d5aca55 100644 --- a/Tests/QtAutogen/CMakeLists.txt +++ b/Tests/QtAutogen/CMakeLists.txt @@ -101,7 +101,14 @@ add_executable(QtAutogen main.cpp calwidget.cpp second_widget.cpp foo.cpp blub.c ) set_property(TARGET QtAutogen APPEND PROPERTY AUTOGEN_TARGET_DEPENDS generate_moc_input "${CMAKE_CURRENT_BINARY_DIR}/myotherinterface.h") -set_target_properties(QtAutogen codeeditorLib privateSlot PROPERTIES AUTOMOC TRUE) +add_executable(targetObjectsTest targetObjectsTest.cpp $<TARGET_OBJECTS:privateSlot>) +target_link_libraries(targetObjectsTest ${QT_LIBRARIES}) + +set_target_properties( + QtAutogen codeeditorLib privateSlot targetObjectsTest + PROPERTIES + AUTOMOC TRUE +) include(GenerateExportHeader) # The order is relevant here. B depends on A, and B headers depend on A diff --git a/Tests/QtAutogen/targetObjectsTest.cpp b/Tests/QtAutogen/targetObjectsTest.cpp new file mode 100644 index 0000000..766b775 --- /dev/null +++ b/Tests/QtAutogen/targetObjectsTest.cpp @@ -0,0 +1,5 @@ + +int main() +{ + return 0; +} diff --git a/Tests/RunCMake/BuildDepends/C-Exe-Manifest.cmake b/Tests/RunCMake/BuildDepends/C-Exe-Manifest.cmake new file mode 100644 index 0000000..ef33012 --- /dev/null +++ b/Tests/RunCMake/BuildDepends/C-Exe-Manifest.cmake @@ -0,0 +1,19 @@ +enable_language(C) + +add_executable(main main.c ${CMAKE_CURRENT_BINARY_DIR}/test.manifest) + +if(MSVC AND NOT MSVC_VERSION LESS 1400) + set(EXTRA_CHECK [[ +file(STRINGS "$<TARGET_FILE:main>" content REGEX "name=\"Kitware.CMake.C-Exe-Manifest-step[0-9]\"") +if(NOT "${content}" MATCHES "name=\"Kitware.CMake.C-Exe-Manifest-step${check_step}\"") + set(RunCMake_TEST_FAILED "Binary has no manifest with name=\"Kitware.CMake.C-Exe-Manifest-step${check_step}\":\n ${content}") +endif() +]]) +endif() + +file(GENERATE OUTPUT check-$<LOWER_CASE:$<CONFIG>>.cmake CONTENT " +set(check_pairs + \"$<TARGET_FILE:main>|${CMAKE_CURRENT_BINARY_DIR}/test.manifest\" + ) +${EXTRA_CHECK} +") diff --git a/Tests/RunCMake/BuildDepends/C-Exe-Manifest.step1.cmake b/Tests/RunCMake/BuildDepends/C-Exe-Manifest.step1.cmake new file mode 100644 index 0000000..c0b939d --- /dev/null +++ b/Tests/RunCMake/BuildDepends/C-Exe-Manifest.step1.cmake @@ -0,0 +1,6 @@ +file(WRITE "${RunCMake_TEST_BINARY_DIR}/test.manifest" [[ +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> + <assemblyIdentity type="win32" version="1.0.0.0" + name="Kitware.CMake.C-Exe-Manifest-step1"/> +</assembly> +]]) diff --git a/Tests/RunCMake/BuildDepends/C-Exe-Manifest.step2.cmake b/Tests/RunCMake/BuildDepends/C-Exe-Manifest.step2.cmake new file mode 100644 index 0000000..a75bf21 --- /dev/null +++ b/Tests/RunCMake/BuildDepends/C-Exe-Manifest.step2.cmake @@ -0,0 +1,6 @@ +file(WRITE "${RunCMake_TEST_BINARY_DIR}/test.manifest" [[ +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> + <assemblyIdentity type="win32" version="1.0.0.0" + name="Kitware.CMake.C-Exe-Manifest-step2"/> +</assembly> +]]) diff --git a/Tests/RunCMake/BuildDepends/C-Exe.cmake b/Tests/RunCMake/BuildDepends/C-Exe.cmake new file mode 100644 index 0000000..5057ca9 --- /dev/null +++ b/Tests/RunCMake/BuildDepends/C-Exe.cmake @@ -0,0 +1,12 @@ +enable_language(C) + +add_executable(main ${CMAKE_CURRENT_BINARY_DIR}/main.c) + +file(GENERATE OUTPUT check-$<LOWER_CASE:$<CONFIG>>.cmake CONTENT " +set(check_pairs + \"$<TARGET_FILE:main>|${CMAKE_CURRENT_BINARY_DIR}/main.c\" + ) +set(check_exes + \"$<TARGET_FILE:main>\" + ) +") diff --git a/Tests/RunCMake/BuildDepends/C-Exe.step1.cmake b/Tests/RunCMake/BuildDepends/C-Exe.step1.cmake new file mode 100644 index 0000000..08e2949 --- /dev/null +++ b/Tests/RunCMake/BuildDepends/C-Exe.step1.cmake @@ -0,0 +1,3 @@ +file(WRITE "${RunCMake_TEST_BINARY_DIR}/main.c" [[ +int main(void) { return 1; } +]]) diff --git a/Tests/RunCMake/BuildDepends/C-Exe.step2.cmake b/Tests/RunCMake/BuildDepends/C-Exe.step2.cmake new file mode 100644 index 0000000..ee4530c --- /dev/null +++ b/Tests/RunCMake/BuildDepends/C-Exe.step2.cmake @@ -0,0 +1,3 @@ +file(WRITE "${RunCMake_TEST_BINARY_DIR}/main.c" [[ +int main(void) { return 2; } +]]) diff --git a/Tests/RunCMake/BuildDepends/CMakeLists.txt b/Tests/RunCMake/BuildDepends/CMakeLists.txt new file mode 100644 index 0000000..74b3ff8 --- /dev/null +++ b/Tests/RunCMake/BuildDepends/CMakeLists.txt @@ -0,0 +1,3 @@ +cmake_minimum_required(VERSION 3.3) +project(${RunCMake_TEST} NONE) +include(${RunCMake_TEST}.cmake) diff --git a/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake b/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake new file mode 100644 index 0000000..a578408 --- /dev/null +++ b/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake @@ -0,0 +1,40 @@ +include(RunCMake) + +if(RunCMake_GENERATOR STREQUAL "Borland Makefiles") + set(fs_delay 3) +else() + set(fs_delay 1.125) +endif() + +function(run_BuildDepends CASE) + # Use a single build tree for a few tests without cleaning. + set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/${CASE}-build) + set(RunCMake_TEST_NO_CLEAN 1) + if(RunCMake_GENERATOR MATCHES "Make|Ninja") + set(RunCMake_TEST_OPTIONS -DCMAKE_BUILD_TYPE=Debug) + endif() + file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") + file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") + include(${RunCMake_SOURCE_DIR}/${CASE}.step1.cmake OPTIONAL) + run_cmake(${CASE}) + set(RunCMake-check-file check.cmake) + set(check_step 1) + run_cmake_command(${CASE}-build1 ${CMAKE_COMMAND} --build . --config Debug) + if(run_BuildDepends_skip_step_2) + return() + endif() + execute_process(COMMAND ${CMAKE_COMMAND} -E sleep ${fs_delay}) # handle 1s resolution + include(${RunCMake_SOURCE_DIR}/${CASE}.step2.cmake OPTIONAL) + set(check_step 2) + run_cmake_command(${CASE}-build2 ${CMAKE_COMMAND} --build . --config Debug) +endfunction() + +run_BuildDepends(C-Exe) +if(NOT RunCMake_GENERATOR MATCHES "Visual Studio [67]|Xcode") + if(RunCMake_GENERATOR MATCHES "Visual Studio 10") + # VS 10 forgets to re-link when a manifest changes + set(run_BuildDepends_skip_step_2 1) + endif() + run_BuildDepends(C-Exe-Manifest) + unset(run_BuildDepends_skip_step_2) +endif() diff --git a/Tests/RunCMake/BuildDepends/check.cmake b/Tests/RunCMake/BuildDepends/check.cmake new file mode 100644 index 0000000..26a9eb6 --- /dev/null +++ b/Tests/RunCMake/BuildDepends/check.cmake @@ -0,0 +1,37 @@ +if(EXISTS ${RunCMake_TEST_BINARY_DIR}/check-debug.cmake) + include(${RunCMake_TEST_BINARY_DIR}/check-debug.cmake) + if(RunCMake_TEST_FAILED) + return() + endif() + foreach(exe IN LISTS check_exes) + execute_process(COMMAND ${exe} RESULT_VARIABLE res) + if(NOT res EQUAL ${check_step}) + set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED} + '${exe}' returned '${res}' but expected '${check_step}' +") + endif() + endforeach() + foreach(p IN LISTS check_pairs) + if("${p}" MATCHES "^(.*)\\|(.*)$") + set(lhs "${CMAKE_MATCH_1}") + set(rhs "${CMAKE_MATCH_2}") + if(NOT EXISTS "${lhs}") + set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED} + '${lhs}' missing +") + elseif(NOT EXISTS "${rhs}") + set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED} + '${rhs}' missing +") + elseif(NOT "${lhs}" IS_NEWER_THAN "${rhs}") + set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED} + '${lhs}' is not newer than '${rhs}' +") + endif() + endif() + endforeach() +else() + set(RunCMake_TEST_FAILED " + '${RunCMake_TEST_BINARY_DIR}/check-debug.cmake' missing +") +endif() diff --git a/Tests/RunCMake/BuildDepends/main.c b/Tests/RunCMake/BuildDepends/main.c new file mode 100644 index 0000000..78f2de1 --- /dev/null +++ b/Tests/RunCMake/BuildDepends/main.c @@ -0,0 +1 @@ +int main(void) { return 0; } diff --git a/Tests/RunCMake/CMP0026/RunCMakeTest.cmake b/Tests/RunCMake/CMP0026/RunCMakeTest.cmake index fc58ea5..6331717 100644 --- a/Tests/RunCMake/CMP0026/RunCMakeTest.cmake +++ b/Tests/RunCMake/CMP0026/RunCMakeTest.cmake @@ -11,3 +11,4 @@ run_cmake(CMP0026-LOCATION-CONFIG-OLD) run_cmake(CMP0026-LOCATION-CONFIG-WARN) run_cmake(ObjlibNotDefined) run_cmake(LOCATION-and-TARGET_OBJECTS) +run_cmake(clear-cached-information) diff --git a/Tests/RunCMake/CMP0026/clear-cached-information-dir/CMakeLists.txt b/Tests/RunCMake/CMP0026/clear-cached-information-dir/CMakeLists.txt new file mode 100644 index 0000000..c51e883 --- /dev/null +++ b/Tests/RunCMake/CMP0026/clear-cached-information-dir/CMakeLists.txt @@ -0,0 +1,2 @@ + +add_executable(Hello ${CMAKE_CURRENT_BINARY_DIR}/main.c) diff --git a/Tests/RunCMake/CMP0026/clear-cached-information.cmake b/Tests/RunCMake/CMP0026/clear-cached-information.cmake new file mode 100644 index 0000000..dd2dd72 --- /dev/null +++ b/Tests/RunCMake/CMP0026/clear-cached-information.cmake @@ -0,0 +1,14 @@ + +enable_language(C) + +cmake_policy(SET CMP0026 OLD) + +add_subdirectory(clear-cached-information-dir) + +# Critical: this needs to happen in root CMakeLists.txt and not inside +# the subdir. +get_target_property(mypath Hello LOCATION) +# Now we create the file later, so you can see, ultimately no error should +# happen e.g. during generate phase: +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/clear-cached-information-dir/main.c) +set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/clear-cached-information-dir/main.c PROPERTIES GENERATED TRUE) diff --git a/Tests/RunCMake/CMP0054/CMP0054-WARN-stderr.txt b/Tests/RunCMake/CMP0054/CMP0054-WARN-stderr.txt index 3d875ae..3cfa5d2 100644 --- a/Tests/RunCMake/CMP0054/CMP0054-WARN-stderr.txt +++ b/Tests/RunCMake/CMP0054/CMP0054-WARN-stderr.txt @@ -9,3 +9,15 @@ CMake Warning \(dev\) at CMP0054-WARN.cmake:3 \(if\): Call Stack \(most recent call first\): CMakeLists.txt:3 \(include\) This warning is for project developers. Use -Wno-dev to suppress it. ++ +CMake Warning \(dev\) at CMP0054-WARN.cmake:5 \(elseif\): + Policy CMP0054 is not set: Only interpret if\(\) arguments as variables or + keywords when unquoted. Run "cmake --help-policy CMP0054" for policy + details. Use the cmake_policy command to set the policy and suppress this + warning. + + Quoted variables like "FOO" will no longer be dereferenced when the policy + is set to NEW. Since the policy is not set the OLD behavior will be used. +Call Stack \(most recent call first\): + CMakeLists.txt:3 \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/CMP0054/CMP0054-WARN.cmake b/Tests/RunCMake/CMP0054/CMP0054-WARN.cmake index 37855fc..a608929 100644 --- a/Tests/RunCMake/CMP0054/CMP0054-WARN.cmake +++ b/Tests/RunCMake/CMP0054/CMP0054-WARN.cmake @@ -2,4 +2,6 @@ set(FOO "BAR") if(NOT "FOO" STREQUAL "BAR") message(FATAL_ERROR "The given literals should match") +elseif("FOO" STREQUAL "BING") + message(FATAL_ERROR "The given literals should not match") endif() diff --git a/Tests/RunCMake/CMP0054/CMP0054-keywords-WARN-stderr.txt b/Tests/RunCMake/CMP0054/CMP0054-keywords-WARN-stderr.txt index b1ebd49..5a8c263 100644 --- a/Tests/RunCMake/CMP0054/CMP0054-keywords-WARN-stderr.txt +++ b/Tests/RunCMake/CMP0054/CMP0054-keywords-WARN-stderr.txt @@ -10,3 +10,16 @@ CMake Warning \(dev\) at CMP0054-keywords-WARN.cmake:1 \(if\): Call Stack \(most recent call first\): CMakeLists.txt:3 \(include\) This warning is for project developers. Use -Wno-dev to suppress it. ++ +CMake Warning \(dev\) at CMP0054-keywords-WARN.cmake:3 \(elseif\): + Policy CMP0054 is not set: Only interpret if\(\) arguments as variables or + keywords when unquoted. Run "cmake --help-policy CMP0054" for policy + details. Use the cmake_policy command to set the policy and suppress this + warning. + + Quoted keywords like "DEFINED" will no longer be interpreted as keywords + when the policy is set to NEW. Since the policy is not set the OLD + behavior will be used. +Call Stack \(most recent call first\): + CMakeLists.txt:3 \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/CMP0054/CMP0054-keywords-WARN.cmake b/Tests/RunCMake/CMP0054/CMP0054-keywords-WARN.cmake index ee0a623..118ab3d 100644 --- a/Tests/RunCMake/CMP0054/CMP0054-keywords-WARN.cmake +++ b/Tests/RunCMake/CMP0054/CMP0054-keywords-WARN.cmake @@ -1,3 +1,5 @@ if("NOT" 1) message(FATAL_ERROR "[\"NOT\" 1] evaluated true") +elseif("DEFINED" NotDefined) + message(FATAL_ERROR "[\"DEFINED\" NotDefined] evaluated true") endif() diff --git a/Tests/RunCMake/CMP0064/CMP0064-WARN-stderr.txt b/Tests/RunCMake/CMP0064/CMP0064-WARN-stderr.txt new file mode 100644 index 0000000..71f1ab7 --- /dev/null +++ b/Tests/RunCMake/CMP0064/CMP0064-WARN-stderr.txt @@ -0,0 +1,10 @@ +CMake Warning \(dev\) at CMP0064-WARN.cmake:3 \(if\): + Policy CMP0064 is not set: Support new TEST if\(\) operator. Run "cmake + --help-policy CMP0064" for policy details. Use the cmake_policy command to + set the policy and suppress this warning. + + TEST will be interpreted as an operator when the policy is set to NEW. + Since the policy is not set the OLD behavior will be used. +Call Stack \(most recent call first\): + CMakeLists.txt:3 \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/CMP0064/CMP0064-WARN.cmake b/Tests/RunCMake/CMP0064/CMP0064-WARN.cmake index bffd3f3..8f26ec6 100644 --- a/Tests/RunCMake/CMP0064/CMP0064-WARN.cmake +++ b/Tests/RunCMake/CMP0064/CMP0064-WARN.cmake @@ -1,4 +1,4 @@ -cmake_policy(SET CMP0064 OLD) + if(TEST) message(FATAL_ERROR "TEST was not recognized to be undefined") diff --git a/Tests/RunCMake/CMP0065/BuildTargetInSubProject.cmake b/Tests/RunCMake/CMP0065/BuildTargetInSubProject.cmake new file mode 100644 index 0000000..9339e46 --- /dev/null +++ b/Tests/RunCMake/CMP0065/BuildTargetInSubProject.cmake @@ -0,0 +1,15 @@ +function(BuildTargetInSubProject P T E) + try_compile(RESULTVAR + ${CMAKE_CURRENT_BINARY_DIR}/subproject + ${CMAKE_CURRENT_SOURCE_DIR}/subproject + ${P} ${T} OUTPUT_VARIABLE O) + if(E AND RESULTVAR) + message(STATUS "${P} target ${T} succeeded as expected") + elseif(E AND NOT RESULTVAR) + message(FATAL_ERROR "${P} target ${T} failed but should have succeeded. Output:${O}") + elseif(NOT E AND NOT RESULTVAR) + message(STATUS "${P} target ${T} failed as expected") + elseif(NOT E AND RESULTVAR) + message(FATAL_ERROR "${P} target ${T} succeeded but should have failed. Output:${O}") + endif() +endfunction() diff --git a/Tests/RunCMake/CMP0065/CMakeLists.txt b/Tests/RunCMake/CMP0065/CMakeLists.txt new file mode 100644 index 0000000..74b3ff8 --- /dev/null +++ b/Tests/RunCMake/CMP0065/CMakeLists.txt @@ -0,0 +1,3 @@ +cmake_minimum_required(VERSION 3.3) +project(${RunCMake_TEST} NONE) +include(${RunCMake_TEST}.cmake) diff --git a/Tests/RunCMake/CMP0065/NEWBad.cmake b/Tests/RunCMake/CMP0065/NEWBad.cmake new file mode 100644 index 0000000..79d9adb --- /dev/null +++ b/Tests/RunCMake/CMP0065/NEWBad.cmake @@ -0,0 +1,4 @@ +enable_language(C) +include(BuildTargetInSubProject.cmake) + +BuildTargetInSubProject(TestPolicyCMP0065 FooNEWBad FALSE) diff --git a/Tests/RunCMake/CMP0065/NEWGood.cmake b/Tests/RunCMake/CMP0065/NEWGood.cmake new file mode 100644 index 0000000..a5b5d04 --- /dev/null +++ b/Tests/RunCMake/CMP0065/NEWGood.cmake @@ -0,0 +1,4 @@ +enable_language(C) +include(BuildTargetInSubProject.cmake) + +BuildTargetInSubProject(TestPolicyCMP0065 FooNEWGood TRUE) diff --git a/Tests/RunCMake/CMP0065/OLDBad1.cmake b/Tests/RunCMake/CMP0065/OLDBad1.cmake new file mode 100644 index 0000000..6d780b4 --- /dev/null +++ b/Tests/RunCMake/CMP0065/OLDBad1.cmake @@ -0,0 +1,4 @@ +enable_language(C) +include(BuildTargetInSubProject.cmake) + +BuildTargetInSubProject(TestPolicyCMP0065 FooOLDBad1 FALSE) diff --git a/Tests/RunCMake/CMP0065/OLDBad2.cmake b/Tests/RunCMake/CMP0065/OLDBad2.cmake new file mode 100644 index 0000000..7196473 --- /dev/null +++ b/Tests/RunCMake/CMP0065/OLDBad2.cmake @@ -0,0 +1,4 @@ +enable_language(C) +include(BuildTargetInSubProject.cmake) + +BuildTargetInSubProject(TestPolicyCMP0065 FooOLDBad2 FALSE) diff --git a/Tests/RunCMake/CMP0065/RunCMakeTest.cmake b/Tests/RunCMake/CMP0065/RunCMakeTest.cmake new file mode 100644 index 0000000..254a4ec --- /dev/null +++ b/Tests/RunCMake/CMP0065/RunCMakeTest.cmake @@ -0,0 +1,8 @@ +include(RunCMake) + +run_cmake(OLDBad1) +run_cmake(OLDBad2) +run_cmake(NEWBad) +run_cmake(NEWGood) +run_cmake(WARN-OFF) +run_cmake(WARN-ON) diff --git a/Tests/RunCMake/CMP0065/WARN-OFF.cmake b/Tests/RunCMake/CMP0065/WARN-OFF.cmake new file mode 100644 index 0000000..dbc9562 --- /dev/null +++ b/Tests/RunCMake/CMP0065/WARN-OFF.cmake @@ -0,0 +1,3 @@ + +enable_language(C) +add_executable(main subproject/main.c) diff --git a/Tests/RunCMake/CMP0065/WARN-ON-stderr.txt b/Tests/RunCMake/CMP0065/WARN-ON-stderr.txt new file mode 100644 index 0000000..dda4fe5 --- /dev/null +++ b/Tests/RunCMake/CMP0065/WARN-ON-stderr.txt @@ -0,0 +1,10 @@ +CMake Warning \(dev\) in CMakeLists.txt: + Policy CMP0065 is not set: Do not add flags to export symbols from + executables without the ENABLE_EXPORTS target property. Run "cmake + --help-policy CMP0065" for policy details. Use the cmake_policy command to + set the policy and suppress this warning. + + For compatibility with older versions of CMake, additional flags may be + added to export symbols on all executables regardless of thier + ENABLE_EXPORTS property. +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/CMP0065/WARN-ON.cmake b/Tests/RunCMake/CMP0065/WARN-ON.cmake new file mode 100644 index 0000000..6ed4a41 --- /dev/null +++ b/Tests/RunCMake/CMP0065/WARN-ON.cmake @@ -0,0 +1,3 @@ +set(CMAKE_POLICY_WARNING_CMP0065 1) +enable_language(C) +add_executable(main subproject/main.c) diff --git a/Tests/RunCMake/CMP0065/subproject/CMakeLists.txt b/Tests/RunCMake/CMP0065/subproject/CMakeLists.txt new file mode 100644 index 0000000..bed5960 --- /dev/null +++ b/Tests/RunCMake/CMP0065/subproject/CMakeLists.txt @@ -0,0 +1,22 @@ +cmake_minimum_required(VERSION 3.3) + +project(TestPolicyCMP0065 C) +set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS BADFLAGS) + +#---------------------------------------------------------------------- +cmake_policy(SET CMP0065 OLD) +add_executable(FooOLDBad1 main.c) + +#---------------------------------------------------------------------- +cmake_policy(SET CMP0065 OLD) +add_executable(FooOLDBad2 main.c) +set_target_properties(FooOLDBad2 PROPERTIES ENABLE_EXPORTS ON) + +#---------------------------------------------------------------------- +cmake_policy(SET CMP0065 NEW) +add_executable(FooNEWGood main.c) + +#---------------------------------------------------------------------- +cmake_policy(SET CMP0065 NEW) +add_executable(FooNEWBad main.c) +set_target_properties(FooNEWBad PROPERTIES ENABLE_EXPORTS ON) diff --git a/Tests/RunCMake/CMP0065/subproject/main.c b/Tests/RunCMake/CMP0065/subproject/main.c new file mode 100644 index 0000000..98725db --- /dev/null +++ b/Tests/RunCMake/CMP0065/subproject/main.c @@ -0,0 +1,7 @@ +#include <stdio.h> + +int main(int argc, char **argv) +{ + printf("Hello World\n"); + return 0; +} diff --git a/Tests/RunCMake/CMakeLists.txt b/Tests/RunCMake/CMakeLists.txt index 5bc9af8..1a0019f 100644 --- a/Tests/RunCMake/CMakeLists.txt +++ b/Tests/RunCMake/CMakeLists.txt @@ -104,6 +104,13 @@ add_RunCMake_test(CMP0057) add_RunCMake_test(CMP0059) add_RunCMake_test(CMP0060) add_RunCMake_test(CMP0064) + +# The test for Policy 65 requires the use of the +# CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS variable, which both the VS and Xcode +# generators ignore. The policy will have no effect on those generators. +if(NOT CMAKE_GENERATOR MATCHES "Visual Studio|Xcode") + add_RunCMake_test(CMP0065) +endif() if(CMAKE_GENERATOR MATCHES "Make") add_RunCMake_test(Make) endif() @@ -124,6 +131,7 @@ if(NOT CMake_TEST_EXTERNAL_CMAKE) ) endif() +add_RunCMake_test(BuildDepends) if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja") add_RunCMake_test(CompilerChange) endif() @@ -139,6 +147,7 @@ add_RunCMake_test(GeneratorToolset) add_RunCMake_test(GNUInstallDirs) add_RunCMake_test(TargetPropertyGeneratorExpressions) add_RunCMake_test(Languages) +add_RunCMake_test(LinkStatic) add_RunCMake_test(ObjectLibrary) add_RunCMake_test(Swift) add_RunCMake_test(TargetObjects) @@ -281,7 +290,7 @@ if("${CMAKE_GENERATOR}" MATCHES "Make|Ninja") add_RunCMake_test(CompilerLauncher) endif() -add_RunCMake_test_group(CPack "DEB;RPM") +add_RunCMake_test_group(CPack "DEB;RPM;TGZ") # add a test to make sure symbols are exported from a shared library # for MSVC compilers CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS property is used add_RunCMake_test(AutoExportDll) diff --git a/Tests/RunCMake/CPack/COMPONENTS_EMPTY_DIR.cmake b/Tests/RunCMake/CPack/COMPONENTS_EMPTY_DIR.cmake new file mode 100644 index 0000000..7210e7d --- /dev/null +++ b/Tests/RunCMake/CPack/COMPONENTS_EMPTY_DIR.cmake @@ -0,0 +1,5 @@ +set(CPACK_COMPONENTS_ALL test) +install(DIRECTORY DESTINATION empty + COMPONENT test) + +set(CPACK_PACKAGE_NAME "components_empty_dir") diff --git a/Tests/RunCMake/CPack/CPackTestHelpers.cmake b/Tests/RunCMake/CPack/CPackTestHelpers.cmake index 7ea2a24..aef1086 100644 --- a/Tests/RunCMake/CPack/CPackTestHelpers.cmake +++ b/Tests/RunCMake/CPack/CPackTestHelpers.cmake @@ -10,47 +10,12 @@ function(run_cpack_test TEST_NAME types build) file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") # execute cmake - execute_process( - COMMAND "${CMAKE_COMMAND}" -DRunCMake_TEST=${TEST_NAME} - -DGENERATOR_TYPE=${TEST_TYPE} "${RunCMake_SOURCE_DIR}" - WORKING_DIRECTORY "${RunCMake_TEST_BINARY_DIR}" - RESULT_VARIABLE res - OUTPUT_FILE "${RunCMake_TEST_BINARY_DIR}/test_output.txt" - ERROR_FILE "${RunCMake_TEST_BINARY_DIR}/test_error.txt" - ) - - if(res) - run_cmake_command( - ${TEST_TYPE}/${TEST_NAME} - "${CMAKE_COMMAND}" - -DRunCMake_TEST_STEP=configure - -Dreturn_code=${res} - "-Dbin_dir=${RunCMake_TEST_BINARY_DIR}" - -P "${RunCMake_SOURCE_DIR}/PreTestError.cmake" - ) - return() - endif() + set(RunCMake_TEST_OPTIONS "-DGENERATOR_TYPE=${TEST_TYPE}") + run_cmake(${TEST_NAME}) # execute optional build step if(build) - execute_process( - COMMAND "${CMAKE_COMMAND}" --build "${RunCMake_TEST_BINARY_DIR}" - RESULT_VARIABLE res - OUTPUT_FILE "${RunCMake_TEST_BINARY_DIR}/test_output.txt" - ERROR_FILE "${RunCMake_TEST_BINARY_DIR}/test_error.txt" - ) - endif() - - if(res) - run_cmake_command( - ${TEST_TYPE}/${TEST_NAME} - "${CMAKE_COMMAND}" - -DRunCMake_TEST_STEP=build - -Dreturn_code=${res} - "-Dbin_dir=${RunCMake_TEST_BINARY_DIR}" - -P "${RunCMake_SOURCE_DIR}/PreTestError.cmake" - ) - return() + run_cmake_command(${TEST_NAME}-Build "${CMAKE_COMMAND}" --build "${RunCMake_TEST_BINARY_DIR}") endif() # execute cpack diff --git a/Tests/RunCMake/CPack/DEB/COMPONENTS_EMPTY_DIR-ExpectedFiles.cmake b/Tests/RunCMake/CPack/DEB/COMPONENTS_EMPTY_DIR-ExpectedFiles.cmake new file mode 100644 index 0000000..5adca68 --- /dev/null +++ b/Tests/RunCMake/CPack/DEB/COMPONENTS_EMPTY_DIR-ExpectedFiles.cmake @@ -0,0 +1,5 @@ +set(whitespaces_ "[\t\n\r ]*") + +set(EXPECTED_FILES_COUNT "1") +set(EXPECTED_FILE_1 "components_empty_dir*.deb") +set(EXPECTED_FILE_CONTENT_1 "^.*/usr/${whitespaces_}.*/usr/empty/$") diff --git a/Tests/RunCMake/CPack/DEB/COMPONENTS_EMPTY_DIR-specifics.cmake b/Tests/RunCMake/CPack/DEB/COMPONENTS_EMPTY_DIR-specifics.cmake new file mode 100644 index 0000000..2720fe9 --- /dev/null +++ b/Tests/RunCMake/CPack/DEB/COMPONENTS_EMPTY_DIR-specifics.cmake @@ -0,0 +1,2 @@ +set(CPACK_PACKAGE_CONTACT "someone") +set(CPACK_DEB_COMPONENT_INSTALL "ON") diff --git a/Tests/RunCMake/CPack/DEB/DEB_EXTRA-VerifyResult.cmake b/Tests/RunCMake/CPack/DEB/DEB_EXTRA-VerifyResult.cmake index 78b6114..5f929ff 100644 --- a/Tests/RunCMake/CPack/DEB/DEB_EXTRA-VerifyResult.cmake +++ b/Tests/RunCMake/CPack/DEB/DEB_EXTRA-VerifyResult.cmake @@ -1,11 +1,17 @@ set(foo_preinst "^echo default_preinst$") +set(foo_preinst_permissions_regex "-rwxr-xr-x .*") set(foo_prerm "^echo default_prerm$") +set(foo_prerm_permissions_regex "-rwxr-xr-x .*") verifyDebControl("${FOUND_FILE_1}" "foo" "preinst;prerm") set(bar_preinst "^echo bar_preinst$") +set(bar_prerm_permissions_regex "-rwx------ .*") set(bar_prerm "^echo bar_prerm$") +set(bar_prerm_permissions_regex "-rwx------ .*") verifyDebControl("${FOUND_FILE_2}" "bar" "preinst;prerm") set(bas_preinst "^echo default_preinst$") +set(bas_prerm_permissions_regex "-rwxr-xr-x .*") set(bas_prerm "^echo default_prerm$") +set(bas_prerm_permissions_regex "-rwxr-xr-x .*") verifyDebControl("${FOUND_FILE_3}" "bas" "preinst;prerm") diff --git a/Tests/RunCMake/CPack/DEB/DEPENDENCIES-VerifyResult.cmake b/Tests/RunCMake/CPack/DEB/DEPENDENCIES-VerifyResult.cmake index 44c862d..ba39f2e 100644 --- a/Tests/RunCMake/CPack/DEB/DEPENDENCIES-VerifyResult.cmake +++ b/Tests/RunCMake/CPack/DEB/DEPENDENCIES-VerifyResult.cmake @@ -1,4 +1,4 @@ -function(checkDepends_ FILE REGEX) +function(checkDependencies_ FILE REGEX) set(whitespaces_ "[\t\n\r ]*") getPackageInfo("${FILE}" "FILE_INFO_") @@ -7,9 +7,28 @@ function(checkDepends_ FILE REGEX) endif() endfunction() -checkDepends_("${FOUND_FILE_1}" ".*Depends${whitespaces_}:${whitespaces_}depend-application, depend-application-b.*") -# use wildcard as we are using dependency auto detection -checkDepends_("${FOUND_FILE_2}" ".*Depends${whitespaces_}:${whitespaces_}.*depend-application, depend-application-b.*") -checkDepends_("${FOUND_FILE_3}" ".*Depends${whitespaces_}:${whitespaces_}depend-headers.*") -checkDepends_("${FOUND_FILE_4}" ".*Depends${whitespaces_}:${whitespaces_}depend-default, depend-default-b.*") -checkDepends_("${FOUND_FILE_5}" ".*Depends${whitespaces_}:${whitespaces_}depend-default, depend-default-b.*") +foreach(dependency_type_ DEPENDS CONFLICTS ENHANCES BREAKS REPLACES RECOMMENDS SUGGESTS) + string(TOLOWER "${dependency_type_}" lower_dependency_type_) + string(SUBSTRING ${lower_dependency_type_} 1 -1 lower_dependency_type_tail_) + string(SUBSTRING ${dependency_type_} 0 1 dependency_type_head_) + set(dependency_type_name_ "${dependency_type_head_}${lower_dependency_type_tail_}") + + checkDependencies_("${FOUND_FILE_1}" ".*${dependency_type_name_}${whitespaces_}:${whitespaces_}${lower_dependency_type_}-application, ${lower_dependency_type_}-application-b.*") + checkDependencies_("${FOUND_FILE_2}" ".*${dependency_type_name_}${whitespaces_}:${whitespaces_}.*${lower_dependency_type_}-application, ${lower_dependency_type_}-application-b.*") + checkDependencies_("${FOUND_FILE_3}" ".*${dependency_type_name_}${whitespaces_}:${whitespaces_}${lower_dependency_type_}-headers.*") + checkDependencies_("${FOUND_FILE_4}" ".*${dependency_type_name_}${whitespaces_}:${whitespaces_}${lower_dependency_type_}-default, ${lower_dependency_type_}-default-b.*") + checkDependencies_("${FOUND_FILE_5}" ".*${dependency_type_name_}${whitespaces_}:${whitespaces_}${lower_dependency_type_}-default, ${lower_dependency_type_}-default-b.*") +endforeach() + +checkDependencies_("${FOUND_FILE_1}" ".*Provides${whitespaces_}:${whitespaces_}provided-default, provided-default-b") +checkDependencies_("${FOUND_FILE_2}" ".*Provides${whitespaces_}:${whitespaces_}provided-default, provided-default-b") +checkDependencies_("${FOUND_FILE_3}" ".*Provides${whitespaces_}:${whitespaces_}provided-default, provided-default-b") +checkDependencies_("${FOUND_FILE_4}" ".*Provides${whitespaces_}:${whitespaces_}provided-lib.*") +checkDependencies_("${FOUND_FILE_5}" ".*Provides${whitespaces_}:${whitespaces_}provided-lib_auto.*, provided-lib_auto-b.*") + +# PREDEPENDS +checkDependencies_("${FOUND_FILE_1}" ".*Pre-Depends${whitespaces_}:${whitespaces_}predepends-application, predepends-application-b.*") +checkDependencies_("${FOUND_FILE_2}" ".*Pre-Depends${whitespaces_}:${whitespaces_}.*predepends-application, predepends-application-b.*") +checkDependencies_("${FOUND_FILE_3}" ".*Pre-Depends${whitespaces_}:${whitespaces_}predepends-headers.*") +checkDependencies_("${FOUND_FILE_4}" ".*Pre-Depends${whitespaces_}:${whitespaces_}predepends-default, predepends-default-b.*") +checkDependencies_("${FOUND_FILE_5}" ".*Pre-Depends${whitespaces_}:${whitespaces_}predepends-default, predepends-default-b.*") diff --git a/Tests/RunCMake/CPack/DEB/DEPENDENCIES-specifics.cmake b/Tests/RunCMake/CPack/DEB/DEPENDENCIES-specifics.cmake index 9e09428..96a9f14 100644 --- a/Tests/RunCMake/CPack/DEB/DEPENDENCIES-specifics.cmake +++ b/Tests/RunCMake/CPack/DEB/DEPENDENCIES-specifics.cmake @@ -7,9 +7,15 @@ set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS FALSE) # to determine their dependencies and we can not be certain if there will be any set(CPACK_DEBIAN_APPLICATIONS_AUTO_PACKAGE_SHLIBDEPS TRUE) -set(CPACK_DEBIAN_PACKAGE_DEPENDS "depend-default, depend-default-b") -set(CPACK_DEBIAN_APPLICATIONS_PACKAGE_DEPENDS "depend-application, depend-application-b") -set(CPACK_DEBIAN_APPLICATIONS_AUTO_PACKAGE_DEPENDS "depend-application, depend-application-b") -set(CPACK_DEBIAN_HEADERS_PACKAGE_DEPENDS "depend-headers") +foreach(dependency_type_ DEPENDS CONFLICTS PREDEPENDS ENHANCES BREAKS REPLACES RECOMMENDS SUGGESTS) + string(TOLOWER "${dependency_type_}" lower_dependency_type_) -# TODO add other dependency tests once CPackDeb supports them + set(CPACK_DEBIAN_PACKAGE_${dependency_type_} "${lower_dependency_type_}-default, ${lower_dependency_type_}-default-b") + set(CPACK_DEBIAN_APPLICATIONS_PACKAGE_${dependency_type_} "${lower_dependency_type_}-application, ${lower_dependency_type_}-application-b") + set(CPACK_DEBIAN_APPLICATIONS_AUTO_PACKAGE_${dependency_type_} "${lower_dependency_type_}-application, ${lower_dependency_type_}-application-b") + set(CPACK_DEBIAN_HEADERS_PACKAGE_${dependency_type_} "${lower_dependency_type_}-headers") +endforeach() + +set(CPACK_DEBIAN_PACKAGE_PROVIDES "provided-default, provided-default-b") +set(CPACK_DEBIAN_LIBS_PACKAGE_PROVIDES "provided-lib") +set(CPACK_DEBIAN_LIBS_AUTO_PACKAGE_PROVIDES "provided-lib_auto, provided-lib_auto-b") diff --git a/Tests/RunCMake/CPack/DEB/EMPTY_DIR-ExpectedFiles.cmake b/Tests/RunCMake/CPack/DEB/EMPTY_DIR-ExpectedFiles.cmake new file mode 100644 index 0000000..1552a36 --- /dev/null +++ b/Tests/RunCMake/CPack/DEB/EMPTY_DIR-ExpectedFiles.cmake @@ -0,0 +1,5 @@ +set(whitespaces_ "[\t\n\r ]*") + +set(EXPECTED_FILES_COUNT "1") +set(EXPECTED_FILE_1 "empty_dir*.deb") +set(EXPECTED_FILE_CONTENT_1 "^.*/usr/${whitespaces_}.*/usr/empty/$") diff --git a/Tests/RunCMake/CPack/DEB/EMPTY_DIR-specifics.cmake b/Tests/RunCMake/CPack/DEB/EMPTY_DIR-specifics.cmake new file mode 100644 index 0000000..8821ab9 --- /dev/null +++ b/Tests/RunCMake/CPack/DEB/EMPTY_DIR-specifics.cmake @@ -0,0 +1 @@ +set(CPACK_PACKAGE_CONTACT "someone") diff --git a/Tests/RunCMake/CPack/DEB/Helpers.cmake b/Tests/RunCMake/CPack/DEB/Helpers.cmake index a204a3c..f490130 100644 --- a/Tests/RunCMake/CPack/DEB/Helpers.cmake +++ b/Tests/RunCMake/CPack/DEB/Helpers.cmake @@ -14,7 +14,7 @@ function(verifyDebControl FILE PREFIX VERIFY_FILES) ERROR_VARIABLE err_) if(err_) - message(FATAL_ERROR "Debian controll verification failed for file: " + message(FATAL_ERROR "Debian control verification failed for file: " "'${FILE}'; error output: '${err_}'") endif() @@ -24,6 +24,19 @@ function(verifyDebControl FILE PREFIX VERIFY_FILES) message(FATAL_ERROR "Unexpected content in for '${PREFIX}_${FILE_}'!" " Content: '${content_}'") endif() + + execute_process(COMMAND ls -l "${CMAKE_CURRENT_BINARY_DIR}/control_${PREFIX}/${FILE_}" + OUTPUT_VARIABLE package_permissions_ + ERROR_VARIABLE package_permissions_error_ + OUTPUT_STRIP_TRAILING_WHITESPACE) + + if(NOT package_permissions_error_) + if(NOT package_permissions_ MATCHES "${${PREFIX}_${FILE_}_permissions_regex}") + message(FATAL_ERROR "Unexpected file permissions for ${PREFIX}_${FILE_}: '${package_permissions_}'!") + endif() + else() + message(FATAL_ERROR "Listing file permissions failed (${package_permissions_error_})!") + endif() endforeach() endfunction() diff --git a/Tests/RunCMake/CPack/DEB_EXTRA.cmake b/Tests/RunCMake/CPack/DEB_EXTRA.cmake index 46d848d..3c291d5 100644 --- a/Tests/RunCMake/CPack/DEB_EXTRA.cmake +++ b/Tests/RunCMake/CPack/DEB_EXTRA.cmake @@ -2,14 +2,32 @@ install(FILES CMakeLists.txt DESTINATION foo COMPONENT foo) install(FILES CMakeLists.txt DESTINATION bar COMPONENT bar) install(FILES CMakeLists.txt DESTINATION bas COMPONENT bas) -file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/preinst "echo default_preinst") -file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/prerm "echo default_prerm") +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tmp/preinst "echo default_preinst") +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tmp/prerm "echo default_prerm") + +foreach(file_ preinst prerm) + file(COPY ${CMAKE_CURRENT_BINARY_DIR}/tmp/${file_} + DESTINATION ${CMAKE_CURRENT_BINARY_DIR} + FILE_PERMISSIONS + OWNER_READ OWNER_WRITE OWNER_EXECUTE + GROUP_READ GROUP_EXECUTE + WORLD_READ WORLD_EXECUTE) +endforeach() set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA - "${CMAKE_CURRENT_BINARY_DIR}/preinst;${CMAKE_CURRENT_BINARY_DIR}/prerm") + "${CMAKE_CURRENT_BINARY_DIR}/preinst;${CMAKE_CURRENT_BINARY_DIR}/prerm;${CMAKE_CURRENT_BINARY_DIR}/conffiles") + +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/bar_tmp/preinst "echo bar_preinst") +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/bar_tmp/prerm "echo bar_prerm") -file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/bar/preinst "echo bar_preinst") -file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/bar/prerm "echo bar_prerm") +foreach(file_ preinst prerm) + # not acceptable permissions for lintian but we need to check that + # permissions are preserved + file(COPY ${CMAKE_CURRENT_BINARY_DIR}/bar_tmp/${file_} + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/bar + FILE_PERMISSIONS + OWNER_READ OWNER_WRITE OWNER_EXECUTE) +endforeach() set(CPACK_DEBIAN_BAR_PACKAGE_CONTROL_EXTRA "${CMAKE_CURRENT_BINARY_DIR}/bar/preinst;${CMAKE_CURRENT_BINARY_DIR}/bar/prerm") diff --git a/Tests/RunCMake/CPack/DEPENDENCIES.cmake b/Tests/RunCMake/CPack/DEPENDENCIES.cmake index 0aef925..4f6d65f 100644 --- a/Tests/RunCMake/CPack/DEPENDENCIES.cmake +++ b/Tests/RunCMake/CPack/DEPENDENCIES.cmake @@ -1,11 +1,13 @@ +set(CMAKE_BUILD_WITH_INSTALL_RPATH 1) + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test_lib.hpp" - "int test_lib();") + "int test_lib();\n") file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test_lib.cpp" - "#include \"test_lib.hpp\"\nint test_lib() {return 0;}") + "#include \"test_lib.hpp\"\nint test_lib() {return 0;}\n") add_library(test_lib SHARED "${CMAKE_CURRENT_BINARY_DIR}/test_lib.cpp") file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/main.cpp" - "#include \"test_lib.hpp\"\nint main() {return test_lib();}") + "#include \"test_lib.hpp\"\nint main() {return test_lib();}\n") add_executable(test_prog "${CMAKE_CURRENT_BINARY_DIR}/main.cpp") target_link_libraries(test_prog test_lib) diff --git a/Tests/RunCMake/CPack/EMPTY_DIR.cmake b/Tests/RunCMake/CPack/EMPTY_DIR.cmake new file mode 100644 index 0000000..023ba17 --- /dev/null +++ b/Tests/RunCMake/CPack/EMPTY_DIR.cmake @@ -0,0 +1,4 @@ +install(DIRECTORY DESTINATION empty + COMPONENT test) + +set(CPACK_PACKAGE_NAME "empty_dir") diff --git a/Tests/RunCMake/CPack/PreTestError.cmake b/Tests/RunCMake/CPack/PreTestError.cmake deleted file mode 100644 index f88f2e8..0000000 --- a/Tests/RunCMake/CPack/PreTestError.cmake +++ /dev/null @@ -1,7 +0,0 @@ -file(READ "${bin_dir}/test_output.txt" output) -file(READ "${bin_dir}/test_error.txt" error) - -message(FATAL_ERROR "Error in pre-test phase '${RunCMake_TEST_STEP}'!\n" - "Return code: '${return_code}'\n" - "Info output: '${output}'\n" - "Error output: '${error}'") diff --git a/Tests/RunCMake/CPack/README.txt b/Tests/RunCMake/CPack/README.txt index 365c737..ea68304 100644 --- a/Tests/RunCMake/CPack/README.txt +++ b/Tests/RunCMake/CPack/README.txt @@ -32,14 +32,14 @@ different types of packages. This script is placed into CPack test root directory even if it will be used for only one of the generators. If test will be used for multiple generators but some of them require some -generator speciffic commands then those commands should be added to a separate +generator specific commands then those commands should be added to a separate file that should be located in '<generator_name>/<test_name>-specifics.cmake' in CPack test root directory. CPack execution phase: ---------------------- -Only exececutes CPack for content that was generated during CMake execution +Only executes CPack for content that was generated during CMake execution phase. Verification of generated files: diff --git a/Tests/RunCMake/CPack/RPM/COMPONENTS_EMPTY_DIR-ExpectedFiles.cmake b/Tests/RunCMake/CPack/RPM/COMPONENTS_EMPTY_DIR-ExpectedFiles.cmake new file mode 100644 index 0000000..d396276 --- /dev/null +++ b/Tests/RunCMake/CPack/RPM/COMPONENTS_EMPTY_DIR-ExpectedFiles.cmake @@ -0,0 +1,5 @@ +set(whitespaces_ "[\t\n\r ]*") + +set(EXPECTED_FILES_COUNT "1") +set(EXPECTED_FILE_1 "components_empty_dir*.rpm") +set(EXPECTED_FILE_CONTENT_1 "^/usr/empty$") diff --git a/Tests/RunCMake/CPack/RPM/COMPONENTS_EMPTY_DIR-stderr.txt b/Tests/RunCMake/CPack/RPM/COMPONENTS_EMPTY_DIR-stderr.txt new file mode 100644 index 0000000..6ddca12 --- /dev/null +++ b/Tests/RunCMake/CPack/RPM/COMPONENTS_EMPTY_DIR-stderr.txt @@ -0,0 +1 @@ +^CPackRPM: Will use GENERATED spec file: .*/Tests/RunCMake/RPM/CPack/COMPONENTS_EMPTY_DIR-build/_CPack_Packages/.*/RPM/SPECS/components_empty_dir.spec$ diff --git a/Tests/RunCMake/CPack/RPM/EMPTY_DIR-ExpectedFiles.cmake b/Tests/RunCMake/CPack/RPM/EMPTY_DIR-ExpectedFiles.cmake new file mode 100644 index 0000000..0c2977f --- /dev/null +++ b/Tests/RunCMake/CPack/RPM/EMPTY_DIR-ExpectedFiles.cmake @@ -0,0 +1,5 @@ +set(whitespaces_ "[\t\n\r ]*") + +set(EXPECTED_FILES_COUNT "1") +set(EXPECTED_FILE_1 "empty_dir*.rpm") +set(EXPECTED_FILE_CONTENT_1 "^/usr/empty$") diff --git a/Tests/RunCMake/CPack/RPM/EMPTY_DIR-stderr.txt b/Tests/RunCMake/CPack/RPM/EMPTY_DIR-stderr.txt new file mode 100644 index 0000000..1777aa0 --- /dev/null +++ b/Tests/RunCMake/CPack/RPM/EMPTY_DIR-stderr.txt @@ -0,0 +1 @@ +^CPackRPM: Will use GENERATED spec file: .*/Tests/RunCMake/RPM/CPack/EMPTY_DIR-build/_CPack_Packages/.*/RPM/SPECS/empty_dir.spec$ diff --git a/Tests/RunCMake/CPack/RunCMakeTest.cmake b/Tests/RunCMake/CPack/RunCMakeTest.cmake index 3e5714d..b7295f4 100644 --- a/Tests/RunCMake/CPack/RunCMakeTest.cmake +++ b/Tests/RunCMake/CPack/RunCMakeTest.cmake @@ -4,7 +4,9 @@ include(RunCMake) include("${RunCMake_SOURCE_DIR}/CPackTestHelpers.cmake") # args: TEST_NAME "GENERATORS" RUN_CMAKE_BUILD_STEP -run_cpack_test(MINIMAL "RPM;DEB" false) +run_cpack_test(MINIMAL "RPM;DEB;TGZ" false) run_cpack_test(PARTIALLY_RELOCATABLE_WARNING "RPM" false) run_cpack_test(DEB_EXTRA "DEB" false) run_cpack_test(DEPENDENCIES "RPM;DEB" true) +run_cpack_test(EMPTY_DIR "RPM;DEB;TGZ" true) +run_cpack_test(COMPONENTS_EMPTY_DIR "RPM;DEB;TGZ" true) diff --git a/Tests/RunCMake/CPack/TGZ/COMPONENTS_EMPTY_DIR-ExpectedFiles.cmake b/Tests/RunCMake/CPack/TGZ/COMPONENTS_EMPTY_DIR-ExpectedFiles.cmake new file mode 100644 index 0000000..26e2ab0 --- /dev/null +++ b/Tests/RunCMake/CPack/TGZ/COMPONENTS_EMPTY_DIR-ExpectedFiles.cmake @@ -0,0 +1,3 @@ +set(EXPECTED_FILES_COUNT "1") +set(EXPECTED_FILE_1 "components_empty_dir*.tar.gz") +set(EXPECTED_FILE_CONTENT_1 "^[^\n]*empty/$") diff --git a/Tests/RunCMake/CPack/TGZ/COMPONENTS_EMPTY_DIR-specifics.cmake b/Tests/RunCMake/CPack/TGZ/COMPONENTS_EMPTY_DIR-specifics.cmake new file mode 100644 index 0000000..81a5035 --- /dev/null +++ b/Tests/RunCMake/CPack/TGZ/COMPONENTS_EMPTY_DIR-specifics.cmake @@ -0,0 +1 @@ +set(CPACK_ARCHIVE_COMPONENT_INSTALL "ON") diff --git a/Tests/RunCMake/CPack/TGZ/EMPTY_DIR-ExpectedFiles.cmake b/Tests/RunCMake/CPack/TGZ/EMPTY_DIR-ExpectedFiles.cmake new file mode 100644 index 0000000..a75514a --- /dev/null +++ b/Tests/RunCMake/CPack/TGZ/EMPTY_DIR-ExpectedFiles.cmake @@ -0,0 +1,3 @@ +set(EXPECTED_FILES_COUNT "1") +set(EXPECTED_FILE_1 "empty_dir*.tar.gz") +set(EXPECTED_FILE_CONTENT_1 "^[^\n]*empty_dir-0.1.1-[^\n]*/empty/$") diff --git a/Tests/RunCMake/CPack/TGZ/Helpers.cmake b/Tests/RunCMake/CPack/TGZ/Helpers.cmake new file mode 100644 index 0000000..f14d532 --- /dev/null +++ b/Tests/RunCMake/CPack/TGZ/Helpers.cmake @@ -0,0 +1,10 @@ +set(ALL_FILES_GLOB "*.tar.gz") + +function(getPackageContent FILE RESULT_VAR) + execute_process(COMMAND ${CMAKE_COMMAND} -E tar -ztvf ${FILE} + OUTPUT_VARIABLE package_content_ + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + + set(${RESULT_VAR} "${package_content_}" PARENT_SCOPE) +endfunction() diff --git a/Tests/RunCMake/CPack/TGZ/MINIMAL-ExpectedFiles.cmake b/Tests/RunCMake/CPack/TGZ/MINIMAL-ExpectedFiles.cmake new file mode 100644 index 0000000..5c31f27 --- /dev/null +++ b/Tests/RunCMake/CPack/TGZ/MINIMAL-ExpectedFiles.cmake @@ -0,0 +1,5 @@ +set(whitespaces_ "[\t\n\r ]*") + +set(EXPECTED_FILES_COUNT "1") +set(EXPECTED_FILE_1 "minimal*.tar.gz") +set(EXPECTED_FILE_CONTENT_1 "^[^\n]*minimal-0.1.1-[^\n]*/foo/\n[^\n]*minimal-0.1.1-[^\n]*/foo/CMakeLists.txt$") diff --git a/Tests/RunCMake/CPack/TGZ/Prerequirements.cmake b/Tests/RunCMake/CPack/TGZ/Prerequirements.cmake new file mode 100644 index 0000000..dbaf682 --- /dev/null +++ b/Tests/RunCMake/CPack/TGZ/Prerequirements.cmake @@ -0,0 +1,4 @@ +function(get_test_prerequirements found_var config_file) + file(WRITE "${config_file}" "") + set(${found_var} true PARENT_SCOPE) +endfunction() diff --git a/Tests/RunCMake/CPack/VerifyResult.cmake b/Tests/RunCMake/CPack/VerifyResult.cmake index 96efa9e..6eab531 100644 --- a/Tests/RunCMake/CPack/VerifyResult.cmake +++ b/Tests/RunCMake/CPack/VerifyResult.cmake @@ -28,8 +28,9 @@ if(NOT EXPECTED_FILES_COUNT EQUAL 0) if(NOT expected_content_list) message(FATAL_ERROR - "Unexpected file content for file No. '${file_no_}'!" - " Content: '${PACKAGE_CONTENT}'" + "Unexpected file content for file No. '${file_no_}'!\n" + " Content: '${PACKAGE_CONTENT}'\n\n" + " Expected: '${EXPECTED_FILE_CONTENT_${file_no_}}'" "${output_error_message}") endif() else() @@ -56,7 +57,7 @@ if(NOT EXPECTED_FILES_COUNT EQUAL 0) "${output_error_message}") endif() - # sanity check that we didn't accidentaly list wrong files with our regular + # sanity check that we didn't accidentally list wrong files with our regular # expressions foreach(expected_ IN LISTS allFoundFiles_) list(FIND foundFiles_ "${expected_}" found_) diff --git a/Tests/RunCMake/CPackConfig/Default-check.cmake b/Tests/RunCMake/CPackConfig/Default-check.cmake new file mode 100644 index 0000000..b67fe81 --- /dev/null +++ b/Tests/RunCMake/CPackConfig/Default-check.cmake @@ -0,0 +1,7 @@ +include(${RunCMake_SOURCE_DIR}/check.cmake) + +test_variable(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "Foo\\Bar") +test_variable(CPACK_NSIS_PACKAGE_NAME "Bar\\Foo") + +test_variable(CPACK_SOURCE_IGNORE_FILES + "/CVS/;/\\.svn/;/\\.bzr/;/\\.hg/;/\\.git/;\\.swp$;\\.#;/#") diff --git a/Tests/RunCMake/CPackConfig/Default.cmake b/Tests/RunCMake/CPackConfig/Default.cmake new file mode 100644 index 0000000..3b3beb3 --- /dev/null +++ b/Tests/RunCMake/CPackConfig/Default.cmake @@ -0,0 +1,3 @@ +# two levels of escaping to pass through CPackConfig.cmake +set(CPACK_PACKAGE_INSTALL_DIRECTORY "Foo\\\\Bar") +set(CPACK_NSIS_DISPLAY_NAME "Bar\\\\Foo") diff --git a/Tests/RunCMake/CPackConfig/RunCMakeTest.cmake b/Tests/RunCMake/CPackConfig/RunCMakeTest.cmake index 6787eb8..16d2cf3 100644 --- a/Tests/RunCMake/CPackConfig/RunCMakeTest.cmake +++ b/Tests/RunCMake/CPackConfig/RunCMakeTest.cmake @@ -1,3 +1,6 @@ include(RunCMake) run_cmake(Simple) +run_cmake(Default) +run_cmake(Special) +run_cmake(Verbatim) diff --git a/Tests/RunCMake/CPackConfig/Special-check.cmake b/Tests/RunCMake/CPackConfig/Special-check.cmake new file mode 100644 index 0000000..0624b79 --- /dev/null +++ b/Tests/RunCMake/CPackConfig/Special-check.cmake @@ -0,0 +1,5 @@ +include(${RunCMake_SOURCE_DIR}/check.cmake) + +test_variable(CPACK_BACKSLASH "\\") +test_variable(CPACK_QUOTE "a;b;c") +test_variable(CPACK_DOLLAR "ab") diff --git a/Tests/RunCMake/CPackConfig/Special.cmake b/Tests/RunCMake/CPackConfig/Special.cmake new file mode 100644 index 0000000..9442c93 --- /dev/null +++ b/Tests/RunCMake/CPackConfig/Special.cmake @@ -0,0 +1,3 @@ +set(CPACK_BACKSLASH "\\\\") +set(CPACK_QUOTE "a\" b \"c") +set(CPACK_DOLLAR "a\${NOTHING}b") diff --git a/Tests/RunCMake/CPackConfig/Verbatim-check.cmake b/Tests/RunCMake/CPackConfig/Verbatim-check.cmake new file mode 100644 index 0000000..958547d --- /dev/null +++ b/Tests/RunCMake/CPackConfig/Verbatim-check.cmake @@ -0,0 +1,10 @@ +include(${RunCMake_SOURCE_DIR}/check.cmake) + +test_variable(CPACK_BACKSLASH "\\\\") +test_variable(CPACK_QUOTE "a\" b \"c") +test_variable(CPACK_DOLLAR "a\${NOTHING}b") + +# make sure the default for this is still set correctly with +# CPACK_VERBATIM_VARIABLES on +test_variable(CPACK_SOURCE_IGNORE_FILES + "/CVS/;/\\.svn/;/\\.bzr/;/\\.hg/;/\\.git/;\\.swp$;\\.#;/#") diff --git a/Tests/RunCMake/CPackConfig/Verbatim.cmake b/Tests/RunCMake/CPackConfig/Verbatim.cmake new file mode 100644 index 0000000..4d271c3 --- /dev/null +++ b/Tests/RunCMake/CPackConfig/Verbatim.cmake @@ -0,0 +1,5 @@ +set(CPACK_VERBATIM_VARIABLES YES) + +set(CPACK_BACKSLASH "\\\\") +set(CPACK_QUOTE "a\" b \"c") +set(CPACK_DOLLAR "a\${NOTHING}b") diff --git a/Tests/RunCMake/CPackConfig/check.cmake b/Tests/RunCMake/CPackConfig/check.cmake index 2fc9f11..ca6229e 100644 --- a/Tests/RunCMake/CPackConfig/check.cmake +++ b/Tests/RunCMake/CPackConfig/check.cmake @@ -1,3 +1,5 @@ +cmake_minimum_required(VERSION ${CMAKE_VERSION} FATAL_ERROR) + function(test_variable NAME EXPECTED_VALUE) if(NOT "${${NAME}}" STREQUAL "${EXPECTED_VALUE}") message(FATAL_ERROR "${NAME}: variable mismatch; expected [${EXPECTED_VALUE}] actual [${${NAME}}]") @@ -5,3 +7,4 @@ function(test_variable NAME EXPECTED_VALUE) endfunction() include(${RunCMake_TEST_BINARY_DIR}/CPackConfig.cmake) +include(${RunCMake_TEST_BINARY_DIR}/CPackSourceConfig.cmake) diff --git a/Tests/RunCMake/CTestCommandLine/RunCMakeTest.cmake b/Tests/RunCMake/CTestCommandLine/RunCMakeTest.cmake index dfc1e33..2bc3693 100644 --- a/Tests/RunCMake/CTestCommandLine/RunCMakeTest.cmake +++ b/Tests/RunCMake/CTestCommandLine/RunCMakeTest.cmake @@ -78,6 +78,21 @@ endfunction() run_LabelCount() +function(run_SerialFailed) + set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/SerialFailed) + set(RunCMake_TEST_NO_CLEAN 1) + file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") + file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") + file(WRITE "${RunCMake_TEST_BINARY_DIR}/CTestTestfile.cmake" " +add_test(NoSuchCommand no_such_command) +set_tests_properties(NoSuchCommand PROPERTIES RUN_SERIAL ON) +add_test(Echo \"${CMAKE_COMMAND}\" -E echo \"EchoTest\") +") + + run_cmake_command(SerialFailed ${CMAKE_CTEST_COMMAND} -V) +endfunction() +run_SerialFailed() + function(run_TestLoad name load) set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/TestLoad) set(RunCMake_TEST_NO_CLEAN 1) @@ -108,3 +123,20 @@ run_TestLoad(test-load-invalid 'two') run_TestLoad(test-load-pass 10) unset(ENV{__CTEST_FAKE_LOAD_AVERAGE_FOR_TESTING}) + +function(run_TestOutputSize) + set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/TestOutputSize) + set(RunCMake_TEST_NO_CLEAN 1) + file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") + file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") + file(WRITE "${RunCMake_TEST_BINARY_DIR}/CTestTestfile.cmake" " + add_test(PassingTest \"${CMAKE_COMMAND}\" -E echo PassingTestOutput) + add_test(FailingTest \"${CMAKE_COMMAND}\" -E no_such_command) +") + run_cmake_command(TestOutputSize + ${CMAKE_CTEST_COMMAND} -M Experimental -T Test + --test-output-size-passed 10 + --test-output-size-failed 12 + ) +endfunction() +run_TestOutputSize() diff --git a/Tests/RunCMake/CTestCommandLine/SerialFailed-result.txt b/Tests/RunCMake/CTestCommandLine/SerialFailed-result.txt new file mode 100644 index 0000000..45a4fb7 --- /dev/null +++ b/Tests/RunCMake/CTestCommandLine/SerialFailed-result.txt @@ -0,0 +1 @@ +8 diff --git a/Tests/RunCMake/CTestCommandLine/SerialFailed-stderr.txt b/Tests/RunCMake/CTestCommandLine/SerialFailed-stderr.txt new file mode 100644 index 0000000..cafe565 --- /dev/null +++ b/Tests/RunCMake/CTestCommandLine/SerialFailed-stderr.txt @@ -0,0 +1 @@ +Unable to find executable: no_such_command diff --git a/Tests/RunCMake/CTestCommandLine/SerialFailed-stdout.txt b/Tests/RunCMake/CTestCommandLine/SerialFailed-stdout.txt new file mode 100644 index 0000000..d7144f7 --- /dev/null +++ b/Tests/RunCMake/CTestCommandLine/SerialFailed-stdout.txt @@ -0,0 +1,10 @@ +Could not find executable no_such_command +.* +2/2 Test #2: Echo ............................. Passed +[0-9.]+ sec ++ +50% tests passed, 1 tests failed out of 2 ++ +Total Test time \(real\) = +[0-9.]+ sec ++ +The following tests FAILED: +[ ]+1 - NoSuchCommand \(Not Run\)$ diff --git a/Tests/RunCMake/CTestCommandLine/TestOutputSize-check.cmake b/Tests/RunCMake/CTestCommandLine/TestOutputSize-check.cmake new file mode 100644 index 0000000..918d242 --- /dev/null +++ b/Tests/RunCMake/CTestCommandLine/TestOutputSize-check.cmake @@ -0,0 +1,17 @@ +file(GLOB test_xml_file "${RunCMake_TEST_BINARY_DIR}/Testing/*/Test.xml") +if(test_xml_file) + file(READ "${test_xml_file}" test_xml LIMIT 4096) + if("${test_xml}" MATCHES [[(<Test Status="passed">.*</Test>).*(<Test Status="failed">.*</Test>)]]) + set(test_passed "${CMAKE_MATCH_1}") + set(test_failed "${CMAKE_MATCH_2}") + else() + set(RunCMake_TEST_FAILED "Test.xml does not contain a passed then failed test:\n ${test_xml}") + endif() + if(NOT "${test_passed}" MATCHES [[<Value>PassingTes\.\.\..*10 bytes]]) + set(RunCMake_TEST_FAILED "Test.xml passed test output not truncated at 10 bytes:\n ${test_passed}") + elseif(NOT "${test_failed}" MATCHES [[<Value>CMake Error:\.\.\..*12 bytes]]) + set(RunCMake_TEST_FAILED "Test.xml failed test output not truncated at 12 bytes:\n ${test_failed}") + endif() +else() + set(RunCMake_TEST_FAILED "Test.xml not found") +endif() diff --git a/Tests/RunCMake/CTestCommandLine/TestOutputSize-result.txt b/Tests/RunCMake/CTestCommandLine/TestOutputSize-result.txt new file mode 100644 index 0000000..9c558e3 --- /dev/null +++ b/Tests/RunCMake/CTestCommandLine/TestOutputSize-result.txt @@ -0,0 +1 @@ +. diff --git a/Tests/RunCMake/CTestCommandLine/TestOutputSize-stderr.txt b/Tests/RunCMake/CTestCommandLine/TestOutputSize-stderr.txt new file mode 100644 index 0000000..ba4235d --- /dev/null +++ b/Tests/RunCMake/CTestCommandLine/TestOutputSize-stderr.txt @@ -0,0 +1 @@ +Errors while running CTest diff --git a/Tests/RunCMake/CommandLine/P_working-dir.cmake b/Tests/RunCMake/CommandLine/P_working-dir.cmake new file mode 100644 index 0000000..4ea0293 --- /dev/null +++ b/Tests/RunCMake/CommandLine/P_working-dir.cmake @@ -0,0 +1,14 @@ +if(NOT IS_DIRECTORY "${EXPECTED_WORKING_DIR}") + message(FATAL_ERROR "EXPECTED_WORKING_DIR is not a directory: ${EXPECTED_WORKING_DIR}") +endif() + +foreach(d CMAKE_BINARY_DIR CMAKE_CURRENT_BINARY_DIR CMAKE_SOURCE_DIR CMAKE_CURRENT_SOURCE_DIR) + if(NOT DEFINED ${d}) + message(FATAL_ERROR "${d} is not defined") + endif() + if(EXPECTED_WORKING_DIR STREQUAL "${${d}}") + message(STATUS "${d} is the expected working directory (${EXPECTED_WORKING_DIR})") + else() + message(FATAL_ERROR "${d} = \"${${d}}\" is not the expected working directory (${EXPECTED_WORKING_DIR})") + endif() +endforeach() diff --git a/Tests/RunCMake/CommandLine/RunCMakeTest.cmake b/Tests/RunCMake/CommandLine/RunCMakeTest.cmake index 0da737d..2d94e29 100644 --- a/Tests/RunCMake/CommandLine/RunCMakeTest.cmake +++ b/Tests/RunCMake/CommandLine/RunCMakeTest.cmake @@ -115,6 +115,7 @@ run_cmake_command(E_sleep-bad-arg2 ${CMAKE_COMMAND} -E sleep 1 -1) run_cmake_command(E_sleep-one-tenth ${CMAKE_COMMAND} -E sleep 0.1) run_cmake_command(P_directory ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}) +run_cmake_command(P_working-dir ${CMAKE_COMMAND} -DEXPECTED_WORKING_DIR=${RunCMake_BINARY_DIR}/P_working-dir-build -P ${RunCMake_SOURCE_DIR}/P_working-dir.cmake) set(RunCMake_TEST_OPTIONS "-DFOO=-DBAR:BOOL=BAZ") @@ -132,52 +133,6 @@ set(RunCMake_TEST_OPTIONS -Wno-dev -Wdev) run_cmake(Wdev) unset(RunCMake_TEST_OPTIONS) -set(RunCMake_TEST_OPTIONS -Werror=dev) -run_cmake(Werror_dev) -unset(RunCMake_TEST_OPTIONS) - -set(RunCMake_TEST_OPTIONS -Wno-error=dev) -run_cmake(Wno-error_deprecated) -unset(RunCMake_TEST_OPTIONS) - -# -Wdev should not override deprecated options if specified -set(RunCMake_TEST_OPTIONS -Wdev -Wno-deprecated) -run_cmake(Wno-deprecated) -unset(RunCMake_TEST_OPTIONS) -set(RunCMake_TEST_OPTIONS -Wno-deprecated -Wdev) -run_cmake(Wno-deprecated) -unset(RunCMake_TEST_OPTIONS) - -# -Wdev should enable deprecated warnings as well -set(RunCMake_TEST_OPTIONS -Wdev) -run_cmake(Wdeprecated) -unset(RunCMake_TEST_OPTIONS) - -# -Werror=dev should enable deprecated errors as well -set(RunCMake_TEST_OPTIONS -Werror=dev) -run_cmake(Werror_deprecated) -unset(RunCMake_TEST_OPTIONS) - -set(RunCMake_TEST_OPTIONS -Wdeprecated) -run_cmake(Wdeprecated) -unset(RunCMake_TEST_OPTIONS) - -set(RunCMake_TEST_OPTIONS -Wno-deprecated) -run_cmake(Wno-deprecated) -unset(RunCMake_TEST_OPTIONS) - -set(RunCMake_TEST_OPTIONS -Werror=deprecated) -run_cmake(Werror_deprecated) -unset(RunCMake_TEST_OPTIONS) - -set(RunCMake_TEST_OPTIONS -Wno-error=deprecated) -run_cmake(Wno-error_deprecated) -unset(RunCMake_TEST_OPTIONS) - -run_cmake_command(W_bad-arg1 ${CMAKE_COMMAND} -W) -run_cmake_command(W_bad-arg2 ${CMAKE_COMMAND} -Wno-) -run_cmake_command(W_bad-arg3 ${CMAKE_COMMAND} -Werror=) - set(RunCMake_TEST_OPTIONS --debug-output) run_cmake(debug-output) unset(RunCMake_TEST_OPTIONS) diff --git a/Tests/RunCMake/CommandLine/W_bad-arg1-result.txt b/Tests/RunCMake/CommandLine/W_bad-arg1-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CommandLine/W_bad-arg1-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CommandLine/W_bad-arg1-stderr.txt b/Tests/RunCMake/CommandLine/W_bad-arg1-stderr.txt deleted file mode 100644 index e912728..0000000 --- a/Tests/RunCMake/CommandLine/W_bad-arg1-stderr.txt +++ /dev/null @@ -1,2 +0,0 @@ -CMake Error: -W must be followed with \[no-\]\[error=\]<name>. -CMake Error: Problem processing arguments. Aborting. diff --git a/Tests/RunCMake/CommandLine/W_bad-arg2-result.txt b/Tests/RunCMake/CommandLine/W_bad-arg2-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CommandLine/W_bad-arg2-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CommandLine/W_bad-arg2-stderr.txt b/Tests/RunCMake/CommandLine/W_bad-arg2-stderr.txt deleted file mode 100644 index cc643df..0000000 --- a/Tests/RunCMake/CommandLine/W_bad-arg2-stderr.txt +++ /dev/null @@ -1,2 +0,0 @@ -CMake Error: No warning name provided. -CMake Error: Problem processing arguments. Aborting. diff --git a/Tests/RunCMake/CommandLine/W_bad-arg3-stderr.txt b/Tests/RunCMake/CommandLine/W_bad-arg3-stderr.txt deleted file mode 100644 index cc643df..0000000 --- a/Tests/RunCMake/CommandLine/W_bad-arg3-stderr.txt +++ /dev/null @@ -1,2 +0,0 @@ -CMake Error: No warning name provided. -CMake Error: Problem processing arguments. Aborting. diff --git a/Tests/RunCMake/CommandLine/Wdeprecated-stderr.txt b/Tests/RunCMake/CommandLine/Wdeprecated-stderr.txt deleted file mode 100644 index e9be1dc..0000000 --- a/Tests/RunCMake/CommandLine/Wdeprecated-stderr.txt +++ /dev/null @@ -1,4 +0,0 @@ -^CMake Deprecation Warning at Wdeprecated.cmake:1 \(message\): - Some deprecated warning -Call Stack \(most recent call first\): - CMakeLists.txt:3 \(include\) diff --git a/Tests/RunCMake/CommandLine/Wdeprecated.cmake b/Tests/RunCMake/CommandLine/Wdeprecated.cmake deleted file mode 100644 index 3142b42..0000000 --- a/Tests/RunCMake/CommandLine/Wdeprecated.cmake +++ /dev/null @@ -1 +0,0 @@ -message(DEPRECATION "Some deprecated warning") diff --git a/Tests/RunCMake/CommandLine/Wdev-stderr.txt b/Tests/RunCMake/CommandLine/Wdev-stderr.txt index f427303..92c1d23 100644 --- a/Tests/RunCMake/CommandLine/Wdev-stderr.txt +++ b/Tests/RunCMake/CommandLine/Wdev-stderr.txt @@ -2,4 +2,10 @@ Some Author Warning Call Stack \(most recent call first\): CMakeLists.txt:3 \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. + +CMake Warning \(dev\) at Wdev.cmake:6 \(include\): + include\(\) given empty file name \(ignored\). +Call Stack \(most recent call first\): + CMakeLists.txt:3 \(include\) This warning is for project developers. Use -Wno-dev to suppress it.$ diff --git a/Tests/RunCMake/CommandLine/Wdev.cmake b/Tests/RunCMake/CommandLine/Wdev.cmake index 0242086..e5026ef 100644 --- a/Tests/RunCMake/CommandLine/Wdev.cmake +++ b/Tests/RunCMake/CommandLine/Wdev.cmake @@ -1 +1,6 @@ message(AUTHOR_WARNING "Some Author Warning") + +# with -Wdev this will also cause an AUTHOR_WARNING message, checks that +# messages issued outside of the message command, by other CMake commands, also +# are affected by -Wdev +include("") diff --git a/Tests/RunCMake/CommandLine/Werror_deprecated-stderr.txt b/Tests/RunCMake/CommandLine/Werror_deprecated-stderr.txt deleted file mode 100644 index 6acdc73..0000000 --- a/Tests/RunCMake/CommandLine/Werror_deprecated-stderr.txt +++ /dev/null @@ -1,4 +0,0 @@ -^CMake Deprecation Error at Werror_deprecated.cmake:1 \(message\): - Some deprecated warning -Call Stack \(most recent call first\): - CMakeLists.txt:3 \(include\) diff --git a/Tests/RunCMake/CommandLine/Werror_deprecated.cmake b/Tests/RunCMake/CommandLine/Werror_deprecated.cmake deleted file mode 100644 index 3142b42..0000000 --- a/Tests/RunCMake/CommandLine/Werror_deprecated.cmake +++ /dev/null @@ -1 +0,0 @@ -message(DEPRECATION "Some deprecated warning") diff --git a/Tests/RunCMake/CommandLine/Werror_dev-stderr.txt b/Tests/RunCMake/CommandLine/Werror_dev-stderr.txt deleted file mode 100644 index c6b4e74..0000000 --- a/Tests/RunCMake/CommandLine/Werror_dev-stderr.txt +++ /dev/null @@ -1,5 +0,0 @@ -^CMake Error \(dev\) at Werror_dev.cmake:1 \(message\): - Some author warning -Call Stack \(most recent call first\): - CMakeLists.txt:3 \(include\) -This error is for project developers. Use -Wno-error=dev to suppress it.$ diff --git a/Tests/RunCMake/CommandLine/Werror_dev.cmake b/Tests/RunCMake/CommandLine/Werror_dev.cmake deleted file mode 100644 index e05cf9d..0000000 --- a/Tests/RunCMake/CommandLine/Werror_dev.cmake +++ /dev/null @@ -1 +0,0 @@ -message(AUTHOR_WARNING "Some author warning") diff --git a/Tests/RunCMake/CommandLine/Wno-deprecated.cmake b/Tests/RunCMake/CommandLine/Wno-deprecated.cmake deleted file mode 100644 index 3142b42..0000000 --- a/Tests/RunCMake/CommandLine/Wno-deprecated.cmake +++ /dev/null @@ -1 +0,0 @@ -message(DEPRECATION "Some deprecated warning") diff --git a/Tests/RunCMake/CommandLine/Wno-dev.cmake b/Tests/RunCMake/CommandLine/Wno-dev.cmake index 0242086..d81b858 100644 --- a/Tests/RunCMake/CommandLine/Wno-dev.cmake +++ b/Tests/RunCMake/CommandLine/Wno-dev.cmake @@ -1 +1,6 @@ message(AUTHOR_WARNING "Some Author Warning") + +# without -Wno-dev this will also cause an AUTHOR_WARNING message, checks that +# messages issued outside of the message command, by other CMake commands, also +# are affected by -Wno-dev +include("") diff --git a/Tests/RunCMake/CommandLine/Wno-error_deprecated.cmake b/Tests/RunCMake/CommandLine/Wno-error_deprecated.cmake deleted file mode 100644 index 3142b42..0000000 --- a/Tests/RunCMake/CommandLine/Wno-error_deprecated.cmake +++ /dev/null @@ -1 +0,0 @@ -message(DEPRECATION "Some deprecated warning") diff --git a/Tests/RunCMake/CommandLine/Wno-error_dev.cmake b/Tests/RunCMake/CommandLine/Wno-error_dev.cmake deleted file mode 100644 index e05cf9d..0000000 --- a/Tests/RunCMake/CommandLine/Wno-error_dev.cmake +++ /dev/null @@ -1 +0,0 @@ -message(AUTHOR_WARNING "Some author warning") diff --git a/Tests/RunCMake/CompileFeatures/RunCMakeTest.cmake b/Tests/RunCMake/CompileFeatures/RunCMakeTest.cmake index c1b2227..8dc627d 100644 --- a/Tests/RunCMake/CompileFeatures/RunCMakeTest.cmake +++ b/Tests/RunCMake/CompileFeatures/RunCMakeTest.cmake @@ -29,7 +29,7 @@ if (NOT CXX_FEATURES) run_cmake(NoSupportedCxxFeatures) run_cmake(NoSupportedCxxFeaturesGenex) else() - if(CXX_STANDARD_DEFAULT) + if(CXX_STANDARD_DEFAULT EQUAL 98) run_cmake(LinkImplementationFeatureCycle) endif() run_cmake(LinkImplementationFeatureCycleSolved) diff --git a/Tests/RunCMake/FindPkgConfig/FindPkgConfig_GET_VARIABLE-stdout.txt b/Tests/RunCMake/FindPkgConfig/FindPkgConfig_GET_VARIABLE-stdout.txt new file mode 100644 index 0000000..5f211eb --- /dev/null +++ b/Tests/RunCMake/FindPkgConfig/FindPkgConfig_GET_VARIABLE-stdout.txt @@ -0,0 +1 @@ +-- g_ir_scanner: .*/g-ir-scanner diff --git a/Tests/RunCMake/FindPkgConfig/FindPkgConfig_GET_VARIABLE.cmake b/Tests/RunCMake/FindPkgConfig/FindPkgConfig_GET_VARIABLE.cmake new file mode 100644 index 0000000..c85efaa --- /dev/null +++ b/Tests/RunCMake/FindPkgConfig/FindPkgConfig_GET_VARIABLE.cmake @@ -0,0 +1,9 @@ +find_package(PkgConfig REQUIRED) +pkg_check_modules(GOBJECT_INTROSPECTION QUIET gobject-introspection-1.0) + +if (GOBJECT_INTROSPECTION_FOUND) + pkg_get_variable(g_ir_scanner gobject-introspection-1.0 g_ir_scanner) + message(STATUS "g_ir_scanner: ${g_ir_scanner}") +else () + message(STATUS "g_ir_scanner: skipping test; gobject-introspection-1.0 not found /g-ir-scanner") +endif () diff --git a/Tests/RunCMake/FindPkgConfig/RunCMakeTest.cmake b/Tests/RunCMake/FindPkgConfig/RunCMakeTest.cmake index 29301d7..bb04aa2 100644 --- a/Tests/RunCMake/FindPkgConfig/RunCMakeTest.cmake +++ b/Tests/RunCMake/FindPkgConfig/RunCMakeTest.cmake @@ -9,3 +9,9 @@ if(APPLE) run_cmake(FindPkgConfig_CMAKE_FRAMEWORK_PATH) run_cmake(FindPkgConfig_CMAKE_APPBUNDLE_PATH) endif() + +# We need a real pkg-config to run the test for get_variable. +find_package(PkgConfig) +if (PKG_CONFIG_FOUND) + run_cmake(FindPkgConfig_GET_VARIABLE) +endif () diff --git a/Tests/RunCMake/FindPkgConfig/dummy-pkg-config.sh b/Tests/RunCMake/FindPkgConfig/dummy-pkg-config.sh index 852e841..abe14bf 100755 --- a/Tests/RunCMake/FindPkgConfig/dummy-pkg-config.sh +++ b/Tests/RunCMake/FindPkgConfig/dummy-pkg-config.sh @@ -10,9 +10,10 @@ case $1 in ;; --exists) shift - echo "Expected: $@" + eval last=\${$#} + echo "Expected: ${last}" echo "Found: ${PKG_CONFIG_PATH}" - [ "$@" = "${PKG_CONFIG_PATH}" ] || exit 1 + [ "${last}" = "${PKG_CONFIG_PATH}" ] || exit 1 ;; *) exit 255 diff --git a/Tests/RunCMake/CommandLine/Werror_dev-result.txt b/Tests/RunCMake/GeneratorExpression/BadSHELL_PATH-result.txt index d00491f..d00491f 100644 --- a/Tests/RunCMake/CommandLine/Werror_dev-result.txt +++ b/Tests/RunCMake/GeneratorExpression/BadSHELL_PATH-result.txt diff --git a/Tests/RunCMake/GeneratorExpression/BadSHELL_PATH-stderr.txt b/Tests/RunCMake/GeneratorExpression/BadSHELL_PATH-stderr.txt new file mode 100644 index 0000000..8d3c4cc --- /dev/null +++ b/Tests/RunCMake/GeneratorExpression/BadSHELL_PATH-stderr.txt @@ -0,0 +1,17 @@ +CMake Error at BadSHELL_PATH.cmake:[0-9]+ \(add_custom_target\): + Error evaluating generator expression: + + \$<SHELL_PATH:> + + "" is not an absolute path. +Call Stack \(most recent call first\): + CMakeLists.txt:3 \(include\) ++ +CMake Error at BadSHELL_PATH.cmake:[0-9]+ \(add_custom_target\): + Error evaluating generator expression: + + \$<SHELL_PATH:Relative/Path> + + "Relative/Path" is not an absolute path. +Call Stack \(most recent call first\): + CMakeLists.txt:3 \(include\) diff --git a/Tests/RunCMake/GeneratorExpression/BadSHELL_PATH.cmake b/Tests/RunCMake/GeneratorExpression/BadSHELL_PATH.cmake new file mode 100644 index 0000000..5eff7bc --- /dev/null +++ b/Tests/RunCMake/GeneratorExpression/BadSHELL_PATH.cmake @@ -0,0 +1,4 @@ +add_custom_target(check ALL COMMAND check + $<SHELL_PATH:> + $<SHELL_PATH:Relative/Path> + VERBATIM) diff --git a/Tests/RunCMake/GeneratorExpression/RunCMakeTest.cmake b/Tests/RunCMake/GeneratorExpression/RunCMakeTest.cmake index 0679024..45175d8 100644 --- a/Tests/RunCMake/GeneratorExpression/RunCMakeTest.cmake +++ b/Tests/RunCMake/GeneratorExpression/RunCMakeTest.cmake @@ -10,6 +10,7 @@ run_cmake(BadTargetName) run_cmake(BadTargetTypeInterface) run_cmake(BadTargetTypeObject) run_cmake(BadInstallPrefix) +run_cmake(BadSHELL_PATH) run_cmake(CMP0044-WARN) run_cmake(NonValidTarget-C_COMPILER_ID) run_cmake(NonValidTarget-CXX_COMPILER_ID) diff --git a/Tests/RunCMake/LinkStatic/CMakeLists.txt b/Tests/RunCMake/LinkStatic/CMakeLists.txt new file mode 100644 index 0000000..74b3ff8 --- /dev/null +++ b/Tests/RunCMake/LinkStatic/CMakeLists.txt @@ -0,0 +1,3 @@ +cmake_minimum_required(VERSION 3.3) +project(${RunCMake_TEST} NONE) +include(${RunCMake_TEST}.cmake) diff --git a/Tests/RunCMake/set_property/LINK_SEARCH_STATIC.cmake b/Tests/RunCMake/LinkStatic/LINK_SEARCH_STATIC.cmake index 70d2fee..6db5c85 100644 --- a/Tests/RunCMake/set_property/LINK_SEARCH_STATIC.cmake +++ b/Tests/RunCMake/LinkStatic/LINK_SEARCH_STATIC.cmake @@ -1,4 +1,4 @@ -project(LinkSearchStatic) +enable_language(C) set(CMAKE_LINK_SEARCH_START_STATIC ON) add_executable(LinkSearchStartStaticInit1 LinkStatic.c) diff --git a/Tests/RunCMake/set_property/LinkStatic.c b/Tests/RunCMake/LinkStatic/LinkStatic.c index 3600977..3600977 100644 --- a/Tests/RunCMake/set_property/LinkStatic.c +++ b/Tests/RunCMake/LinkStatic/LinkStatic.c diff --git a/Tests/RunCMake/LinkStatic/RunCMakeTest.cmake b/Tests/RunCMake/LinkStatic/RunCMakeTest.cmake new file mode 100644 index 0000000..0d29492 --- /dev/null +++ b/Tests/RunCMake/LinkStatic/RunCMakeTest.cmake @@ -0,0 +1,3 @@ +include(RunCMake) + +run_cmake(LINK_SEARCH_STATIC) diff --git a/Tests/RunCMake/RunCMake.cmake b/Tests/RunCMake/RunCMake.cmake index 46bc494..db9911d 100644 --- a/Tests/RunCMake/RunCMake.cmake +++ b/Tests/RunCMake/RunCMake.cmake @@ -102,7 +102,7 @@ function(run_cmake test) endif() foreach(o out err) string(REGEX REPLACE "\r\n" "\n" actual_std${o} "${actual_std${o}}") - string(REGEX REPLACE "(^|\n)((==[0-9]+==|BullseyeCoverage|[a-z]+\\([0-9]+\\) malloc:|Error kstat returned)[^\n]*\n)+" "\\1" actual_std${o} "${actual_std${o}}") + string(REGEX REPLACE "(^|\n)((==[0-9]+==|BullseyeCoverage|[a-z]+\\([0-9]+\\) malloc:|Error kstat returned|[^\n]*from Time Machine by path|[^\n]*Bullseye Testing Technology)[^\n]*\n)+" "\\1" actual_std${o} "${actual_std${o}}") string(REGEX REPLACE "\n+$" "" actual_std${o} "${actual_std${o}}") set(expect_${o} "") if(DEFINED expect_std${o}) @@ -115,7 +115,11 @@ function(run_cmake test) endif() endforeach() unset(RunCMake_TEST_FAILED) - include(${top_src}/${test}-check.cmake OPTIONAL) + if(RunCMake-check-file AND EXISTS ${top_src}/${RunCMake-check-file}) + include(${top_src}/${RunCMake-check-file}) + else() + include(${top_src}/${test}-check.cmake OPTIONAL) + endif() if(RunCMake_TEST_FAILED) set(msg "${RunCMake_TEST_FAILED}\n${msg}") endif() diff --git a/Tests/RunCMake/Swift/Enable-stdout.txt b/Tests/RunCMake/Swift/Enable-stdout.txt deleted file mode 100644 index 39e133f..0000000 --- a/Tests/RunCMake/Swift/Enable-stdout.txt +++ /dev/null @@ -1 +0,0 @@ --- The Swift compiler identification is Apple diff --git a/Tests/RunCMake/Swift/Enable.cmake b/Tests/RunCMake/Swift/Enable.cmake deleted file mode 100644 index 19f297a..0000000 --- a/Tests/RunCMake/Swift/Enable.cmake +++ /dev/null @@ -1 +0,0 @@ -enable_language(Swift) diff --git a/Tests/RunCMake/Swift/RunCMakeTest.cmake b/Tests/RunCMake/Swift/RunCMakeTest.cmake index 0a57121..4864295 100644 --- a/Tests/RunCMake/Swift/RunCMakeTest.cmake +++ b/Tests/RunCMake/Swift/RunCMakeTest.cmake @@ -3,8 +3,6 @@ include(RunCMake) if(RunCMake_GENERATOR STREQUAL Xcode) if(XCODE_BELOW_6_1) run_cmake(XcodeTooOld) - else() - run_cmake(Enable) endif() else() run_cmake(NotSupported) diff --git a/Tests/RunCMake/TargetPolicies/PolicyList-stderr.txt b/Tests/RunCMake/TargetPolicies/PolicyList-stderr.txt index d0aa995..57047fb 100644 --- a/Tests/RunCMake/TargetPolicies/PolicyList-stderr.txt +++ b/Tests/RunCMake/TargetPolicies/PolicyList-stderr.txt @@ -19,6 +19,7 @@ \* CMP0052 \* CMP0060 \* CMP0063 + \* CMP0065 Call Stack \(most recent call first\): CMakeLists.txt:3 \(include\) diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-exe-stderr.txt b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-exe-stderr.txt new file mode 100644 index 0000000..b8d726f --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-exe-stderr.txt @@ -0,0 +1,15 @@ +CMake Warning \(dev\) at CMP0063-WARN-exe.cmake:[0-9]+ \(add_executable\): + Policy CMP0063 is not set: Honor visibility properties for all target + types. Run "cmake --help-policy CMP0063" for policy details. Use the + cmake_policy command to set the policy and suppress this warning. + + Target "myexe" of type "EXECUTABLE" has the following visibility properties + set for CXX: + + CXX_VISIBILITY_PRESET + VISIBILITY_INLINES_HIDDEN + + For compatibility CMake is not honoring them for this target. +Call Stack \(most recent call first\): + CMakeLists.txt:[0-9]+ \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes.cmake b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-exe.cmake index 3388e4d..cef1d75 100644 --- a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes.cmake +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-exe.cmake @@ -5,4 +5,7 @@ enable_language(CXX) set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden") set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY "-fvisibility=") -include(CMP0063-Common.cmake) +set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) +set(CMAKE_CXX_VISIBILITY_PRESET hidden) + +add_executable(myexe lib.cpp) diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-obj-stderr.txt b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-obj-stderr.txt new file mode 100644 index 0000000..3a7732a --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-obj-stderr.txt @@ -0,0 +1,15 @@ +CMake Warning \(dev\) at CMP0063-WARN-obj.cmake:[0-9]+ \(add_library\): + Policy CMP0063 is not set: Honor visibility properties for all target + types. Run "cmake --help-policy CMP0063" for policy details. Use the + cmake_policy command to set the policy and suppress this warning. + + Target "myobject" of type "OBJECT_LIBRARY" has the following visibility + properties set for CXX: + + CXX_VISIBILITY_PRESET + VISIBILITY_INLINES_HIDDEN + + For compatibility CMake is not honoring them for this target. +Call Stack \(most recent call first\): + CMakeLists.txt:[0-9]+ \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-obj.cmake b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-obj.cmake new file mode 100644 index 0000000..81d1c33 --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-obj.cmake @@ -0,0 +1,11 @@ + +enable_language(CXX) + +# Ensure CMake warns even if toolchain does not really have these flags. +set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden") +set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY "-fvisibility=") + +set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) +set(CMAKE_CXX_VISIBILITY_PRESET hidden) + +add_library(myobject OBJECT lib.cpp) diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-sta-stderr.txt b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-sta-stderr.txt new file mode 100644 index 0000000..1efa1b5 --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-sta-stderr.txt @@ -0,0 +1,15 @@ +CMake Warning \(dev\) at CMP0063-WARN-sta.cmake:[0-9]+ \(add_library\): + Policy CMP0063 is not set: Honor visibility properties for all target + types. Run "cmake --help-policy CMP0063" for policy details. Use the + cmake_policy command to set the policy and suppress this warning. + + Target "mystatic" of type "STATIC_LIBRARY" has the following visibility + properties set for CXX: + + CXX_VISIBILITY_PRESET + VISIBILITY_INLINES_HIDDEN + + For compatibility CMake is not honoring them for this target. +Call Stack \(most recent call first\): + CMakeLists.txt:[0-9]+ \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-sta.cmake b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-sta.cmake new file mode 100644 index 0000000..132e076 --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-sta.cmake @@ -0,0 +1,11 @@ + +enable_language(CXX) + +# Ensure CMake warns even if toolchain does not really have these flags. +set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden") +set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY "-fvisibility=") + +set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) +set(CMAKE_CXX_VISIBILITY_PRESET hidden) + +add_library(mystatic STATIC lib.cpp) diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes-stderr.txt b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes-stderr.txt deleted file mode 100644 index 59a4b8f..0000000 --- a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes-stderr.txt +++ /dev/null @@ -1,50 +0,0 @@ -^CMake Warning \(dev\) at CMP0063-Common.cmake:[0-9]+ \(add_executable\): - Policy CMP0063 is not set: Honor visibility properties for all target - types. Run "cmake --help-policy CMP0063" for policy details. Use the - cmake_policy command to set the policy and suppress this warning. - - Target "myexe" of type "EXECUTABLE" has the following visibility properties - set for CXX: - - CXX_VISIBILITY_PRESET - VISIBILITY_INLINES_HIDDEN - - For compatibility CMake is not honoring them for this target. -Call Stack \(most recent call first\): - CMP0063-WARN-yes.cmake:[0-9]+ \(include\) - CMakeLists.txt:[0-9]+ \(include\) -This warning is for project developers. Use -Wno-dev to suppress it. -+ -CMake Warning \(dev\) at CMP0063-Common.cmake:[0-9]+ \(add_library\): - Policy CMP0063 is not set: Honor visibility properties for all target - types. Run "cmake --help-policy CMP0063" for policy details. Use the - cmake_policy command to set the policy and suppress this warning. - - Target "myobject" of type "OBJECT_LIBRARY" has the following visibility - properties set for CXX: - - CXX_VISIBILITY_PRESET - VISIBILITY_INLINES_HIDDEN - - For compatibility CMake is not honoring them for this target. -Call Stack \(most recent call first\): - CMP0063-WARN-yes.cmake:[0-9]+ \(include\) - CMakeLists.txt:[0-9]+ \(include\) -This warning is for project developers. Use -Wno-dev to suppress it. -+ -CMake Warning \(dev\) at CMP0063-Common.cmake:[0-9]+ \(add_library\): - Policy CMP0063 is not set: Honor visibility properties for all target - types. Run "cmake --help-policy CMP0063" for policy details. Use the - cmake_policy command to set the policy and suppress this warning. - - Target "mystatic" of type "STATIC_LIBRARY" has the following visibility - properties set for CXX: - - CXX_VISIBILITY_PRESET - VISIBILITY_INLINES_HIDDEN - - For compatibility CMake is not honoring them for this target. -Call Stack \(most recent call first\): - CMP0063-WARN-yes.cmake:[0-9]+ \(include\) - CMakeLists.txt:[0-9]+ \(include\) -This warning is for project developers. Use -Wno-dev to suppress it.$ diff --git a/Tests/RunCMake/VisibilityPreset/RunCMakeTest.cmake b/Tests/RunCMake/VisibilityPreset/RunCMakeTest.cmake index c7eb808..7a000ee 100644 --- a/Tests/RunCMake/VisibilityPreset/RunCMakeTest.cmake +++ b/Tests/RunCMake/VisibilityPreset/RunCMakeTest.cmake @@ -2,6 +2,8 @@ include(RunCMake) run_cmake(PropertyTypo) run_cmake(CMP0063-OLD) -run_cmake(CMP0063-WARN-yes) +run_cmake(CMP0063-WARN-exe) +run_cmake(CMP0063-WARN-obj) +run_cmake(CMP0063-WARN-sta) run_cmake(CMP0063-WARN-no) run_cmake(CMP0063-NEW) diff --git a/Tests/RunCMake/XcodeProject/RunCMakeTest.cmake b/Tests/RunCMake/XcodeProject/RunCMakeTest.cmake index 8ab618b..f89d620 100644 --- a/Tests/RunCMake/XcodeProject/RunCMakeTest.cmake +++ b/Tests/RunCMake/XcodeProject/RunCMakeTest.cmake @@ -4,6 +4,9 @@ run_cmake(XcodeFileType) run_cmake(XcodeAttributeGenex) run_cmake(XcodeAttributeGenexError) run_cmake(XcodeObjectNeedsQuote) +run_cmake(XcodeOptimizationFlags) +run_cmake(XcodePreserveNonOptimizationFlags) +run_cmake(XcodePreserveObjcFlag) if (NOT XCODE_VERSION VERSION_LESS 6) run_cmake(XcodePlatformFrameworks) endif() @@ -55,6 +58,38 @@ if(NOT XCODE_VERSION VERSION_LESS 5) endif() if(NOT XCODE_VERSION VERSION_LESS 7) + set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/XcodeBundlesWatchOS-build) + set(RunCMake_TEST_NO_CLEAN 1) + set(RunCMake_TEST_OPTIONS "-DTEST_WATCHOS=ON") + + file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") + file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") + + run_cmake(XcodeBundles) + run_cmake_command(XcodeBundles-build ${CMAKE_COMMAND} --build .) + + unset(RunCMake_TEST_BINARY_DIR) + unset(RunCMake_TEST_NO_CLEAN) + unset(RunCMake_TEST_OPTIONS) +endif() + +if(NOT XCODE_VERSION VERSION_LESS 7.1) + set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/XcodeBundlesTvOS-build) + set(RunCMake_TEST_NO_CLEAN 1) + set(RunCMake_TEST_OPTIONS "-DTEST_TVOS=ON") + + file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") + file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") + + run_cmake(XcodeBundles) + run_cmake_command(XcodeBundles-build ${CMAKE_COMMAND} --build .) + + unset(RunCMake_TEST_BINARY_DIR) + unset(RunCMake_TEST_NO_CLEAN) + unset(RunCMake_TEST_OPTIONS) +endif() + +if(NOT XCODE_VERSION VERSION_LESS 7) set(RunCMake_TEST_OPTIONS "-DCMAKE_TOOLCHAIN_FILE=${RunCMake_SOURCE_DIR}/osx.cmake") run_cmake(XcodeTbdStub) unset(RunCMake_TEST_OPTIONS) diff --git a/Tests/RunCMake/XcodeProject/XcodeBundles.cmake b/Tests/RunCMake/XcodeProject/XcodeBundles.cmake index 2cbccfa..0fdc6af 100644 --- a/Tests/RunCMake/XcodeProject/XcodeBundles.cmake +++ b/Tests/RunCMake/XcodeProject/XcodeBundles.cmake @@ -10,6 +10,22 @@ if(TEST_IOS) set(CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE "NO") endif(TEST_IOS) +if(TEST_WATCHOS) + set(CMAKE_OSX_SYSROOT watchos) + set(CMAKE_OSX_ARCHITECTURES "armv7k") + set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO") + set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "") + set(CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE "YES") +endif() + +if(TEST_TVOS) + set(CMAKE_OSX_SYSROOT appletvos) + set(CMAKE_OSX_ARCHITECTURES "arm64") + set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO") + set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "") + set(CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE "YES") +endif() + # App Bundle add_executable(AppBundle MACOSX_BUNDLE main.m) @@ -35,11 +51,13 @@ endif() # Bundle -add_library(Bundle MODULE main.c) -set_target_properties(Bundle PROPERTIES BUNDLE TRUE) +if(NOT CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE) + add_library(Bundle MODULE main.c) + set_target_properties(Bundle PROPERTIES BUNDLE TRUE) -add_custom_target(BundleTest ALL - COMMAND ${CMAKE_COMMAND} -E copy - "$<TARGET_FILE:Bundle>" "$<TARGET_FILE:Bundle>.old") + add_custom_target(BundleTest ALL + COMMAND ${CMAKE_COMMAND} -E copy + "$<TARGET_FILE:Bundle>" "$<TARGET_FILE:Bundle>.old") -add_dependencies(BundleTest Bundle) + add_dependencies(BundleTest Bundle) +endif() diff --git a/Tests/RunCMake/XcodeProject/XcodeOptimizationFlags-check.cmake b/Tests/RunCMake/XcodeProject/XcodeOptimizationFlags-check.cmake new file mode 100644 index 0000000..f5595b3 --- /dev/null +++ b/Tests/RunCMake/XcodeProject/XcodeOptimizationFlags-check.cmake @@ -0,0 +1,7 @@ +foreach(level 1 2 3 s fast) + file(STRINGS ${RunCMake_TEST_BINARY_DIR}/XcodeOptimizationFlags.xcodeproj/project.pbxproj actual-${level} + REGEX "GCC_OPTIMIZATION_LEVEL = ${level};" LIMIT_COUNT 1) + if(NOT actual-${level}) + message(SEND_ERROR "Optimization level '${level}' not found in Xcode project.") + endif() +endforeach() diff --git a/Tests/RunCMake/XcodeProject/XcodeOptimizationFlags.cmake b/Tests/RunCMake/XcodeProject/XcodeOptimizationFlags.cmake new file mode 100644 index 0000000..e14bf80 --- /dev/null +++ b/Tests/RunCMake/XcodeProject/XcodeOptimizationFlags.cmake @@ -0,0 +1,20 @@ +set(CMAKE_CONFIGURATION_TYPES "Release" CACHE INTERNAL "Supported configuration types") + +set(CMAKE_CXX_FLAGS_RELEASE "") + +project(XcodeOptimizationFlags CXX) + +add_library(fooO1 STATIC foo.cpp) +set_target_properties(fooO1 PROPERTIES COMPILE_OPTIONS -O1) + +add_library(fooO2 STATIC foo.cpp) +set_target_properties(fooO2 PROPERTIES COMPILE_OPTIONS -O2) + +add_library(fooO3 STATIC foo.cpp) +set_target_properties(fooO3 PROPERTIES COMPILE_OPTIONS -O3) + +add_library(fooOs STATIC foo.cpp) +set_target_properties(fooOs PROPERTIES COMPILE_OPTIONS -Os) + +add_library(fooOfast STATIC foo.cpp) +set_target_properties(fooOfast PROPERTIES COMPILE_OPTIONS -Ofast) diff --git a/Tests/RunCMake/XcodeProject/XcodePreserveNonOptimizationFlags-check.cmake b/Tests/RunCMake/XcodeProject/XcodePreserveNonOptimizationFlags-check.cmake new file mode 100644 index 0000000..2f6c03d --- /dev/null +++ b/Tests/RunCMake/XcodeProject/XcodePreserveNonOptimizationFlags-check.cmake @@ -0,0 +1,8 @@ +file(STRINGS ${RunCMake_TEST_BINARY_DIR}/XcodePreserveNonOptimizationFlags.xcodeproj/project.pbxproj actual + REGEX "OTHER_CPLUSPLUSFLAGS = [^;]*;") +foreach(expect "-DA" "-DB +-DC" "-DD") + if(NOT "${actual}" MATCHES "${expect}") + message(SEND_ERROR "The actual project contains the lines:\n ${actual}\n" + "which do not match expected regex:\n ${expect}\n") + endif() +endforeach() diff --git a/Tests/RunCMake/XcodeProject/XcodePreserveNonOptimizationFlags.cmake b/Tests/RunCMake/XcodeProject/XcodePreserveNonOptimizationFlags.cmake new file mode 100644 index 0000000..16f0381 --- /dev/null +++ b/Tests/RunCMake/XcodeProject/XcodePreserveNonOptimizationFlags.cmake @@ -0,0 +1,12 @@ +set(CMAKE_CONFIGURATION_TYPES "Release" CACHE INTERNAL "Supported configuration types") + +project(XcodePreserveNonOptimizationFlags CXX) + +add_library(preserveStart STATIC foo.cpp) +set_property(TARGET preserveStart PROPERTY COMPILE_OPTIONS -DA -O1) + +add_library(preserveBoth STATIC foo.cpp) +set_property(TARGET preserveBoth PROPERTY COMPILE_OPTIONS -DB -O1 -DC) + +add_library(preserveEnd STATIC foo.cpp) +set_property(TARGET preserveEnd PROPERTY COMPILE_OPTIONS -O1 -DD) diff --git a/Tests/RunCMake/XcodeProject/XcodePreserveObjcFlag-check.cmake b/Tests/RunCMake/XcodeProject/XcodePreserveObjcFlag-check.cmake new file mode 100644 index 0000000..332906f --- /dev/null +++ b/Tests/RunCMake/XcodeProject/XcodePreserveObjcFlag-check.cmake @@ -0,0 +1,7 @@ +set(expect "-ObjC") +file(STRINGS ${RunCMake_TEST_BINARY_DIR}/XcodePreserveObjcFlag.xcodeproj/project.pbxproj actual + REGEX "OTHER_CPLUSPLUSFLAGS = [^;]*;" LIMIT_COUNT 1) +if(NOT "${actual}" MATCHES "${expect}") + message(SEND_ERROR "The actual project contains the line:\n ${actual}\n" + "which does not match expected regex:\n ${expect}\n") +endif() diff --git a/Tests/RunCMake/XcodeProject/XcodePreserveObjcFlag.cmake b/Tests/RunCMake/XcodeProject/XcodePreserveObjcFlag.cmake new file mode 100644 index 0000000..64db633 --- /dev/null +++ b/Tests/RunCMake/XcodeProject/XcodePreserveObjcFlag.cmake @@ -0,0 +1,6 @@ +set(CMAKE_CONFIGURATION_TYPES "Release" CACHE INTERNAL "Supported configuration types") + +project(XcodePreserveObjcFlag CXX) + +add_library(foo STATIC foo.cpp) +set_target_properties(foo PROPERTIES COMPILE_OPTIONS -ObjC) diff --git a/Tests/RunCMake/ctest_test/CMakeLists.txt.in b/Tests/RunCMake/ctest_test/CMakeLists.txt.in index cedf379..e61b556 100644 --- a/Tests/RunCMake/ctest_test/CMakeLists.txt.in +++ b/Tests/RunCMake/ctest_test/CMakeLists.txt.in @@ -2,3 +2,4 @@ cmake_minimum_required(VERSION 3.1) project(CTestTest@CASE_NAME@ NONE) include(CTest) add_test(NAME RunCMakeVersion COMMAND "${CMAKE_COMMAND}" --version) +@CASE_CMAKELISTS_SUFFIX_CODE@ diff --git a/Tests/RunCMake/ctest_test/RunCMakeTest.cmake b/Tests/RunCMake/ctest_test/RunCMakeTest.cmake index 76dc143..1b31726 100644 --- a/Tests/RunCMake/ctest_test/RunCMakeTest.cmake +++ b/Tests/RunCMake/ctest_test/RunCMakeTest.cmake @@ -59,3 +59,19 @@ function(run_TestChangeId) run_ctest(TestChangeId) endfunction() run_TestChangeId() + +function(run_TestOutputSize) + set(CASE_CTEST_TEST_ARGS EXCLUDE RunCMakeVersion) + set(CASE_TEST_PREFIX_CODE [[ +set(CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE 10) +set(CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE 12) + ]]) + set(CASE_CMAKELISTS_SUFFIX_CODE [[ +add_test(NAME PassingTest COMMAND ${CMAKE_COMMAND} -E echo PassingTestOutput) +add_test(NAME FailingTest COMMAND ${CMAKE_COMMAND} -E no_such_command) + ]]) + + unset(ENV{CTEST_PARALLEL_LEVEL}) + run_ctest(TestOutputSize) +endfunction() +run_TestOutputSize() diff --git a/Tests/RunCMake/ctest_test/TestOutputSize-check.cmake b/Tests/RunCMake/ctest_test/TestOutputSize-check.cmake new file mode 100644 index 0000000..74ad669 --- /dev/null +++ b/Tests/RunCMake/ctest_test/TestOutputSize-check.cmake @@ -0,0 +1,17 @@ +file(GLOB test_xml_file "${RunCMake_TEST_BINARY_DIR}/Testing/*/Test.xml") +if(test_xml_file) + file(READ "${test_xml_file}" test_xml LIMIT 4096) + if("${test_xml}" MATCHES [[(<Test Status="passed">.*</Test>).*(<Test Status="failed">.*</Test>)]]) + set(test_passed "${CMAKE_MATCH_1}") + set(test_failed "${CMAKE_MATCH_2}") + if(NOT "${test_passed}" MATCHES [[<Value>PassingTes\.\.\..*10 bytes]]) + set(RunCMake_TEST_FAILED "Test.xml passed test output not truncated at 10 bytes:\n ${test_passed}") + elseif(NOT "${test_failed}" MATCHES [[<Value>CMake Error:\.\.\..*12 bytes]]) + set(RunCMake_TEST_FAILED "Test.xml failed test output not truncated at 12 bytes:\n ${test_failed}") + endif() + else() + set(RunCMake_TEST_FAILED "Test.xml does not contain a passed then failed test:\n ${test_xml}") + endif() +else() + set(RunCMake_TEST_FAILED "Test.xml not found") +endif() diff --git a/Tests/RunCMake/find_program/A/testAandB b/Tests/RunCMake/find_program/A/testAandB new file mode 100755 index 0000000..1a24852 --- /dev/null +++ b/Tests/RunCMake/find_program/A/testAandB @@ -0,0 +1 @@ +#!/bin/sh diff --git a/Tests/RunCMake/find_program/B/testAandB b/Tests/RunCMake/find_program/B/testAandB new file mode 100755 index 0000000..1a24852 --- /dev/null +++ b/Tests/RunCMake/find_program/B/testAandB @@ -0,0 +1 @@ +#!/bin/sh diff --git a/Tests/RunCMake/find_program/EnvAndHints-stdout.txt b/Tests/RunCMake/find_program/EnvAndHints-stdout.txt new file mode 100644 index 0000000..39329b2 --- /dev/null +++ b/Tests/RunCMake/find_program/EnvAndHints-stdout.txt @@ -0,0 +1 @@ +-- PROG='[^']*/Tests/RunCMake/find_program/A/testAandB' diff --git a/Tests/RunCMake/find_program/EnvAndHints.cmake b/Tests/RunCMake/find_program/EnvAndHints.cmake new file mode 100644 index 0000000..14ebd6e --- /dev/null +++ b/Tests/RunCMake/find_program/EnvAndHints.cmake @@ -0,0 +1,8 @@ +set(ENV_PATH "$ENV{PATH}") +set(ENV{PATH} ${CMAKE_CURRENT_SOURCE_DIR}/A) +find_program(PROG + NAMES testAandB + HINTS ${CMAKE_CURRENT_SOURCE_DIR}/A ${CMAKE_CURRENT_SOURCE_DIR}/B + ) +message(STATUS "PROG='${PROG}'") +set(ENV{PATH} "${ENV_PATH}") diff --git a/Tests/RunCMake/find_program/RunCMakeTest.cmake b/Tests/RunCMake/find_program/RunCMakeTest.cmake index 2adec11..89307c1 100644 --- a/Tests/RunCMake/find_program/RunCMakeTest.cmake +++ b/Tests/RunCMake/find_program/RunCMakeTest.cmake @@ -1,5 +1,6 @@ include(RunCMake) +run_cmake(EnvAndHints) run_cmake(DirsPerName) run_cmake(NamesPerDir) diff --git a/Tests/RunCMake/CommandLine/Werror_deprecated-result.txt b/Tests/RunCMake/install/DIRECTORY-DESTINATION-bad-result.txt index d00491f..d00491f 100644 --- a/Tests/RunCMake/CommandLine/Werror_deprecated-result.txt +++ b/Tests/RunCMake/install/DIRECTORY-DESTINATION-bad-result.txt diff --git a/Tests/RunCMake/install/DIRECTORY-DESTINATION-bad-stderr.txt b/Tests/RunCMake/install/DIRECTORY-DESTINATION-bad-stderr.txt new file mode 100644 index 0000000..9844158 --- /dev/null +++ b/Tests/RunCMake/install/DIRECTORY-DESTINATION-bad-stderr.txt @@ -0,0 +1,6 @@ +CMake Error: + Error evaluating generator expression: + + \$<NOTAGENEX> + + Expression did not evaluate to a known generator expression diff --git a/Tests/RunCMake/install/DIRECTORY-DESTINATION-bad.cmake b/Tests/RunCMake/install/DIRECTORY-DESTINATION-bad.cmake new file mode 100644 index 0000000..f050cdf --- /dev/null +++ b/Tests/RunCMake/install/DIRECTORY-DESTINATION-bad.cmake @@ -0,0 +1 @@ +install(DIRECTORY dir DESTINATION $<NOTAGENEX>) diff --git a/Tests/RunCMake/CommandLine/W_bad-arg3-result.txt b/Tests/RunCMake/install/FILES-DESTINATION-bad-result.txt index d00491f..d00491f 100644 --- a/Tests/RunCMake/CommandLine/W_bad-arg3-result.txt +++ b/Tests/RunCMake/install/FILES-DESTINATION-bad-result.txt diff --git a/Tests/RunCMake/install/FILES-DESTINATION-bad-stderr.txt b/Tests/RunCMake/install/FILES-DESTINATION-bad-stderr.txt new file mode 100644 index 0000000..9844158 --- /dev/null +++ b/Tests/RunCMake/install/FILES-DESTINATION-bad-stderr.txt @@ -0,0 +1,6 @@ +CMake Error: + Error evaluating generator expression: + + \$<NOTAGENEX> + + Expression did not evaluate to a known generator expression diff --git a/Tests/RunCMake/install/FILES-DESTINATION-bad.cmake b/Tests/RunCMake/install/FILES-DESTINATION-bad.cmake new file mode 100644 index 0000000..0fda078 --- /dev/null +++ b/Tests/RunCMake/install/FILES-DESTINATION-bad.cmake @@ -0,0 +1 @@ +install(FILES empty.c DESTINATION $<NOTAGENEX>) diff --git a/Tests/RunCMake/install/RunCMakeTest.cmake b/Tests/RunCMake/install/RunCMakeTest.cmake index a5f5bd0..043bd1f 100644 --- a/Tests/RunCMake/install/RunCMakeTest.cmake +++ b/Tests/RunCMake/install/RunCMakeTest.cmake @@ -6,6 +6,8 @@ run_cmake(DIRECTORY-message-lazy) run_cmake(SkipInstallRulesWarning) run_cmake(SkipInstallRulesNoWarning1) run_cmake(SkipInstallRulesNoWarning2) +run_cmake(DIRECTORY-DESTINATION-bad) +run_cmake(FILES-DESTINATION-bad) run_cmake(TARGETS-DESTINATION-bad) run_cmake(CMP0062-OLD) run_cmake(CMP0062-NEW) diff --git a/Tests/RunCMake/set_property/COMPILE_DEFINITIONS-stdout.txt b/Tests/RunCMake/set_property/COMPILE_DEFINITIONS-stdout.txt new file mode 100644 index 0000000..dd5bae1 --- /dev/null +++ b/Tests/RunCMake/set_property/COMPILE_DEFINITIONS-stdout.txt @@ -0,0 +1,2 @@ +-- Target COMPILE_DEFINITIONS is 'a;b;c;d;;e' +-- Directory COMPILE_DEFINITIONS is 'a;b;c;d;;e' diff --git a/Tests/RunCMake/set_property/COMPILE_DEFINITIONS.cmake b/Tests/RunCMake/set_property/COMPILE_DEFINITIONS.cmake new file mode 100644 index 0000000..f0c63bf --- /dev/null +++ b/Tests/RunCMake/set_property/COMPILE_DEFINITIONS.cmake @@ -0,0 +1,3 @@ +include(Common.cmake) +test_target_property(COMPILE_DEFINITIONS) +test_directory_property(COMPILE_DEFINITIONS) diff --git a/Tests/RunCMake/set_property/COMPILE_FEATURES-stdout.txt b/Tests/RunCMake/set_property/COMPILE_FEATURES-stdout.txt new file mode 100644 index 0000000..bd5a992 --- /dev/null +++ b/Tests/RunCMake/set_property/COMPILE_FEATURES-stdout.txt @@ -0,0 +1 @@ +-- Target COMPILE_FEATURES is 'a;b;c;d;;e' diff --git a/Tests/RunCMake/set_property/COMPILE_FEATURES.cmake b/Tests/RunCMake/set_property/COMPILE_FEATURES.cmake new file mode 100644 index 0000000..1ab52ef --- /dev/null +++ b/Tests/RunCMake/set_property/COMPILE_FEATURES.cmake @@ -0,0 +1,2 @@ +include(Common.cmake) +test_target_property(COMPILE_FEATURES) diff --git a/Tests/RunCMake/set_property/COMPILE_OPTIONS-stdout.txt b/Tests/RunCMake/set_property/COMPILE_OPTIONS-stdout.txt new file mode 100644 index 0000000..1a20501 --- /dev/null +++ b/Tests/RunCMake/set_property/COMPILE_OPTIONS-stdout.txt @@ -0,0 +1,2 @@ +-- Target COMPILE_OPTIONS is 'a;b;c;d;;e' +-- Directory COMPILE_OPTIONS is 'a;b;c;d;;e' diff --git a/Tests/RunCMake/set_property/COMPILE_OPTIONS.cmake b/Tests/RunCMake/set_property/COMPILE_OPTIONS.cmake new file mode 100644 index 0000000..75f0535 --- /dev/null +++ b/Tests/RunCMake/set_property/COMPILE_OPTIONS.cmake @@ -0,0 +1,3 @@ +include(Common.cmake) +test_target_property(COMPILE_OPTIONS) +test_directory_property(COMPILE_OPTIONS) diff --git a/Tests/RunCMake/set_property/Common.cmake b/Tests/RunCMake/set_property/Common.cmake new file mode 100644 index 0000000..9d5e4f4 --- /dev/null +++ b/Tests/RunCMake/set_property/Common.cmake @@ -0,0 +1,28 @@ +macro(test_target_property PROP) + add_custom_target(CustomTarget) + set_property(TARGET CustomTarget PROPERTY ${PROP} x) + set_property(TARGET CustomTarget PROPERTY ${PROP}) + set_property(TARGET CustomTarget APPEND PROPERTY ${PROP}) + set_property(TARGET CustomTarget PROPERTY ${PROP} a) + set_property(TARGET CustomTarget APPEND PROPERTY ${PROP} "") + set_property(TARGET CustomTarget APPEND PROPERTY ${PROP} b c) + set_property(TARGET CustomTarget APPEND PROPERTY ${PROP}) + set_property(TARGET CustomTarget APPEND PROPERTY ${PROP} "d;;e") + get_property(val TARGET CustomTarget PROPERTY ${PROP}) + message(STATUS "Target ${PROP} is '${val}'") + set_property(TARGET CustomTarget PROPERTY ${PROP}) +endmacro() + +macro(test_directory_property PROP) + set_property(DIRECTORY PROPERTY ${PROP} x) + set_property(DIRECTORY PROPERTY ${PROP}) + set_property(DIRECTORY APPEND PROPERTY ${PROP}) + set_property(DIRECTORY PROPERTY ${PROP} a) + set_property(DIRECTORY APPEND PROPERTY ${PROP} "") + set_property(DIRECTORY APPEND PROPERTY ${PROP} b c) + set_property(DIRECTORY APPEND PROPERTY ${PROP}) + set_property(DIRECTORY APPEND PROPERTY ${PROP} "d;;e") + get_property(val DIRECTORY PROPERTY ${PROP}) + message(STATUS "Directory ${PROP} is '${val}'") + set_property(DIRECTORY PROPERTY ${PROP}) +endmacro() diff --git a/Tests/RunCMake/set_property/INCLUDE_DIRECTORIES-stdout.txt b/Tests/RunCMake/set_property/INCLUDE_DIRECTORIES-stdout.txt new file mode 100644 index 0000000..c957dd5 --- /dev/null +++ b/Tests/RunCMake/set_property/INCLUDE_DIRECTORIES-stdout.txt @@ -0,0 +1,2 @@ +-- Target INCLUDE_DIRECTORIES is 'a;b;c;d;;e' +-- Directory INCLUDE_DIRECTORIES is 'a;b;c;d;;e' diff --git a/Tests/RunCMake/set_property/INCLUDE_DIRECTORIES.cmake b/Tests/RunCMake/set_property/INCLUDE_DIRECTORIES.cmake new file mode 100644 index 0000000..c9a9151 --- /dev/null +++ b/Tests/RunCMake/set_property/INCLUDE_DIRECTORIES.cmake @@ -0,0 +1,3 @@ +include(Common.cmake) +test_target_property(INCLUDE_DIRECTORIES) +test_directory_property(INCLUDE_DIRECTORIES) diff --git a/Tests/RunCMake/set_property/LINK_LIBRARIES-stdout.txt b/Tests/RunCMake/set_property/LINK_LIBRARIES-stdout.txt new file mode 100644 index 0000000..9a3988e --- /dev/null +++ b/Tests/RunCMake/set_property/LINK_LIBRARIES-stdout.txt @@ -0,0 +1 @@ +-- Target LINK_LIBRARIES is 'a;b;c;d;;e' diff --git a/Tests/RunCMake/set_property/LINK_LIBRARIES.cmake b/Tests/RunCMake/set_property/LINK_LIBRARIES.cmake index 994e874..5155f59 100644 --- a/Tests/RunCMake/set_property/LINK_LIBRARIES.cmake +++ b/Tests/RunCMake/set_property/LINK_LIBRARIES.cmake @@ -1,7 +1,2 @@ -add_custom_target(CustomTarget) -set_property(TARGET CustomTarget PROPERTY LINK_LIBRARIES) -set_property(TARGET CustomTarget APPEND PROPERTY LINK_LIBRARIES) -get_property(val TARGET CustomTarget PROPERTY LINK_LIBRARIES) -if (NOT "${val}" STREQUAL "") - message(FATAL_ERROR "LINK_LIBRARIES value is '${val}' but should be ''") -endif() +include(Common.cmake) +test_target_property(LINK_LIBRARIES) diff --git a/Tests/RunCMake/set_property/RunCMakeTest.cmake b/Tests/RunCMake/set_property/RunCMakeTest.cmake index ada8804..37c7124 100644 --- a/Tests/RunCMake/set_property/RunCMakeTest.cmake +++ b/Tests/RunCMake/set_property/RunCMakeTest.cmake @@ -1,4 +1,9 @@ include(RunCMake) +run_cmake(COMPILE_DEFINITIONS) +run_cmake(COMPILE_FEATURES) +run_cmake(COMPILE_OPTIONS) +run_cmake(INCLUDE_DIRECTORIES) run_cmake(LINK_LIBRARIES) -run_cmake(LINK_SEARCH_STATIC) +run_cmake(SOURCES) +run_cmake(USER_PROP) diff --git a/Tests/RunCMake/set_property/SOURCES-stdout.txt b/Tests/RunCMake/set_property/SOURCES-stdout.txt new file mode 100644 index 0000000..921d5b1 --- /dev/null +++ b/Tests/RunCMake/set_property/SOURCES-stdout.txt @@ -0,0 +1 @@ +-- Target SOURCES is 'a;b;c;d;e' diff --git a/Tests/RunCMake/set_property/SOURCES.cmake b/Tests/RunCMake/set_property/SOURCES.cmake new file mode 100644 index 0000000..820641e --- /dev/null +++ b/Tests/RunCMake/set_property/SOURCES.cmake @@ -0,0 +1,2 @@ +include(Common.cmake) +test_target_property(SOURCES) diff --git a/Tests/RunCMake/set_property/USER_PROP-stdout.txt b/Tests/RunCMake/set_property/USER_PROP-stdout.txt new file mode 100644 index 0000000..107cc87 --- /dev/null +++ b/Tests/RunCMake/set_property/USER_PROP-stdout.txt @@ -0,0 +1,2 @@ +-- Target USER_PROP is 'a;b;c;d;;e' +-- Directory USER_PROP is 'a;b;c;d;;e' diff --git a/Tests/RunCMake/set_property/USER_PROP.cmake b/Tests/RunCMake/set_property/USER_PROP.cmake new file mode 100644 index 0000000..aa0aa83 --- /dev/null +++ b/Tests/RunCMake/set_property/USER_PROP.cmake @@ -0,0 +1,3 @@ +include(Common.cmake) +test_target_property(USER_PROP) +test_directory_property(USER_PROP) diff --git a/Tests/SimpleInstall/CMakeLists.txt b/Tests/SimpleInstall/CMakeLists.txt index cc3c3be..e365076 100644 --- a/Tests/SimpleInstall/CMakeLists.txt +++ b/Tests/SimpleInstall/CMakeLists.txt @@ -209,9 +209,9 @@ else() ARCHIVE DESTINATION MyTest/lib/static OPTIONAL # for coverage...target should always exist ) - install(FILES lib1.h DESTINATION MyTest/include/foo) + install(FILES lib1.h DESTINATION MyTest/include/$<1:foo>$<0:/wrong>) install(FILES lib2.h - DESTINATION MyTest/include/foo + DESTINATION $<1:MyTest/include/foo>$<0:/wrong> COMPONENT Development PERMISSIONS OWNER_READ OWNER_WRITE RENAME lib2renamed.h @@ -252,7 +252,7 @@ else() file(REMOVE_RECURSE "${CMAKE_INSTALL_PREFIX}/MyTest/share/CVS") file(REMOVE_RECURSE "${CMAKE_INSTALL_PREFIX}/MyTest/share/TestSubDir/CVS") install( - DIRECTORY TestSubDir scripts/ DESTINATION MyTest/share + DIRECTORY TestSubDir scripts/ DESTINATION $<1:MyTest/share>$<0:/wrong> FILE_PERMISSIONS OWNER_READ OWNER_WRITE DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE @@ -263,14 +263,14 @@ else() # Alternate directory installation for coverage. install( - DIRECTORY scripts/ DESTINATION MyTest/share/alt + DIRECTORY scripts/ DESTINATION $<1:MyTest/share/alt>$<0:/wrong> COMPONENT Development USE_SOURCE_PERMISSIONS PATTERN "CVS" EXCLUDE REGEX "\\.txt$" EXCLUDE ) install( - DIRECTORY TestSubDir DESTINATION MyTest/share/alt + DIRECTORY TestSubDir DESTINATION $<1:MyTest/share/alt>$<0:/wrong> FILE_PERMISSIONS OWNER_READ OWNER_WRITE DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE diff --git a/Tests/SimpleInstallS2/CMakeLists.txt b/Tests/SimpleInstallS2/CMakeLists.txt index cc3c3be..e365076 100644 --- a/Tests/SimpleInstallS2/CMakeLists.txt +++ b/Tests/SimpleInstallS2/CMakeLists.txt @@ -209,9 +209,9 @@ else() ARCHIVE DESTINATION MyTest/lib/static OPTIONAL # for coverage...target should always exist ) - install(FILES lib1.h DESTINATION MyTest/include/foo) + install(FILES lib1.h DESTINATION MyTest/include/$<1:foo>$<0:/wrong>) install(FILES lib2.h - DESTINATION MyTest/include/foo + DESTINATION $<1:MyTest/include/foo>$<0:/wrong> COMPONENT Development PERMISSIONS OWNER_READ OWNER_WRITE RENAME lib2renamed.h @@ -252,7 +252,7 @@ else() file(REMOVE_RECURSE "${CMAKE_INSTALL_PREFIX}/MyTest/share/CVS") file(REMOVE_RECURSE "${CMAKE_INSTALL_PREFIX}/MyTest/share/TestSubDir/CVS") install( - DIRECTORY TestSubDir scripts/ DESTINATION MyTest/share + DIRECTORY TestSubDir scripts/ DESTINATION $<1:MyTest/share>$<0:/wrong> FILE_PERMISSIONS OWNER_READ OWNER_WRITE DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE @@ -263,14 +263,14 @@ else() # Alternate directory installation for coverage. install( - DIRECTORY scripts/ DESTINATION MyTest/share/alt + DIRECTORY scripts/ DESTINATION $<1:MyTest/share/alt>$<0:/wrong> COMPONENT Development USE_SOURCE_PERMISSIONS PATTERN "CVS" EXCLUDE REGEX "\\.txt$" EXCLUDE ) install( - DIRECTORY TestSubDir DESTINATION MyTest/share/alt + DIRECTORY TestSubDir DESTINATION $<1:MyTest/share/alt>$<0:/wrong> FILE_PERMISSIONS OWNER_READ OWNER_WRITE DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE diff --git a/Tests/SubDir/CMakeLists.txt b/Tests/SubDir/CMakeLists.txt index 6822e6b..32aa93f 100644 --- a/Tests/SubDir/CMakeLists.txt +++ b/Tests/SubDir/CMakeLists.txt @@ -1,6 +1,10 @@ cmake_minimum_required (VERSION 2.6) project(SUBDIR) + subdirs(Executable EXCLUDE_FROM_ALL Examples) + +set(DEFINED_AFTER_SUBDIRS_COMMAND 42) + write_file(${SUBDIR_BINARY_DIR}/ShouldBeHere "This file should exist.") #WATCOM WMAKE does not support + in the name of a file! if(WATCOM) diff --git a/Tests/SubDir/Executable/CMakeLists.txt b/Tests/SubDir/Executable/CMakeLists.txt index 77e6751..fbe338e 100644 --- a/Tests/SubDir/Executable/CMakeLists.txt +++ b/Tests/SubDir/Executable/CMakeLists.txt @@ -1 +1,13 @@ add_executable(test test.cxx) + +if (NOT DEFINED_AFTER_SUBDIRS_COMMAND) + message(FATAL_ERROR "DEFINED_AFTER_SUBDIRS_COMMAND should be defined.") +endif() + +string(FIND "${CMAKE_CURRENT_BINARY_DIR}" "SubDir/Executable" location) +string(LENGTH "${CMAKE_CURRENT_BINARY_DIR}" dirLength) +math(EXPR suffixLength "${dirLength} - ${location}") + +if (NOT suffixLength EQUAL 17) + message(FATAL_ERROR "CMAKE_CURRENT_BINARY_DIR does not end with \"SubDir/Executable\"") +endif() diff --git a/Tests/SwiftMix/SwiftMain.swift b/Tests/SwiftMix/SwiftMain.swift index 7e7c4ab..3629ac8 100644 --- a/Tests/SwiftMix/SwiftMain.swift +++ b/Tests/SwiftMix/SwiftMain.swift @@ -1,8 +1,10 @@ -@objc class SwiftMainClass { +import Foundation + +@objc class SwiftMainClass : NSObject { class func SwiftMain(argc:Int, argv:UnsafePointer<UnsafePointer<CChar>>) -> Int32 { dump("argc: \(argc)") for (var i = 0; i < argc; ++i) { - var argi = String.fromCString(argv[i]) + let argi = String.fromCString(argv[i]) dump("arg[\(i)]: \(argi)"); } return 0; diff --git a/Tests/VSGNUFortran/subdir/fortran/CMakeLists.txt b/Tests/VSGNUFortran/subdir/fortran/CMakeLists.txt index 3ee1855..f68e38e 100644 --- a/Tests/VSGNUFortran/subdir/fortran/CMakeLists.txt +++ b/Tests/VSGNUFortran/subdir/fortran/CMakeLists.txt @@ -35,12 +35,12 @@ add_library(hello SHARED hello.f) add_library(world SHARED world.f) target_link_libraries(hello world) if(CMAKE_Fortran_COMPILER_ID MATCHES SunPro) - target_link_libraries(hello fsu) + target_link_libraries(hello PRIVATE fsu) if(CMAKE_Fortran_PLATFORM_ID MATCHES SunOS) - target_link_libraries(hello sunmath m) + target_link_libraries(hello PRIVATE sunmath m) test_sunquad(CMAKE_HAS_SUNQUAD) if(CMAKE_HAS_SUNQUAD) - target_link_libraries(hello sunquad) + target_link_libraries(hello PRIVATE sunquad) endif() endif() endif() diff --git a/Tests/VSWinStorePhone/CMakeLists.txt b/Tests/VSWinStorePhone/CMakeLists.txt index 8357d5f..ae82755 100644 --- a/Tests/VSWinStorePhone/CMakeLists.txt +++ b/Tests/VSWinStorePhone/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.0) project(VSWinStorePhone) - -if(MSVC_VERSION GREATER 1700) +if(MSVC_VERSION GREATER 1899) + set(COMPILER_VERSION "14") +elseif(MSVC_VERSION GREATER 1700) set(COMPILER_VERSION "12") elseif(MSVC_VERSION GREATER 1600) set(COMPILER_VERSION "11") @@ -91,6 +92,7 @@ elseif (NOT "${PLATFORM}" STREQUAL "DESKTOP") set(ASSET_FILES ${ASSET_FILES} Direct3DApp1/Assets/Logo.png Direct3DApp1/Assets/SmallLogo.png + Direct3DApp1/Assets/SmallLogo44x44.png Direct3DApp1/Assets/SplashScreen.png Direct3DApp1/Assets/StoreLogo.png ) @@ -124,4 +126,15 @@ source_group("Resource Files" FILES ${RESOURCE_FILES}) add_executable(${EXE_NAME} WIN32 ${SOURCE_FILES} ${HEADER_FILES} ${RESOURCE_FILES}) set_property(TARGET ${EXE_NAME} PROPERTY VS_WINRT_COMPONENT TRUE) + +string(SUBSTRING "${CMAKE_SYSTEM_VERSION}" 0, 4, SHORT_VERSION) + +if("${SHORT_VERSION}" STREQUAL "10.0") + message(STATUS "Targeting Windows 10. Setting Extensions to version ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") + set_property(TARGET ${EXE_NAME} PROPERTY VS_DESKTOP_EXTENSIONS_VERSION "${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") + set_property(TARGET ${EXE_NAME} PROPERTY VS_MOBILE_EXTENSIONS_VERSION "${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") + set_property(TARGET ${EXE_NAME} PROPERTY VS_IOT_EXTENSIONS_VERSION "${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") +endif() + + target_link_libraries(${EXE_NAME} d3d11) diff --git a/Tests/VSWinStorePhone/Direct3DApp1/Assets/SmallLogo44x44.png b/Tests/VSWinStorePhone/Direct3DApp1/Assets/SmallLogo44x44.png Binary files differnew file mode 100644 index 0000000..28810b7 --- /dev/null +++ b/Tests/VSWinStorePhone/Direct3DApp1/Assets/SmallLogo44x44.png diff --git a/Tests/VSWinStorePhone/cmake/Package_vc14.store.appxmanifest.in b/Tests/VSWinStorePhone/cmake/Package_vc14.store.appxmanifest.in new file mode 100644 index 0000000..6b27ab7 --- /dev/null +++ b/Tests/VSWinStorePhone/cmake/Package_vc14.store.appxmanifest.in @@ -0,0 +1,36 @@ +<?xml version="1.0" encoding="utf-8"?> +<Package + xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10" + xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest" + xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10" + IgnorableNamespaces="uap mp"> + + <Identity Name="@PACKAGE_GUID@" Publisher="CN=mgong" Version="1.1.0.0" /> + <mp:PhoneIdentity PhoneProductId="@PACKAGE_GUID@" PhonePublisherId="00000000-0000-0000-0000-000000000000"/> + + <Properties> + <DisplayName>@SHORT_NAME@</DisplayName> + <PublisherDisplayName>mgong</PublisherDisplayName> + <Logo>Assets/StoreLogo.png</Logo> + </Properties> + + <Dependencies> + <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.0.0" MaxVersionTested="10.0.65535.65535" /> + </Dependencies> + + <Resources> + <Resource Language="x-generate" /> + </Resources> + <Applications> + <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="@SHORT_NAME@.App"> + <uap:VisualElements + DisplayName="@SHORT_NAME@" + Description="@SHORT_NAME@" + BackgroundColor="#336699" + Square150x150Logo="Assets/Logo.png" + Square44x44Logo="Assets/SmallLogo44x44.png"> + <uap:SplashScreen Image="Assets/SplashScreen.png" /> + </uap:VisualElements> + </Application> + </Applications> +</Package> diff --git a/Utilities/Release/Cygwin/README.cygwin.in b/Utilities/Release/Cygwin/README.cygwin.in index 6c42a4c..17cf2a1 100644 --- a/Utilities/Release/Cygwin/README.cygwin.in +++ b/Utilities/Release/Cygwin/README.cygwin.in @@ -8,7 +8,7 @@ Build requirements make Canonical homepage: - http://www.cmake.org + https://cmake.org Canonical download: ftp://www.cmake.org/pub/cmake/ diff --git a/Utilities/Release/create-cmake-release.cmake b/Utilities/Release/create-cmake-release.cmake index 4b93e6e..76057d1 100644 --- a/Utilities/Release/create-cmake-release.cmake +++ b/Utilities/Release/create-cmake-release.cmake @@ -7,8 +7,7 @@ file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/logs) set(RELEASE_SCRIPTS_BATCH_1 dash2win64_release.cmake # Windows - dashmacmini2_release.cmake # Mac Darwin universal ppc;i386 - dashmacmini5_release.cmake # Mac Darwin64 universal x86_64;i386 + dashmacmini5_release.cmake # OS X x86_64 magrathea_release.cmake # Linux linux64_release.cmake # Linux x86_64 ) @@ -54,6 +53,7 @@ mkdir \${name}-build && cd \${name}-build && \"${CMAKE_COMMAND}\" ../\${name}-src/Utilities/Sphinx \\ -DCMAKE_INSTALL_PREFIX=\"\$inst/\" \\ + -DCMAKE_DOC_DIR=doc/cmake \\ -DSPHINX_EXECUTABLE=\"${SPHINX_EXECUTABLE}\" \\ -DSPHINX_HTML=ON -DSPHINX_MAN=ON && make install && diff --git a/Utilities/Release/dash2win64_cygwin.cmake b/Utilities/Release/dash2win64_cygwin.cmake index d15915a..ca590ed 100644 --- a/Utilities/Release/dash2win64_cygwin.cmake +++ b/Utilities/Release/dash2win64_cygwin.cmake @@ -1,5 +1,6 @@ set(CMAKE_RELEASE_DIRECTORY "c:/cygwin/home/dashboard/CMakeReleaseCygwin") set(PROCESSORS 9) +set(BOOTSTRAP_ARGS "") set(MAKE_PROGRAM "make") set(MAKE "${MAKE_PROGRAM} -j8") set(HOST dash2win64) @@ -27,4 +28,6 @@ get_filename_component(path "${CMAKE_CURRENT_LIST_FILE}" PATH) # allows us to produce cygwin builds in the short term. set(EXTRA_CTEST_ARGS "-E ExternalProject") +set(LOCAL_DIR cygwin) + include(${path}/release_cmake.cmake) diff --git a/Utilities/Release/dash2win64_release.cmake b/Utilities/Release/dash2win64_release.cmake index 3ea895a..ecfd7c5 100644 --- a/Utilities/Release/dash2win64_release.cmake +++ b/Utilities/Release/dash2win64_release.cmake @@ -1,6 +1,6 @@ set(CMAKE_RELEASE_DIRECTORY "c:/cygwin/home/dashboard/CMakeReleaseDirectory") set(CONFIGURE_WITH_CMAKE TRUE) -set(CMAKE_CONFIGURE_PATH "c:/Program\\ Files\\ \\(x86\\)/CMake\\ 2.8/bin/cmake.exe") +set(CMAKE_CONFIGURE_PATH "c:/Program\\ Files\\ \\(x86\\)/CMake/bin/cmake.exe") set(PROCESSORS 8) set(HOST dash2win64) set(CPACK_BINARY_GENERATORS "NSIS ZIP") @@ -8,6 +8,7 @@ set(CPACK_SOURCE_GENERATORS "ZIP") set(MAKE_PROGRAM "make") set(MAKE "${MAKE_PROGRAM} -j8") set(INITIAL_CACHE "CMAKE_BUILD_TYPE:STRING=Release +CMAKE_DOC_DIR:STRING=doc/cmake CMAKE_USE_OPENSSL:BOOL=OFF CMAKE_SKIP_BOOTSTRAP_TEST:STRING=TRUE CMAKE_Fortran_COMPILER:FILEPATH=FALSE diff --git a/Utilities/Release/dashmacmini2_release.cmake b/Utilities/Release/dashmacmini2_release.cmake deleted file mode 100644 index 01f5b8b..0000000 --- a/Utilities/Release/dashmacmini2_release.cmake +++ /dev/null @@ -1,25 +0,0 @@ -set(PROCESSORS 2) -set(CMAKE_RELEASE_DIRECTORY /Users/kitware/CMakeReleaseDirectory) -set(USER_OVERRIDE "set(CMAKE_CXX_LINK_EXECUTABLE \\\"gcc <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES> -shared-libgcc -lstdc++-static\\\")") -set(INSTALL_PREFIX /) -set(HOST dashmacmini2) -set(MAKE_PROGRAM "make") -set(MAKE "${MAKE_PROGRAM} -j2") -set(CPACK_BINARY_GENERATORS "DragNDrop TGZ TZ") -set(CPACK_DMG_FORMAT "UDBZ") #build using bzip2 for smaller package size -set(INITIAL_CACHE " -CMAKE_BUILD_TYPE:STRING=Release -CMAKE_OSX_ARCHITECTURES:STRING=ppc;i386 -CMAKE_USE_OPENSSL:BOOL=ON -OPENSSL_CRYPTO_LIBRARY:FILEPATH=/Users/kitware/openssl-1.0.1g-install/lib/libcrypto.a -OPENSSL_INCLUDE_DIR:PATH=/Users/kitware/openssl-1.0.1g-install/include -OPENSSL_SSL_LIBRARY:FILEPATH=/Users/kitware/openssl-1.0.1g-install/lib/libssl.a -CMAKE_SKIP_BOOTSTRAP_TEST:STRING=TRUE -CPACK_SYSTEM_NAME:STRING=Darwin-universal -BUILD_QtDialog:BOOL=TRUE -CMake_GUI_DISTRIBUTE_WITH_Qt_LGPL:BOOL=TRUE -CMake_INSTALL_DEPENDENCIES:BOOL=ON -QT_QMAKE_EXECUTABLE:FILEPATH=/Users/kitware/Support/qt-4.8.0/install/bin/qmake -") -get_filename_component(path "${CMAKE_CURRENT_LIST_FILE}" PATH) -include(${path}/release_cmake.cmake) diff --git a/Utilities/Release/dashmacmini5_release.cmake b/Utilities/Release/dashmacmini5_release.cmake index be1dfa9..b147013 100644 --- a/Utilities/Release/dashmacmini5_release.cmake +++ b/Utilities/Release/dashmacmini5_release.cmake @@ -1,7 +1,7 @@ set(PROCESSORS 4) set(CMAKE_RELEASE_DIRECTORY /Users/kitware/CMakeReleaseDirectory) # set(USER_OVERRIDE "set(CMAKE_CXX_LINK_EXECUTABLE \\\"gcc <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES> -shared-libgcc -lstdc++-static\\\")") -set(INSTALL_PREFIX /) +set(BOOTSTRAP_ARGS "--prefix=/ --docdir=doc/cmake") set(HOST dashmacmini5) set(MAKE_PROGRAM "make") set(MAKE "${MAKE_PROGRAM} -j5") diff --git a/Utilities/Release/linux64_release.cmake b/Utilities/Release/linux64_release.cmake index 25da00a..81442e7 100644 --- a/Utilities/Release/linux64_release.cmake +++ b/Utilities/Release/linux64_release.cmake @@ -1,4 +1,5 @@ set(PROCESSORS 4) +set(BOOTSTRAP_ARGS "--docdir=doc/cmake") set(HOST linux64) set(MAKE_PROGRAM "make") set(CC /opt/gcc-4.9.2/bin/gcc) diff --git a/Utilities/Release/magrathea_release.cmake b/Utilities/Release/magrathea_release.cmake index b031eb8..0634dda 100644 --- a/Utilities/Release/magrathea_release.cmake +++ b/Utilities/Release/magrathea_release.cmake @@ -1,4 +1,5 @@ set(PROCESSORS 1) +set(BOOTSTRAP_ARGS "--docdir=doc/cmake") set(HOST magrathea) set(MAKE_PROGRAM "make") set(CC gcc332s) diff --git a/Utilities/Release/release_cmake.cmake b/Utilities/Release/release_cmake.cmake index 4c4dd8a..c50602d 100644 --- a/Utilities/Release/release_cmake.cmake +++ b/Utilities/Release/release_cmake.cmake @@ -119,27 +119,34 @@ foreach(gen ${generators}) set(SUFFIXES ${SUFFIXES} "*.exe") endif() endforeach() + +if(LOCAL_DIR) + file(MAKE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${LOCAL_DIR}") +else() + set(LOCAL_DIR .) +endif() + # copy all the files over from the remote machine set(PROJECT_PREFIX cmake-) foreach(suffix ${SUFFIXES}) - message("scp ${HOST}:${FINAL_PATH}/${PROJECT_PREFIX}${suffix} .") + message("scp ${HOST}:${FINAL_PATH}/${PROJECT_PREFIX}${suffix} ${LOCAL_DIR}") execute_process(COMMAND - scp ${HOST}:${FINAL_PATH}/${PROJECT_PREFIX}${suffix} . + scp ${HOST}:${FINAL_PATH}/${PROJECT_PREFIX}${suffix} ${LOCAL_DIR} RESULT_VARIABLE result) if(${result} GREATER 0) - message("error getting file back scp ${HOST}:${FINAL_PATH}/${PROJECT_PREFIX}${suffix} .") + message("error getting file back scp ${HOST}:${FINAL_PATH}/${PROJECT_PREFIX}${suffix} ${LOCAL_DIR}") endif() endforeach() # if there are extra files to copy get them as well if(extra_files) foreach(f ${extra_files}) - message("scp ${HOST}:${FINAL_PATH}/${f} .") + message("scp ${HOST}:${FINAL_PATH}/${f} ${LOCAL_DIR}") execute_process(COMMAND - scp ${HOST}:${FINAL_PATH}/${f} . + scp ${HOST}:${FINAL_PATH}/${f} ${LOCAL_DIR} RESULT_VARIABLE result) if(${result} GREATER 0) - message("error getting file back scp ${HOST}:${FINAL_PATH}/${f} .") + message("error getting file back scp ${HOST}:${FINAL_PATH}/${f} ${LOCAL_DIR}") endif() endforeach() endif() diff --git a/Utilities/Release/release_cmake.sh.in b/Utilities/Release/release_cmake.sh.in index 76fdb3a..06e720f 100755 --- a/Utilities/Release/release_cmake.sh.in +++ b/Utilities/Release/release_cmake.sh.in @@ -116,15 +116,9 @@ if [ ! -z "@CONFIGURE_WITH_CMAKE@" ]; then @CMAKE_CONFIGURE_PATH@ ../@CMAKE_CREATE_VERSION@ check_exit_value $? "Configure cmake" || exit 1 else - if [ -z "@INSTALL_PREFIX@" ]; then - echo "Run cmake bootstrap --parallel=@PROCESSORS@" - ../@CMAKE_CREATE_VERSION@/bootstrap --parallel=@PROCESSORS@ - check_exit_value $? "Bootstrap cmake" || exit 1 - else - echo "Run cmake bootstrap --prefix=@INSTALL_PREFIX@ --parallel=@PROCESSORS@" - ../@CMAKE_CREATE_VERSION@/bootstrap --prefix=@INSTALL_PREFIX@ --parallel=@PROCESSORS@ - check_exit_value $? "Bootstrap cmake" || exit 1 - fi + echo "Run cmake bootstrap @BOOTSTRAP_ARGS@ --parallel=@PROCESSORS@" + ../@CMAKE_CREATE_VERSION@/bootstrap @BOOTSTRAP_ARGS@ --parallel=@PROCESSORS@ + check_exit_value $? "Bootstrap cmake" || exit 1 fi echo "Build cmake with @MAKE@" diff --git a/Utilities/Release/upload_release.cmake b/Utilities/Release/upload_release.cmake index ac41300..171811a 100644 --- a/Utilities/Release/upload_release.cmake +++ b/Utilities/Release/upload_release.cmake @@ -1,6 +1,6 @@ set(CTEST_RUN_CURRENT_SCRIPT 0) if(NOT VERSION) - set(VERSION 3.3) + set(VERSION 3.4) endif() if(NOT DEFINED PROJECT_PREFIX) set(PROJECT_PREFIX cmake-${VERSION}) diff --git a/Utilities/Sphinx/templates/layout.html b/Utilities/Sphinx/templates/layout.html index 1c5728c..177e044 100644 --- a/Utilities/Sphinx/templates/layout.html +++ b/Utilities/Sphinx/templates/layout.html @@ -5,7 +5,7 @@ style="vertical-align: middle; margin-top: -2px" /> </li> <li> - <a href="http://www.cmake.org/">CMake</a>{{ reldelim1 }} + <a href="https://cmake.org/">CMake</a>{{ reldelim1 }} </li> <li> <a href="{{ pathto(master_doc) }}">{{ shorttitle|e }}</a>{{ reldelim1 }} diff --git a/Utilities/cmcurl/CMakeLists.txt b/Utilities/cmcurl/CMakeLists.txt index d12c73f..39b70c0 100644 --- a/Utilities/cmcurl/CMakeLists.txt +++ b/Utilities/cmcurl/CMakeLists.txt @@ -43,6 +43,14 @@ if(WIN32) set(HAVE_INET_PTON 0 CACHE INTERNAL "Do not use inet_pton") endif() +# Starting with OSX 10.11 there is an unrelated libnetwork library which will +# be picked up during curl configuration. Linking against this library is +# unnecessary and breaks backward compatibility of the resulting binaries +# because libnetwork is unavailable on older OSX versions. +if(APPLE) + set(HAVE_LIBNETWORK 0 CACHE INTERNAL "Do not use libnetwork") +endif(APPLE) + # Disable warnings to avoid changing 3rd party code. if(CMAKE_C_COMPILER_ID MATCHES "^(GNU|Clang|AppleClang|XL|VisualAge|SunPro|MIPSpro|HP|Intel)$") diff --git a/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp b/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp index 41896a7..7b33828 100644 --- a/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp +++ b/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp @@ -529,7 +529,7 @@ bool Reader::decodeNumber(Token& token, Value& decoded) { return addError("'" + std::string(token.start_, token.end_) + "' is not a number.", token); - Value::UInt digit(c - '0'); + Value::UInt digit(static_cast<Value::UInt>(c - '0')); if (value >= threshold) { // We've hit or exceeded the max value divided by 10 (rounded down). If // a) we've only just touched the limit, b) this is the last digit, and diff --git a/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp b/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp index b64cdb0..e3f4e53 100644 --- a/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp +++ b/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp @@ -24,7 +24,9 @@ // Solaris #if defined(__sun) # include <ieeefp.h> -# define isfinite finite +# if !defined(isfinite) +# define isfinite finite +# endif #endif // AIX diff --git a/Utilities/cmlibarchive/CMakeLists.txt b/Utilities/cmlibarchive/CMakeLists.txt index b150408..00550e2 100644 --- a/Utilities/cmlibarchive/CMakeLists.txt +++ b/Utilities/cmlibarchive/CMakeLists.txt @@ -8,6 +8,9 @@ endif() # On MacOS, prefer MacPorts libraries to system libraries. # I haven't come up with a compelling argument for this to be conditional. list(APPEND CMAKE_PREFIX_PATH /opt/local) +# Enable @rpath in the install name. +# detail in "cmake --help-policy CMP0042" +SET(CMAKE_MACOSX_RPATH ON) # # Version - read from 'version' file. @@ -71,9 +74,12 @@ OPTION(ENABLE_OPENSSL "Enable use of OpenSSL" ON) OPTION(ENABLE_LZMA "Enable the use of the system found LZMA library if found" ON) OPTION(ENABLE_ZLIB "Enable the use of the system found ZLIB library if found" ON) OPTION(ENABLE_BZip2 "Enable the use of the system found BZip2 library if found" ON) +OPTION(ENABLE_LIBXML2 "Enable the use of the system found libxml2 library if found" ON) OPTION(ENABLE_EXPAT "Enable the use of the system found EXPAT library if found" ON) OPTION(ENABLE_PCREPOSIX "Enable the use of the system found PCREPOSIX library if found" ON) OPTION(ENABLE_LibGCC "Enable the use of the system found LibGCC library if found" ON) +# CNG is used for encrypt/decrypt Zip archives on Windows. +OPTION(ENABLE_CNG "Enable the use of CNG(Crypto Next Generation)" ON) OPTION(ENABLE_XATTR "Enable extended attribute support" ON) OPTION(ENABLE_ACL "Enable ACL support" ON) @@ -88,6 +94,8 @@ IF(WIN32) SET(_WIN32_WINNT ${WINVER}) ENDIF(WIN32) +set(HAVE_PTHREAD_H 0) # no threads in CMake + IF("${CMAKE_C_PLATFORM_ID}" MATCHES "^(HP-UX)$") ADD_DEFINITIONS(-D_XOPEN_SOURCE=500) # Ask wchar.h for mbstate_t ENDIF() @@ -273,6 +281,8 @@ IF(BZIP2_FOUND) ENDIF(BZIP2_FOUND) MARK_AS_ADVANCED(CLEAR BZIP2_INCLUDE_DIR) MARK_AS_ADVANCED(CLEAR BZIP2_LIBRARIES) + + # # Find LZMA # @@ -335,6 +345,35 @@ ENDIF(LZO2_FOUND) MARK_AS_ADVANCED(CLEAR LZO2_INCLUDE_DIR) MARK_AS_ADVANCED(CLEAR LZO2_LIBRARY) ENDIF() +IF(0) # CMake does not need LZ4 support in libarchive +# +# Find LZ4 +# +IF (LZ4_INCLUDE_DIR) + # Already in cache, be silent + SET(LZ4_FIND_QUIETLY TRUE) +ENDIF (LZ4_INCLUDE_DIR) + +FIND_PATH(LZ4_INCLUDE_DIR lz4.h) +FIND_LIBRARY(LZ4_LIBRARY NAMES lz4 liblz4) +INCLUDE(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(LZ4 DEFAULT_MSG LZ4_LIBRARY LZ4_INCLUDE_DIR) +IF(LZ4_FOUND) + SET(HAVE_LIBLZ4 1) + SET(HAVE_LZ4_H 1) + CMAKE_PUSH_CHECK_STATE() # Save the state of the variables + SET(CMAKE_REQUIRED_INCLUDES ${LZ4_INCLUDE_DIR}) + CHECK_INCLUDE_FILES("lz4hc.h" HAVE_LZ4HC_H) + CMAKE_POP_CHECK_STATE() # Restore the state of the variables + INCLUDE_DIRECTORIES(${LZ4_INCLUDE_DIR}) + LIST(APPEND ADDITIONAL_LIBS ${LZ4_LIBRARY}) + # + # TODO: test for static library. + # +ENDIF(LZ4_FOUND) +MARK_AS_ADVANCED(CLEAR LZ4_INCLUDE_DIR) +MARK_AS_ADVANCED(CLEAR LZ4_LIBRARY) +ENDIF() # # Check headers @@ -384,7 +423,9 @@ LA_CHECK_INCLUDE_FILE("memory.h" HAVE_MEMORY_H) LA_CHECK_INCLUDE_FILE("paths.h" HAVE_PATHS_H) LA_CHECK_INCLUDE_FILE("poll.h" HAVE_POLL_H) LA_CHECK_INCLUDE_FILE("process.h" HAVE_PROCESS_H) +LA_CHECK_INCLUDE_FILE("pthread.h" HAVE_PTHREAD_H) LA_CHECK_INCLUDE_FILE("pwd.h" HAVE_PWD_H) +LA_CHECK_INCLUDE_FILE("readpassphrase.h" HAVE_READPASSPHRASE_H) LA_CHECK_INCLUDE_FILE("regex.h" HAVE_REGEX_H) LA_CHECK_INCLUDE_FILE("signal.h" HAVE_SIGNAL_H) LA_CHECK_INCLUDE_FILE("spawn.h" HAVE_SPAWN_H) @@ -415,6 +456,11 @@ LA_CHECK_INCLUDE_FILE("utime.h" HAVE_UTIME_H) LA_CHECK_INCLUDE_FILE("wchar.h" HAVE_WCHAR_H) LA_CHECK_INCLUDE_FILE("wctype.h" HAVE_WCTYPE_H) LA_CHECK_INCLUDE_FILE("windows.h" HAVE_WINDOWS_H) +IF(ENABLE_CNG) + LA_CHECK_INCLUDE_FILE("Bcrypt.h" HAVE_BCRYPT_H) +ELSE(ENABLE_CNG) + UNSET(HAVE_BCRYPT_H CACHE) +ENDIF(ENABLE_CNG) # Following files need windwos.h, so we should test it after windows.h test. LA_CHECK_INCLUDE_FILE("wincrypt.h" HAVE_WINCRYPT_H) LA_CHECK_INCLUDE_FILE("winioctl.h" HAVE_WINIOCTL_H) @@ -446,6 +492,7 @@ IF(ENABLE_NETTLE) SET(HAVE_NETTLE_SHA_H 1) INCLUDE_DIRECTORIES(${NETTLE_INCLUDE_DIR}) LIST(APPEND ADDITIONAL_LIBS ${NETTLE_LIBRARIES}) + LA_CHECK_INCLUDE_FILE("nettle/pbkdf2.h" HAVE_NETTLE_PBKDF2_H) ENDIF(NETTLE_FOUND) MARK_AS_ADVANCED(CLEAR NETTLE_INCLUDE_DIR) MARK_AS_ADVANCED(CLEAR NETTLE_LIBRARIES) @@ -457,6 +504,9 @@ ENDIF(ENABLE_NETTLE) # IF(ENABLE_OPENSSL AND NOT CMAKE_SYSTEM_NAME MATCHES "Darwin") FIND_PACKAGE(OpenSSL) + IF(OPENSSL_FOUND) + SET(HAVE_LIBCRYPTO 1) + ENDIF(OPENSSL_FOUND) ELSE() SET(OPENSSL_FOUND FALSE) # Override cached value ENDIF() @@ -475,7 +525,7 @@ ENDIF(NOT OPENSSL_FOUND) # # How to prove that CRYPTO functions, which have several names on various -# platforms, just see if archive_crypto.c can compile and link against +# platforms, just see if archive_digest.c can compile and link against # required libraries. # MACRO(CHECK_CRYPTO ALGORITHMS IMPLEMENTATION) @@ -514,7 +564,7 @@ MACRO(CHECK_CRYPTO ALGORITHMS IMPLEMENTATION) ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h) FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h" CONFDEFS_H) - FILE(READ "${CMAKE_CURRENT_SOURCE_DIR}/libarchive/archive_crypto.c" + FILE(READ "${CMAKE_CURRENT_SOURCE_DIR}/libarchive/archive_digest.c" ARCHIVE_CRYPTO_C) SET(SOURCE "${CONFDEFS_H} @@ -664,14 +714,15 @@ ENDMACRO(CHECK_CRYPTO_WIN CRYPTO_LIST) MACRO(CHECK_ICONV LIB TRY_ICONV_CONST) IF(NOT HAVE_ICONV) CMAKE_PUSH_CHECK_STATE() # Save the state of the variables - IF (CMAKE_C_COMPILER_ID STREQUAL "GNU") + IF (CMAKE_C_COMPILER_ID STREQUAL "GNU" OR + CMAKE_C_COMPILER_ID STREQUAL "Clang") # # During checking iconv proto type, we should use -Werror to avoid the # success of iconv detection with a warnig which success is a miss # detection. So this needs for all build mode(even it's a release mode). # SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror") - ENDIF (CMAKE_C_COMPILER_ID STREQUAL "GNU") + ENDIF () IF (MSVC) # NOTE: /WX option is the same as gcc's -Werror option. SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} /WX") @@ -795,7 +846,11 @@ IF(0) # CMake does not need XML support in libarchive # # Find Libxml2 # -FIND_PACKAGE(LibXml2) +IF(ENABLE_LIBXML2) + FIND_PACKAGE(LibXml2) +ELSE() + SET(LIBXML2_FOUND FALSE) +ENDIF() IF(LIBXML2_FOUND) CMAKE_PUSH_CHECK_STATE() # Save the state of the variables INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR}) @@ -820,7 +875,11 @@ ELSE(LIBXML2_FOUND) # # Find Expat # - FIND_PACKAGE(EXPAT) + IF(ENABLE_EXPAT) + FIND_PACKAGE(EXPAT) + ELSE() + SET(EXPAT_FOUND FALSE) + ENDIF() IF(EXPAT_FOUND) CMAKE_PUSH_CHECK_STATE() # Save the state of the variables INCLUDE_DIRECTORIES(${EXPAT_INCLUDE_DIR}) @@ -838,7 +897,8 @@ ENDIF() # Check functions # CMAKE_PUSH_CHECK_STATE() # Save the state of the variables -IF (CMAKE_C_COMPILER_ID STREQUAL "GNU") +IF (CMAKE_C_COMPILER_ID STREQUAL "GNU" OR + CMAKE_C_COMPILER_ID STREQUAL "Clang") # # During checking functions, we should use -fno-builtin to avoid the # failure of function detection which failure is an error "conflicting @@ -847,6 +907,7 @@ IF (CMAKE_C_COMPILER_ID STREQUAL "GNU") SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fno-builtin") ENDIF () CHECK_SYMBOL_EXISTS(_CrtSetReportMode "crtdbg.h" HAVE__CrtSetReportMode) +CHECK_FUNCTION_EXISTS_GLIBC(arc4random_buf HAVE_ARC4RANDOM_BUF) CHECK_FUNCTION_EXISTS_GLIBC(chflags HAVE_CHFLAGS) CHECK_FUNCTION_EXISTS_GLIBC(chown HAVE_CHOWN) CHECK_FUNCTION_EXISTS_GLIBC(chroot HAVE_CHROOT) @@ -894,6 +955,7 @@ CHECK_FUNCTION_EXISTS_GLIBC(pipe HAVE_PIPE) CHECK_FUNCTION_EXISTS_GLIBC(poll HAVE_POLL) CHECK_FUNCTION_EXISTS_GLIBC(posix_spawnp HAVE_POSIX_SPAWNP) CHECK_FUNCTION_EXISTS_GLIBC(readlink HAVE_READLINK) +CHECK_FUNCTION_EXISTS_GLIBC(readpassphrase HAVE_READPASSPHRASE) CHECK_FUNCTION_EXISTS_GLIBC(select HAVE_SELECT) CHECK_FUNCTION_EXISTS_GLIBC(setenv HAVE_SETENV) CHECK_FUNCTION_EXISTS_GLIBC(setlocale HAVE_SETLOCALE) @@ -932,6 +994,7 @@ CHECK_FUNCTION_EXISTS(strftime HAVE_STRFTIME) CHECK_FUNCTION_EXISTS(vprintf HAVE_VPRINTF) CHECK_FUNCTION_EXISTS(wmemcmp HAVE_WMEMCMP) CHECK_FUNCTION_EXISTS(wmemcpy HAVE_WMEMCPY) +CHECK_FUNCTION_EXISTS(wmemmove HAVE_WMEMMOVE) CMAKE_POP_CHECK_STATE() # Restore the state of the variables diff --git a/Utilities/cmlibarchive/COPYING b/Utilities/cmlibarchive/COPYING index b258806..93952b7 100644 --- a/Utilities/cmlibarchive/COPYING +++ b/Utilities/cmlibarchive/COPYING @@ -17,12 +17,11 @@ the actual statements in the files are controlling. files for details: libarchive/archive_entry.c libarchive/archive_read_support_filter_compress.c - libarchive/archive_write_set_filter_compress.c + libarchive/archive_write_add_filter_compress.c libarchive/mtree.5 - tar/matching.c * The following source files are in the public domain: - tar/getdate.c + libarchive/archive_getdate.c * The build files---including Makefiles, configure scripts, and auxiliary scripts used as part of the compile process---have diff --git a/Utilities/cmlibarchive/README-CMake.txt b/Utilities/cmlibarchive/README-CMake.txt index 8f3b29b..0a3e34a 100644 --- a/Utilities/cmlibarchive/README-CMake.txt +++ b/Utilities/cmlibarchive/README-CMake.txt @@ -11,7 +11,7 @@ branch, but it is merged into our history. Update libarchive from upstream as follows. Create a local branch to explicitly reference the upstream snapshot branch head: - git branch libarchive-upstream 37f225b7 + git branch libarchive-upstream 1a8c7bc2 Use a temporary directory to checkout the branch: @@ -24,7 +24,7 @@ Use a temporary directory to checkout the branch: Now place the (reduced) libarchive content in this directory. See instructions shown by - git log 37f225b7 + git log 1a8c7bc2 for help extracting the content from the upstream svn repo. Then run the following commands to commit the new version. Substitute the @@ -34,8 +34,8 @@ appropriate date and version number: GIT_AUTHOR_NAME='LibArchive Upstream' \ GIT_AUTHOR_EMAIL='libarchive-discuss@googlegroups.com' \ - GIT_AUTHOR_DATE='Mon Apr 14 19:19:05 2014 -0700' \ - git commit -m 'libarchive 3.1.2-246-ga5a5d28b (reduced)' && + GIT_AUTHOR_DATE='Wed Oct 21 01:47:34 2015 -0700' \ + git commit -m 'libarchive 3.1.2-601-g3bfe5f1 (reduced)' && git commit --amend Edit the commit message to describe the procedure used to obtain the diff --git a/Utilities/cmlibarchive/build/cmake/CreatePkgConfigFile.cmake b/Utilities/cmlibarchive/build/cmake/CreatePkgConfigFile.cmake index f96bbef..fc8529a 100644 --- a/Utilities/cmlibarchive/build/cmake/CreatePkgConfigFile.cmake +++ b/Utilities/cmlibarchive/build/cmake/CreatePkgConfigFile.cmake @@ -27,5 +27,7 @@ CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/pkgconfig/libarchive.pc.in ${CMAKE_CURRENT_SOURCE_DIR}/build/pkgconfig/libarchive.pc @ONLY) # And install it, of course ;). -INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/build/pkgconfig/libarchive.pc - DESTINATION "lib/pkgconfig") +IF(ENABLE_INSTALL) + INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/build/pkgconfig/libarchive.pc + DESTINATION "lib/pkgconfig") +ENDIF() diff --git a/Utilities/cmlibarchive/build/cmake/config.h.in b/Utilities/cmlibarchive/build/cmake/config.h.in index 32a29d0..1abeaaa 100644 --- a/Utilities/cmlibarchive/build/cmake/config.h.in +++ b/Utilities/cmlibarchive/build/cmake/config.h.in @@ -66,7 +66,7 @@ typedef long long int64_t; * Similarly for int32_t */ #if !defined(HAVE_INT32_T) && SIZE_OF_INT == 4 -typedef long int32_t; +typedef int int32_t; #define HAVE_INT32_T #endif @@ -331,9 +331,15 @@ typedef uint64_t uintmax_t; /* True for systems with POSIX ACL support */ #cmakedefine HAVE_ACL_USER 1 +/* Define to 1 if you have the `arc4random_buf' function. */ +#cmakedefine HAVE_ARC4RANDOM_BUF 1 + /* Define to 1 if you have the <attr/xattr.h> header file. */ #cmakedefine HAVE_ATTR_XATTR_H 1 +/* Define to 1 if you have the <Bcrypt.h> header file. */ +#cmakedefine HAVE_BCRYPT_H 1 + /* Define to 1 if you have the <bsdxml.h> header file. */ #cmakedefine HAVE_BSDXML_H 1 @@ -582,12 +588,21 @@ typedef uint64_t uintmax_t; /* Define to 1 if you have the `bz2' library (-lbz2). */ #cmakedefine HAVE_LIBBZ2 1 +/* Define to 1 if you have the `charset' library (-lcharset). */ +#cmakedefine HAVE_LIBCHARSET 1 + +/* Define to 1 if you have the `crypto' library (-lcrypto). */ +#cmakedefine HAVE_LIBCRYPTO 1 + /* Define to 1 if you have the `expat' library (-lexpat). */ #cmakedefine HAVE_LIBEXPAT 1 /* Define to 1 if you have the `gcc' library (-lgcc). */ #cmakedefine HAVE_LIBGCC 1 +/* Define to 1 if you have the `lz4' library (-llz4). */ +#cmakedefine HAVE_LIBLZ4 1 + /* Define to 1 if you have the `lzma' library (-llzma). */ #cmakedefine HAVE_LIBLZMA 1 @@ -682,6 +697,12 @@ typedef uint64_t uintmax_t; /* Define to 1 if you have the `lutimes' function. */ #cmakedefine HAVE_LUTIMES 1 +/* Define to 1 if you have the <lz4hc.h> header file. */ +#cmakedefine HAVE_LZ4HC_H 1 + +/* Define to 1 if you have the <lz4.h> header file. */ +#cmakedefine HAVE_LZ4_H 1 + /* Define to 1 if you have the <lzmadec.h> header file. */ #cmakedefine HAVE_LZMADEC_H 1 @@ -721,6 +742,9 @@ typedef uint64_t uintmax_t; /* Define to 1 if you have the <nettle/md5.h> header file. */ #cmakedefine HAVE_NETTLE_MD5_H 1 +/* Define to 1 if you have the <nettle/pbkdf2.h> header file. */ +#cmakedefine HAVE_NETTLE_PBKDF2_H 1 + /* Define to 1 if you have the <nettle/ripemd160.h> header file. */ #cmakedefine HAVE_NETTLE_RIPEMD160_H 1 @@ -742,6 +766,9 @@ typedef uint64_t uintmax_t; /* Define to 1 if you have the `pipe' function. */ #cmakedefine HAVE_PIPE 1 +/* Define to 1 if you have the `PKCS5_PBKDF2_HMAC_SHA1' function. */ +#cmakedefine HAVE_PKCS5_PBKDF2_HMAC_SHA1 1 + /* Define to 1 if you have the `poll' function. */ #cmakedefine HAVE_POLL 1 @@ -754,6 +781,9 @@ typedef uint64_t uintmax_t; /* Define to 1 if you have the <process.h> header file. */ #cmakedefine HAVE_PROCESS_H 1 +/* Define to 1 if you have the <pthread.h> header file. */ +#cmakedefine HAVE_PTHREAD_H 1 + /* Define to 1 if you have the <pwd.h> header file. */ #cmakedefine HAVE_PWD_H 1 @@ -766,6 +796,12 @@ typedef uint64_t uintmax_t; /* Define to 1 if you have the `readlinkat' function. */ #cmakedefine HAVE_READLINKAT 1 +/* Define to 1 if you have the `readpassphrase' function. */ +#cmakedefine HAVE_READPASSPHRASE 1 + +/* Define to 1 if you have the <readpassphrase.h> header file. */ +#cmakedefine HAVE_READPASSPHRASE_H 1 + /* Define to 1 if you have the <regex.h> header file. */ #cmakedefine HAVE_REGEX_H 1 @@ -1021,6 +1057,9 @@ typedef uint64_t uintmax_t; /* Define to 1 if you have the `wmemcpy' function. */ #cmakedefine HAVE_WMEMCPY 1 +/* Define to 1 if you have the `wmemmove' function. */ +#cmakedefine HAVE_WMEMMOVE 1 + /* Define to 1 if you have a working EXT2_IOC_GETFLAGS */ #cmakedefine HAVE_WORKING_EXT2_IOC_GETFLAGS 1 diff --git a/Utilities/cmlibarchive/libarchive/CMakeLists.txt b/Utilities/cmlibarchive/libarchive/CMakeLists.txt index 8908a62..891c728 100644 --- a/Utilities/cmlibarchive/libarchive/CMakeLists.txt +++ b/Utilities/cmlibarchive/libarchive/CMakeLists.txt @@ -18,8 +18,10 @@ SET(libarchive_SOURCES archive_cmdline.c archive_cmdline_private.h archive_crc32.h - archive_crypto.c - archive_crypto_private.h + archive_cryptor.c + archive_cryptor_private.h + archive_digest.c + archive_digest_private.h archive_endian.h archive_entry.c archive_entry.h @@ -32,6 +34,8 @@ SET(libarchive_SOURCES archive_entry_strmode.c archive_entry_xattr.c archive_getdate.c + archive_hmac.c + archive_hmac_private.h archive_match.c archive_options.c archive_options_private.h @@ -44,9 +48,12 @@ SET(libarchive_SOURCES archive_ppmd7.c archive_ppmd7_private.h archive_private.h + archive_random.c + archive_random_private.h archive_rb.c archive_rb.h archive_read.c + archive_read_add_passphrase.c archive_read_append_filter.c archive_read_data_into_fd.c archive_read_disk_entry_from_file.c @@ -68,6 +75,7 @@ SET(libarchive_SOURCES archive_read_support_filter_gzip.c archive_read_support_filter_grzip.c archive_read_support_filter_lrzip.c + archive_read_support_filter_lz4.c archive_read_support_filter_lzop.c archive_read_support_filter_none.c archive_read_support_filter_program.c @@ -87,6 +95,7 @@ SET(libarchive_SOURCES archive_read_support_format_rar.c archive_read_support_format_raw.c archive_read_support_format_tar.c + archive_read_support_format_warc.c archive_read_support_format_xar.c archive_read_support_format_zip.c archive_string.c @@ -113,6 +122,7 @@ SET(libarchive_SOURCES archive_write_add_filter_grzip.c archive_write_add_filter_gzip.c archive_write_add_filter_lrzip.c + archive_write_add_filter_lz4.c archive_write_add_filter_lzop.c archive_write_add_filter_none.c archive_write_add_filter_program.c @@ -124,6 +134,7 @@ SET(libarchive_SOURCES archive_write_set_format_by_name.c archive_write_set_format_cpio.c archive_write_set_format_cpio_newc.c + archive_write_set_format_filter_by_ext.c archive_write_set_format_gnutar.c archive_write_set_format_iso9660.c archive_write_set_format_mtree.c @@ -132,11 +143,15 @@ SET(libarchive_SOURCES archive_write_set_format_shar.c archive_write_set_format_ustar.c archive_write_set_format_v7tar.c + archive_write_set_format_warc.c archive_write_set_format_xar.c archive_write_set_format_zip.c archive_write_set_options.c + archive_write_set_passphrase.c + archive_xxhash.h filter_fork_posix.c filter_fork.h + xxhash.c ) # Man pages @@ -149,12 +164,14 @@ SET(libarchive_MANS archive_entry_stat.3 archive_entry_time.3 archive_read.3 + archive_read_add_passphrase.3 archive_read_disk.3 archive_read_set_options.3 archive_util.3 archive_write.3 archive_write_disk.3 archive_write_set_options.3 + archive_write_set_passphrase.3 cpio.5 libarchive.3 libarchive_internals.3 diff --git a/Utilities/cmlibarchive/libarchive/archive.h b/Utilities/cmlibarchive/libarchive/archive.h index 9cf762d..a8d4c6c 100644 --- a/Utilities/cmlibarchive/libarchive/archive.h +++ b/Utilities/cmlibarchive/libarchive/archive.h @@ -28,6 +28,16 @@ #ifndef ARCHIVE_H_INCLUDED #define ARCHIVE_H_INCLUDED +/* + * The version number is expressed as a single integer that makes it + * easy to compare versions at build time: for version a.b.c, the + * version number is printf("%d%03d%03d",a,b,c). For example, if you + * know your application requires version 2.12.108 or later, you can + * assert that ARCHIVE_VERSION_NUMBER >= 2012108. + */ +/* Note: Compiler will complain if this does not match archive_entry.h! */ +#define ARCHIVE_VERSION_NUMBER 3001002 + #include <sys/stat.h> #include <stddef.h> /* for wchar_t */ #include <stdio.h> /* For FILE * */ @@ -45,32 +55,44 @@ # include <inttypes.h> #endif -/* Borland symbols are case-insensitive. This workaround only works - within CMake because we do not mix compilers. */ -#if defined(__BORLANDC__) -# define archive_read_open_FILE archive_read_open_FILE_ -# define archive_write_open_FILE archive_write_open_FILE_ +/* Get appropriate definitions of 64-bit integer */ +#if !defined(__LA_INT64_T_DEFINED) +/* Older code relied on the __LA_INT64_T macro; after 4.0 we'll switch to the typedef exclusively. */ +# if ARCHIVE_VERSION_NUMBER < 4000000 +#define __LA_INT64_T la_int64_t +# endif +#define __LA_INT64_T_DEFINED +# if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__WATCOMC__) +typedef __int64 la_int64_t; +# else +# include <unistd.h> /* ssize_t */ +# if defined(_SCO_DS) || defined(__osf__) +typedef long long la_int64_t; +# else +typedef int64_t la_int64_t; +# endif +# endif #endif -/* Get appropriate definitions of standard POSIX-style types. */ -/* These should match the types used in 'struct stat' */ -#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__WATCOMC__) -# define __LA_INT64_T __int64 -# if defined(_SSIZE_T_DEFINED) || defined(_SSIZE_T_) -# define __LA_SSIZE_T ssize_t -# elif defined(_WIN64) -# define __LA_SSIZE_T __int64 -# else -# define __LA_SSIZE_T long +/* The la_ssize_t should match the type used in 'struct stat' */ +#if !defined(__LA_SSIZE_T_DEFINED) +/* Older code relied on the __LA_SSIZE_T macro; after 4.0 we'll switch to the typedef exclusively. */ +# if ARCHIVE_VERSION_NUMBER < 4000000 +#define __LA_SSIZE_T la_ssize_t # endif -#else -# include <unistd.h> /* ssize_t, uid_t, and gid_t */ -# if defined(_SCO_DS) || defined(__osf__) -# define __LA_INT64_T long long +#define __LA_SSIZE_T_DEFINED +# if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__WATCOMC__) +# if defined(_SSIZE_T_DEFINED) || defined(_SSIZE_T_) +typedef ssize_t la_ssize_t; +# elif defined(_WIN64) +typedef __int64 la_ssize_t; +# else +typedef long la_ssize_t; +# endif # else -# define __LA_INT64_T int64_t +# include <unistd.h> /* ssize_t */ +typedef ssize_t la_ssize_t; # endif -# define __LA_SSIZE_T ssize_t #endif /* @@ -119,26 +141,21 @@ extern "C" { * header and library are very different, you should expect some * strangeness. Don't do that. */ - -/* - * The version number is expressed as a single integer that makes it - * easy to compare versions at build time: for version a.b.c, the - * version number is printf("%d%03d%03d",a,b,c). For example, if you - * know your application requires version 2.12.108 or later, you can - * assert that ARCHIVE_VERSION_NUMBER >= 2012108. - */ -/* Note: Compiler will complain if this does not match archive_entry.h! */ -#define ARCHIVE_VERSION_NUMBER 3001002 __LA_DECL int archive_version_number(void); /* * Textual name/version of the library, useful for version displays. */ -#define ARCHIVE_VERSION_STRING "libarchive 3.1.2" +#define ARCHIVE_VERSION_ONLY_STRING "3.1.2" +#define ARCHIVE_VERSION_STRING "libarchive " ARCHIVE_VERSION_ONLY_STRING __LA_DECL const char * archive_version_string(void); /* * Detailed textual name/version of the library and its dependencies. + * This has the form: + * "libarchive x.y.z zlib/a.b.c liblzma/d.e.f ... etc ..." + * the list of libraries described here will vary depending on how + * libarchive was compiled. */ __LA_DECL const char * archive_version_details(void); @@ -182,7 +199,7 @@ struct archive_entry; */ /* Returns pointer and size of next block of data from archive. */ -typedef __LA_SSIZE_T archive_read_callback(struct archive *, +typedef la_ssize_t archive_read_callback(struct archive *, void *_client_data, const void **_buffer); /* Skips at most request bytes from archive and returns the skipped amount. @@ -190,18 +207,18 @@ typedef __LA_SSIZE_T archive_read_callback(struct archive *, * If you do skip fewer bytes than requested, libarchive will invoke your * read callback and discard data as necessary to make up the full skip. */ -typedef __LA_INT64_T archive_skip_callback(struct archive *, - void *_client_data, __LA_INT64_T request); +typedef la_int64_t archive_skip_callback(struct archive *, + void *_client_data, la_int64_t request); /* Seeks to specified location in the file and returns the position. * Whence values are SEEK_SET, SEEK_CUR, SEEK_END from stdio.h. * Return ARCHIVE_FATAL if the seek fails for any reason. */ -typedef __LA_INT64_T archive_seek_callback(struct archive *, - void *_client_data, __LA_INT64_T offset, int whence); +typedef la_int64_t archive_seek_callback(struct archive *, + void *_client_data, la_int64_t offset, int whence); /* Returns size actually written, zero on EOF, -1 on error. */ -typedef __LA_SSIZE_T archive_write_callback(struct archive *, +typedef la_ssize_t archive_write_callback(struct archive *, void *_client_data, const void *_buffer, size_t _length); @@ -217,6 +234,13 @@ typedef int archive_switch_callback(struct archive *, void *_client_data1, void *_client_data2); /* + * Returns a passphrase used for encryption or decryption, NULL on nothing + * to do and give it up. + */ +typedef const char *archive_passphrase_callback(struct archive *, + void *_client_data); + +/* * Codes to identify various stream filters. */ #define ARCHIVE_FILTER_NONE 0 @@ -232,6 +256,7 @@ typedef int archive_switch_callback(struct archive *, void *_client_data1, #define ARCHIVE_FILTER_LRZIP 10 #define ARCHIVE_FILTER_LZOP 11 #define ARCHIVE_FILTER_GRZIP 12 +#define ARCHIVE_FILTER_LZ4 13 #if ARCHIVE_VERSION_NUMBER < 4000000 #define ARCHIVE_COMPRESSION_NONE ARCHIVE_FILTER_NONE @@ -293,6 +318,7 @@ typedef int archive_switch_callback(struct archive *, void *_client_data1, #define ARCHIVE_FORMAT_CAB 0xC0000 #define ARCHIVE_FORMAT_RAR 0xD0000 #define ARCHIVE_FORMAT_7ZIP 0xE0000 +#define ARCHIVE_FORMAT_WARC 0xF0000 /* * Codes returned by archive_read_format_capabilities(). @@ -375,6 +401,7 @@ __LA_DECL int archive_read_support_filter_compress(struct archive *); __LA_DECL int archive_read_support_filter_gzip(struct archive *); __LA_DECL int archive_read_support_filter_grzip(struct archive *); __LA_DECL int archive_read_support_filter_lrzip(struct archive *); +__LA_DECL int archive_read_support_filter_lz4(struct archive *); __LA_DECL int archive_read_support_filter_lzip(struct archive *); __LA_DECL int archive_read_support_filter_lzma(struct archive *); __LA_DECL int archive_read_support_filter_lzop(struct archive *); @@ -402,6 +429,7 @@ __LA_DECL int archive_read_support_format_mtree(struct archive *); __LA_DECL int archive_read_support_format_rar(struct archive *); __LA_DECL int archive_read_support_format_raw(struct archive *); __LA_DECL int archive_read_support_format_tar(struct archive *); +__LA_DECL int archive_read_support_format_warc(struct archive *); __LA_DECL int archive_read_support_format_xar(struct archive *); /* archive_read_support_format_zip() enables both streamable and seekable * zip readers. */ @@ -482,9 +510,9 @@ __LA_DECL int archive_read_open_file(struct archive *, const char *_filename, size_t _block_size) __LA_DEPRECATED; /* Read an archive that's stored in memory. */ __LA_DECL int archive_read_open_memory(struct archive *, - void * buff, size_t size); + const void * buff, size_t size); /* A more involved version that is only used for internal testing. */ -__LA_DECL int archive_read_open_memory2(struct archive *a, void *buff, +__LA_DECL int archive_read_open_memory2(struct archive *a, const void *buff, size_t size, size_t read_size); /* Read an archive that's already open, using the file descriptor. */ __LA_DECL int archive_read_open_fd(struct archive *, int _fd, @@ -505,7 +533,7 @@ __LA_DECL int archive_read_next_header2(struct archive *, * Retrieve the byte offset in UNCOMPRESSED data where last-read * header started. */ -__LA_DECL __LA_INT64_T archive_read_header_position(struct archive *); +__LA_DECL la_int64_t archive_read_header_position(struct archive *); /* * Returns 1 if the archive contains at least one encrypted entry. @@ -534,11 +562,11 @@ __LA_DECL int archive_read_has_encrypted_entries(struct archive *); __LA_DECL int archive_read_format_capabilities(struct archive *); /* Read data from the body of an entry. Similar to read(2). */ -__LA_DECL __LA_SSIZE_T archive_read_data(struct archive *, +__LA_DECL la_ssize_t archive_read_data(struct archive *, void *, size_t); /* Seek within the body of an entry. Similar to lseek(2). */ -__LA_DECL __LA_INT64_T archive_seek_data(struct archive *, __LA_INT64_T, int); +__LA_DECL la_int64_t archive_seek_data(struct archive *, la_int64_t, int); /* * A zero-copy version of archive_read_data that also exposes the file offset @@ -547,7 +575,7 @@ __LA_DECL __LA_INT64_T archive_seek_data(struct archive *, __LA_INT64_T, int); * be strictly increasing and that returned blocks will not overlap. */ __LA_DECL int archive_read_data_block(struct archive *a, - const void **buff, size_t *size, __LA_INT64_T *offset); + const void **buff, size_t *size, la_int64_t *offset); /*- * Some convenience functions that are built on archive_read_data: @@ -577,6 +605,14 @@ __LA_DECL int archive_read_set_option(struct archive *_a, __LA_DECL int archive_read_set_options(struct archive *_a, const char *opts); +/* + * Add a decryption passphrase. + */ +__LA_DECL int archive_read_add_passphrase(struct archive *, const char *); +__LA_DECL int archive_read_set_passphrase_callback(struct archive *, + void *client_data, archive_passphrase_callback *); + + /*- * Convenience function to recreate the current entry (whose header * has just been read) on disk. @@ -629,6 +665,10 @@ __LA_DECL int archive_read_set_options(struct archive *_a, /* Default: Do not use HFS+ compression if it was not compressed. */ /* This has no effect except on Mac OS v10.6 or later. */ #define ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED (0x8000) +/* Default: Do not reject entries with absolute paths */ +#define ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS (0x10000) +/* Default: Do not clear no-change flags when unlinking object */ +#define ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS (0x20000) __LA_DECL int archive_read_extract(struct archive *, struct archive_entry *, int flags); @@ -640,7 +680,7 @@ __LA_DECL void archive_read_extract_set_progress_callback(struct archive *, /* Record the dev/ino of a file that will not be written. This is * generally set to the dev/ino of the archive being read. */ __LA_DECL void archive_read_extract_set_skip_file(struct archive *, - __LA_INT64_T, __LA_INT64_T); + la_int64_t, la_int64_t); /* Close the file and release most resources. */ __LA_DECL int archive_read_close(struct archive *); @@ -679,7 +719,7 @@ __LA_DECL int archive_write_get_bytes_in_last_block(struct archive *); /* The dev/ino of a file that won't be archived. This is used * to avoid recursively adding an archive to itself. */ __LA_DECL int archive_write_set_skip_file(struct archive *, - __LA_INT64_T, __LA_INT64_T); + la_int64_t, la_int64_t); #if ARCHIVE_VERSION_NUMBER < 4000000 __LA_DECL int archive_write_set_compression_bzip2(struct archive *) @@ -710,6 +750,7 @@ __LA_DECL int archive_write_add_filter_compress(struct archive *); __LA_DECL int archive_write_add_filter_grzip(struct archive *); __LA_DECL int archive_write_add_filter_gzip(struct archive *); __LA_DECL int archive_write_add_filter_lrzip(struct archive *); +__LA_DECL int archive_write_add_filter_lz4(struct archive *); __LA_DECL int archive_write_add_filter_lzip(struct archive *); __LA_DECL int archive_write_add_filter_lzma(struct archive *); __LA_DECL int archive_write_add_filter_lzop(struct archive *); @@ -742,8 +783,11 @@ __LA_DECL int archive_write_set_format_shar(struct archive *); __LA_DECL int archive_write_set_format_shar_dump(struct archive *); __LA_DECL int archive_write_set_format_ustar(struct archive *); __LA_DECL int archive_write_set_format_v7tar(struct archive *); +__LA_DECL int archive_write_set_format_warc(struct archive *); __LA_DECL int archive_write_set_format_xar(struct archive *); __LA_DECL int archive_write_set_format_zip(struct archive *); +__LA_DECL int archive_write_set_format_filter_by_ext(struct archive *a, const char *filename); +__LA_DECL int archive_write_set_format_filter_by_ext_def(struct archive *a, const char *filename, const char * def_ext); __LA_DECL int archive_write_zip_set_compression_deflate(struct archive *); __LA_DECL int archive_write_zip_set_compression_store(struct archive *); __LA_DECL int archive_write_open(struct archive *, void *, @@ -768,12 +812,12 @@ __LA_DECL int archive_write_open_memory(struct archive *, */ __LA_DECL int archive_write_header(struct archive *, struct archive_entry *); -__LA_DECL __LA_SSIZE_T archive_write_data(struct archive *, +__LA_DECL la_ssize_t archive_write_data(struct archive *, const void *, size_t); /* This interface is currently only available for archive_write_disk handles. */ -__LA_DECL __LA_SSIZE_T archive_write_data_block(struct archive *, - const void *, size_t, __LA_INT64_T); +__LA_DECL la_ssize_t archive_write_data_block(struct archive *, + const void *, size_t, la_int64_t); __LA_DECL int archive_write_finish_entry(struct archive *); __LA_DECL int archive_write_close(struct archive *); @@ -808,6 +852,13 @@ __LA_DECL int archive_write_set_option(struct archive *_a, __LA_DECL int archive_write_set_options(struct archive *_a, const char *opts); +/* + * Set a encryption passphrase. + */ +__LA_DECL int archive_write_set_passphrase(struct archive *_a, const char *p); +__LA_DECL int archive_write_set_passphrase_callback(struct archive *, + void *client_data, archive_passphrase_callback *); + /*- * ARCHIVE_WRITE_DISK API * @@ -827,7 +878,7 @@ __LA_DECL int archive_write_set_options(struct archive *_a, __LA_DECL struct archive *archive_write_disk_new(void); /* This file will not be overwritten. */ __LA_DECL int archive_write_disk_set_skip_file(struct archive *, - __LA_INT64_T, __LA_INT64_T); + la_int64_t, la_int64_t); /* Set flags to control how the next item gets created. * This accepts a bitmask of ARCHIVE_EXTRACT_XXX flags defined above. */ __LA_DECL int archive_write_disk_set_options(struct archive *, @@ -857,14 +908,14 @@ __LA_DECL int archive_write_disk_set_standard_lookup(struct archive *); */ __LA_DECL int archive_write_disk_set_group_lookup(struct archive *, void * /* private_data */, - __LA_INT64_T (*)(void *, const char *, __LA_INT64_T), + la_int64_t (*)(void *, const char *, la_int64_t), void (* /* cleanup */)(void *)); __LA_DECL int archive_write_disk_set_user_lookup(struct archive *, void * /* private_data */, - __LA_INT64_T (*)(void *, const char *, __LA_INT64_T), + la_int64_t (*)(void *, const char *, la_int64_t), void (* /* cleanup */)(void *)); -__LA_DECL __LA_INT64_T archive_write_disk_gid(struct archive *, const char *, __LA_INT64_T); -__LA_DECL __LA_INT64_T archive_write_disk_uid(struct archive *, const char *, __LA_INT64_T); +__LA_DECL la_int64_t archive_write_disk_gid(struct archive *, const char *, la_int64_t); +__LA_DECL la_int64_t archive_write_disk_uid(struct archive *, const char *, la_int64_t); /* * ARCHIVE_READ_DISK API @@ -885,19 +936,19 @@ __LA_DECL int archive_read_disk_entry_from_file(struct archive *, struct archive_entry *, int /* fd */, const struct stat *); /* Look up gname for gid or uname for uid. */ /* Default implementations are very, very stupid. */ -__LA_DECL const char *archive_read_disk_gname(struct archive *, __LA_INT64_T); -__LA_DECL const char *archive_read_disk_uname(struct archive *, __LA_INT64_T); +__LA_DECL const char *archive_read_disk_gname(struct archive *, la_int64_t); +__LA_DECL const char *archive_read_disk_uname(struct archive *, la_int64_t); /* "Standard" implementation uses getpwuid_r, getgrgid_r and caches the * results for performance. */ __LA_DECL int archive_read_disk_set_standard_lookup(struct archive *); /* You can install your own lookups if you like. */ __LA_DECL int archive_read_disk_set_gname_lookup(struct archive *, void * /* private_data */, - const char *(* /* lookup_fn */)(void *, __LA_INT64_T), + const char *(* /* lookup_fn */)(void *, la_int64_t), void (* /* cleanup_fn */)(void *)); __LA_DECL int archive_read_disk_set_uname_lookup(struct archive *, void * /* private_data */, - const char *(* /* lookup_fn */)(void *, __LA_INT64_T), + const char *(* /* lookup_fn */)(void *, la_int64_t), void (* /* cleanup_fn */)(void *)); /* Start traversal. */ __LA_DECL int archive_read_disk_open(struct archive *, const char *); @@ -927,8 +978,10 @@ __LA_DECL int archive_read_disk_set_atime_restored(struct archive *); /* Default: Skip a mac resource fork file whose prefix is "._" because of * using copyfile. */ #define ARCHIVE_READDISK_MAC_COPYFILE (0x0004) -/* Default: Do not traverse mount points. */ +/* Default: Traverse mount points. */ #define ARCHIVE_READDISK_NO_TRAVERSE_MOUNTS (0x0008) +/* Default: Xattrs are read from disk. */ +#define ARCHIVE_READDISK_NO_XATTR (0x0010) __LA_DECL int archive_read_disk_set_behavior(struct archive *, int flags); @@ -961,7 +1014,7 @@ __LA_DECL int archive_free(struct archive *); * last filter, which is always the pseudo-filter that wraps the * client callbacks. */ __LA_DECL int archive_filter_count(struct archive *); -__LA_DECL __LA_INT64_T archive_filter_bytes(struct archive *, int); +__LA_DECL la_int64_t archive_filter_bytes(struct archive *, int); __LA_DECL int archive_filter_code(struct archive *, int); __LA_DECL const char * archive_filter_name(struct archive *, int); @@ -969,10 +1022,10 @@ __LA_DECL const char * archive_filter_name(struct archive *, int); /* These don't properly handle multiple filters, so are deprecated and * will eventually be removed. */ /* As of libarchive 3.0, this is an alias for archive_filter_bytes(a, -1); */ -__LA_DECL __LA_INT64_T archive_position_compressed(struct archive *) +__LA_DECL la_int64_t archive_position_compressed(struct archive *) __LA_DEPRECATED; /* As of libarchive 3.0, this is an alias for archive_filter_bytes(a, 0); */ -__LA_DECL __LA_INT64_T archive_position_uncompressed(struct archive *) +__LA_DECL la_int64_t archive_position_uncompressed(struct archive *) __LA_DEPRECATED; /* As of libarchive 3.0, this is an alias for archive_filter_name(a, 0); */ __LA_DECL const char *archive_compression_name(struct archive *) @@ -1088,8 +1141,8 @@ __LA_DECL int archive_match_exclude_entry(struct archive *, __LA_DECL int archive_match_owner_excluded(struct archive *, struct archive_entry *); /* Add inclusion uid, gid, uname and gname. */ -__LA_DECL int archive_match_include_uid(struct archive *, __LA_INT64_T); -__LA_DECL int archive_match_include_gid(struct archive *, __LA_INT64_T); +__LA_DECL int archive_match_include_uid(struct archive *, la_int64_t); +__LA_DECL int archive_match_include_gid(struct archive *, la_int64_t); __LA_DECL int archive_match_include_uname(struct archive *, const char *); __LA_DECL int archive_match_include_uname_w(struct archive *, const wchar_t *); @@ -1108,9 +1161,4 @@ __LA_DECL int archive_utility_string_sort(char **); /* These are meaningless outside of this header. */ #undef __LA_DECL -/* These need to remain defined because they're used in the - * callback type definitions. XXX Fix this. This is ugly. XXX */ -/* #undef __LA_INT64_T */ -/* #undef __LA_SSIZE_T */ - #endif /* !ARCHIVE_H_INCLUDED */ diff --git a/Utilities/cmlibarchive/libarchive/archive_cryptor.c b/Utilities/cmlibarchive/libarchive/archive_cryptor.c new file mode 100644 index 0000000..efd350d --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_cryptor.c @@ -0,0 +1,435 @@ +/*- +* Copyright (c) 2014 Michihiro NAKAJIMA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* +* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR +* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "archive_platform.h" + +#ifdef HAVE_STRING_H +#include <string.h> +#endif +#include "archive.h" +#include "archive_cryptor_private.h" + +#ifdef ARCHIVE_CRYPTOR_USE_Apple_CommonCrypto + +static int +pbkdf2_sha1(const char *pw, size_t pw_len, const uint8_t *salt, + size_t salt_len, unsigned rounds, uint8_t *derived_key, + size_t derived_key_len) +{ + CCKeyDerivationPBKDF(kCCPBKDF2, (const char *)pw, + pw_len, salt, salt_len, kCCPRFHmacAlgSHA1, rounds, + derived_key, derived_key_len); + return 0; +} + +#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H) +#ifdef _MSC_VER +#pragma comment(lib, "Bcrypt.lib") +#endif + +static int +pbkdf2_sha1(const char *pw, size_t pw_len, const uint8_t *salt, + size_t salt_len, unsigned rounds, uint8_t *derived_key, + size_t derived_key_len) +{ + NTSTATUS status; + BCRYPT_ALG_HANDLE hAlg; + + status = BCryptOpenAlgorithmProvider(&hAlg, BCRYPT_SHA1_ALGORITHM, + MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG); + if (!BCRYPT_SUCCESS(status)) + return -1; + + status = BCryptDeriveKeyPBKDF2(hAlg, + (PUCHAR)(uintptr_t)pw, (ULONG)pw_len, + (PUCHAR)(uintptr_t)salt, (ULONG)salt_len, rounds, + (PUCHAR)derived_key, (ULONG)derived_key_len, 0); + + BCryptCloseAlgorithmProvider(hAlg, 0); + + return (BCRYPT_SUCCESS(status)) ? 0: -1; +} + +#elif defined(HAVE_LIBNETTLE) && defined(HAVE_NETTLE_PBKDF2_H) + +static int +pbkdf2_sha1(const char *pw, size_t pw_len, const uint8_t *salt, + size_t salt_len, unsigned rounds, uint8_t *derived_key, + size_t derived_key_len) { + pbkdf2_hmac_sha1((unsigned)pw_len, (const uint8_t *)pw, rounds, + salt_len, salt, derived_key_len, derived_key); + return 0; +} + +#elif defined(HAVE_LIBCRYPTO) && defined(HAVE_PKCS5_PBKDF2_HMAC_SHA1) + +static int +pbkdf2_sha1(const char *pw, size_t pw_len, const uint8_t *salt, + size_t salt_len, unsigned rounds, uint8_t *derived_key, + size_t derived_key_len) { + + PKCS5_PBKDF2_HMAC_SHA1(pw, pw_len, salt, salt_len, rounds, + derived_key_len, derived_key); + return 0; +} + +#else + +/* Stub */ +static int +pbkdf2_sha1(const char *pw, size_t pw_len, const uint8_t *salt, + size_t salt_len, unsigned rounds, uint8_t *derived_key, + size_t derived_key_len) { + (void)pw; /* UNUSED */ + (void)pw_len; /* UNUSED */ + (void)salt; /* UNUSED */ + (void)salt_len; /* UNUSED */ + (void)rounds; /* UNUSED */ + (void)derived_key; /* UNUSED */ + (void)derived_key_len; /* UNUSED */ + return -1; /* UNSUPPORTED */ +} + +#endif + +#ifdef ARCHIVE_CRYPTOR_USE_Apple_CommonCrypto +# if MAC_OS_X_VERSION_MAX_ALLOWED < 1090 +# define kCCAlgorithmAES kCCAlgorithmAES128 +# endif + +static int +aes_ctr_init(archive_crypto_ctx *ctx, const uint8_t *key, size_t key_len) +{ + CCCryptorStatus r; + + ctx->key_len = key_len; + memcpy(ctx->key, key, key_len); + memset(ctx->nonce, 0, sizeof(ctx->nonce)); + ctx->encr_pos = AES_BLOCK_SIZE; + r = CCCryptorCreateWithMode(kCCEncrypt, kCCModeECB, kCCAlgorithmAES, + ccNoPadding, NULL, key, key_len, NULL, 0, 0, 0, &ctx->ctx); + return (r == kCCSuccess)? 0: -1; +} + +static int +aes_ctr_encrypt_counter(archive_crypto_ctx *ctx) +{ + CCCryptorRef ref = ctx->ctx; + CCCryptorStatus r; + + r = CCCryptorReset(ref, NULL); + if (r != kCCSuccess) + return -1; + r = CCCryptorUpdate(ref, ctx->nonce, AES_BLOCK_SIZE, ctx->encr_buf, + AES_BLOCK_SIZE, NULL); + return (r == kCCSuccess)? 0: -1; +} + +static int +aes_ctr_release(archive_crypto_ctx *ctx) +{ + memset(ctx->key, 0, ctx->key_len); + memset(ctx->nonce, 0, sizeof(ctx->nonce)); + return 0; +} + +#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H) + +static int +aes_ctr_init(archive_crypto_ctx *ctx, const uint8_t *key, size_t key_len) +{ + BCRYPT_ALG_HANDLE hAlg; + BCRYPT_KEY_HANDLE hKey; + DWORD keyObj_len, aes_key_len; + PBYTE keyObj; + ULONG result; + NTSTATUS status; + BCRYPT_KEY_LENGTHS_STRUCT key_lengths; + + ctx->hAlg = NULL; + ctx->hKey = NULL; + ctx->keyObj = NULL; + switch (key_len) { + case 16: aes_key_len = 128; break; + case 24: aes_key_len = 192; break; + case 32: aes_key_len = 256; break; + default: return -1; + } + status = BCryptOpenAlgorithmProvider(&hAlg, BCRYPT_AES_ALGORITHM, + MS_PRIMITIVE_PROVIDER, 0); + if (!BCRYPT_SUCCESS(status)) + return -1; + status = BCryptGetProperty(hAlg, BCRYPT_KEY_LENGTHS, (PUCHAR)&key_lengths, + sizeof(key_lengths), &result, 0); + if (!BCRYPT_SUCCESS(status)) { + BCryptCloseAlgorithmProvider(hAlg, 0); + return -1; + } + if (key_lengths.dwMinLength > aes_key_len + || key_lengths.dwMaxLength < aes_key_len) { + BCryptCloseAlgorithmProvider(hAlg, 0); + return -1; + } + status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH, (PUCHAR)&keyObj_len, + sizeof(keyObj_len), &result, 0); + if (!BCRYPT_SUCCESS(status)) { + BCryptCloseAlgorithmProvider(hAlg, 0); + return -1; + } + keyObj = (PBYTE)HeapAlloc(GetProcessHeap(), 0, keyObj_len); + if (keyObj == NULL) { + BCryptCloseAlgorithmProvider(hAlg, 0); + return -1; + } + status = BCryptSetProperty(hAlg, BCRYPT_CHAINING_MODE, + (PUCHAR)BCRYPT_CHAIN_MODE_ECB, sizeof(BCRYPT_CHAIN_MODE_ECB), 0); + if (!BCRYPT_SUCCESS(status)) { + BCryptCloseAlgorithmProvider(hAlg, 0); + HeapFree(GetProcessHeap(), 0, keyObj); + return -1; + } + status = BCryptGenerateSymmetricKey(hAlg, &hKey, + keyObj, keyObj_len, + (PUCHAR)(uintptr_t)key, (ULONG)key_len, 0); + if (!BCRYPT_SUCCESS(status)) { + BCryptCloseAlgorithmProvider(hAlg, 0); + HeapFree(GetProcessHeap(), 0, keyObj); + return -1; + } + + ctx->hAlg = hAlg; + ctx->hKey = hKey; + ctx->keyObj = keyObj; + ctx->keyObj_len = keyObj_len; + ctx->encr_pos = AES_BLOCK_SIZE; + + return 0; +} + +static int +aes_ctr_encrypt_counter(archive_crypto_ctx *ctx) +{ + NTSTATUS status; + ULONG result; + + status = BCryptEncrypt(ctx->hKey, (PUCHAR)ctx->nonce, AES_BLOCK_SIZE, + NULL, NULL, 0, (PUCHAR)ctx->encr_buf, AES_BLOCK_SIZE, + &result, 0); + return BCRYPT_SUCCESS(status) ? 0 : -1; +} + +static int +aes_ctr_release(archive_crypto_ctx *ctx) +{ + + if (ctx->hAlg != NULL) { + BCryptCloseAlgorithmProvider(ctx->hAlg, 0); + ctx->hAlg = NULL; + BCryptDestroyKey(ctx->hKey); + ctx->hKey = NULL; + HeapFree(GetProcessHeap(), 0, ctx->keyObj); + ctx->keyObj = NULL; + } + memset(ctx, 0, sizeof(*ctx)); + return 0; +} + +#elif defined(HAVE_LIBNETTLE) + +static int +aes_ctr_init(archive_crypto_ctx *ctx, const uint8_t *key, size_t key_len) +{ + ctx->key_len = key_len; + memcpy(ctx->key, key, key_len); + memset(ctx->nonce, 0, sizeof(ctx->nonce)); + ctx->encr_pos = AES_BLOCK_SIZE; + memset(&ctx->ctx, 0, sizeof(ctx->ctx)); + return 0; +} + +static int +aes_ctr_encrypt_counter(archive_crypto_ctx *ctx) +{ + aes_set_encrypt_key(&ctx->ctx, ctx->key_len, ctx->key); + aes_encrypt(&ctx->ctx, AES_BLOCK_SIZE, ctx->encr_buf, ctx->nonce); + return 0; +} + +static int +aes_ctr_release(archive_crypto_ctx *ctx) +{ + memset(ctx, 0, sizeof(*ctx)); + return 0; +} + +#elif defined(HAVE_LIBCRYPTO) + +static int +aes_ctr_init(archive_crypto_ctx *ctx, const uint8_t *key, size_t key_len) +{ + + switch (key_len) { + case 16: ctx->type = EVP_aes_128_ecb(); break; + case 24: ctx->type = EVP_aes_192_ecb(); break; + case 32: ctx->type = EVP_aes_256_ecb(); break; + default: ctx->type = NULL; return -1; + } + + ctx->key_len = key_len; + memcpy(ctx->key, key, key_len); + memset(ctx->nonce, 0, sizeof(ctx->nonce)); + ctx->encr_pos = AES_BLOCK_SIZE; + EVP_CIPHER_CTX_init(&ctx->ctx); + return 0; +} + +static int +aes_ctr_encrypt_counter(archive_crypto_ctx *ctx) +{ + int outl = 0; + int r; + + r = EVP_EncryptInit_ex(&ctx->ctx, ctx->type, NULL, ctx->key, NULL); + if (r == 0) + return -1; + r = EVP_EncryptUpdate(&ctx->ctx, ctx->encr_buf, &outl, ctx->nonce, + AES_BLOCK_SIZE); + if (r == 0 || outl != AES_BLOCK_SIZE) + return -1; + return 0; +} + +static int +aes_ctr_release(archive_crypto_ctx *ctx) +{ + EVP_CIPHER_CTX_cleanup(&ctx->ctx); + memset(ctx->key, 0, ctx->key_len); + memset(ctx->nonce, 0, sizeof(ctx->nonce)); + return 0; +} + +#else + +#define ARCHIVE_CRYPTOR_STUB +/* Stub */ +static int +aes_ctr_init(archive_crypto_ctx *ctx, const uint8_t *key, size_t key_len) +{ + (void)ctx; /* UNUSED */ + (void)key; /* UNUSED */ + (void)key_len; /* UNUSED */ + return -1; +} + +static int +aes_ctr_encrypt_counter(archive_crypto_ctx *ctx) +{ + (void)ctx; /* UNUSED */ + return -1; +} + +static int +aes_ctr_release(archive_crypto_ctx *ctx) +{ + (void)ctx; /* UNUSED */ + return 0; +} + +#endif + +#ifdef ARCHIVE_CRYPTOR_STUB +static int +aes_ctr_update(archive_crypto_ctx *ctx, const uint8_t * const in, + size_t in_len, uint8_t * const out, size_t *out_len) +{ + (void)ctx; /* UNUSED */ + (void)in; /* UNUSED */ + (void)in_len; /* UNUSED */ + (void)out; /* UNUSED */ + (void)out_len; /* UNUSED */ + aes_ctr_encrypt_counter(ctx); /* UNUSED */ /* Fix unused function warning */ + return -1; +} + +#else +static void +aes_ctr_increase_counter(archive_crypto_ctx *ctx) +{ + uint8_t *const nonce = ctx->nonce; + int j; + + for (j = 0; j < 8; j++) { + if (++nonce[j]) + break; + } +} + +static int +aes_ctr_update(archive_crypto_ctx *ctx, const uint8_t * const in, + size_t in_len, uint8_t * const out, size_t *out_len) +{ + uint8_t *const ebuf = ctx->encr_buf; + unsigned pos = ctx->encr_pos; + unsigned max = (unsigned)((in_len < *out_len)? in_len: *out_len); + unsigned i; + + for (i = 0; i < max; ) { + if (pos == AES_BLOCK_SIZE) { + aes_ctr_increase_counter(ctx); + if (aes_ctr_encrypt_counter(ctx) != 0) + return -1; + while (max -i >= AES_BLOCK_SIZE) { + for (pos = 0; pos < AES_BLOCK_SIZE; pos++) + out[i+pos] = in[i+pos] ^ ebuf[pos]; + i += AES_BLOCK_SIZE; + aes_ctr_increase_counter(ctx); + if (aes_ctr_encrypt_counter(ctx) != 0) + return -1; + } + pos = 0; + if (i >= max) + break; + } + out[i] = in[i] ^ ebuf[pos++]; + i++; + } + ctx->encr_pos = pos; + *out_len = i; + + return 0; +} +#endif /* ARCHIVE_CRYPTOR_STUB */ + + +const struct archive_cryptor __archive_cryptor = +{ + &pbkdf2_sha1, + &aes_ctr_init, + &aes_ctr_update, + &aes_ctr_release, + &aes_ctr_init, + &aes_ctr_update, + &aes_ctr_release, +}; diff --git a/Utilities/cmlibarchive/libarchive/archive_cryptor_private.h b/Utilities/cmlibarchive/libarchive/archive_cryptor_private.h new file mode 100644 index 0000000..9a96aee --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_cryptor_private.h @@ -0,0 +1,152 @@ +/*- +* Copyright (c) 2014 Michihiro NAKAJIMA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* +* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR +* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef __LIBARCHIVE_BUILD +#error This header is only to be used internally to libarchive. +#endif + +#ifndef ARCHIVE_CRYPTOR_PRIVATE_H_INCLUDED +#define ARCHIVE_CRYPTOR_PRIVATE_H_INCLUDED + +#ifdef __APPLE__ +# include <AvailabilityMacros.h> +# if MAC_OS_X_VERSION_MAX_ALLOWED >= 1080 +# define ARCHIVE_CRYPTOR_USE_Apple_CommonCrypto +# endif +#endif + +#ifdef ARCHIVE_CRYPTOR_USE_Apple_CommonCrypto +#include <CommonCrypto/CommonCryptor.h> +#include <CommonCrypto/CommonKeyDerivation.h> +#define AES_BLOCK_SIZE 16 +#define AES_MAX_KEY_SIZE kCCKeySizeAES256 + +typedef struct { + CCCryptorRef ctx; + uint8_t key[AES_MAX_KEY_SIZE]; + unsigned key_len; + uint8_t nonce[AES_BLOCK_SIZE]; + uint8_t encr_buf[AES_BLOCK_SIZE]; + unsigned encr_pos; +} archive_crypto_ctx; + +#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H) +#include <Bcrypt.h> + +/* Common in other bcrypt implementations, but missing from VS2008. */ +#ifndef BCRYPT_SUCCESS +#define BCRYPT_SUCCESS(r) ((NTSTATUS)(r) == STATUS_SUCCESS) +#endif + +#define AES_MAX_KEY_SIZE 32 +#define AES_BLOCK_SIZE 16 +typedef struct { + BCRYPT_ALG_HANDLE hAlg; + BCRYPT_KEY_HANDLE hKey; + PBYTE keyObj; + DWORD keyObj_len; + uint8_t nonce[AES_BLOCK_SIZE]; + uint8_t encr_buf[AES_BLOCK_SIZE]; + unsigned encr_pos; +} archive_crypto_ctx; + +#elif defined(HAVE_LIBNETTLE) +#if defined(HAVE_NETTLE_PBKDF2_H) +#include <nettle/pbkdf2.h> +#endif +#include <nettle/aes.h> + +typedef struct { + struct aes_ctx ctx; + uint8_t key[AES_MAX_KEY_SIZE]; + unsigned key_len; + uint8_t nonce[AES_BLOCK_SIZE]; + uint8_t encr_buf[AES_BLOCK_SIZE]; + unsigned encr_pos; +} archive_crypto_ctx; + +#elif defined(HAVE_LIBCRYPTO) +#include <openssl/evp.h> +#define AES_BLOCK_SIZE 16 +#define AES_MAX_KEY_SIZE 32 + +typedef struct { + EVP_CIPHER_CTX ctx; + const EVP_CIPHER *type; + uint8_t key[AES_MAX_KEY_SIZE]; + unsigned key_len; + uint8_t nonce[AES_BLOCK_SIZE]; + uint8_t encr_buf[AES_BLOCK_SIZE]; + unsigned encr_pos; +} archive_crypto_ctx; + +#else + +#define AES_BLOCK_SIZE 16 +#define AES_MAX_KEY_SIZE 32 +typedef int archive_crypto_ctx; + +#endif + +/* defines */ +#define archive_pbkdf2_sha1(pw, pw_len, salt, salt_len, rounds, dk, dk_len)\ + __archive_cryptor.pbkdf2sha1(pw, pw_len, salt, salt_len, rounds, dk, dk_len) + +#define archive_decrypto_aes_ctr_init(ctx, key, key_len) \ + __archive_cryptor.decrypto_aes_ctr_init(ctx, key, key_len) +#define archive_decrypto_aes_ctr_update(ctx, in, in_len, out, out_len) \ + __archive_cryptor.decrypto_aes_ctr_update(ctx, in, in_len, out, out_len) +#define archive_decrypto_aes_ctr_release(ctx) \ + __archive_cryptor.decrypto_aes_ctr_release(ctx) + +#define archive_encrypto_aes_ctr_init(ctx, key, key_len) \ + __archive_cryptor.encrypto_aes_ctr_init(ctx, key, key_len) +#define archive_encrypto_aes_ctr_update(ctx, in, in_len, out, out_len) \ + __archive_cryptor.encrypto_aes_ctr_update(ctx, in, in_len, out, out_len) +#define archive_encrypto_aes_ctr_release(ctx) \ + __archive_cryptor.encrypto_aes_ctr_release(ctx) + +/* Minimal interface to cryptographic functionality for internal use in + * libarchive */ +struct archive_cryptor +{ + /* PKCS5 PBKDF2 HMAC-SHA1 */ + int (*pbkdf2sha1)(const char *pw, size_t pw_len, const uint8_t *salt, + size_t salt_len, unsigned rounds, uint8_t *derived_key, + size_t derived_key_len); + /* AES CTR mode(little endian version) */ + int (*decrypto_aes_ctr_init)(archive_crypto_ctx *, const uint8_t *, size_t); + int (*decrypto_aes_ctr_update)(archive_crypto_ctx *, const uint8_t *, + size_t, uint8_t *, size_t *); + int (*decrypto_aes_ctr_release)(archive_crypto_ctx *); + int (*encrypto_aes_ctr_init)(archive_crypto_ctx *, const uint8_t *, size_t); + int (*encrypto_aes_ctr_update)(archive_crypto_ctx *, const uint8_t *, + size_t, uint8_t *, size_t *); + int (*encrypto_aes_ctr_release)(archive_crypto_ctx *); +}; + +extern const struct archive_cryptor __archive_cryptor; + +#endif diff --git a/Utilities/cmlibarchive/libarchive/archive_crypto.c b/Utilities/cmlibarchive/libarchive/archive_digest.c index 85aba3a..f009d31 100644 --- a/Utilities/cmlibarchive/libarchive/archive_crypto.c +++ b/Utilities/cmlibarchive/libarchive/archive_digest.c @@ -28,7 +28,7 @@ #include "archive_platform.h" #include "archive.h" -#include "archive_crypto_private.h" +#include "archive_digest_private.h" /* In particular, force the configure probe to break if it tries * to test a combination of OpenSSL and libmd. */ @@ -1216,8 +1216,8 @@ __archive_stub_sha512final(archive_sha512_ctx *ctx, void *md) #endif -/* NOTE: Crypto functions are set based on availability and by the following - * order of preference. +/* NOTE: Message Digest functions are set based on availability and by the + * following order of preference. * 1. libc * 2. libc2 * 3. libc3 @@ -1227,7 +1227,7 @@ __archive_stub_sha512final(archive_sha512_ctx *ctx, void *md) * 7. libmd * 8. Windows API */ -const struct archive_crypto __archive_crypto = +const struct archive_digest __archive_digest = { /* MD5 */ #if defined(ARCHIVE_CRYPTO_MD5_LIBC) @@ -1412,7 +1412,7 @@ const struct archive_crypto __archive_crypto = #elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE) &__archive_nettle_sha512init, &__archive_nettle_sha512update, - &__archive_nettle_sha512final, + &__archive_nettle_sha512final #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL) &__archive_openssl_sha512init, &__archive_openssl_sha512update, diff --git a/Utilities/cmlibarchive/libarchive/archive_crypto_private.h b/Utilities/cmlibarchive/libarchive/archive_digest_private.h index f8b1fb3..77fad58 100644 --- a/Utilities/cmlibarchive/libarchive/archive_crypto_private.h +++ b/Utilities/cmlibarchive/libarchive/archive_digest_private.h @@ -264,11 +264,11 @@ typedef unsigned char archive_sha512_ctx; #define ARCHIVE_HAS_MD5 #endif #define archive_md5_init(ctx)\ - __archive_crypto.md5init(ctx) + __archive_digest.md5init(ctx) #define archive_md5_final(ctx, md)\ - __archive_crypto.md5final(ctx, md) + __archive_digest.md5final(ctx, md) #define archive_md5_update(ctx, buf, n)\ - __archive_crypto.md5update(ctx, buf, n) + __archive_digest.md5update(ctx, buf, n) #if defined(ARCHIVE_CRYPTO_RMD160_LIBC) ||\ defined(ARCHIVE_CRYPTO_RMD160_NETTLE) ||\ @@ -276,11 +276,11 @@ typedef unsigned char archive_sha512_ctx; #define ARCHIVE_HAS_RMD160 #endif #define archive_rmd160_init(ctx)\ - __archive_crypto.rmd160init(ctx) + __archive_digest.rmd160init(ctx) #define archive_rmd160_final(ctx, md)\ - __archive_crypto.rmd160final(ctx, md) + __archive_digest.rmd160final(ctx, md) #define archive_rmd160_update(ctx, buf, n)\ - __archive_crypto.rmd160update(ctx, buf, n) + __archive_digest.rmd160update(ctx, buf, n) #if defined(ARCHIVE_CRYPTO_SHA1_LIBC) ||\ defined(ARCHIVE_CRYPTO_SHA1_LIBMD) || \ @@ -291,11 +291,11 @@ typedef unsigned char archive_sha512_ctx; #define ARCHIVE_HAS_SHA1 #endif #define archive_sha1_init(ctx)\ - __archive_crypto.sha1init(ctx) + __archive_digest.sha1init(ctx) #define archive_sha1_final(ctx, md)\ - __archive_crypto.sha1final(ctx, md) + __archive_digest.sha1final(ctx, md) #define archive_sha1_update(ctx, buf, n)\ - __archive_crypto.sha1update(ctx, buf, n) + __archive_digest.sha1update(ctx, buf, n) #if defined(ARCHIVE_CRYPTO_SHA256_LIBC) ||\ defined(ARCHIVE_CRYPTO_SHA256_LIBC2) ||\ @@ -308,11 +308,11 @@ typedef unsigned char archive_sha512_ctx; #define ARCHIVE_HAS_SHA256 #endif #define archive_sha256_init(ctx)\ - __archive_crypto.sha256init(ctx) + __archive_digest.sha256init(ctx) #define archive_sha256_final(ctx, md)\ - __archive_crypto.sha256final(ctx, md) + __archive_digest.sha256final(ctx, md) #define archive_sha256_update(ctx, buf, n)\ - __archive_crypto.sha256update(ctx, buf, n) + __archive_digest.sha256update(ctx, buf, n) #if defined(ARCHIVE_CRYPTO_SHA384_LIBC) ||\ defined(ARCHIVE_CRYPTO_SHA384_LIBC2) ||\ @@ -324,11 +324,11 @@ typedef unsigned char archive_sha512_ctx; #define ARCHIVE_HAS_SHA384 #endif #define archive_sha384_init(ctx)\ - __archive_crypto.sha384init(ctx) + __archive_digest.sha384init(ctx) #define archive_sha384_final(ctx, md)\ - __archive_crypto.sha384final(ctx, md) + __archive_digest.sha384final(ctx, md) #define archive_sha384_update(ctx, buf, n)\ - __archive_crypto.sha384update(ctx, buf, n) + __archive_digest.sha384update(ctx, buf, n) #if defined(ARCHIVE_CRYPTO_SHA512_LIBC) ||\ defined(ARCHIVE_CRYPTO_SHA512_LIBC2) ||\ @@ -341,14 +341,14 @@ typedef unsigned char archive_sha512_ctx; #define ARCHIVE_HAS_SHA512 #endif #define archive_sha512_init(ctx)\ - __archive_crypto.sha512init(ctx) + __archive_digest.sha512init(ctx) #define archive_sha512_final(ctx, md)\ - __archive_crypto.sha512final(ctx, md) + __archive_digest.sha512final(ctx, md) #define archive_sha512_update(ctx, buf, n)\ - __archive_crypto.sha512update(ctx, buf, n) + __archive_digest.sha512update(ctx, buf, n) -/* Minimal interface to crypto functionality for internal use in libarchive */ -struct archive_crypto +/* Minimal interface to digest functionality for internal use in libarchive */ +struct archive_digest { /* Message Digest */ int (*md5init)(archive_md5_ctx *ctx); @@ -371,6 +371,6 @@ struct archive_crypto int (*sha512final)(archive_sha512_ctx *, void *); }; -extern const struct archive_crypto __archive_crypto; +extern const struct archive_digest __archive_digest; #endif diff --git a/Utilities/cmlibarchive/libarchive/archive_entry.3 b/Utilities/cmlibarchive/libarchive/archive_entry.3 index f77f385..f5e22af 100644 --- a/Utilities/cmlibarchive/libarchive/archive_entry.3 +++ b/Utilities/cmlibarchive/libarchive/archive_entry.3 @@ -131,11 +131,11 @@ be discarded in favor of the new data. .\" .Sh RETURN VALUES .\" .Sh ERRORS .Sh SEE ALSO -.Xr archive 3 , .Xr archive_entry_acl 3 , .Xr archive_entry_paths 3 , .Xr archive_entry_perms 3 , .Xr archive_entry_time 3 +.Xr libarchive 3 , .Sh HISTORY The .Nm libarchive diff --git a/Utilities/cmlibarchive/libarchive/archive_entry.c b/Utilities/cmlibarchive/libarchive/archive_entry.c index 293c701..4ac1966 100644 --- a/Utilities/cmlibarchive/libarchive/archive_entry.c +++ b/Utilities/cmlibarchive/libarchive/archive_entry.c @@ -418,6 +418,18 @@ archive_entry_gname(struct archive_entry *entry) return (NULL); } +const char * +archive_entry_gname_utf8(struct archive_entry *entry) +{ + const char *p; + if (archive_mstring_get_utf8(entry->archive, &entry->ae_gname, &p) == 0) + return (p); + if (errno == ENOMEM) + __archive_errx(1, "No memory"); + return (NULL); +} + + const wchar_t * archive_entry_gname_w(struct archive_entry *entry) { @@ -450,6 +462,20 @@ archive_entry_hardlink(struct archive_entry *entry) return (NULL); } +const char * +archive_entry_hardlink_utf8(struct archive_entry *entry) +{ + const char *p; + if ((entry->ae_set & AE_SET_HARDLINK) == 0) + return (NULL); + if (archive_mstring_get_utf8( + entry->archive, &entry->ae_hardlink, &p) == 0) + return (p); + if (errno == ENOMEM) + __archive_errx(1, "No memory"); + return (NULL); +} + const wchar_t * archive_entry_hardlink_w(struct archive_entry *entry) { @@ -536,6 +562,18 @@ archive_entry_pathname(struct archive_entry *entry) return (NULL); } +const char * +archive_entry_pathname_utf8(struct archive_entry *entry) +{ + const char *p; + if (archive_mstring_get_utf8( + entry->archive, &entry->ae_pathname, &p) == 0) + return (p); + if (errno == ENOMEM) + __archive_errx(1, "No memory"); + return (NULL); +} + const wchar_t * archive_entry_pathname_w(struct archive_entry *entry) { @@ -637,6 +675,20 @@ archive_entry_symlink(struct archive_entry *entry) return (NULL); } +const char * +archive_entry_symlink_utf8(struct archive_entry *entry) +{ + const char *p; + if ((entry->ae_set & AE_SET_SYMLINK) == 0) + return (NULL); + if (archive_mstring_get_utf8( + entry->archive, &entry->ae_symlink, &p) == 0) + return (p); + if (errno == ENOMEM) + __archive_errx(1, "No memory"); + return (NULL); +} + const wchar_t * archive_entry_symlink_w(struct archive_entry *entry) { @@ -680,6 +732,17 @@ archive_entry_uname(struct archive_entry *entry) return (NULL); } +const char * +archive_entry_uname_utf8(struct archive_entry *entry) +{ + const char *p; + if (archive_mstring_get_utf8(entry->archive, &entry->ae_uname, &p) == 0) + return (p); + if (errno == ENOMEM) + __archive_errx(1, "No memory"); + return (NULL); +} + const wchar_t * archive_entry_uname_w(struct archive_entry *entry) { @@ -769,6 +832,12 @@ archive_entry_set_gname(struct archive_entry *entry, const char *name) } void +archive_entry_set_gname_utf8(struct archive_entry *entry, const char *name) +{ + archive_mstring_copy_utf8(&entry->ae_gname, name); +} + +void archive_entry_copy_gname(struct archive_entry *entry, const char *name) { archive_mstring_copy_mbs(&entry->ae_gname, name); @@ -825,6 +894,16 @@ archive_entry_set_hardlink(struct archive_entry *entry, const char *target) } void +archive_entry_set_hardlink_utf8(struct archive_entry *entry, const char *target) +{ + archive_mstring_copy_utf8(&entry->ae_hardlink, target); + if (target != NULL) + entry->ae_set |= AE_SET_HARDLINK; + else + entry->ae_set &= ~AE_SET_HARDLINK; +} + +void archive_entry_copy_hardlink(struct archive_entry *entry, const char *target) { archive_mstring_copy_mbs(&entry->ae_hardlink, target); @@ -962,6 +1041,15 @@ archive_entry_set_link(struct archive_entry *entry, const char *target) archive_mstring_copy_mbs(&entry->ae_hardlink, target); } +void +archive_entry_set_link_utf8(struct archive_entry *entry, const char *target) +{ + if (entry->ae_set & AE_SET_SYMLINK) + archive_mstring_copy_utf8(&entry->ae_symlink, target); + else + archive_mstring_copy_utf8(&entry->ae_hardlink, target); +} + /* Set symlink if symlink is already set, else set hardlink. */ void archive_entry_copy_link(struct archive_entry *entry, const char *target) @@ -1052,6 +1140,12 @@ archive_entry_set_pathname(struct archive_entry *entry, const char *name) } void +archive_entry_set_pathname_utf8(struct archive_entry *entry, const char *name) +{ + archive_mstring_copy_utf8(&entry->ae_pathname, name); +} + +void archive_entry_copy_pathname(struct archive_entry *entry, const char *name) { archive_mstring_copy_mbs(&entry->ae_pathname, name); @@ -1152,6 +1246,16 @@ archive_entry_set_symlink(struct archive_entry *entry, const char *linkname) } void +archive_entry_set_symlink_utf8(struct archive_entry *entry, const char *linkname) +{ + archive_mstring_copy_utf8(&entry->ae_symlink, linkname); + if (linkname != NULL) + entry->ae_set |= AE_SET_SYMLINK; + else + entry->ae_set &= ~AE_SET_SYMLINK; +} + +void archive_entry_copy_symlink(struct archive_entry *entry, const char *linkname) { archive_mstring_copy_mbs(&entry->ae_symlink, linkname); @@ -1215,6 +1319,12 @@ archive_entry_set_uname(struct archive_entry *entry, const char *name) } void +archive_entry_set_uname_utf8(struct archive_entry *entry, const char *name) +{ + archive_mstring_copy_utf8(&entry->ae_uname, name); +} + +void archive_entry_copy_uname(struct archive_entry *entry, const char *name) { archive_mstring_copy_mbs(&entry->ae_uname, name); @@ -1629,19 +1739,23 @@ ae_strtofflags(const char *s, unsigned long *setp, unsigned long *clrp) while (*start == '\t' || *start == ' ' || *start == ',') start++; while (*start != '\0') { + size_t length; /* Locate end of token. */ end = start; while (*end != '\0' && *end != '\t' && *end != ' ' && *end != ',') end++; + length = end - start; for (flag = flags; flag->name != NULL; flag++) { - if (memcmp(start, flag->name, end - start) == 0) { + size_t flag_length = strlen(flag->name); + if (length == flag_length + && memcmp(start, flag->name, length) == 0) { /* Matched "noXXXX", so reverse the sense. */ clear |= flag->set; set |= flag->clear; break; - } else if (memcmp(start, flag->name + 2, end - start) - == 0) { + } else if (length == flag_length - 2 + && memcmp(start, flag->name + 2, length) == 0) { /* Matched "XXXX", so don't reverse. */ set |= flag->set; clear |= flag->clear; @@ -1693,19 +1807,23 @@ ae_wcstofflags(const wchar_t *s, unsigned long *setp, unsigned long *clrp) while (*start == L'\t' || *start == L' ' || *start == L',') start++; while (*start != L'\0') { + size_t length; /* Locate end of token. */ end = start; while (*end != L'\0' && *end != L'\t' && *end != L' ' && *end != L',') end++; + length = end - start; for (flag = flags; flag->wname != NULL; flag++) { - if (wmemcmp(start, flag->wname, end - start) == 0) { + size_t flag_length = wcslen(flag->wname); + if (length == flag_length + && wmemcmp(start, flag->wname, length) == 0) { /* Matched "noXXXX", so reverse the sense. */ clear |= flag->set; set |= flag->clear; break; - } else if (wmemcmp(start, flag->wname + 2, end - start) - == 0) { + } else if (length == flag_length - 2 + && wmemcmp(start, flag->wname + 2, length) == 0) { /* Matched "XXXX", so don't reverse. */ set |= flag->set; clear |= flag->clear; diff --git a/Utilities/cmlibarchive/libarchive/archive_entry.h b/Utilities/cmlibarchive/libarchive/archive_entry.h index efc4d73..68d8ab9 100644 --- a/Utilities/cmlibarchive/libarchive/archive_entry.h +++ b/Utilities/cmlibarchive/libarchive/archive_entry.h @@ -43,15 +43,25 @@ #include <stddef.h> /* for wchar_t */ #include <time.h> +#if defined(_WIN32) && !defined(__CYGWIN__) +#include <windows.h> +#endif + /* Get a suitable 64-bit integer type. */ -#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__WATCOMC__) -# define __LA_INT64_T __int64 -#else -#include <unistd.h> -# if defined(_SCO_DS) || defined(__osf__) -# define __LA_INT64_T long long +#if !defined(__LA_INT64_T_DEFINED) +# if ARCHIVE_VERSION_NUMBER < 4000000 +#define __LA_INT64_T la_int64_t +# endif +#define __LA_INT64_T_DEFINED +# if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__WATCOMC__) +typedef __int64 la_int64_t; # else -# define __LA_INT64_T int64_t +#include <unistd.h> +# if defined(_SCO_DS) || defined(__osf__) +typedef long long la_int64_t; +# else +typedef int64_t la_int64_t; +# endif # endif #endif @@ -202,13 +212,15 @@ __LA_DECL void archive_entry_fflags(struct archive_entry *, unsigned long * /* set */, unsigned long * /* clear */); __LA_DECL const char *archive_entry_fflags_text(struct archive_entry *); -__LA_DECL __LA_INT64_T archive_entry_gid(struct archive_entry *); +__LA_DECL la_int64_t archive_entry_gid(struct archive_entry *); __LA_DECL const char *archive_entry_gname(struct archive_entry *); +__LA_DECL const char *archive_entry_gname_utf8(struct archive_entry *); __LA_DECL const wchar_t *archive_entry_gname_w(struct archive_entry *); __LA_DECL const char *archive_entry_hardlink(struct archive_entry *); +__LA_DECL const char *archive_entry_hardlink_utf8(struct archive_entry *); __LA_DECL const wchar_t *archive_entry_hardlink_w(struct archive_entry *); -__LA_DECL __LA_INT64_T archive_entry_ino(struct archive_entry *); -__LA_DECL __LA_INT64_T archive_entry_ino64(struct archive_entry *); +__LA_DECL la_int64_t archive_entry_ino(struct archive_entry *); +__LA_DECL la_int64_t archive_entry_ino64(struct archive_entry *); __LA_DECL int archive_entry_ino_is_set(struct archive_entry *); __LA_DECL __LA_MODE_T archive_entry_mode(struct archive_entry *); __LA_DECL time_t archive_entry_mtime(struct archive_entry *); @@ -216,6 +228,7 @@ __LA_DECL long archive_entry_mtime_nsec(struct archive_entry *); __LA_DECL int archive_entry_mtime_is_set(struct archive_entry *); __LA_DECL unsigned int archive_entry_nlink(struct archive_entry *); __LA_DECL const char *archive_entry_pathname(struct archive_entry *); +__LA_DECL const char *archive_entry_pathname_utf8(struct archive_entry *); __LA_DECL const wchar_t *archive_entry_pathname_w(struct archive_entry *); __LA_DECL __LA_MODE_T archive_entry_perm(struct archive_entry *); __LA_DECL dev_t archive_entry_rdev(struct archive_entry *); @@ -223,13 +236,15 @@ __LA_DECL dev_t archive_entry_rdevmajor(struct archive_entry *); __LA_DECL dev_t archive_entry_rdevminor(struct archive_entry *); __LA_DECL const char *archive_entry_sourcepath(struct archive_entry *); __LA_DECL const wchar_t *archive_entry_sourcepath_w(struct archive_entry *); -__LA_DECL __LA_INT64_T archive_entry_size(struct archive_entry *); +__LA_DECL la_int64_t archive_entry_size(struct archive_entry *); __LA_DECL int archive_entry_size_is_set(struct archive_entry *); __LA_DECL const char *archive_entry_strmode(struct archive_entry *); __LA_DECL const char *archive_entry_symlink(struct archive_entry *); +__LA_DECL const char *archive_entry_symlink_utf8(struct archive_entry *); __LA_DECL const wchar_t *archive_entry_symlink_w(struct archive_entry *); -__LA_DECL __LA_INT64_T archive_entry_uid(struct archive_entry *); +__LA_DECL la_int64_t archive_entry_uid(struct archive_entry *); __LA_DECL const char *archive_entry_uname(struct archive_entry *); +__LA_DECL const char *archive_entry_uname_utf8(struct archive_entry *); __LA_DECL const wchar_t *archive_entry_uname_w(struct archive_entry *); __LA_DECL int archive_entry_is_data_encrypted(struct archive_entry *); __LA_DECL int archive_entry_is_metadata_encrypted(struct archive_entry *); @@ -265,18 +280,21 @@ __LA_DECL const char *archive_entry_copy_fflags_text(struct archive_entry *, const char *); __LA_DECL const wchar_t *archive_entry_copy_fflags_text_w(struct archive_entry *, const wchar_t *); -__LA_DECL void archive_entry_set_gid(struct archive_entry *, __LA_INT64_T); +__LA_DECL void archive_entry_set_gid(struct archive_entry *, la_int64_t); __LA_DECL void archive_entry_set_gname(struct archive_entry *, const char *); +__LA_DECL void archive_entry_set_gname_utf8(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_gname(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_gname_w(struct archive_entry *, const wchar_t *); __LA_DECL int archive_entry_update_gname_utf8(struct archive_entry *, const char *); __LA_DECL void archive_entry_set_hardlink(struct archive_entry *, const char *); +__LA_DECL void archive_entry_set_hardlink_utf8(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_hardlink(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_hardlink_w(struct archive_entry *, const wchar_t *); __LA_DECL int archive_entry_update_hardlink_utf8(struct archive_entry *, const char *); -__LA_DECL void archive_entry_set_ino(struct archive_entry *, __LA_INT64_T); -__LA_DECL void archive_entry_set_ino64(struct archive_entry *, __LA_INT64_T); +__LA_DECL void archive_entry_set_ino(struct archive_entry *, la_int64_t); +__LA_DECL void archive_entry_set_ino64(struct archive_entry *, la_int64_t); __LA_DECL void archive_entry_set_link(struct archive_entry *, const char *); +__LA_DECL void archive_entry_set_link_utf8(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_link(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_link_w(struct archive_entry *, const wchar_t *); __LA_DECL int archive_entry_update_link_utf8(struct archive_entry *, const char *); @@ -285,6 +303,7 @@ __LA_DECL void archive_entry_set_mtime(struct archive_entry *, time_t, long); __LA_DECL void archive_entry_unset_mtime(struct archive_entry *); __LA_DECL void archive_entry_set_nlink(struct archive_entry *, unsigned int); __LA_DECL void archive_entry_set_pathname(struct archive_entry *, const char *); +__LA_DECL void archive_entry_set_pathname_utf8(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_pathname(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_pathname_w(struct archive_entry *, const wchar_t *); __LA_DECL int archive_entry_update_pathname_utf8(struct archive_entry *, const char *); @@ -292,16 +311,18 @@ __LA_DECL void archive_entry_set_perm(struct archive_entry *, __LA_MODE_T); __LA_DECL void archive_entry_set_rdev(struct archive_entry *, dev_t); __LA_DECL void archive_entry_set_rdevmajor(struct archive_entry *, dev_t); __LA_DECL void archive_entry_set_rdevminor(struct archive_entry *, dev_t); -__LA_DECL void archive_entry_set_size(struct archive_entry *, __LA_INT64_T); +__LA_DECL void archive_entry_set_size(struct archive_entry *, la_int64_t); __LA_DECL void archive_entry_unset_size(struct archive_entry *); __LA_DECL void archive_entry_copy_sourcepath(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_sourcepath_w(struct archive_entry *, const wchar_t *); __LA_DECL void archive_entry_set_symlink(struct archive_entry *, const char *); +__LA_DECL void archive_entry_set_symlink_utf8(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_symlink(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_symlink_w(struct archive_entry *, const wchar_t *); __LA_DECL int archive_entry_update_symlink_utf8(struct archive_entry *, const char *); -__LA_DECL void archive_entry_set_uid(struct archive_entry *, __LA_INT64_T); +__LA_DECL void archive_entry_set_uid(struct archive_entry *, la_int64_t); __LA_DECL void archive_entry_set_uname(struct archive_entry *, const char *); +__LA_DECL void archive_entry_set_uname_utf8(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_uname(struct archive_entry *, const char *); __LA_DECL void archive_entry_copy_uname_w(struct archive_entry *, const wchar_t *); __LA_DECL int archive_entry_update_uname_utf8(struct archive_entry *, const char *); @@ -515,7 +536,7 @@ __LA_DECL int archive_entry_xattr_next(struct archive_entry *, __LA_DECL void archive_entry_sparse_clear(struct archive_entry *); __LA_DECL void archive_entry_sparse_add_entry(struct archive_entry *, - __LA_INT64_T /* offset */, __LA_INT64_T /* length */); + la_int64_t /* offset */, la_int64_t /* length */); /* * To retrieve the xattr list, first "reset", then repeatedly ask for the @@ -525,7 +546,7 @@ __LA_DECL void archive_entry_sparse_add_entry(struct archive_entry *, __LA_DECL int archive_entry_sparse_count(struct archive_entry *); __LA_DECL int archive_entry_sparse_reset(struct archive_entry *); __LA_DECL int archive_entry_sparse_next(struct archive_entry *, - __LA_INT64_T * /* offset */, __LA_INT64_T * /* length */); + la_int64_t * /* offset */, la_int64_t * /* length */); /* * Utility to match up hardlinks. diff --git a/Utilities/cmlibarchive/libarchive/archive_entry_acl.3 b/Utilities/cmlibarchive/libarchive/archive_entry_acl.3 index f5c3377..5aff996 100644 --- a/Utilities/cmlibarchive/libarchive/archive_entry_acl.3 +++ b/Utilities/cmlibarchive/libarchive/archive_entry_acl.3 @@ -226,8 +226,8 @@ The returned long string is valid until the next call to or .Fn archive_entry_acl_text_w . .Sh SEE ALSO -.Xr archive 3 , .Xr archive_entry 3 +.Xr libarchive 3 , .Sh BUGS .Dv ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID and diff --git a/Utilities/cmlibarchive/libarchive/archive_entry_paths.3 b/Utilities/cmlibarchive/libarchive/archive_entry_paths.3 index 51c8b8c..fd22cf7 100644 --- a/Utilities/cmlibarchive/libarchive/archive_entry_paths.3 +++ b/Utilities/cmlibarchive/libarchive/archive_entry_paths.3 @@ -149,5 +149,5 @@ It doesn't have a corresponding get accessor function. is an alias for .Fn archive_entry_copy_XXX . .Sh SEE ALSO -.Xr archive 3 , .Xr archive_entry 3 +.Xr libarchive 3 , diff --git a/Utilities/cmlibarchive/libarchive/archive_entry_perms.3 b/Utilities/cmlibarchive/libarchive/archive_entry_perms.3 index 5b7b5d9..340c5ea 100644 --- a/Utilities/cmlibarchive/libarchive/archive_entry_perms.3 +++ b/Utilities/cmlibarchive/libarchive/archive_entry_perms.3 @@ -194,11 +194,11 @@ every name that is recognized. .Xr strtofflags 3 , which stops parsing at the first unrecognized name.) .Sh SEE ALSO -.Xr archive 3 , .Xr archive_entry 3 , .Xr archive_entry_acl 3 , .Xr archive_read_disk 3 , .Xr archive_write_disk 3 +.Xr libarchive 3 , .Sh BUGS The platform types .Vt uid_t diff --git a/Utilities/cmlibarchive/libarchive/archive_entry_stat.3 b/Utilities/cmlibarchive/libarchive/archive_entry_stat.3 index 84a4ea1..26611e4 100644 --- a/Utilities/cmlibarchive/libarchive/archive_entry_stat.3 +++ b/Utilities/cmlibarchive/libarchive/archive_entry_stat.3 @@ -226,7 +226,7 @@ and are used by .Xr archive_entry_linkify 3 to find hardlinks. -The pair of device and inode is suppossed to identify hardlinked files. +The pair of device and inode is supposed to identify hardlinked files. .Pp The device major and minor number can be obtained independently using .Fn archive_entry_devmajor @@ -267,8 +267,8 @@ platforms. Some archive formats use the combined form, while other formats use the split form. .Sh SEE ALSO -.Xr archive 3 , .Xr archive_entry_acl 3 , .Xr archive_entry_perms 3 , .Xr archive_entry_time 3 , +.Xr libarchive 3 , .Xr stat 2 diff --git a/Utilities/cmlibarchive/libarchive/archive_entry_time.3 b/Utilities/cmlibarchive/libarchive/archive_entry_time.3 index 17c658a..1864521 100644 --- a/Utilities/cmlibarchive/libarchive/archive_entry_time.3 +++ b/Utilities/cmlibarchive/libarchive/archive_entry_time.3 @@ -113,8 +113,8 @@ The current state can be queried using .Fn XXX_is_set . Unset time fields have a second and nanosecond field of 0. .Sh SEE ALSO -.Xr archive 3 , .Xr archive_entry 3 +.Xr libarchive 3 , .Sh HISTORY The .Nm libarchive diff --git a/Utilities/cmlibarchive/libarchive/archive_entry_xattr.c b/Utilities/cmlibarchive/libarchive/archive_entry_xattr.c index a3efe7c..05eb90f 100644 --- a/Utilities/cmlibarchive/libarchive/archive_entry_xattr.c +++ b/Utilities/cmlibarchive/libarchive/archive_entry_xattr.c @@ -98,7 +98,10 @@ archive_entry_xattr_add_entry(struct archive_entry *entry, /* XXX Error XXX */ return; - xp->name = strdup(name); + if ((xp->name = strdup(name)) == NULL) + /* XXX Error XXX */ + return; + if ((xp->value = malloc(size)) != NULL) { memcpy(xp->value, value, size); xp->size = size; diff --git a/Utilities/cmlibarchive/libarchive/archive_hmac.c b/Utilities/cmlibarchive/libarchive/archive_hmac.c new file mode 100644 index 0000000..36e3e1c --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_hmac.c @@ -0,0 +1,234 @@ +/*- +* Copyright (c) 2014 Michihiro NAKAJIMA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* +* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR +* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "archive_platform.h" + +#ifdef HAVE_STRING_H +#include <string.h> +#endif +#include "archive.h" +#include "archive_hmac_private.h" + +#ifdef ARCHIVE_HMAC_USE_Apple_CommonCrypto + +static int +__hmac_sha1_init(archive_hmac_sha1_ctx *ctx, const uint8_t *key, size_t key_len) +{ + CCHmacInit(ctx, kCCHmacAlgSHA1, key, key_len); + return 0; +} + +static void +__hmac_sha1_update(archive_hmac_sha1_ctx *ctx, const uint8_t *data, + size_t data_len) +{ + CCHmacUpdate(ctx, data, data_len); +} + +static void +__hmac_sha1_final(archive_hmac_sha1_ctx *ctx, uint8_t *out, size_t *out_len) +{ + CCHmacFinal(ctx, out); + *out_len = 20; +} + +static void +__hmac_sha1_cleanup(archive_hmac_sha1_ctx *ctx) +{ + memset(ctx, 0, sizeof(*ctx)); +} + +#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H) + +static int +__hmac_sha1_init(archive_hmac_sha1_ctx *ctx, const uint8_t *key, size_t key_len) +{ + BCRYPT_ALG_HANDLE hAlg; + BCRYPT_HASH_HANDLE hHash; + DWORD hash_len; + PBYTE hash; + ULONG result; + NTSTATUS status; + + ctx->hAlg = NULL; + status = BCryptOpenAlgorithmProvider(&hAlg, BCRYPT_SHA1_ALGORITHM, + MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG); + if (!BCRYPT_SUCCESS(status)) + return -1; + status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH, (PUCHAR)&hash_len, + sizeof(hash_len), &result, 0); + if (!BCRYPT_SUCCESS(status)) { + BCryptCloseAlgorithmProvider(hAlg, 0); + return -1; + } + hash = (PBYTE)HeapAlloc(GetProcessHeap(), 0, hash_len); + if (hash == NULL) { + BCryptCloseAlgorithmProvider(hAlg, 0); + return -1; + } + status = BCryptCreateHash(hAlg, &hHash, NULL, 0, + (PUCHAR)key, (ULONG)key_len, BCRYPT_HASH_REUSABLE_FLAG); + if (!BCRYPT_SUCCESS(status)) { + BCryptCloseAlgorithmProvider(hAlg, 0); + HeapFree(GetProcessHeap(), 0, hash); + return -1; + } + + ctx->hAlg = hAlg; + ctx->hHash = hHash; + ctx->hash_len = hash_len; + ctx->hash = hash; + + return 0; +} + +static void +__hmac_sha1_update(archive_hmac_sha1_ctx *ctx, const uint8_t *data, + size_t data_len) +{ + BCryptHashData(ctx->hHash, (PUCHAR)(uintptr_t)data, (ULONG)data_len, 0); +} + +static void +__hmac_sha1_final(archive_hmac_sha1_ctx *ctx, uint8_t *out, size_t *out_len) +{ + BCryptFinishHash(ctx->hHash, ctx->hash, ctx->hash_len, 0); + if (ctx->hash_len == *out_len) + memcpy(out, ctx->hash, *out_len); +} + +static void +__hmac_sha1_cleanup(archive_hmac_sha1_ctx *ctx) +{ + if (ctx->hAlg != NULL) { + BCryptCloseAlgorithmProvider(ctx->hAlg, 0); + HeapFree(GetProcessHeap(), 0, ctx->hash); + ctx->hAlg = NULL; + } +} + +#elif defined(HAVE_LIBNETTLE) + +static int +__hmac_sha1_init(archive_hmac_sha1_ctx *ctx, const uint8_t *key, size_t key_len) +{ + hmac_sha1_set_key(ctx, key_len, key); + return 0; +} + +static void +__hmac_sha1_update(archive_hmac_sha1_ctx *ctx, const uint8_t *data, + size_t data_len) +{ + hmac_sha1_update(ctx, data_len, data); +} + +static void +__hmac_sha1_final(archive_hmac_sha1_ctx *ctx, uint8_t *out, size_t *out_len) +{ + hmac_sha1_digest(ctx, (unsigned)*out_len, out); +} + +static void +__hmac_sha1_cleanup(archive_hmac_sha1_ctx *ctx) +{ + memset(ctx, 0, sizeof(*ctx)); +} + +#elif defined(HAVE_LIBCRYPTO) + +static int +__hmac_sha1_init(archive_hmac_sha1_ctx *ctx, const uint8_t *key, size_t key_len) +{ + HMAC_CTX_init(ctx); + HMAC_Init(ctx, key, key_len, EVP_sha1()); + return 0; +} + +static void +__hmac_sha1_update(archive_hmac_sha1_ctx *ctx, const uint8_t *data, + size_t data_len) +{ + HMAC_Update(ctx, data, data_len); +} + +static void +__hmac_sha1_final(archive_hmac_sha1_ctx *ctx, uint8_t *out, size_t *out_len) +{ + unsigned int len = (unsigned int)*out_len; + HMAC_Final(ctx, out, &len); + *out_len = len; +} + +static void +__hmac_sha1_cleanup(archive_hmac_sha1_ctx *ctx) +{ + HMAC_CTX_cleanup(ctx); + memset(ctx, 0, sizeof(*ctx)); +} + +#else + +/* Stub */ +static int +__hmac_sha1_init(archive_hmac_sha1_ctx *ctx, const uint8_t *key, size_t key_len) +{ + (void)ctx;/* UNUSED */ + (void)key;/* UNUSED */ + (void)key_len;/* UNUSED */ + return -1; +} + +static void +__hmac_sha1_update(archive_hmac_sha1_ctx *ctx, const uint8_t *data, + size_t data_len) +{ + (void)ctx;/* UNUSED */ + (void)data;/* UNUSED */ + (void)data_len;/* UNUSED */ +} + +static void +__hmac_sha1_final(archive_hmac_sha1_ctx *ctx, uint8_t *out, size_t *out_len) +{ + (void)ctx;/* UNUSED */ + (void)out;/* UNUSED */ + (void)out_len;/* UNUSED */ +} + +static void +__hmac_sha1_cleanup(archive_hmac_sha1_ctx *ctx) +{ + (void)ctx;/* UNUSED */ +} + +#endif + +const struct archive_hmac __archive_hmac = { + &__hmac_sha1_init, + &__hmac_sha1_update, + &__hmac_sha1_final, + &__hmac_sha1_cleanup, +}; diff --git a/Utilities/cmlibarchive/libarchive/archive_hmac_private.h b/Utilities/cmlibarchive/libarchive/archive_hmac_private.h new file mode 100644 index 0000000..a9fb8ec --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_hmac_private.h @@ -0,0 +1,95 @@ +/*- +* Copyright (c) 2014 Michihiro NAKAJIMA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* +* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR +* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef __LIBARCHIVE_BUILD +#error This header is only to be used internally to libarchive. +#endif + +#ifndef ARCHIVE_HMAC_PRIVATE_H_INCLUDED +#define ARCHIVE_HMAC_PRIVATE_H_INCLUDED + +#ifdef __APPLE__ +# include <AvailabilityMacros.h> +# if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 +# define ARCHIVE_HMAC_USE_Apple_CommonCrypto +# endif +#endif + +#ifdef ARCHIVE_HMAC_USE_Apple_CommonCrypto +#include <CommonCrypto/CommonHMAC.h> + +typedef CCHmacContext archive_hmac_sha1_ctx; + +#elif defined(_WIN32) && !defined(__CYGWIN__) && defined(HAVE_BCRYPT_H) +#include <bcrypt.h> + +typedef struct { + BCRYPT_ALG_HANDLE hAlg; + BCRYPT_HASH_HANDLE hHash; + DWORD hash_len; + PBYTE hash; + +} archive_hmac_sha1_ctx; + +#elif defined(HAVE_LIBNETTLE) +#include <nettle/hmac.h> + +typedef struct hmac_sha1_ctx archive_hmac_sha1_ctx; + +#elif defined(HAVE_LIBCRYPTO) +#include <openssl/hmac.h> + +typedef HMAC_CTX archive_hmac_sha1_ctx; + +#else + +typedef int archive_hmac_sha1_ctx; + +#endif + + +/* HMAC */ +#define archive_hmac_sha1_init(ctx, key, key_len)\ + __archive_hmac.__hmac_sha1_init(ctx, key, key_len) +#define archive_hmac_sha1_update(ctx, data, data_len)\ + __archive_hmac.__hmac_sha1_update(ctx, data, data_len) +#define archive_hmac_sha1_final(ctx, out, out_len)\ + __archive_hmac.__hmac_sha1_final(ctx, out, out_len) +#define archive_hmac_sha1_cleanup(ctx)\ + __archive_hmac.__hmac_sha1_cleanup(ctx) + + +struct archive_hmac { + /* HMAC */ + int (*__hmac_sha1_init)(archive_hmac_sha1_ctx *, const uint8_t *, + size_t); + void (*__hmac_sha1_update)(archive_hmac_sha1_ctx *, const uint8_t *, + size_t); + void (*__hmac_sha1_final)(archive_hmac_sha1_ctx *, uint8_t *, size_t *); + void (*__hmac_sha1_cleanup)(archive_hmac_sha1_ctx *); +}; + +extern const struct archive_hmac __archive_hmac; +#endif /* ARCHIVE_HMAC_PRIVATE_H_INCLUDED */ diff --git a/Utilities/cmlibarchive/libarchive/archive_match.c b/Utilities/cmlibarchive/libarchive/archive_match.c index 6fb8644..74aaacb 100644 --- a/Utilities/cmlibarchive/libarchive/archive_match.c +++ b/Utilities/cmlibarchive/libarchive/archive_match.c @@ -580,6 +580,7 @@ add_pattern_from_file(struct archive_match *a, struct match_list *mlist, return (ARCHIVE_FATAL); } r = archive_read_support_format_raw(ar); + r = archive_read_support_format_empty(ar); if (r != ARCHIVE_OK) { archive_copy_error(&(a->archive), ar); archive_read_free(ar); @@ -596,9 +597,13 @@ add_pattern_from_file(struct archive_match *a, struct match_list *mlist, } r = archive_read_next_header(ar, &ae); if (r != ARCHIVE_OK) { - archive_copy_error(&(a->archive), ar); archive_read_free(ar); - return (r); + if (r == ARCHIVE_EOF) { + return (ARCHIVE_OK); + } else { + archive_copy_error(&(a->archive), ar); + return (r); + } } archive_string_init(&as); diff --git a/Utilities/cmlibarchive/libarchive/archive_pathmatch.c b/Utilities/cmlibarchive/libarchive/archive_pathmatch.c index 505252a..619e2b6 100644 --- a/Utilities/cmlibarchive/libarchive/archive_pathmatch.c +++ b/Utilities/cmlibarchive/libarchive/archive_pathmatch.c @@ -394,8 +394,8 @@ __archive_pathmatch(const char *p, const char *s, int flags) if (*p == '/' && *s != '/') return (0); - /* Certain patterns and file names anchor implicitly. */ - if (*p == '*' || *p == '/' || *p == '/') { + /* Certain patterns anchor implicitly. */ + if (*p == '*' || *p == '/') { while (*p == '/') ++p; while (*s == '/') @@ -434,8 +434,8 @@ __archive_pathmatch_w(const wchar_t *p, const wchar_t *s, int flags) if (*p == L'/' && *s != L'/') return (0); - /* Certain patterns and file names anchor implicitly. */ - if (*p == L'*' || *p == L'/' || *p == L'/') { + /* Certain patterns anchor implicitly. */ + if (*p == L'*' || *p == L'/') { while (*p == L'/') ++p; while (*s == L'/') diff --git a/Utilities/cmlibarchive/libarchive/archive_private.h b/Utilities/cmlibarchive/libarchive/archive_private.h index 30d472f..4b4be97 100644 --- a/Utilities/cmlibarchive/libarchive/archive_private.h +++ b/Utilities/cmlibarchive/libarchive/archive_private.h @@ -119,6 +119,23 @@ struct archive { unsigned current_codepage; /* Current ACP(ANSI CodePage). */ unsigned current_oemcp; /* Current OEMCP(OEM CodePage). */ struct archive_string_conv *sconv; + + /* + * Used by archive_read_data() to track blocks and copy + * data to client buffers, filling gaps with zero bytes. + */ + const char *read_data_block; + int64_t read_data_offset; + int64_t read_data_output_offset; + size_t read_data_remaining; + + /* + * Used by formats/filters to determine the amount of data + * requested from a call to archive_read_data(). This is only + * useful when the format/filter has seek support. + */ + char read_data_is_posix_read; + size_t read_data_requested; }; /* Check magic value and state; return(ARCHIVE_FATAL) if it isn't valid. */ @@ -139,6 +156,8 @@ int __archive_mktemp(const char *tmpdir); int __archive_clean(struct archive *); +void __archive_reset_read_data(struct archive *); + #define err_combine(a,b) ((a) < (b) ? (a) : (b)) #if defined(__BORLANDC__) || (defined(_MSC_VER) && _MSC_VER <= 1300) diff --git a/Utilities/cmlibarchive/libarchive/archive_random.c b/Utilities/cmlibarchive/libarchive/archive_random.c new file mode 100644 index 0000000..a20b9b1 --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_random.c @@ -0,0 +1,269 @@ +/*- + * Copyright (c) 2014 Michihiro NAKAJIMA + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "archive_platform.h" +__FBSDID("$FreeBSD$"); + +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif + +#if !defined(HAVE_ARC4RANDOM_BUF) && (!defined(_WIN32) || defined(__CYGWIN__)) + +#ifdef HAVE_FCNTL +#include <fcntl.h> +#endif +#ifdef HAVE_LIMITS_H +#include <limits.h> +#endif +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif +#ifdef HAVE_SYS_TYPES_H +#include <sys/types.h> +#endif +#ifdef HAVE_SYS_TIME_H +#include <sys/time.h> +#endif +#ifdef HAVE_PTHREAD_H +#include <pthread.h> +#endif + +static void arc4random_buf(void *, size_t); + +#endif /* HAVE_ARC4RANDOM_BUF */ + +#include "archive.h" +#include "archive_random_private.h" + +#if defined(HAVE_WINCRYPT_H) && !defined(__CYGWIN__) +#include <wincrypt.h> +#endif + +#ifndef O_CLOEXEC +#define O_CLOEXEC 0 +#endif + +/* + * Random number generator function. + * This simply calls arc4random_buf function if the platform provides it. + */ + +int +archive_random(void *buf, size_t nbytes) +{ +#if defined(_WIN32) && !defined(__CYGWIN__) + HCRYPTPROV hProv; + BOOL success; + + success = CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, + CRYPT_VERIFYCONTEXT); + if (!success && GetLastError() == NTE_BAD_KEYSET) { + success = CryptAcquireContext(&hProv, NULL, NULL, + PROV_RSA_FULL, CRYPT_NEWKEYSET); + } + if (success) { + success = CryptGenRandom(hProv, (DWORD)nbytes, (BYTE*)buf); + CryptReleaseContext(hProv, 0); + if (success) + return ARCHIVE_OK; + } + /* TODO: Does this case really happen? */ + return ARCHIVE_FAILED; +#else + arc4random_buf(buf, nbytes); + return ARCHIVE_OK; +#endif +} + +#if !defined(HAVE_ARC4RANDOM_BUF) && (!defined(_WIN32) || defined(__CYGWIN__)) + +/* $OpenBSD: arc4random.c,v 1.24 2013/06/11 16:59:50 deraadt Exp $ */ +/* + * Copyright (c) 1996, David Mazieres <dm@uun.org> + * Copyright (c) 2008, Damien Miller <djm@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * Arc4 random number generator for OpenBSD. + * + * This code is derived from section 17.1 of Applied Cryptography, + * second edition, which describes a stream cipher allegedly + * compatible with RSA Labs "RC4" cipher (the actual description of + * which is a trade secret). The same algorithm is used as a stream + * cipher called "arcfour" in Tatu Ylonen's ssh package. + * + * RC4 is a registered trademark of RSA Laboratories. + */ + +#ifdef __GNUC__ +#define inline __inline +#else /* !__GNUC__ */ +#define inline +#endif /* !__GNUC__ */ + +struct arc4_stream { + uint8_t i; + uint8_t j; + uint8_t s[256]; +}; + +#define RANDOMDEV "/dev/urandom" +#define KEYSIZE 128 +#ifdef HAVE_PTHREAD_H +static pthread_mutex_t arc4random_mtx = PTHREAD_MUTEX_INITIALIZER; +#define _ARC4_LOCK() pthread_mutex_lock(&arc4random_mtx); +#define _ARC4_UNLOCK() pthread_mutex_unlock(&arc4random_mtx); +#else +#define _ARC4_LOCK() +#define _ARC4_UNLOCK() +#endif + +static int rs_initialized; +static struct arc4_stream rs; +static pid_t arc4_stir_pid; +static int arc4_count; + +static inline uint8_t arc4_getbyte(void); +static void arc4_stir(void); + +static inline void +arc4_init(void) +{ + int n; + + for (n = 0; n < 256; n++) + rs.s[n] = n; + rs.i = 0; + rs.j = 0; +} + +static inline void +arc4_addrandom(u_char *dat, int datlen) +{ + int n; + uint8_t si; + + rs.i--; + for (n = 0; n < 256; n++) { + rs.i = (rs.i + 1); + si = rs.s[rs.i]; + rs.j = (rs.j + si + dat[n % datlen]); + rs.s[rs.i] = rs.s[rs.j]; + rs.s[rs.j] = si; + } + rs.j = rs.i; +} + +static void +arc4_stir(void) +{ + int done, fd, i; + struct { + struct timeval tv; + pid_t pid; + u_char rnd[KEYSIZE]; + } rdat; + + if (!rs_initialized) { + arc4_init(); + rs_initialized = 1; + } + done = 0; + fd = open(RANDOMDEV, O_RDONLY | O_CLOEXEC, 0); + if (fd >= 0) { + if (read(fd, &rdat, KEYSIZE) == KEYSIZE) + done = 1; + (void)close(fd); + } + if (!done) { + (void)gettimeofday(&rdat.tv, NULL); + rdat.pid = getpid(); + /* We'll just take whatever was on the stack too... */ + } + + arc4_addrandom((u_char *)&rdat, KEYSIZE); + + /* + * Discard early keystream, as per recommendations in: + * "(Not So) Random Shuffles of RC4" by Ilya Mironov. + */ + for (i = 0; i < 1024; i++) + (void)arc4_getbyte(); + arc4_count = 1600000; +} + +static void +arc4_stir_if_needed(void) +{ + pid_t pid = getpid(); + + if (arc4_count <= 0 || !rs_initialized || arc4_stir_pid != pid) { + arc4_stir_pid = pid; + arc4_stir(); + } +} + +static inline uint8_t +arc4_getbyte(void) +{ + uint8_t si, sj; + + rs.i = (rs.i + 1); + si = rs.s[rs.i]; + rs.j = (rs.j + si); + sj = rs.s[rs.j]; + rs.s[rs.i] = sj; + rs.s[rs.j] = si; + return (rs.s[(si + sj) & 0xff]); +} + +static void +arc4random_buf(void *_buf, size_t n) +{ + u_char *buf = (u_char *)_buf; + _ARC4_LOCK(); + arc4_stir_if_needed(); + while (n--) { + if (--arc4_count <= 0) + arc4_stir(); + buf[n] = arc4_getbyte(); + } + _ARC4_UNLOCK(); +} + +#endif /* !HAVE_ARC4RANDOM_BUF */ diff --git a/Utilities/cmlibarchive/libarchive/archive_random_private.h b/Utilities/cmlibarchive/libarchive/archive_random_private.h new file mode 100644 index 0000000..c414779 --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_random_private.h @@ -0,0 +1,36 @@ +/*- + * Copyright (c) 2014 Michihiro NAKAJIMA + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __LIBARCHIVE_BUILD +#error This header is only to be used internally to libarchive. +#endif + +#ifndef ARCHIVE_RANDOM_PRIVATE_H_INCLUDED +#define ARCHIVE_RANDOM_PRIVATE_H_INCLUDED + +/* Random number generator. */ +int archive_random(void *buf, size_t nbytes); + +#endif /* ARCHIVE_RANDOM_PRIVATE_H_INCLUDED */ diff --git a/Utilities/cmlibarchive/libarchive/archive_read.3 b/Utilities/cmlibarchive/libarchive/archive_read.3 index a29cc1e..d37e732 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read.3 +++ b/Utilities/cmlibarchive/libarchive/archive_read.3 @@ -130,7 +130,7 @@ which provides a slightly more efficient interface. You may prefer to use the higher-level .Fn archive_read_data_skip , which reads and discards the data for this entry, -.Fn archive_read_data_to_file , +.Fn archive_read_data_into_fd , which copies the data to the provided file descriptor, or .Fn archive_read_extract , which recreates the specified entry on disk and copies data @@ -186,7 +186,7 @@ list_archive(const char *name) free(mydata); } -ssize_t +la_ssize_t myread(struct archive *a, void *client_data, const void **buff) { struct mydata *mydata = client_data; diff --git a/Utilities/cmlibarchive/libarchive/archive_read.c b/Utilities/cmlibarchive/libarchive/archive_read.c index a65b94d..033ed8b 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read.c +++ b/Utilities/cmlibarchive/libarchive/archive_read.c @@ -101,16 +101,17 @@ archive_read_new(void) { struct archive_read *a; - a = (struct archive_read *)malloc(sizeof(*a)); + a = (struct archive_read *)calloc(1, sizeof(*a)); if (a == NULL) return (NULL); - memset(a, 0, sizeof(*a)); a->archive.magic = ARCHIVE_READ_MAGIC; a->archive.state = ARCHIVE_STATE_NEW; a->entry = archive_entry_new2(&a->archive); a->archive.vtable = archive_read_vtable(); + a->passphrases.last = &a->passphrases.first; + return (&a->archive); } @@ -194,10 +195,12 @@ client_skip_proxy(struct archive_read_filter *self, int64_t request) ask = skip_limit; get = (self->archive->client.skipper) (&self->archive->archive, self->data, ask); - if (get == 0) + total += get; + if (get == 0 || get == request) return (total); + if (get > request) + return ARCHIVE_FATAL; request -= get; - total += get; } } else if (self->archive->client.seeker != NULL && request > 64 * 1024) { @@ -230,8 +233,11 @@ client_seek_proxy(struct archive_read_filter *self, int64_t offset, int whence) * other libarchive code that assumes a successful forward * seek means it can also seek backwards. */ - if (self->archive->client.seeker == NULL) + if (self->archive->client.seeker == NULL) { + archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, + "Current client reader does not support seeking a device"); return (ARCHIVE_FAILED); + } return (self->archive->client.seeker)(&self->archive->archive, self->data, offset, whence); } @@ -454,7 +460,7 @@ archive_read_open1(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; struct archive_read_filter *filter, *tmp; - int slot, e; + int slot, e = ARCHIVE_OK; unsigned int i; archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, @@ -544,13 +550,13 @@ archive_read_open1(struct archive *_a) static int choose_filters(struct archive_read *a) { - int number_bidders, i, bid, best_bid; + int number_bidders, i, bid, best_bid, n; struct archive_read_filter_bidder *bidder, *best_bidder; struct archive_read_filter *filter; ssize_t avail; int r; - for (;;) { + for (n = 0; n < 25; ++n) { number_bidders = sizeof(a->bidders) / sizeof(a->bidders[0]); best_bid = 0; @@ -596,6 +602,9 @@ choose_filters(struct archive_read *a) return (ARCHIVE_FATAL); } } + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Input requires too many filters for decoding"); + return (ARCHIVE_FATAL); } /* @@ -658,16 +667,14 @@ _archive_read_next_header2(struct archive *_a, struct archive_entry *entry) break; } - a->read_data_output_offset = 0; - a->read_data_remaining = 0; - a->read_data_is_posix_read = 0; - a->read_data_requested = 0; + __archive_reset_read_data(&a->archive); + a->data_start_node = a->client.cursor; /* EOF always wins; otherwise return the worst error. */ return (r2 < r1 || r2 == ARCHIVE_EOF) ? r2 : r1; } -int +static int _archive_read_next_header(struct archive *_a, struct archive_entry **entryp) { int ret; @@ -813,7 +820,7 @@ archive_read_format_capabilities(struct archive *_a) ssize_t archive_read_data(struct archive *_a, void *buff, size_t s) { - struct archive_read *a = (struct archive_read *)_a; + struct archive *a = (struct archive *)_a; char *dest; const void *read_buf; size_t bytes_read; @@ -828,7 +835,7 @@ archive_read_data(struct archive *_a, void *buff, size_t s) read_buf = a->read_data_block; a->read_data_is_posix_read = 1; a->read_data_requested = s; - r = _archive_read_data_block(&a->archive, &read_buf, + r = archive_read_data_block(a, &read_buf, &a->read_data_remaining, &a->read_data_offset); a->read_data_block = read_buf; if (r == ARCHIVE_EOF) @@ -843,7 +850,7 @@ archive_read_data(struct archive *_a, void *buff, size_t s) } if (a->read_data_offset < a->read_data_output_offset) { - archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, "Encountered out-of-order sparse blocks"); return (ARCHIVE_RETRY); } @@ -887,6 +894,21 @@ archive_read_data(struct archive *_a, void *buff, size_t s) } /* + * Reset the read_data_* variables, used for starting a new entry. + */ +void __archive_reset_read_data(struct archive * a) +{ + a->read_data_output_offset = 0; + a->read_data_remaining = 0; + a->read_data_is_posix_read = 0; + a->read_data_requested = 0; + + /* extra resets, from rar.c */ + a->read_data_block = NULL; + a->read_data_offset = 0; +} + +/* * Skip over all remaining data in this entry. */ int @@ -953,7 +975,7 @@ _archive_read_data_block(struct archive *_a, if (a->format->read_data == NULL) { archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER, "Internal error: " - "No format_read_data_block function registered"); + "No format->read_data function registered"); return (ARCHIVE_FATAL); } @@ -1040,6 +1062,7 @@ static int _archive_read_free(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; + struct archive_read_passphrase *p; int i, n; int slots; int r = ARCHIVE_OK; @@ -1077,9 +1100,20 @@ _archive_read_free(struct archive *_a) } } + /* Release passphrase list. */ + p = a->passphrases.first; + while (p != NULL) { + struct archive_read_passphrase *np = p->next; + + /* A passphrase should be cleaned. */ + memset(p->passphrase, 0, strlen(p->passphrase)); + free(p->passphrase); + free(p); + p = np; + } + archive_string_free(&a->archive.error_string); - if (a->entry) - archive_entry_free(a->entry); + archive_entry_free(a->entry); a->archive.magic = 0; __archive_clean(&a->archive); free(a->client.dataset); @@ -1451,6 +1485,8 @@ __archive_read_filter_consume(struct archive_read_filter * filter, { int64_t skipped; + if (request < 0) + return ARCHIVE_FATAL; if (request == 0) return 0; diff --git a/Utilities/cmlibarchive/libarchive/archive_read_add_passphrase.3 b/Utilities/cmlibarchive/libarchive/archive_read_add_passphrase.3 new file mode 100644 index 0000000..8b242ea --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_read_add_passphrase.3 @@ -0,0 +1,74 @@ +.\" Copyright (c) 2014 Michihiro NAKAJIMA +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $FreeBSD$ +.\" +.Dd September 14, 2014 +.Dt ARCHIVE_READ_ADD_PASSPHRASE 3 +.Os +.Sh NAME +.Nm archive_read_add_passphrase , +.Nm archive_read_set_passphrase_callback +.Nd functions for reading encrypted archives +.Sh LIBRARY +Streaming Archive Library (libarchive, -larchive) +.Sh SYNOPSIS +.In archive.h +.Ft int +.Fo archive_read_add_passphrase +.Fa "struct archive *" +.Fa "const char *passphrase" +.Fc +.Ft int +.Fo archive_read_set_passphrase_callback +.Fa "struct archive *" +.Fa "void *client_data" +.Fa "archive_passphrase_callback *" +.Fc +.Sh DESCRIPTION +.Bl -tag -width indent +.It Fn archive_read_add_passphrase +Register passphrases for reading an encryption archive. +If +.Ar passphrase +is +.Dv NULL +or empty, this function will do nothing and +.Cm ARCHIVE_FAILED +will be returned. +Otherwise, +.Cm ARCHIVE_OK +will be returned. +.It Fn archive_read_set_passphrase_callback +Register callback function that will be invoked to get a passphrase +for decrption after trying all passphrases registered by the +.Fn archive_read_add_passphrase +function failed. +.El +.\" .Sh ERRORS +.Sh SEE ALSO +.Xr tar 1 , +.Xr libarchive 3 , +.Xr archive_read 3 , +.Xr archive_read_set_options 3 diff --git a/Utilities/cmlibarchive/libarchive/archive_read_add_passphrase.c b/Utilities/cmlibarchive/libarchive/archive_read_add_passphrase.c new file mode 100644 index 0000000..f67f1eb --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_read_add_passphrase.c @@ -0,0 +1,186 @@ +/*- + * Copyright (c) 2014 Michihiro NAKAJIMA + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "archive_platform.h" +__FBSDID("$FreeBSD$"); + +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif +#include "archive_read_private.h" + +static void +add_passphrase_to_tail(struct archive_read *a, + struct archive_read_passphrase *p) +{ + *a->passphrases.last = p; + a->passphrases.last = &p->next; + p->next = NULL; +} + +static struct archive_read_passphrase * +remove_passphrases_from_head(struct archive_read *a) +{ + struct archive_read_passphrase *p; + + p = a->passphrases.first; + if (p != NULL) + a->passphrases.first = p->next; + return (p); +} + +static void +insert_passphrase_to_head(struct archive_read *a, + struct archive_read_passphrase *p) +{ + p->next = a->passphrases.first; + a->passphrases.first = p; +} + +static struct archive_read_passphrase * +new_read_passphrase(struct archive_read *a, const char *passphrase) +{ + struct archive_read_passphrase *p; + + p = malloc(sizeof(*p)); + if (p == NULL) { + archive_set_error(&a->archive, ENOMEM, + "Can't allocate memory"); + return (NULL); + } + p->passphrase = strdup(passphrase); + if (p->passphrase == NULL) { + free(p); + archive_set_error(&a->archive, ENOMEM, + "Can't allocate memory"); + return (NULL); + } + return (p); +} + +int +archive_read_add_passphrase(struct archive *_a, const char *passphrase) +{ + struct archive_read *a = (struct archive_read *)_a; + struct archive_read_passphrase *p; + + archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, + "archive_read_add_passphrase"); + + if (passphrase == NULL || passphrase[0] == '\0') { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Empty passphrase is unacceptable"); + return (ARCHIVE_FAILED); + } + + p = new_read_passphrase(a, passphrase); + if (p == NULL) + return (ARCHIVE_FATAL); + add_passphrase_to_tail(a, p); + + return (ARCHIVE_OK); +} + +int +archive_read_set_passphrase_callback(struct archive *_a, void *client_data, + archive_passphrase_callback *cb) +{ + struct archive_read *a = (struct archive_read *)_a; + + archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, + "archive_read_set_passphrase_callback"); + + a->passphrases.callback = cb; + a->passphrases.client_data = client_data; + return (ARCHIVE_OK); +} + +/* + * Call this in advance when you start to get a passphrase for decryption + * for a entry. + */ +void +__archive_read_reset_passphrase(struct archive_read *a) +{ + + a->passphrases.candiate = -1; +} + +/* + * Get a passphrase for decryption. + */ +const char * +__archive_read_next_passphrase(struct archive_read *a) +{ + struct archive_read_passphrase *p; + const char *passphrase; + + if (a->passphrases.candiate < 0) { + /* Count out how many passphrases we have. */ + int cnt = 0; + + for (p = a->passphrases.first; p != NULL; p = p->next) + cnt++; + a->passphrases.candiate = cnt; + p = a->passphrases.first; + } else if (a->passphrases.candiate > 1) { + /* Rotate a passphrase list. */ + a->passphrases.candiate--; + p = remove_passphrases_from_head(a); + add_passphrase_to_tail(a, p); + /* Pick a new passphrase candiate up. */ + p = a->passphrases.first; + } else if (a->passphrases.candiate == 1) { + /* This case is that all cadiates failed to decryption. */ + a->passphrases.candiate = 0; + if (a->passphrases.first->next != NULL) { + /* Rotate a passphrase list. */ + p = remove_passphrases_from_head(a); + add_passphrase_to_tail(a, p); + } + p = NULL; + } else /* There is no passphrase candaite. */ + p = NULL; + + if (p != NULL) + passphrase = p->passphrase; + else if (a->passphrases.callback != NULL) { + /* Get a passphrase through a call-back function + * since we tried all passphrases out or we don't + * have it. */ + passphrase = a->passphrases.callback(&a->archive, + a->passphrases.client_data); + if (passphrase != NULL) { + p = new_read_passphrase(a, passphrase); + if (p == NULL) + return (NULL); + insert_passphrase_to_head(a, p); + a->passphrases.candiate = 1; + } + } else + passphrase = NULL; + + return (passphrase); +} diff --git a/Utilities/cmlibarchive/libarchive/archive_read_append_filter.c b/Utilities/cmlibarchive/libarchive/archive_read_append_filter.c index 017d7c6..3a0d4d6 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_append_filter.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_append_filter.c @@ -43,7 +43,7 @@ archive_read_append_filter(struct archive *_a, int code) struct archive_read_filter *filter; struct archive_read *a = (struct archive_read *)_a; - r1 = r2 = (ARCHIVE_OK); + r2 = (ARCHIVE_OK); switch (code) { case ARCHIVE_FILTER_NONE: @@ -85,6 +85,10 @@ archive_read_append_filter(struct archive *_a, int code) strcpy(str, "rpm"); r1 = archive_read_support_filter_rpm(_a); break; + case ARCHIVE_FILTER_LZ4: + strcpy(str, "lz4"); + r1 = archive_read_support_filter_lz4(_a); + break; case ARCHIVE_FILTER_LZIP: strcpy(str, "lzip"); r1 = archive_read_support_filter_lzip(_a); diff --git a/Utilities/cmlibarchive/libarchive/archive_read_data.3 b/Utilities/cmlibarchive/libarchive/archive_read_data.3 index bf0578c..c1bc15d 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_data.3 +++ b/Utilities/cmlibarchive/libarchive/archive_read_data.3 @@ -37,7 +37,7 @@ Streaming Archive Library (libarchive, -larchive) .Sh SYNOPSIS .In archive.h -.Ft ssize_t +.Ft la_ssize_t .Fn archive_read_data "struct archive *" "void *buff" "size_t len" .Ft int .Fo archive_read_data_block diff --git a/Utilities/cmlibarchive/libarchive/archive_read_disk_entry_from_file.c b/Utilities/cmlibarchive/libarchive/archive_read_disk_entry_from_file.c index e81cbec..38303aa 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_disk_entry_from_file.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_disk_entry_from_file.c @@ -251,9 +251,11 @@ archive_read_disk_entry_from_file(struct archive *_a, #endif /* HAVE_READLINK || HAVE_READLINKAT */ r = setup_acls(a, entry, &fd); - r1 = setup_xattrs(a, entry, &fd); - if (r1 < r) - r = r1; + if (!a->suppress_xattr) { + r1 = setup_xattrs(a, entry, &fd); + if (r1 < r) + r = r1; + } if (a->enable_copyfile) { r1 = setup_mac_metadata(a, entry, &fd); if (r1 < r) diff --git a/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c b/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c index 94eb5e7..f480539 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c @@ -356,6 +356,8 @@ static int _archive_read_free(struct archive *); static int _archive_read_close(struct archive *); static int _archive_read_data_block(struct archive *, const void **, size_t *, int64_t *); +static int _archive_read_next_header(struct archive *, + struct archive_entry **); static int _archive_read_next_header2(struct archive *, struct archive_entry *); static const char *trivial_lookup_gname(void *, int64_t gid); @@ -377,6 +379,7 @@ archive_read_disk_vtable(void) av.archive_free = _archive_read_free; av.archive_close = _archive_read_close; av.archive_read_data_block = _archive_read_data_block; + av.archive_read_next_header = _archive_read_next_header; av.archive_read_next_header2 = _archive_read_next_header2; inited = 1; } @@ -459,6 +462,7 @@ archive_read_disk_new(void) a->archive.magic = ARCHIVE_READ_DISK_MAGIC; a->archive.state = ARCHIVE_STATE_NEW; a->archive.vtable = archive_read_disk_vtable(); + a->entry = archive_entry_new2(&a->archive); a->lookup_uname = trivial_lookup_uname; a->lookup_gname = trivial_lookup_gname; a->enable_copyfile = 1; @@ -491,6 +495,7 @@ _archive_read_free(struct archive *_a) if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL) (a->cleanup_uname)(a->lookup_uname_data); archive_string_free(&a->archive.error_string); + archive_entry_free(a->entry); a->archive.magic = 0; __archive_clean(&a->archive); free(a); @@ -609,6 +614,10 @@ archive_read_disk_set_behavior(struct archive *_a, int flags) a->traverse_mount_points = 0; else a->traverse_mount_points = 1; + if (flags & ARCHIVE_READDISK_NO_XATTR) + a->suppress_xattr = 1; + else + a->suppress_xattr = 0; return (r); } @@ -974,7 +983,7 @@ next_entry(struct archive_read_disk *a, struct tree *t, t->initial_filesystem_id = t->current_filesystem_id; if (!a->traverse_mount_points) { if (t->initial_filesystem_id != t->current_filesystem_id) - return (ARCHIVE_RETRY); + descend = 0; } t->descend = descend; @@ -1081,6 +1090,17 @@ next_entry(struct archive_read_disk *a, struct tree *t, } static int +_archive_read_next_header(struct archive *_a, struct archive_entry **entryp) +{ + int ret; + struct archive_read_disk *a = (struct archive_read_disk *)_a; + *entryp = NULL; + ret = _archive_read_next_header2(_a, a->entry); + *entryp = a->entry; + return ret; +} + +static int _archive_read_next_header2(struct archive *_a, struct archive_entry *entry) { struct archive_read_disk *a = (struct archive_read_disk *)_a; @@ -1148,6 +1168,7 @@ _archive_read_next_header2(struct archive *_a, struct archive_entry *entry) break; } + __archive_reset_read_data(&a->archive); return (r); } diff --git a/Utilities/cmlibarchive/libarchive/archive_read_disk_private.h b/Utilities/cmlibarchive/libarchive/archive_read_disk_private.h index e5af16b..2569321 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_disk_private.h +++ b/Utilities/cmlibarchive/libarchive/archive_read_disk_private.h @@ -39,6 +39,9 @@ struct archive_entry; struct archive_read_disk { struct archive archive; + /* Reused by archive_read_next_header() */ + struct archive_entry *entry; + /* * Symlink mode is one of 'L'ogical, 'P'hysical, or 'H'ybrid, * following an old BSD convention. 'L' follows all symlinks, @@ -68,6 +71,8 @@ struct archive_read_disk { int enable_copyfile; /* Set 1 if users request to traverse mount points. */ int traverse_mount_points; + /* Set 1 if users want to suppress xattr information. */ + int suppress_xattr; const char * (*lookup_gname)(void *private, int64_t gid); void (*cleanup_gname)(void *private); diff --git a/Utilities/cmlibarchive/libarchive/archive_read_disk_set_standard_lookup.c b/Utilities/cmlibarchive/libarchive/archive_read_disk_set_standard_lookup.c index 3bc52c7..d6b2d55 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_disk_set_standard_lookup.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_disk_set_standard_lookup.c @@ -83,7 +83,7 @@ static const char * lookup_uname_helper(struct name_cache *, id_t uid); * a simple cache to accelerate such lookups---into the archive_read_disk * object. This is in a separate file because getpwuid()/getgrgid() * can pull in a LOT of library code (including NIS/LDAP functions, which - * pull in DNS resolveers, etc). This can easily top 500kB, which makes + * pull in DNS resolvers, etc). This can easily top 500kB, which makes * it inappropriate for some space-constrained applications. * * Applications that are size-sensitive may want to just use the diff --git a/Utilities/cmlibarchive/libarchive/archive_read_disk_windows.c b/Utilities/cmlibarchive/libarchive/archive_read_disk_windows.c index 5c0f366..53bd4b8 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_disk_windows.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_disk_windows.c @@ -288,6 +288,8 @@ static int _archive_read_free(struct archive *); static int _archive_read_close(struct archive *); static int _archive_read_data_block(struct archive *, const void **, size_t *, int64_t *); +static int _archive_read_next_header(struct archive *, + struct archive_entry **); static int _archive_read_next_header2(struct archive *, struct archive_entry *); static const char *trivial_lookup_gname(void *, int64_t gid); @@ -310,6 +312,7 @@ archive_read_disk_vtable(void) av.archive_free = _archive_read_free; av.archive_close = _archive_read_close; av.archive_read_data_block = _archive_read_data_block; + av.archive_read_next_header = _archive_read_next_header; av.archive_read_next_header2 = _archive_read_next_header2; inited = 1; } @@ -393,6 +396,7 @@ archive_read_disk_new(void) a->archive.magic = ARCHIVE_READ_DISK_MAGIC; a->archive.state = ARCHIVE_STATE_NEW; a->archive.vtable = archive_read_disk_vtable(); + a->entry = archive_entry_new2(&a->archive); a->lookup_uname = trivial_lookup_uname; a->lookup_gname = trivial_lookup_gname; a->enable_copyfile = 1; @@ -422,6 +426,7 @@ _archive_read_free(struct archive *_a) if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL) (a->cleanup_uname)(a->lookup_uname_data); archive_string_free(&a->archive.error_string); + archive_entry_free(a->entry); a->archive.magic = 0; free(a); return (r); @@ -945,6 +950,17 @@ next_entry(struct archive_read_disk *a, struct tree *t, } static int +_archive_read_next_header(struct archive *_a, struct archive_entry **entryp) +{ + int ret; + struct archive_read_disk *a = (struct archive_read_disk *)_a; + *entryp = NULL; + ret = _archive_read_next_header2(_a, a->entry); + *entryp = a->entry; + return ret; +} + +static int _archive_read_next_header2(struct archive *_a, struct archive_entry *entry) { struct archive_read_disk *a = (struct archive_read_disk *)_a; @@ -1000,6 +1016,7 @@ _archive_read_next_header2(struct archive *_a, struct archive_entry *entry) break; } + __archive_reset_read_data(&a->archive); return (r); } @@ -1851,8 +1868,6 @@ entry_copy_bhfi(struct archive_entry *entry, const wchar_t *path, break; case L'C': case L'c': if (((p[2] == L'M' || p[2] == L'm' ) && - (p[3] == L'D' || p[3] == L'd' )) || - ((p[2] == L'M' || p[2] == L'm' ) && (p[3] == L'D' || p[3] == L'd' ))) mode |= S_IXUSR | S_IXGRP | S_IXOTH; break; diff --git a/Utilities/cmlibarchive/libarchive/archive_read_extract.c b/Utilities/cmlibarchive/libarchive/archive_read_extract.c index ce76a6c..b7973fa 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_extract.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_extract.c @@ -35,8 +35,6 @@ __FBSDID("$FreeBSD: src/lib/libarchive/archive_read_extract.c,v 1.61 2008/05/26 #include "archive_private.h" #include "archive_read_private.h" -static int archive_read_extract_cleanup(struct archive_read *); - int archive_read_extract(struct archive *_a, struct archive_entry *entry, int flags) { @@ -55,23 +53,8 @@ archive_read_extract(struct archive *_a, struct archive_entry *entry, int flags) return (ARCHIVE_FATAL); } archive_write_disk_set_standard_lookup(extract->ad); - a->cleanup_archive_extract = archive_read_extract_cleanup; } archive_write_disk_set_options(extract->ad, flags); return (archive_read_extract2(&a->archive, entry, extract->ad)); } - -/* - * Cleanup function for archive_extract. - */ -static int -archive_read_extract_cleanup(struct archive_read *a) -{ - int ret = ARCHIVE_OK; - - ret = archive_write_free(a->extract->ad); - free(a->extract); - a->extract = NULL; - return (ret); -} diff --git a/Utilities/cmlibarchive/libarchive/archive_read_extract2.c b/Utilities/cmlibarchive/libarchive/archive_read_extract2.c index 3c65e80..7b2c126 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_extract2.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_extract2.c @@ -42,6 +42,8 @@ __FBSDID("$FreeBSD: src/lib/libarchive/archive_read_extract.c,v 1.61 2008/05/26 #include "archive_read_private.h" static int copy_data(struct archive *ar, struct archive *aw); +static int archive_read_extract_cleanup(struct archive_read *); + /* Retrieve an extract object without initialising the associated * archive_write_disk object. @@ -56,10 +58,27 @@ __archive_read_get_extract(struct archive_read *a) return (NULL); } memset(a->extract, 0, sizeof(*a->extract)); + a->cleanup_archive_extract = archive_read_extract_cleanup; } return (a->extract); } +/* + * Cleanup function for archive_extract. + */ +static int +archive_read_extract_cleanup(struct archive_read *a) +{ + int ret = ARCHIVE_OK; + + if (a->extract->ad != NULL) { + ret = archive_write_free(a->extract->ad); + } + free(a->extract); + a->extract = NULL; + return (ret); +} + int archive_read_extract2(struct archive *_a, struct archive_entry *entry, struct archive *ad) @@ -125,7 +144,7 @@ copy_data(struct archive *ar, struct archive *aw) r = (int)archive_write_data_block(aw, buff, size, offset); if (r < ARCHIVE_WARN) r = ARCHIVE_WARN; - if (r != ARCHIVE_OK) { + if (r < ARCHIVE_OK) { archive_set_error(ar, archive_errno(aw), "%s", archive_error_string(aw)); return (r); diff --git a/Utilities/cmlibarchive/libarchive/archive_read_filter.3 b/Utilities/cmlibarchive/libarchive/archive_read_filter.3 index 8761127..47effac 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_filter.3 +++ b/Utilities/cmlibarchive/libarchive/archive_read_filter.3 @@ -24,7 +24,7 @@ .\" .\" $FreeBSD$ .\" -.Dd February 2, 2012 +.Dd August 14, 2014 .Dt ARCHIVE_READ_FILTER 3 .Os .Sh NAME @@ -32,8 +32,11 @@ .Nm archive_read_support_filter_bzip2 , .Nm archive_read_support_filter_compress , .Nm archive_read_support_filter_gzip , +.Nm archive_read_support_filter_lz4 , .Nm archive_read_support_filter_lzma , .Nm archive_read_support_filter_none , +.Nm archive_read_support_filter_rpm , +.Nm archive_read_support_filter_uu , .Nm archive_read_support_filter_xz , .Nm archive_read_support_filter_program , .Nm archive_read_support_filter_program_signature @@ -52,10 +55,18 @@ Streaming Archive Library (libarchive, -larchive) .Ft int .Fn archive_read_support_filter_gzip "struct archive *" .Ft int +.Fn archive_read_support_filter_lz4 "struct archive *" +.Ft int .Fn archive_read_support_filter_lzma "struct archive *" .Ft int +.Fn archive_read_support_filter_lzop "struct archive *" +.Ft int .Fn archive_read_support_filter_none "struct archive *" .Ft int +.Fn archive_read_support_filter_rpm "struct archive *" +.Ft int +.Fn archive_read_support_filter_uu "struct archive *" +.Ft int .Fn archive_read_support_filter_xz "struct archive *" .Ft int .Fo archive_read_support_filter_program @@ -76,8 +87,12 @@ Streaming Archive Library (libarchive, -larchive) .Fn archive_read_support_filter_bzip2 , .Fn archive_read_support_filter_compress , .Fn archive_read_support_filter_gzip , +.Fn archive_read_support_filter_lz4 , .Fn archive_read_support_filter_lzma , +.Fn archive_read_support_filter_lzop , .Fn archive_read_support_filter_none , +.Fn archive_read_support_filter_rpm , +.Fn archive_read_support_filter_uu , .Fn archive_read_support_filter_xz .Xc Enables auto-detection code and decompression support for the diff --git a/Utilities/cmlibarchive/libarchive/archive_read_open.3 b/Utilities/cmlibarchive/libarchive/archive_read_open.3 index 30a740b..4d8272c 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_open.3 +++ b/Utilities/cmlibarchive/libarchive/archive_read_open.3 @@ -130,14 +130,14 @@ objects can be found in the overview manual page for The callback functions must match the following prototypes: .Bl -item -offset indent .It -.Ft typedef ssize_t +.Ft typedef la_ssize_t .Fo archive_read_callback .Fa "struct archive *" .Fa "void *client_data" .Fa "const void **buffer" .Fc .It -.Ft typedef off_t +.Ft typedef la_int64_t .Fo archive_skip_callback .Fa "struct archive *" .Fa "void *client_data" diff --git a/Utilities/cmlibarchive/libarchive/archive_read_open_fd.c b/Utilities/cmlibarchive/libarchive/archive_read_open_fd.c index e0f95bf..f59cd07 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_open_fd.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_open_fd.c @@ -59,6 +59,7 @@ struct read_fd_data { static int file_close(struct archive *, void *); static ssize_t file_read(struct archive *, void *, const void **buff); +static int64_t file_seek(struct archive *, void *, int64_t request, int); static int64_t file_skip(struct archive *, void *, int64_t request); int @@ -102,6 +103,7 @@ archive_read_open_fd(struct archive *a, int fd, size_t block_size) archive_read_set_read_callback(a, file_read); archive_read_set_skip_callback(a, file_skip); + archive_read_set_seek_callback(a, file_seek); archive_read_set_close_callback(a, file_close); archive_read_set_callback_data(a, mine); return (archive_read_open1(a)); @@ -170,6 +172,33 @@ file_skip(struct archive *a, void *client_data, int64_t request) return (-1); } +/* + * TODO: Store the offset and use it in the read callback. + */ +static int64_t +file_seek(struct archive *a, void *client_data, int64_t request, int whence) +{ + struct read_fd_data *mine = (struct read_fd_data *)client_data; + int64_t r; + + /* We use off_t here because lseek() is declared that way. */ + /* See above for notes about when off_t is less than 64 bits. */ + r = lseek(mine->fd, request, whence); + if (r >= 0) + return r; + + if (errno == ESPIPE) { + archive_set_error(a, errno, + "A file descriptor(%d) is not seekable(PIPE)", mine->fd); + return (ARCHIVE_FAILED); + } else { + /* If the input is corrupted or truncated, fail. */ + archive_set_error(a, errno, + "Error seeking in a file descriptor(%d)", mine->fd); + return (ARCHIVE_FATAL); + } +} + static int file_close(struct archive *a, void *client_data) { diff --git a/Utilities/cmlibarchive/libarchive/archive_read_open_memory.c b/Utilities/cmlibarchive/libarchive/archive_read_open_memory.c index bcc7d6f..ff935a7 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_open_memory.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_open_memory.c @@ -41,9 +41,9 @@ __FBSDID("$FreeBSD: src/lib/libarchive/archive_read_open_memory.c,v 1.6 2007/07/ */ struct read_memory_data { - unsigned char *start; - unsigned char *p; - unsigned char *end; + const unsigned char *start; + const unsigned char *p; + const unsigned char *end; ssize_t read_size; }; @@ -54,7 +54,7 @@ static int64_t memory_read_skip(struct archive *, void *, int64_t request); static ssize_t memory_read(struct archive *, void *, const void **buff); int -archive_read_open_memory(struct archive *a, void *buff, size_t size) +archive_read_open_memory(struct archive *a, const void *buff, size_t size) { return archive_read_open_memory2(a, buff, size, size); } @@ -65,7 +65,7 @@ archive_read_open_memory(struct archive *a, void *buff, size_t size) * test harnesses can exercise block operations inside the library. */ int -archive_read_open_memory2(struct archive *a, void *buff, +archive_read_open_memory2(struct archive *a, const void *buff, size_t size, size_t read_size) { struct read_memory_data *mine; @@ -76,7 +76,7 @@ archive_read_open_memory2(struct archive *a, void *buff, return (ARCHIVE_FATAL); } memset(mine, 0, sizeof(*mine)); - mine->start = mine->p = (unsigned char *)buff; + mine->start = mine->p = (const unsigned char *)buff; mine->end = mine->start + size; mine->read_size = read_size; archive_read_set_open_callback(a, memory_read_open); diff --git a/Utilities/cmlibarchive/libarchive/archive_read_private.h b/Utilities/cmlibarchive/libarchive/archive_read_private.h index 27e203b..9b61a53 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_private.h +++ b/Utilities/cmlibarchive/libarchive/archive_read_private.h @@ -26,8 +26,10 @@ */ #ifndef __LIBARCHIVE_BUILD +#ifndef __LIBARCHIVE_TEST #error This header is only to be used internally to libarchive. #endif +#endif #ifndef ARCHIVE_READ_PRIVATE_H_INCLUDED #define ARCHIVE_READ_PRIVATE_H_INCLUDED @@ -141,6 +143,10 @@ struct archive_read_client { int64_t position; struct archive_read_data_node *dataset; }; +struct archive_read_passphrase { + char *passphrase; + struct archive_read_passphrase *next; +}; struct archive_read_extract { struct archive *ad; /* archive_write_disk object */ @@ -160,28 +166,11 @@ struct archive_read { int64_t skip_file_dev; int64_t skip_file_ino; - /* - * Used by archive_read_data() to track blocks and copy - * data to client buffers, filling gaps with zero bytes. - */ - const char *read_data_block; - int64_t read_data_offset; - int64_t read_data_output_offset; - size_t read_data_remaining; - - /* - * Used by formats/filters to determine the amount of data - * requested from a call to archive_read_data(). This is only - * useful when the format/filter has seek support. - */ - char read_data_is_posix_read; - size_t read_data_requested; - /* Callbacks to open/read/write/close client archive streams. */ struct archive_read_client client; /* Registered filter bidders. */ - struct archive_read_filter_bidder bidders[14]; + struct archive_read_filter_bidder bidders[16]; /* Last filter in chain */ struct archive_read_filter *filter; @@ -225,6 +214,17 @@ struct archive_read { */ struct archive_read_extract *extract; int (*cleanup_archive_extract)(struct archive_read *); + + /* + * Decryption passphrase. + */ + struct { + struct archive_read_passphrase *first; + struct archive_read_passphrase **last; + int candiate; + archive_passphrase_callback *callback; + void *client_data; + } passphrases; }; int __archive_read_register_format(struct archive_read *a, @@ -254,4 +254,11 @@ int __archive_read_program(struct archive_read_filter *, const char *); void __archive_read_free_filters(struct archive_read *); int __archive_read_close_filters(struct archive_read *); struct archive_read_extract *__archive_read_get_extract(struct archive_read *); + + +/* + * Get a decryption passphrase. + */ +void __archive_read_reset_passphrase(struct archive_read *a); +const char * __archive_read_next_passphrase(struct archive_read *a); #endif diff --git a/Utilities/cmlibarchive/libarchive/archive_read_set_options.c b/Utilities/cmlibarchive/libarchive/archive_read_set_options.c index 46678b1..2e2eea6 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_set_options.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_set_options.c @@ -76,14 +76,13 @@ archive_set_format_option(struct archive *_a, const char *m, const char *o, const char *v) { struct archive_read *a = (struct archive_read *)_a; - struct archive_format_descriptor *format; size_t i; int r, rv = ARCHIVE_WARN, matched_modules = 0; for (i = 0; i < sizeof(a->formats)/sizeof(a->formats[0]); i++) { - format = &a->formats[i]; - if (format == NULL || format->options == NULL || - format->name == NULL) + struct archive_format_descriptor *format = &a->formats[i]; + + if (format->options == NULL || format->name == NULL) /* This format does not support option. */ continue; if (m != NULL) { diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_all.c b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_all.c index b778cfb..68c53de 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_all.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_all.c @@ -69,6 +69,8 @@ archive_read_support_filter_all(struct archive *a) archive_read_support_filter_lzop(a); /* The decode code always uses "grzip -d" command-line. */ archive_read_support_filter_grzip(a); + /* Lz4 falls back to "lz4 -d" command-line program. */ + archive_read_support_filter_lz4(a); /* Note: We always return ARCHIVE_OK here, even if some of the * above return ARCHIVE_WARN. The intent here is to enable diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_compress.c b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_compress.c index 3f5d1f3..e05132d 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_compress.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_compress.c @@ -185,19 +185,22 @@ compress_bidder_bid(struct archive_read_filter_bidder *self, (void)self; /* UNUSED */ - buffer = __archive_read_filter_ahead(filter, 2, &avail); + /* Shortest valid compress file is 3 bytes. */ + buffer = __archive_read_filter_ahead(filter, 3, &avail); if (buffer == NULL) return (0); bits_checked = 0; + /* First two bytes are the magic value */ if (buffer[0] != 0x1F || buffer[1] != 0x9D) return (0); - bits_checked += 16; - - /* - * TODO: Verify more. - */ + /* Third byte holds compression parameters. */ + if (buffer[2] & 0x20) /* Reserved bit, must be zero. */ + return (0); + if (buffer[2] & 0x40) /* Reserved bit, must be zero. */ + return (0); + bits_checked += 18; return (bits_checked); } @@ -239,7 +242,13 @@ compress_bidder_init(struct archive_read_filter *self) (void)getbits(self, 8); /* Skip first signature byte. */ (void)getbits(self, 8); /* Skip second signature byte. */ + /* Get compression parameters. */ code = getbits(self, 8); + if ((code & 0x1f) > 16) { + archive_set_error(&self->archive->archive, -1, + "Invalid compressed data"); + return (ARCHIVE_FATAL); + } state->maxcode_bits = code & 0x1f; state->maxcode = (1 << state->maxcode_bits); state->use_reset_code = code & 0x80; @@ -368,7 +377,8 @@ next_code(struct archive_read_filter *self) return (next_code(self)); } - if (code > state->free_ent) { + if (code > state->free_ent + || (code == state->free_ent && state->oldcode < 0)) { /* An invalid code is a fatal error. */ archive_set_error(&(self->archive->archive), -1, "Invalid compressed data"); diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_lz4.c b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_lz4.c new file mode 100644 index 0000000..db62cb3 --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_lz4.c @@ -0,0 +1,728 @@ +/*- + * Copyright (c) 2014 Michihiro NAKAJIMA + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "archive_platform.h" + +__FBSDID("$FreeBSD$"); + +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif +#include <stdio.h> +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif +#ifdef HAVE_STRING_H +#include <string.h> +#endif +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif +#ifdef HAVE_LZ4_H +#include <lz4.h> +#endif + +#include "archive.h" +#include "archive_endian.h" +#include "archive_private.h" +#include "archive_read_private.h" +#include "archive_xxhash.h" + +#define LZ4_MAGICNUMBER 0x184d2204 +#define LZ4_SKIPPABLED 0x184d2a50 +#define LZ4_LEGACY 0x184c2102 + +#if defined(HAVE_LIBLZ4) +struct private_data { + enum { SELECT_STREAM, + READ_DEFAULT_STREAM, + READ_DEFAULT_BLOCK, + READ_LEGACY_STREAM, + READ_LEGACY_BLOCK, + } stage; + struct { + unsigned block_independence:1; + unsigned block_checksum:3; + unsigned stream_size:1; + unsigned stream_checksum:1; + unsigned preset_dictionary:1; + int block_maximum_size; + } flags; + int64_t stream_size; + uint32_t dict_id; + char *out_block; + size_t out_block_size; + + /* Bytes read but not yet consumed via __archive_read_consume() */ + size_t unconsumed; + size_t decoded_size; + void *xxh32_state; + + char valid; /* True = decompressor is initialized */ + char eof; /* True = found end of compressed data. */ +}; + +#define LEGACY_BLOCK_SIZE (8 * 1024 * 1024) + +/* Lz4 filter */ +static ssize_t lz4_filter_read(struct archive_read_filter *, const void **); +static int lz4_filter_close(struct archive_read_filter *); +#endif + +/* + * Note that we can detect lz4 archives even if we can't decompress + * them. (In fact, we like detecting them because we can give better + * error messages.) So the bid framework here gets compiled even + * if liblz4 is unavailable. + */ +static int lz4_reader_bid(struct archive_read_filter_bidder *, struct archive_read_filter *); +static int lz4_reader_init(struct archive_read_filter *); +static int lz4_reader_free(struct archive_read_filter_bidder *); +#if defined(HAVE_LIBLZ4) +static ssize_t lz4_filter_read_default_stream(struct archive_read_filter *, + const void **); +static ssize_t lz4_filter_read_legacy_stream(struct archive_read_filter *, + const void **); +#endif + +int +archive_read_support_filter_lz4(struct archive *_a) +{ + struct archive_read *a = (struct archive_read *)_a; + struct archive_read_filter_bidder *reader; + + archive_check_magic(_a, ARCHIVE_READ_MAGIC, + ARCHIVE_STATE_NEW, "archive_read_support_filter_lz4"); + + if (__archive_read_get_bidder(a, &reader) != ARCHIVE_OK) + return (ARCHIVE_FATAL); + + reader->data = NULL; + reader->name = "lz4"; + reader->bid = lz4_reader_bid; + reader->init = lz4_reader_init; + reader->options = NULL; + reader->free = lz4_reader_free; +#if defined(HAVE_LIBLZ4) + return (ARCHIVE_OK); +#else + archive_set_error(_a, ARCHIVE_ERRNO_MISC, + "Using external lz4 program"); + return (ARCHIVE_WARN); +#endif +} + +static int +lz4_reader_free(struct archive_read_filter_bidder *self){ + (void)self; /* UNUSED */ + return (ARCHIVE_OK); +} + +/* + * Test whether we can handle this data. + * + * This logic returns zero if any part of the signature fails. It + * also tries to Do The Right Thing if a very short buffer prevents us + * from verifying as much as we would like. + */ +static int +lz4_reader_bid(struct archive_read_filter_bidder *self, + struct archive_read_filter *filter) +{ + const unsigned char *buffer; + ssize_t avail; + int bits_checked; + uint32_t number; + + (void)self; /* UNUSED */ + + /* Minimal lz4 archive is 11 bytes. */ + buffer = __archive_read_filter_ahead(filter, 11, &avail); + if (buffer == NULL) + return (0); + + /* First four bytes must be LZ4 magic numbers. */ + bits_checked = 0; + if ((number = archive_le32dec(buffer)) == LZ4_MAGICNUMBER) { + unsigned char flag, BD; + + bits_checked += 32; + /* Next follows a stream descriptor. */ + /* Descriptor Flags. */ + flag = buffer[4]; + /* A version number must be "01". */ + if (((flag & 0xc0) >> 6) != 1) + return (0); + /* A reserved bit must be "0". */ + if (flag & 2) + return (0); + bits_checked += 8; + BD = buffer[5]; + /* A block maximum size shuld be more than 3. */ + if (((BD & 0x70) >> 4) < 4) + return (0); + /* Reserved bits must be "0". */ + if (BD & ~0x70) + return (0); + bits_checked += 8; + } else if (number == LZ4_LEGACY) { + bits_checked += 32; + } + + return (bits_checked); +} + +#if !defined(HAVE_LIBLZ4) + +/* + * If we don't have the library on this system, we can't actually do the + * decompression. We can, however, still detect compressed archives + * and emit a useful message. + */ +static int +lz4_reader_init(struct archive_read_filter *self) +{ + int r; + + r = __archive_read_program(self, "lz4 -d -q"); + /* Note: We set the format here even if __archive_read_program() + * above fails. We do, after all, know what the format is + * even if we weren't able to read it. */ + self->code = ARCHIVE_FILTER_LZ4; + self->name = "lz4"; + return (r); +} + + +#else + +/* + * Setup the callbacks. + */ +static int +lz4_reader_init(struct archive_read_filter *self) +{ + struct private_data *state; + + self->code = ARCHIVE_FILTER_LZ4; + self->name = "lz4"; + + state = (struct private_data *)calloc(sizeof(*state), 1); + if (state == NULL) { + archive_set_error(&self->archive->archive, ENOMEM, + "Can't allocate data for lz4 decompression"); + return (ARCHIVE_FATAL); + } + + self->data = state; + state->stage = SELECT_STREAM; + self->read = lz4_filter_read; + self->skip = NULL; /* not supported */ + self->close = lz4_filter_close; + + return (ARCHIVE_OK); +} + +static int +lz4_allocate_out_block(struct archive_read_filter *self) +{ + struct private_data *state = (struct private_data *)self->data; + size_t out_block_size = state->flags.block_maximum_size; + void *out_block; + + if (!state->flags.block_independence) + out_block_size += 64 * 1024; + if (state->out_block_size < out_block_size) { + free(state->out_block); + out_block = (unsigned char *)malloc(out_block_size); + state->out_block_size = out_block_size; + if (out_block == NULL) { + archive_set_error(&self->archive->archive, ENOMEM, + "Can't allocate data for lz4 decompression"); + return (ARCHIVE_FATAL); + } + state->out_block = out_block; + } + if (!state->flags.block_independence) + memset(state->out_block, 0, 64 * 1024); + return (ARCHIVE_OK); +} + +static int +lz4_allocate_out_block_for_legacy(struct archive_read_filter *self) +{ + struct private_data *state = (struct private_data *)self->data; + size_t out_block_size = LEGACY_BLOCK_SIZE; + void *out_block; + + if (state->out_block_size < out_block_size) { + free(state->out_block); + out_block = (unsigned char *)malloc(out_block_size); + state->out_block_size = out_block_size; + if (out_block == NULL) { + archive_set_error(&self->archive->archive, ENOMEM, + "Can't allocate data for lz4 decompression"); + return (ARCHIVE_FATAL); + } + state->out_block = out_block; + } + return (ARCHIVE_OK); +} + +/* + * Return the next block of decompressed data. + */ +static ssize_t +lz4_filter_read(struct archive_read_filter *self, const void **p) +{ + struct private_data *state = (struct private_data *)self->data; + ssize_t ret; + + if (state->eof) { + *p = NULL; + return (0); + } + + __archive_read_filter_consume(self->upstream, state->unconsumed); + state->unconsumed = 0; + + switch (state->stage) { + case SELECT_STREAM: + break; + case READ_DEFAULT_STREAM: + case READ_LEGACY_STREAM: + /* Reading a lz4 stream already failed. */ + archive_set_error(&self->archive->archive, + ARCHIVE_ERRNO_MISC, "Invalid sequence."); + return (ARCHIVE_FATAL); + case READ_DEFAULT_BLOCK: + ret = lz4_filter_read_default_stream(self, p); + if (ret != 0 || state->stage != SELECT_STREAM) + return ret; + break; + case READ_LEGACY_BLOCK: + ret = lz4_filter_read_legacy_stream(self, p); + if (ret != 0 || state->stage != SELECT_STREAM) + return ret; + break; + default: + archive_set_error(&self->archive->archive, + ARCHIVE_ERRNO_MISC, "Program error."); + return (ARCHIVE_FATAL); + break; + } + + while (state->stage == SELECT_STREAM) { + const char *read_buf; + + /* Read a magic number. */ + read_buf = __archive_read_filter_ahead(self->upstream, 4, + NULL); + if (read_buf == NULL) { + state->eof = 1; + *p = NULL; + return (0); + } + uint32_t number = archive_le32dec(read_buf); + __archive_read_filter_consume(self->upstream, 4); + if (number == LZ4_MAGICNUMBER) + return lz4_filter_read_default_stream(self, p); + else if (number == LZ4_LEGACY) + return lz4_filter_read_legacy_stream(self, p); + else if ((number & ~0xF) == LZ4_SKIPPABLED) { + read_buf = __archive_read_filter_ahead( + self->upstream, 4, NULL); + if (read_buf == NULL) { + archive_set_error( + &self->archive->archive, + ARCHIVE_ERRNO_MISC, + "Malformed lz4 data"); + return (ARCHIVE_FATAL); + } + uint32_t skip_bytes = archive_le32dec(read_buf); + __archive_read_filter_consume(self->upstream, + 4 + skip_bytes); + } else { + /* Ignore following unrecognized data. */ + state->eof = 1; + *p = NULL; + return (0); + } + } + state->eof = 1; + *p = NULL; + return (0); +} + +static int +lz4_filter_read_descriptor(struct archive_read_filter *self) +{ + struct private_data *state = (struct private_data *)self->data; + const char *read_buf; + ssize_t bytes_remaining; + ssize_t descriptor_bytes; + unsigned char flag, bd; + unsigned int chsum, chsum_verifier; + + /* Make sure we have 2 bytes for flags. */ + read_buf = __archive_read_filter_ahead(self->upstream, 2, + &bytes_remaining); + if (read_buf == NULL) { + archive_set_error(&self->archive->archive, + ARCHIVE_ERRNO_MISC, + "truncated lz4 input"); + return (ARCHIVE_FATAL); + } + + /* + Parse flags. + */ + flag = (unsigned char)read_buf[0]; + /* Verify version number. */ + if ((flag & 0xc0) != 1<<6) + goto malformed_error; + /* A reserved bit must be zero. */ + if (flag & 0x02) + goto malformed_error; + state->flags.block_independence = (flag & 0x20) != 0; + state->flags.block_checksum = (flag & 0x10)?4:0; + state->flags.stream_size = (flag & 0x08) != 0; + state->flags.stream_checksum = (flag & 0x04) != 0; + state->flags.preset_dictionary = (flag & 0x01) != 0; + + /* BD */ + bd = (unsigned char)read_buf[1]; + /* Reserved bits must be zero. */ + if (bd & 0x8f) + goto malformed_error; + /* Get a maxinum block size. */ + switch (read_buf[1] >> 4) { + case 4: /* 64 KB */ + state->flags.block_maximum_size = 64 * 1024; + break; + case 5: /* 256 KB */ + state->flags.block_maximum_size = 256 * 1024; + break; + case 6: /* 1 MB */ + state->flags.block_maximum_size = 1024 * 1024; + break; + case 7: /* 4 MB */ + state->flags.block_maximum_size = 4 * 1024 * 1024; + break; + default: + goto malformed_error; + } + + /* Read the whole descriptor in a stream block. */ + descriptor_bytes = 3; + if (state->flags.stream_size) + descriptor_bytes += 8; + if (state->flags.preset_dictionary) + descriptor_bytes += 4; + if (bytes_remaining < descriptor_bytes) { + read_buf = __archive_read_filter_ahead(self->upstream, + descriptor_bytes, &bytes_remaining); + if (read_buf == NULL) { + archive_set_error(&self->archive->archive, + ARCHIVE_ERRNO_MISC, + "truncated lz4 input"); + return (ARCHIVE_FATAL); + } + } + /* Check if a descriptor is corrupted */ + chsum = __archive_xxhash.XXH32(read_buf, (int)descriptor_bytes -1, 0); + chsum = (chsum >> 8) & 0xff; + chsum_verifier = read_buf[descriptor_bytes-1] & 0xff; + if (chsum != chsum_verifier) + goto malformed_error; + + __archive_read_filter_consume(self->upstream, descriptor_bytes); + + /* Make sure we have an enough buffer for uncompressed data. */ + if (lz4_allocate_out_block(self) != ARCHIVE_OK) + return (ARCHIVE_FATAL); + if (state->flags.stream_checksum) + state->xxh32_state = __archive_xxhash.XXH32_init(0); + + state->decoded_size = 0; + /* Success */ + return (ARCHIVE_OK); +malformed_error: + archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, + "malformed lz4 data"); + return (ARCHIVE_FATAL); +} + +static ssize_t +lz4_filter_read_data_block(struct archive_read_filter *self, const void **p) +{ + struct private_data *state = (struct private_data *)self->data; + ssize_t compressed_size; + const char *read_buf; + ssize_t bytes_remaining; + int checksum_size; + ssize_t uncompressed_size; + size_t prefix64k; + + *p = NULL; + + /* Make sure we have 4 bytes for a block size. */ + read_buf = __archive_read_filter_ahead(self->upstream, 4, + &bytes_remaining); + if (read_buf == NULL) + goto truncated_error; + compressed_size = archive_le32dec(read_buf); + if ((compressed_size & ~(1 << 31)) > state->flags.block_maximum_size) + goto malformed_error; + /* A compressed size == 0 means the end of stream blocks. */ + if (compressed_size == 0) { + __archive_read_filter_consume(self->upstream, 4); + return 0; + } + + checksum_size = state->flags.block_checksum; + /* Check if the block is uncompressed. */ + if (compressed_size & (1 << 31)) { + compressed_size &= ~(1 << 31); + uncompressed_size = compressed_size; + } else + uncompressed_size = 0;/* Unknown yet. */ + + /* + Unfortunately, lz4 decompression API requires a whole block + for its decompression speed, so we read a whole block and allocate + a huge buffer used for decoded data. + */ + read_buf = __archive_read_filter_ahead(self->upstream, + 4 + compressed_size + checksum_size, &bytes_remaining); + if (read_buf == NULL) + goto truncated_error; + + /* Optional process, checking a block sum. */ + if (checksum_size) { + unsigned int chsum = __archive_xxhash.XXH32( + read_buf + 4, (int)compressed_size, 0); + unsigned int chsum_block = + archive_le32dec(read_buf + 4 + compressed_size); + if (chsum != chsum_block) + goto malformed_error; + } + + + /* If the block is uncompressed, there is nothing to do. */ + if (uncompressed_size) { + /* Prepare a prefix 64k block for next block. */ + if (!state->flags.block_independence) { + prefix64k = 64 * 1024; + if (uncompressed_size < (ssize_t)prefix64k) { + memcpy(state->out_block + + prefix64k - uncompressed_size, + read_buf + 4, + uncompressed_size); + memset(state->out_block, 0, + prefix64k - uncompressed_size); + } else { + memcpy(state->out_block, + read_buf + 4 + + uncompressed_size - prefix64k, + prefix64k); + } + state->decoded_size = 0; + } + state->unconsumed = 4 + uncompressed_size + checksum_size; + *p = read_buf + 4; + return uncompressed_size; + } + + /* + Decompress a block data. + */ + if (state->flags.block_independence) { + prefix64k = 0; + uncompressed_size = LZ4_decompress_safe(read_buf + 4, + state->out_block, (int)compressed_size, + state->flags.block_maximum_size); + } else { + prefix64k = 64 * 1024; + if (state->decoded_size) { + if (state->decoded_size < prefix64k) { + memmove(state->out_block + + prefix64k - state->decoded_size, + state->out_block + prefix64k, + state->decoded_size); + memset(state->out_block, 0, + prefix64k - state->decoded_size); + } else { + memmove(state->out_block, + state->out_block + state->decoded_size, + prefix64k); + } + } + uncompressed_size = LZ4_decompress_safe_withPrefix64k( + read_buf + 4, + state->out_block + prefix64k, (int)compressed_size, + state->flags.block_maximum_size); + } + + /* Check if an error happend in decompression process. */ + if (uncompressed_size < 0) { + archive_set_error(&(self->archive->archive), + ARCHIVE_ERRNO_MISC, "lz4 decompression failed"); + return (ARCHIVE_FATAL); + } + + state->unconsumed = 4 + compressed_size + checksum_size; + *p = state->out_block + prefix64k; + state->decoded_size = uncompressed_size; + return uncompressed_size; + +malformed_error: + archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, + "malformed lz4 data"); + return (ARCHIVE_FATAL); +truncated_error: + archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, + "truncated lz4 input"); + return (ARCHIVE_FATAL); +} + +static ssize_t +lz4_filter_read_default_stream(struct archive_read_filter *self, const void **p) +{ + struct private_data *state = (struct private_data *)self->data; + const char *read_buf; + ssize_t bytes_remaining; + ssize_t ret; + + if (state->stage == SELECT_STREAM) { + state->stage = READ_DEFAULT_STREAM; + /* First, read a desciprtor. */ + if((ret = lz4_filter_read_descriptor(self)) != ARCHIVE_OK) + return (ret); + state->stage = READ_DEFAULT_BLOCK; + } + /* Decompress a block. */ + ret = lz4_filter_read_data_block(self, p); + + /* If the end of block is detected, change the filter status + to read next stream. */ + if (ret == 0 && *p == NULL) + state->stage = SELECT_STREAM; + + /* Optional process, checking a stream sum. */ + if (state->flags.stream_checksum) { + if (state->stage == SELECT_STREAM) { + unsigned int checksum; + unsigned int checksum_stream; + read_buf = __archive_read_filter_ahead(self->upstream, + 4, &bytes_remaining); + if (read_buf == NULL) { + archive_set_error(&self->archive->archive, + ARCHIVE_ERRNO_MISC, "truncated lz4 input"); + return (ARCHIVE_FATAL); + } + checksum = archive_le32dec(read_buf); + __archive_read_filter_consume(self->upstream, 4); + checksum_stream = __archive_xxhash.XXH32_digest( + state->xxh32_state); + state->xxh32_state = NULL; + if (checksum != checksum_stream) { + archive_set_error(&self->archive->archive, + ARCHIVE_ERRNO_MISC, + "lz4 stream cheksum error"); + return (ARCHIVE_FATAL); + } + } else if (ret > 0) + __archive_xxhash.XXH32_update(state->xxh32_state, + *p, (int)ret); + } + return (ret); +} + +static ssize_t +lz4_filter_read_legacy_stream(struct archive_read_filter *self, const void **p) +{ + struct private_data *state = (struct private_data *)self->data; + int compressed; + const char *read_buf; + ssize_t ret; + + *p = NULL; + ret = lz4_allocate_out_block_for_legacy(self); + if (ret != ARCHIVE_OK) + return ret; + + /* Make sure we have 4 bytes for a block size. */ + read_buf = __archive_read_filter_ahead(self->upstream, 4, NULL); + if (read_buf == NULL) { + if (state->stage == SELECT_STREAM) { + state->stage = READ_LEGACY_STREAM; + archive_set_error(&self->archive->archive, + ARCHIVE_ERRNO_MISC, + "truncated lz4 input"); + return (ARCHIVE_FATAL); + } + state->stage = SELECT_STREAM; + return 0; + } + state->stage = READ_LEGACY_BLOCK; + compressed = archive_le32dec(read_buf); + if (compressed > LZ4_COMPRESSBOUND(LEGACY_BLOCK_SIZE)) { + state->stage = SELECT_STREAM; + return 0; + } + + /* Make sure we have a whole block. */ + read_buf = __archive_read_filter_ahead(self->upstream, + 4 + compressed, NULL); + ret = LZ4_decompress_safe(read_buf + 4, state->out_block, + compressed, (int)state->out_block_size); + if (ret < 0) { + archive_set_error(&(self->archive->archive), + ARCHIVE_ERRNO_MISC, "lz4 decompression failed"); + return (ARCHIVE_FATAL); + } + *p = state->out_block; + state->unconsumed = 4 + compressed; + return ret; +} + +/* + * Clean up the decompressor. + */ +static int +lz4_filter_close(struct archive_read_filter *self) +{ + struct private_data *state; + int ret = ARCHIVE_OK; + + state = (struct private_data *)self->data; + free(state->xxh32_state); + free(state->out_block); + free(state); + return (ret); +} + +#endif /* HAVE_LIBLZ4 */ diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_lzop.c b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_lzop.c index 9ef2054..23c18c7 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_lzop.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_lzop.c @@ -242,10 +242,17 @@ consume_header(struct archive_read_filter *self) if (version >= 0x940) { unsigned level = *p++; +#if 0 unsigned default_level[] = {0, 3, 1, 9}; +#endif if (level == 0) /* Method is 1..3 here due to check above. */ +#if 0 /* Avoid an error Clang Static Analyzer claims + "Value stored to 'level' is never read". */ level = default_level[method]; +#else + ;/* NOP */ +#endif else if (level > 9) { archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, "Invalid level"); diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_uu.c b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_uu.c index 471771b..787a619 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_uu.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_uu.c @@ -509,7 +509,7 @@ read_more: return (ARCHIVE_FATAL); } llen = len; - if (nl == 0) { + if ((nl == 0) && (uudecode->state != ST_UUEND)) { /* * Save remaining data which does not contain * NL('\n','\r'). @@ -527,6 +527,7 @@ read_more: self->upstream, ravail); goto read_more; } + used += len; break; } switch (uudecode->state) { diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_xz.c b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_xz.c index a3ad67a..8f48273 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_filter_xz.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_filter_xz.c @@ -627,7 +627,7 @@ lzip_tail(struct archive_read_filter *self) f = __archive_read_filter_ahead(self->upstream, tail, &avail_in); if (f == NULL && avail_in < 0) return (ARCHIVE_FATAL); - if (avail_in < tail) { + if (f == NULL || avail_in < tail) { archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, "Lzip: Remaining data is less bytes"); return (ARCHIVE_FAILED); diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c index 47e0752..f045b8f 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c @@ -108,6 +108,7 @@ __FBSDID("$FreeBSD$"); #define kMTime 0x14 #define kAttributes 0x15 #define kEncodedHeader 0x17 +#define kDummy 0x19 struct _7z_digests { unsigned char *defineds; @@ -331,6 +332,11 @@ struct _7zip { int has_encrypted_entries; }; +/* Maximum entry size. This limitation prevents reading intentional + * corrupted 7-zip files on assuming there are not so many entries in + * the files. */ +#define UMAX_ENTRY ARCHIVE_LITERAL_ULL(100000000) + static int archive_read_format_7zip_has_encrypted_entries(struct archive_read *); static int archive_read_support_format_7zip_capabilities(struct archive_read *a); static int archive_read_format_7zip_bid(struct archive_read *, int); @@ -640,7 +646,7 @@ archive_read_format_7zip_read_header(struct archive_read *a, } zip_entry = zip->entry; - if (zip->entries_remaining <= 0) + if (zip->entries_remaining <= 0 || zip_entry == NULL) return ARCHIVE_EOF; --zip->entries_remaining; @@ -1663,7 +1669,7 @@ parse_7zip_uint64(struct archive_read *a, uint64_t *val) mask >>= 1; continue; } - *val += (avail & (mask -1)) << (8 * i); + *val += ((uint64_t)(avail & (mask -1))) << (8 * i); break; } return (0); @@ -1763,7 +1769,7 @@ read_PackInfo(struct archive_read *a, struct _7z_pack_info *pi) return (-1); if (pi->numPackStreams == 0) return (-1); - if (1000000 < pi->numPackStreams) + if (UMAX_ENTRY < pi->numPackStreams) return (-1); /* @@ -1892,12 +1898,12 @@ read_Folder(struct archive_read *a, struct _7z_folder *f) if (parse_7zip_uint64( a, &(f->coders[i].numInStreams)) < 0) return (-1); - if (1000000 < f->coders[i].numInStreams) + if (UMAX_ENTRY < f->coders[i].numInStreams) return (-1); if (parse_7zip_uint64( a, &(f->coders[i].numOutStreams)) < 0) return (-1); - if (1000000 < f->coders[i].numOutStreams) + if (UMAX_ENTRY < f->coders[i].numOutStreams) return (-1); } @@ -1937,11 +1943,11 @@ read_Folder(struct archive_read *a, struct _7z_folder *f) for (i = 0; i < f->numBindPairs; i++) { if (parse_7zip_uint64(a, &(f->bindPairs[i].inIndex)) < 0) return (-1); - if (1000000 < f->bindPairs[i].inIndex) + if (UMAX_ENTRY < f->bindPairs[i].inIndex) return (-1); if (parse_7zip_uint64(a, &(f->bindPairs[i].outIndex)) < 0) return (-1); - if (1000000 < f->bindPairs[i].outIndex) + if (UMAX_ENTRY < f->bindPairs[i].outIndex) return (-1); } @@ -1967,7 +1973,7 @@ read_Folder(struct archive_read *a, struct _7z_folder *f) for (i = 0; i < f->numPackedStreams; i++) { if (parse_7zip_uint64(a, &(f->packedStreams[i])) < 0) return (-1); - if (1000000 < f->packedStreams[i]) + if (UMAX_ENTRY < f->packedStreams[i]) return (-1); } } @@ -2009,8 +2015,8 @@ read_CodersInfo(struct archive_read *a, struct _7z_coders_info *ci) */ if (parse_7zip_uint64(a, &(ci->numFolders)) < 0) goto failed; - if (1000000 < ci->numFolders) - return (-1); + if (UMAX_ENTRY < ci->numFolders) + return (-1); /* * Read External. @@ -2031,9 +2037,18 @@ read_CodersInfo(struct archive_read *a, struct _7z_coders_info *ci) case 1: if (parse_7zip_uint64(a, &(ci->dataStreamIndex)) < 0) return (-1); - if (1000000 < ci->dataStreamIndex) + if (UMAX_ENTRY < ci->dataStreamIndex) return (-1); + if (ci->numFolders > 0) { + archive_set_error(&a->archive, -1, + "Malformed 7-Zip archive"); + goto failed; + } break; + default: + archive_set_error(&a->archive, -1, + "Malformed 7-Zip archive"); + goto failed; } if ((p = header_bytes(a, 1)) == NULL) @@ -2136,7 +2151,7 @@ read_SubStreamsInfo(struct archive_read *a, struct _7z_substream_info *ss, for (i = 0; i < numFolders; i++) { if (parse_7zip_uint64(a, &(f[i].numUnpackStreams)) < 0) return (-1); - if (1000000 < f[i].numUnpackStreams) + if (UMAX_ENTRY < f[i].numUnpackStreams) return (-1); unpack_streams += (size_t)f[i].numUnpackStreams; } @@ -2385,8 +2400,8 @@ read_Header(struct archive_read *a, struct _7z_header_info *h, if (parse_7zip_uint64(a, &(zip->numFiles)) < 0) return (-1); - if (1000000 < zip->numFiles) - return (-1); + if (UMAX_ENTRY < zip->numFiles) + return (-1); zip->entries = calloc((size_t)zip->numFiles, sizeof(*zip->entries)); if (zip->entries == NULL) @@ -2545,6 +2560,9 @@ read_Header(struct archive_read *a, struct _7z_header_info *h, } break; } + case kDummy: + if (ll == 0) + break; default: if (header_bytes(a, ll) == NULL) return (-1); @@ -2684,7 +2702,7 @@ read_Times(struct archive_read *a, struct _7z_header_info *h, int type) if (*p) { if (parse_7zip_uint64(a, &(h->dataIndex)) < 0) goto failed; - if (1000000 < h->dataIndex) + if (UMAX_ENTRY < h->dataIndex) goto failed; } diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_all.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_all.c index 53fe6fa..2127ebd3 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_all.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_all.c @@ -61,6 +61,7 @@ archive_read_support_format_all(struct archive *a) archive_read_support_format_mtree(a); archive_read_support_format_tar(a); archive_read_support_format_xar(a); + archive_read_support_format_warc(a); /* * Install expensive bidders last. By doing them last, we diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_ar.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_ar.c index 82756c9..4b5b66b 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_ar.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_ar.c @@ -180,7 +180,7 @@ _ar_read_header(struct archive_read *a, struct archive_entry *entry, if (strncmp(h + AR_fmag_offset, "`\n", 2) != 0) { archive_set_error(&a->archive, EINVAL, "Incorrect file header signature"); - return (ARCHIVE_WARN); + return (ARCHIVE_FATAL); } /* Copy filename into work buffer. */ @@ -239,8 +239,15 @@ _ar_read_header(struct archive_read *a, struct archive_entry *entry, * and are not terminated in '/', so we don't trim anything * that starts with '/'.) */ - if (filename[0] != '/' && *p == '/') + if (filename[0] != '/' && p > filename && *p == '/') { *p = '\0'; + } + + if (p < filename) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Found entry with empty filename"); + return (ARCHIVE_FATAL); + } /* * '//' is the GNU filename table. @@ -262,12 +269,12 @@ _ar_read_header(struct archive_read *a, struct archive_entry *entry, if (entry_size == 0) { archive_set_error(&a->archive, EINVAL, "Invalid string table"); - return (ARCHIVE_WARN); + return (ARCHIVE_FATAL); } if (ar->strtab != NULL) { archive_set_error(&a->archive, EINVAL, "More than one string tables exist"); - return (ARCHIVE_WARN); + return (ARCHIVE_FATAL); } /* Read the filename table into memory. */ @@ -311,11 +318,11 @@ _ar_read_header(struct archive_read *a, struct archive_entry *entry, */ if (ar->strtab == NULL || number > ar->strtab_size) { archive_set_error(&a->archive, EINVAL, - "Can't find long filename for entry"); + "Can't find long filename for GNU/SVR4 archive entry"); archive_entry_copy_pathname(entry, filename); /* Parse the time, owner, mode, size fields. */ ar_parse_common_header(ar, entry, h); - return (ARCHIVE_WARN); + return (ARCHIVE_FATAL); } archive_entry_copy_pathname(entry, &ar->strtab[(size_t)number]); @@ -573,7 +580,7 @@ bad_string_table: "Invalid string table"); free(ar->strtab); ar->strtab = NULL; - return (ARCHIVE_WARN); + return (ARCHIVE_FATAL); } static uint64_t diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_cpio.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_cpio.c index 0b69689..c2ca85b 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_cpio.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_cpio.c @@ -198,7 +198,7 @@ static int archive_read_format_cpio_read_data(struct archive_read *, static int archive_read_format_cpio_read_header(struct archive_read *, struct archive_entry *); static int archive_read_format_cpio_skip(struct archive_read *); -static int be4(const unsigned char *); +static int64_t be4(const unsigned char *); static int find_odc_header(struct archive_read *); static int find_newc_header(struct archive_read *); static int header_bin_be(struct archive_read *, struct cpio *, @@ -213,7 +213,7 @@ static int header_afiol(struct archive_read *, struct cpio *, struct archive_entry *, size_t *, size_t *); static int is_octal(const char *, size_t); static int is_hex(const char *, size_t); -static int le4(const unsigned char *); +static int64_t le4(const unsigned char *); static int record_hardlink(struct archive_read *a, struct cpio *cpio, struct archive_entry *entry); @@ -866,8 +866,11 @@ header_bin_le(struct archive_read *a, struct cpio *cpio, /* Read fixed-size portion of header. */ h = __archive_read_ahead(a, bin_header_size, NULL); - if (h == NULL) + if (h == NULL) { + archive_set_error(&a->archive, 0, + "End of file trying to read next cpio header"); return (ARCHIVE_FATAL); + } /* Parse out binary fields. */ header = (const unsigned char *)h; @@ -902,8 +905,11 @@ header_bin_be(struct archive_read *a, struct cpio *cpio, /* Read fixed-size portion of header. */ h = __archive_read_ahead(a, bin_header_size, NULL); - if (h == NULL) + if (h == NULL) { + archive_set_error(&a->archive, 0, + "End of file trying to read next cpio header"); return (ARCHIVE_FATAL); + } /* Parse out binary fields. */ header = (const unsigned char *)h; @@ -946,17 +952,17 @@ archive_read_format_cpio_cleanup(struct archive_read *a) return (ARCHIVE_OK); } -static int +static int64_t le4(const unsigned char *p) { - return ((p[0]<<16) + (p[1]<<24) + (p[2]<<0) + (p[3]<<8)); + return ((p[0] << 16) + (((int64_t)p[1]) << 24) + (p[2] << 0) + (p[3] << 8)); } -static int +static int64_t be4(const unsigned char *p) { - return ((p[0]<<24) + (p[1]<<16) + (p[2]<<8) + (p[3])); + return ((((int64_t)p[0]) << 24) + (p[1] << 16) + (p[2] << 8) + (p[3])); } /* diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c index 2219e61..3628025 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c @@ -387,7 +387,7 @@ static int archive_read_format_iso9660_read_data(struct archive_read *, static int archive_read_format_iso9660_read_data_skip(struct archive_read *); static int archive_read_format_iso9660_read_header(struct archive_read *, struct archive_entry *); -static const char *build_pathname(struct archive_string *, struct file_info *); +static const char *build_pathname(struct archive_string *, struct file_info *, int); static int build_pathname_utf16be(unsigned char *, size_t, size_t *, struct file_info *); #if DEBUG @@ -1225,6 +1225,7 @@ archive_read_format_iso9660_read_header(struct archive_read *a, archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, "Pathname is too long"); + return (ARCHIVE_FATAL); } r = archive_entry_copy_pathname_l(entry, @@ -1247,9 +1248,16 @@ archive_read_format_iso9660_read_header(struct archive_read *a, rd_r = ARCHIVE_WARN; } } else { - archive_string_empty(&iso9660->pathname); - archive_entry_set_pathname(entry, - build_pathname(&iso9660->pathname, file)); + const char *path = build_pathname(&iso9660->pathname, file, 0); + if (path == NULL) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, + "Pathname is too long"); + return (ARCHIVE_FATAL); + } else { + archive_string_empty(&iso9660->pathname); + archive_entry_set_pathname(entry, path); + } } iso9660->entry_bytes_remaining = file->size; @@ -1744,12 +1752,12 @@ parse_file_info(struct archive_read *a, struct file_info *parent, const unsigned char *isodirrec) { struct iso9660 *iso9660; - struct file_info *file; + struct file_info *file, *filep; size_t name_len; const unsigned char *rr_start, *rr_end; const unsigned char *p; size_t dr_len; - uint64_t fsize; + uint64_t fsize, offset; int32_t location; int flags; @@ -1793,6 +1801,16 @@ parse_file_info(struct archive_read *a, struct file_info *parent, return (NULL); } + /* Sanity check that this entry does not create a cycle. */ + offset = iso9660->logical_block_size * (uint64_t)location; + for (filep = parent; filep != NULL; filep = filep->parent) { + if (filep->offset == offset) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Directory structure contains loop"); + return (NULL); + } + } + /* Create a new file entry and copy data from the ISO dir record. */ file = (struct file_info *)calloc(1, sizeof(*file)); if (file == NULL) { @@ -1801,7 +1819,7 @@ parse_file_info(struct archive_read *a, struct file_info *parent, return (NULL); } file->parent = parent; - file->offset = iso9660->logical_block_size * (uint64_t)location; + file->offset = offset; file->size = fsize; file->mtime = isodate7(isodirrec + DR_date_offset); file->ctime = file->atime = file->mtime; @@ -3147,29 +3165,39 @@ static time_t time_from_tm(struct tm *t) { #if HAVE_TIMEGM - /* Use platform timegm() if available. */ - return (timegm(t)); + /* Use platform timegm() if available. */ + return (timegm(t)); #elif HAVE__MKGMTIME64 - return (_mkgmtime64(t)); + return (_mkgmtime64(t)); #else - /* Else use direct calculation using POSIX assumptions. */ - /* First, fix up tm_yday based on the year/month/day. */ - if (mktime(t) == (time_t)-1) - return ((time_t)-1); - /* Then we can compute timegm() from first principles. */ - return (t->tm_sec + t->tm_min * 60 + t->tm_hour * 3600 - + t->tm_yday * 86400 + (t->tm_year - 70) * 31536000 - + ((t->tm_year - 69) / 4) * 86400 - - ((t->tm_year - 1) / 100) * 86400 - + ((t->tm_year + 299) / 400) * 86400); + /* Else use direct calculation using POSIX assumptions. */ + /* First, fix up tm_yday based on the year/month/day. */ + if (mktime(t) == (time_t)-1) + return ((time_t)-1); + /* Then we can compute timegm() from first principles. */ + return (t->tm_sec + + t->tm_min * 60 + + t->tm_hour * 3600 + + t->tm_yday * 86400 + + (t->tm_year - 70) * 31536000 + + ((t->tm_year - 69) / 4) * 86400 + - ((t->tm_year - 1) / 100) * 86400 + + ((t->tm_year + 299) / 400) * 86400); #endif } static const char * -build_pathname(struct archive_string *as, struct file_info *file) +build_pathname(struct archive_string *as, struct file_info *file, int depth) { + // Plain ISO9660 only allows 8 dir levels; if we get + // to 1000, then something is very, very wrong. + if (depth > 1000) { + return NULL; + } if (file->parent != NULL && archive_strlen(&file->parent->name) > 0) { - build_pathname(as, file->parent); + if (build_pathname(as, file->parent, depth + 1) == NULL) { + return NULL; + } archive_strcat(as, "/"); } if (archive_strlen(&file->name) == 0) diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c index b88731a..eff02d8 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2008-2012 Michihiro NAKAJIMA + * Copyright (c) 2008-2014 Michihiro NAKAJIMA * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -82,9 +82,6 @@ struct lzh_dec { /* The length how many bytes we can copy decoded code from * the window. */ int copy_len; - /* The remaining bytes that we have not copied decoded data from - * the window to an output buffer. */ - int w_remaining; /* * Bit stream reader. @@ -140,10 +137,10 @@ struct lzh_dec { struct lzh_stream { const unsigned char *next_in; - int64_t avail_in; + int avail_in; int64_t total_in; - unsigned char *next_out; - int64_t avail_out; + const unsigned char *ref_ptr; + int avail_out; int64_t total_out; struct lzh_dec *ds; }; @@ -198,9 +195,6 @@ struct lha { char end_of_entry_cleanup; char entry_is_compressed; - unsigned char *uncompressed_buffer; - size_t uncompressed_buffer_size; - char format_name[64]; struct lzh_stream strm; @@ -214,41 +208,6 @@ struct lha { #define H_LEVEL_OFFSET 20 /* Header Level. */ #define H_SIZE 22 /* Minimum header size. */ -static const uint16_t crc16tbl[256] = { - 0x0000,0xC0C1,0xC181,0x0140,0xC301,0x03C0,0x0280,0xC241, - 0xC601,0x06C0,0x0780,0xC741,0x0500,0xC5C1,0xC481,0x0440, - 0xCC01,0x0CC0,0x0D80,0xCD41,0x0F00,0xCFC1,0xCE81,0x0E40, - 0x0A00,0xCAC1,0xCB81,0x0B40,0xC901,0x09C0,0x0880,0xC841, - 0xD801,0x18C0,0x1980,0xD941,0x1B00,0xDBC1,0xDA81,0x1A40, - 0x1E00,0xDEC1,0xDF81,0x1F40,0xDD01,0x1DC0,0x1C80,0xDC41, - 0x1400,0xD4C1,0xD581,0x1540,0xD701,0x17C0,0x1680,0xD641, - 0xD201,0x12C0,0x1380,0xD341,0x1100,0xD1C1,0xD081,0x1040, - 0xF001,0x30C0,0x3180,0xF141,0x3300,0xF3C1,0xF281,0x3240, - 0x3600,0xF6C1,0xF781,0x3740,0xF501,0x35C0,0x3480,0xF441, - 0x3C00,0xFCC1,0xFD81,0x3D40,0xFF01,0x3FC0,0x3E80,0xFE41, - 0xFA01,0x3AC0,0x3B80,0xFB41,0x3900,0xF9C1,0xF881,0x3840, - 0x2800,0xE8C1,0xE981,0x2940,0xEB01,0x2BC0,0x2A80,0xEA41, - 0xEE01,0x2EC0,0x2F80,0xEF41,0x2D00,0xEDC1,0xEC81,0x2C40, - 0xE401,0x24C0,0x2580,0xE541,0x2700,0xE7C1,0xE681,0x2640, - 0x2200,0xE2C1,0xE381,0x2340,0xE101,0x21C0,0x2080,0xE041, - 0xA001,0x60C0,0x6180,0xA141,0x6300,0xA3C1,0xA281,0x6240, - 0x6600,0xA6C1,0xA781,0x6740,0xA501,0x65C0,0x6480,0xA441, - 0x6C00,0xACC1,0xAD81,0x6D40,0xAF01,0x6FC0,0x6E80,0xAE41, - 0xAA01,0x6AC0,0x6B80,0xAB41,0x6900,0xA9C1,0xA881,0x6840, - 0x7800,0xB8C1,0xB981,0x7940,0xBB01,0x7BC0,0x7A80,0xBA41, - 0xBE01,0x7EC0,0x7F80,0xBF41,0x7D00,0xBDC1,0xBC81,0x7C40, - 0xB401,0x74C0,0x7580,0xB541,0x7700,0xB7C1,0xB681,0x7640, - 0x7200,0xB2C1,0xB381,0x7340,0xB101,0x71C0,0x7080,0xB041, - 0x5000,0x90C1,0x9181,0x5140,0x9301,0x53C0,0x5280,0x9241, - 0x9601,0x56C0,0x5780,0x9741,0x5500,0x95C1,0x9481,0x5440, - 0x9C01,0x5CC0,0x5D80,0x9D41,0x5F00,0x9FC1,0x9E81,0x5E40, - 0x5A00,0x9AC1,0x9B81,0x5B40,0x9901,0x59C0,0x5880,0x9841, - 0x8801,0x48C0,0x4980,0x8941,0x4B00,0x8BC1,0x8A81,0x4A40, - 0x4E00,0x8EC1,0x8F81,0x4F40,0x8D01,0x4DC0,0x4C80,0x8C41, - 0x4400,0x84C1,0x8581,0x4540,0x8701,0x47C0,0x4680,0x8641, - 0x8201,0x42C0,0x4380,0x8341,0x4100,0x81C1,0x8081,0x4040 -}; - static int archive_read_format_lha_bid(struct archive_read *, int); static int archive_read_format_lha_options(struct archive_read *, const char *, const char *); @@ -279,6 +238,7 @@ static int lha_read_data_none(struct archive_read *, const void **, size_t *, int64_t *); static int lha_read_data_lzh(struct archive_read *, const void **, size_t *, int64_t *); +static void lha_crc16_init(void); static uint16_t lha_crc16(uint16_t, const void *, size_t); static int lzh_decode_init(struct lzh_stream *, const char *); static void lzh_decode_free(struct lzh_stream *); @@ -520,6 +480,8 @@ archive_read_format_lha_read_header(struct archive_read *a, const char *signature; int err; + lha_crc16_init(); + a->archive.archive_format = ARCHIVE_FORMAT_LHA; if (a->archive.archive_format_name == NULL) a->archive.archive_format_name = "lha"; @@ -1232,13 +1194,15 @@ lha_read_file_extended_header(struct archive_read *a, struct lha *lha, archive_string_empty(&lha->filename); break; } + if (extdheader[0] == '\0') + goto invalid; archive_strncpy(&lha->filename, (const char *)extdheader, datasize); break; case EXT_DIRECTORY: - if (datasize == 0) + if (datasize == 0 || extdheader[0] == '\0') /* no directory name data. exit this case. */ - break; + goto invalid; archive_strncpy(&lha->dirname, (const char *)extdheader, datasize); @@ -1378,6 +1342,26 @@ invalid: } static int +lha_end_of_entry(struct archive_read *a) +{ + struct lha *lha = (struct lha *)(a->format->data); + int r = ARCHIVE_EOF; + + if (!lha->end_of_entry_cleanup) { + if ((lha->setflag & CRC_IS_SET) && + lha->crc != lha->entry_crc_calculated) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "LHa data CRC error"); + r = ARCHIVE_WARN; + } + + /* End-of-entry cleanup done. */ + lha->end_of_entry_cleanup = 1; + } + return (r); +} + +static int archive_read_format_lha_read_data(struct archive_read *a, const void **buff, size_t *size, int64_t *offset) { @@ -1390,22 +1374,10 @@ archive_read_format_lha_read_data(struct archive_read *a, lha->entry_unconsumed = 0; } if (lha->end_of_entry) { - if (!lha->end_of_entry_cleanup) { - if ((lha->setflag & CRC_IS_SET) && - lha->crc != lha->entry_crc_calculated) { - archive_set_error(&a->archive, - ARCHIVE_ERRNO_MISC, - "LHa data CRC error"); - return (ARCHIVE_WARN); - } - - /* End-of-entry cleanup done. */ - lha->end_of_entry_cleanup = 1; - } *offset = lha->entry_offset; *size = 0; *buff = NULL; - return (ARCHIVE_EOF); + return (lha_end_of_entry(a)); } if (lha->entry_is_compressed) @@ -1477,18 +1449,6 @@ lha_read_data_lzh(struct archive_read *a, const void **buff, ssize_t bytes_avail; int r; - /* If the buffer hasn't been allocated, allocate it now. */ - if (lha->uncompressed_buffer == NULL) { - lha->uncompressed_buffer_size = 64 * 1024; - lha->uncompressed_buffer - = (unsigned char *)malloc(lha->uncompressed_buffer_size); - if (lha->uncompressed_buffer == NULL) { - archive_set_error(&a->archive, ENOMEM, - "No memory for lzh decompression"); - return (ARCHIVE_FATAL); - } - } - /* If we haven't yet read any data, initialize the decompressor. */ if (!lha->decompress_init) { r = lzh_decode_init(&(lha->strm), lha->method); @@ -1534,12 +1494,9 @@ lha_read_data_lzh(struct archive_read *a, const void **buff, if (bytes_avail > lha->entry_bytes_remaining) bytes_avail = (ssize_t)lha->entry_bytes_remaining; - lha->strm.avail_in = bytes_avail; + lha->strm.avail_in = (int)bytes_avail; lha->strm.total_in = 0; - if (lha->strm.avail_out == 0) { - lha->strm.next_out = lha->uncompressed_buffer; - lha->strm.avail_out = lha->uncompressed_buffer_size; - } + lha->strm.avail_out = 0; r = lzh_decode(&(lha->strm), bytes_avail == lha->entry_bytes_remaining); switch (r) { @@ -1556,10 +1513,10 @@ lha_read_data_lzh(struct archive_read *a, const void **buff, lha->entry_unconsumed = lha->strm.total_in; lha->entry_bytes_remaining -= lha->strm.total_in; - if (lha->strm.avail_out == 0 || lha->end_of_entry) { + if (lha->strm.avail_out) { *offset = lha->entry_offset; - *size = lha->strm.next_out - lha->uncompressed_buffer; - *buff = lha->uncompressed_buffer; + *size = lha->strm.avail_out; + *buff = lha->strm.ref_ptr; lha->entry_crc_calculated = lha_crc16(lha->entry_crc_calculated, *buff, *size); lha->entry_offset += *size; @@ -1567,6 +1524,8 @@ lha_read_data_lzh(struct archive_read *a, const void **buff, *offset = lha->entry_offset; *size = 0; *buff = NULL; + if (lha->end_of_entry) + return (lha_end_of_entry(a)); } return (ARCHIVE_OK); } @@ -1611,7 +1570,6 @@ archive_read_format_lha_cleanup(struct archive_read *a) struct lha *lha = (struct lha *)(a->format->data); lzh_decode_free(&(lha->strm)); - free(lha->uncompressed_buffer); archive_string_free(&(lha->dirname)); archive_string_free(&(lha->filename)); archive_string_free(&(lha->uname)); @@ -1702,50 +1660,90 @@ lha_calcsum(unsigned char sum, const void *pp, int offset, size_t size) return (sum); } -#define CRC16(crc, v) do { \ - (crc) = crc16tbl[((crc) ^ v) & 0xFF] ^ ((crc) >> 8); \ -} while (0) +static uint16_t crc16tbl[2][256]; +static void +lha_crc16_init(void) +{ + unsigned int i; + static int crc16init = 0; + + if (crc16init) + return; + crc16init = 1; + + for (i = 0; i < 256; i++) { + unsigned int j; + uint16_t crc = (uint16_t)i; + for (j = 8; j; j--) + crc = (crc >> 1) ^ ((crc & 1) * 0xA001); + crc16tbl[0][i] = crc; + } + + for (i = 0; i < 256; i++) { + crc16tbl[1][i] = (crc16tbl[0][i] >> 8) + ^ crc16tbl[0][crc16tbl[0][i] & 0xff]; + } +} static uint16_t lha_crc16(uint16_t crc, const void *pp, size_t len) { - const unsigned char *buff = (const unsigned char *)pp; - - while (len >= 8) { - CRC16(crc, *buff++); CRC16(crc, *buff++); - CRC16(crc, *buff++); CRC16(crc, *buff++); - CRC16(crc, *buff++); CRC16(crc, *buff++); - CRC16(crc, *buff++); CRC16(crc, *buff++); - len -= 8; + const unsigned char *p = (const unsigned char *)pp; + const uint16_t *buff; + const union { + uint32_t i; + char c[4]; + } u = { 0x01020304 }; + + if (len == 0) + return crc; + + /* Process unaligned address. */ + if (((uintptr_t)p) & (uintptr_t)0x1) { + crc = (crc >> 8) ^ crc16tbl[0][(crc ^ *p++) & 0xff]; + len--; } - switch (len) { - case 7: - CRC16(crc, *buff++); - /* FALL THROUGH */ - case 6: - CRC16(crc, *buff++); - /* FALL THROUGH */ - case 5: - CRC16(crc, *buff++); - /* FALL THROUGH */ - case 4: - CRC16(crc, *buff++); - /* FALL THROUGH */ - case 3: - CRC16(crc, *buff++); - /* FALL THROUGH */ - case 2: - CRC16(crc, *buff++); - /* FALL THROUGH */ - case 1: - CRC16(crc, *buff); - /* FALL THROUGH */ - case 0: - break; + buff = (const uint16_t *)p; + /* + * Modern C compiler such as GCC does not unroll automatically yet + * without unrolling pragma, and Clang is so. So we should + * unroll this loop for its performance. + */ + for (;len >= 8; len -= 8) { + /* This if statement expects compiler optimization will + * remove the stament which will not be executed. */ +#ifndef __has_builtin +# define __has_builtin(x) 0 +#endif +#if defined(_MSC_VER) && _MSC_VER >= 1400 /* Visual Studio */ +# define bswap16(x) _byteswap_ushort(x) +#elif (defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 8) \ + || (defined(__clang__) && __has_builtin(__builtin_bswap16)) +# define bswap16(x) __builtin_bswap16(x) +#else +# define bswap16(x) ((((x) >> 8) & 0xff) | ((x) << 8)) +#endif +#define CRC16W do { \ + if(u.c[0] == 1) { /* Big endian */ \ + crc ^= bswap16(*buff); buff++; \ + } else \ + crc ^= *buff++; \ + crc = crc16tbl[1][crc & 0xff] ^ crc16tbl[0][crc >> 8];\ +} while (0) + CRC16W; + CRC16W; + CRC16W; + CRC16W; +#undef CRC16W +#undef bswap16 } - return (crc); -} + p = (const unsigned char *)buff; + for (;len; len--) { + crc = (crc >> 8) ^ crc16tbl[0][(crc ^ *p++) & 0xff]; + } + return crc; +} /* * Initialize LZHUF decoder. @@ -1784,18 +1782,18 @@ lzh_decode_init(struct lzh_stream *strm, const char *method) return (ARCHIVE_FAILED);/* Not supported. */ } ds->error = ARCHIVE_FATAL; - w_size = ds->w_size; - ds->w_size = 1U << w_bits; + /* Expand a window size up to 128 KiB for decompressing process + * performance whatever its original window size is. */ + ds->w_size = 1U << 17; ds->w_mask = ds->w_size -1; - if (ds->w_buff == NULL || w_size != ds->w_size) { - free(ds->w_buff); + if (ds->w_buff == NULL) { ds->w_buff = malloc(ds->w_size); if (ds->w_buff == NULL) return (ARCHIVE_FATAL); } - memset(ds->w_buff, 0x20, ds->w_size); + w_size = 1U << w_bits; + memset(ds->w_buff + ds->w_size - w_size, 0x20, w_size); ds->w_pos = 0; - ds->w_remaining = 0; ds->state = 0; ds->pos_pt_len_size = w_bits + 1; ds->pos_pt_len_bits = (w_bits == 15 || w_bits == 16)? 5: 4; @@ -1882,9 +1880,10 @@ lzh_br_fillup(struct lzh_stream *strm, struct lzh_br *br) int n = CACHE_BITS - br->cache_avail; for (;;) { - switch (n >> 3) { - case 8: - if (strm->avail_in >= 8) { + const int x = n >> 3; + if (strm->avail_in >= x) { + switch (x) { + case 8: br->cache_buffer = ((uint64_t)strm->next_in[0]) << 56 | ((uint64_t)strm->next_in[1]) << 48 | @@ -1898,10 +1897,7 @@ lzh_br_fillup(struct lzh_stream *strm, struct lzh_br *br) strm->avail_in -= 8; br->cache_avail += 8 * 8; return (1); - } - break; - case 7: - if (strm->avail_in >= 7) { + case 7: br->cache_buffer = (br->cache_buffer << 56) | ((uint64_t)strm->next_in[0]) << 48 | @@ -1915,10 +1911,7 @@ lzh_br_fillup(struct lzh_stream *strm, struct lzh_br *br) strm->avail_in -= 7; br->cache_avail += 7 * 8; return (1); - } - break; - case 6: - if (strm->avail_in >= 6) { + case 6: br->cache_buffer = (br->cache_buffer << 48) | ((uint64_t)strm->next_in[0]) << 40 | @@ -1931,14 +1924,13 @@ lzh_br_fillup(struct lzh_stream *strm, struct lzh_br *br) strm->avail_in -= 6; br->cache_avail += 6 * 8; return (1); + case 0: + /* We have enough compressed data in + * the cache buffer.*/ + return (1); + default: + break; } - break; - case 0: - /* We have enough compressed data in - * the cache buffer.*/ - return (1); - default: - break; } if (strm->avail_in == 0) { /* There is not enough compressed data to fill up the @@ -1993,7 +1985,7 @@ static int lzh_decode(struct lzh_stream *strm, int last) { struct lzh_dec *ds = strm->ds; - int64_t avail_in; + int avail_in; int r; if (ds->error) @@ -2010,35 +2002,12 @@ lzh_decode(struct lzh_stream *strm, int last) return (r); } -static int -lzh_copy_from_window(struct lzh_stream *strm, struct lzh_dec *ds) +static void +lzh_emit_window(struct lzh_stream *strm, size_t s) { - size_t copy_bytes; - - if (ds->w_remaining == 0 && ds->w_pos > 0) { - if (ds->w_pos - ds->copy_pos <= strm->avail_out) - copy_bytes = ds->w_pos - ds->copy_pos; - else - copy_bytes = (size_t)strm->avail_out; - memcpy(strm->next_out, - ds->w_buff + ds->copy_pos, copy_bytes); - ds->copy_pos += (int)copy_bytes; - } else { - if (ds->w_remaining <= strm->avail_out) - copy_bytes = ds->w_remaining; - else - copy_bytes = (size_t)strm->avail_out; - memcpy(strm->next_out, - ds->w_buff + ds->w_size - ds->w_remaining, copy_bytes); - ds->w_remaining -= (int)copy_bytes; - } - strm->next_out += copy_bytes; - strm->avail_out -= copy_bytes; - strm->total_out += copy_bytes; - if (strm->avail_out == 0) - return (0); - else - return (1); + strm->ref_ptr = strm->ds->w_buff; + strm->avail_out = (int)s; + strm->total_out += s; } static int @@ -2073,8 +2042,9 @@ lzh_read_blocks(struct lzh_stream *strm, int last) goto failed; } if (ds->w_pos > 0) { - if (!lzh_copy_from_window(strm, ds)) - return (ARCHIVE_OK); + lzh_emit_window(strm, ds->w_pos); + ds->w_pos = 0; + return (ARCHIVE_OK); } /* End of compressed data; we have completely * handled all compressed data. */ @@ -2291,10 +2261,6 @@ lzh_decode_blocks(struct lzh_stream *strm, int last) int lt_max_bits = lt->max_bits, pt_max_bits = pt->max_bits; int state = ds->state; - if (ds->w_remaining > 0) { - if (!lzh_copy_from_window(strm, ds)) - goto next_data; - } for (;;) { switch (state) { case ST_GET_LITERAL: @@ -2349,9 +2315,8 @@ lzh_decode_blocks(struct lzh_stream *strm, int last) w_buff[w_pos] = c; if (++w_pos >= w_size) { w_pos = 0; - ds->w_remaining = w_size; - if (!lzh_copy_from_window(strm, ds)) - goto next_data; + lzh_emit_window(strm, w_size); + goto next_data; } } /* 'c' is the length of a match pattern we have @@ -2429,25 +2394,26 @@ lzh_decode_blocks(struct lzh_stream *strm, int last) d = w_buff + w_pos; s = w_buff + copy_pos; - for (li = 0; li < l; li++) + for (li = 0; li < l-1;) { + d[li] = s[li];li++; + d[li] = s[li];li++; + } + if (li < l) d[li] = s[li]; } - w_pos = (w_pos + l) & w_mask; - if (w_pos == 0) { - ds->w_remaining = w_size; - if (!lzh_copy_from_window(strm, ds)) { - if (copy_len <= l) - state = ST_GET_LITERAL; - else { - state = ST_COPY_DATA; - ds->copy_len = - copy_len - l; - ds->copy_pos = - (copy_pos + l) - & w_mask; - } - goto next_data; + w_pos += l; + if (w_pos == w_size) { + w_pos = 0; + lzh_emit_window(strm, w_size); + if (copy_len <= l) + state = ST_GET_LITERAL; + else { + state = ST_COPY_DATA; + ds->copy_len = copy_len - l; + ds->copy_pos = + (copy_pos + l) & w_mask; } + goto next_data; } if (copy_len <= l) /* A copy of current pattern ended. */ @@ -2507,14 +2473,80 @@ lzh_huffman_free(struct huffman *hf) free(hf->tree); } +static char bitlen_tbl[0x400] = { + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, + 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 16, 0 +}; static int lzh_read_pt_bitlen(struct lzh_stream *strm, int start, int end) { struct lzh_dec *ds = strm->ds; - struct lzh_br * br = &(ds->br); + struct lzh_br *br = &(ds->br); int c, i; - for (i = start; i < end;) { + for (i = start; i < end; ) { /* * bit pattern the number we need * 000 -> 0 @@ -2530,17 +2562,13 @@ lzh_read_pt_bitlen(struct lzh_stream *strm, int start, int end) if (!lzh_br_read_ahead(strm, br, 3)) return (i); if ((c = lzh_br_bits(br, 3)) == 7) { - int d; if (!lzh_br_read_ahead(strm, br, 13)) return (i); - d = lzh_br_bits(br, 13); - while (d & 0x200) { - c++; - d <<= 1; - } - if (c > 16) + c = bitlen_tbl[lzh_br_bits(br, 13) & 0x3FF]; + if (c) + lzh_br_consume(br, c - 3); + else return (-1);/* Invalid data. */ - lzh_br_consume(br, c - 3); } else lzh_br_consume(br, 3); ds->pt.bitlen[i++] = c; @@ -2603,7 +2631,7 @@ lzh_make_huffman_table(struct huffman *hf) } } if (maxbits > HTBL_BITS) { - int htbl_max; + unsigned htbl_max; uint16_t *p; diffbits = maxbits - HTBL_BITS; @@ -2647,8 +2675,40 @@ lzh_make_huffman_table(struct huffman *hf) return (0);/* Invalid */ /* Update the table */ p = &(tbl[ptn]); - while (--cnt >= 0) - p[cnt] = (uint16_t)i; + if (cnt > 7) { + uint16_t *pc; + + cnt -= 8; + pc = &p[cnt]; + pc[0] = (uint16_t)i; + pc[1] = (uint16_t)i; + pc[2] = (uint16_t)i; + pc[3] = (uint16_t)i; + pc[4] = (uint16_t)i; + pc[5] = (uint16_t)i; + pc[6] = (uint16_t)i; + pc[7] = (uint16_t)i; + if (cnt > 7) { + cnt -= 8; + memcpy(&p[cnt], pc, + 8 * sizeof(uint16_t)); + pc = &p[cnt]; + while (cnt > 15) { + cnt -= 16; + memcpy(&p[cnt], pc, + 16 * sizeof(uint16_t)); + } + } + if (cnt) + memcpy(p, pc, cnt * sizeof(uint16_t)); + } else { + while (cnt > 1) { + p[--cnt] = (uint16_t)i; + p[--cnt] = (uint16_t)i; + } + if (cnt) + p[--cnt] = (uint16_t)i; + } continue; } @@ -2742,7 +2802,7 @@ lzh_decode_huffman(struct huffman *hf, unsigned rbits) * If it fails, search a huffman tree for. */ c = hf->tbl[rbits >> hf->shift_bits]; - if (c < hf->len_avail) + if (c < hf->len_avail || hf->len_avail == 0) return (c); /* This bit pattern needs to be found out at a huffman tree. */ return (lzh_decode_huffman_tree(hf, rbits, c)); diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c index d82d4c1..b5f8e30 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c @@ -139,16 +139,19 @@ get_time_t_max(void) #if defined(TIME_T_MAX) return TIME_T_MAX; #else - static time_t t; - time_t a; - if (t == 0) { - a = 1; - while (a > t) { - t = a; - a = a * 2 + 1; - } + /* ISO C allows time_t to be a floating-point type, + but POSIX requires an integer type. The following + should work on any system that follows the POSIX + conventions. */ + if (((time_t)0) < ((time_t)-1)) { + /* Time_t is unsigned */ + return (~(time_t)0); + } else { + /* Time_t is signed. */ + const uintmax_t max_unsigned_time_t = (uintmax_t)(~(time_t)0); + const uintmax_t max_signed_time_t = max_unsigned_time_t >> 1; + return (time_t)max_signed_time_t; } - return t; #endif } @@ -158,20 +161,16 @@ get_time_t_min(void) #if defined(TIME_T_MIN) return TIME_T_MIN; #else - /* 't' will hold the minimum value, which will be zero (if - * time_t is unsigned) or -2^n (if time_t is signed). */ - static int computed; - static time_t t; - time_t a; - if (computed == 0) { - a = (time_t)-1; - while (a < t) { - t = a; - a = a * 2; - } - computed = 1; + if (((time_t)0) < ((time_t)-1)) { + /* Time_t is unsigned */ + return (time_t)0; + } else { + /* Time_t is signed. */ + const uintmax_t max_unsigned_time_t = (uintmax_t)(~(time_t)0); + const uintmax_t max_signed_time_t = max_unsigned_time_t >> 1; + const intmax_t min_signed_time_t = (intmax_t)~max_signed_time_t; + return (time_t)min_signed_time_t; } - return t; #endif } @@ -532,32 +531,34 @@ bid_entry(const char *p, ssize_t len, ssize_t nl, int *last_is_path) 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* E0 - EF */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* F0 - FF */ }; - ssize_t ll = len; + ssize_t ll; const char *pp = p; + const char * const pp_end = pp + len; *last_is_path = 0; /* * Skip the path-name which is quoted. */ - while (ll > 0 && *pp != ' ' &&*pp != '\t' && *pp != '\r' && - *pp != '\n') { + for (;pp < pp_end; ++pp) { if (!safe_char[*(const unsigned char *)pp]) { - f = 0; + if (*pp != ' ' && *pp != '\t' && *pp != '\r' + && *pp != '\n') + f = 0; break; } - ++pp; - --ll; - ++f; + f = 1; } + ll = pp_end - pp; + /* If a path-name was not found at the first, try to check - * a mtree format ``NetBSD's mtree -D'' creates, which - * places the path-name at the last. */ + * a mtree format(a.k.a form D) ``NetBSD's mtree -D'' creates, + * which places the path-name at the last. */ if (f == 0) { const char *pb = p + len - nl; int name_len = 0; int slash; - /* Do not accept multi lines for form D. */ + /* The form D accepts only a single line for an entry. */ if (pb-2 >= p && pb[-1] == '\\' && (pb[-2] == ' ' || pb[-2] == '\t')) return (-1); @@ -1056,7 +1057,8 @@ read_header(struct archive_read *a, struct archive_entry *entry) } if (!mtree->this_entry->used) { use_next = 0; - r = parse_file(a, entry, mtree, mtree->this_entry, &use_next); + r = parse_file(a, entry, mtree, mtree->this_entry, + &use_next); if (use_next == 0) return (r); } @@ -1151,8 +1153,8 @@ parse_file(struct archive_read *a, struct archive_entry *entry, mtree->fd = open(path, O_RDONLY | O_BINARY | O_CLOEXEC); __archive_ensure_cloexec_flag(mtree->fd); if (mtree->fd == -1 && - (errno != ENOENT || - archive_strlen(&mtree->contents_name) > 0)) { + (errno != ENOENT || + archive_strlen(&mtree->contents_name) > 0)) { archive_set_error(&a->archive, errno, "Can't open %s", path); r = ARCHIVE_WARN; @@ -1175,76 +1177,79 @@ parse_file(struct archive_read *a, struct archive_entry *entry, } /* - * Check for a mismatch between the type in the specification and - * the type of the contents object on disk. + * Check for a mismatch between the type in the specification + * and the type of the contents object on disk. */ if (st != NULL) { - if ( - ((st->st_mode & S_IFMT) == S_IFREG && - archive_entry_filetype(entry) == AE_IFREG) + if (((st->st_mode & S_IFMT) == S_IFREG && + archive_entry_filetype(entry) == AE_IFREG) #ifdef S_IFLNK - || ((st->st_mode & S_IFMT) == S_IFLNK && - archive_entry_filetype(entry) == AE_IFLNK) + ||((st->st_mode & S_IFMT) == S_IFLNK && + archive_entry_filetype(entry) == AE_IFLNK) #endif #ifdef S_IFSOCK - || ((st->st_mode & S_IFSOCK) == S_IFSOCK && - archive_entry_filetype(entry) == AE_IFSOCK) + ||((st->st_mode & S_IFSOCK) == S_IFSOCK && + archive_entry_filetype(entry) == AE_IFSOCK) #endif #ifdef S_IFCHR - || ((st->st_mode & S_IFMT) == S_IFCHR && - archive_entry_filetype(entry) == AE_IFCHR) + ||((st->st_mode & S_IFMT) == S_IFCHR && + archive_entry_filetype(entry) == AE_IFCHR) #endif #ifdef S_IFBLK - || ((st->st_mode & S_IFMT) == S_IFBLK && - archive_entry_filetype(entry) == AE_IFBLK) + ||((st->st_mode & S_IFMT) == S_IFBLK && + archive_entry_filetype(entry) == AE_IFBLK) #endif - || ((st->st_mode & S_IFMT) == S_IFDIR && - archive_entry_filetype(entry) == AE_IFDIR) + ||((st->st_mode & S_IFMT) == S_IFDIR && + archive_entry_filetype(entry) == AE_IFDIR) #ifdef S_IFIFO - || ((st->st_mode & S_IFMT) == S_IFIFO && - archive_entry_filetype(entry) == AE_IFIFO) + ||((st->st_mode & S_IFMT) == S_IFIFO && + archive_entry_filetype(entry) == AE_IFIFO) #endif - ) { - /* Types match. */ - } else { - /* Types don't match; bail out gracefully. */ - if (mtree->fd >= 0) - close(mtree->fd); - mtree->fd = -1; - if (parsed_kws & MTREE_HAS_OPTIONAL) { - /* It's not an error for an optional entry - to not match disk. */ - *use_next = 1; - } else if (r == ARCHIVE_OK) { - archive_set_error(&a->archive, - ARCHIVE_ERRNO_MISC, - "mtree specification has different type for %s", - archive_entry_pathname(entry)); - r = ARCHIVE_WARN; - } - return r; - } + ) { + /* Types match. */ + } else { + /* Types don't match; bail out gracefully. */ + if (mtree->fd >= 0) + close(mtree->fd); + mtree->fd = -1; + if (parsed_kws & MTREE_HAS_OPTIONAL) { + /* It's not an error for an optional + * entry to not match disk. */ + *use_next = 1; + } else if (r == ARCHIVE_OK) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_MISC, + "mtree specification has different" + " type for %s", + archive_entry_pathname(entry)); + r = ARCHIVE_WARN; + } + return (r); + } } /* - * If there is a contents file on disk, pick some of the metadata - * from that file. For most of these, we only set it from the contents - * if it wasn't already parsed from the specification. + * If there is a contents file on disk, pick some of the + * metadata from that file. For most of these, we only + * set it from the contents if it wasn't already parsed + * from the specification. */ if (st != NULL) { if (((parsed_kws & MTREE_HAS_DEVICE) == 0 || - (parsed_kws & MTREE_HAS_NOCHANGE) != 0) && - (archive_entry_filetype(entry) == AE_IFCHR || - archive_entry_filetype(entry) == AE_IFBLK)) + (parsed_kws & MTREE_HAS_NOCHANGE) != 0) && + (archive_entry_filetype(entry) == AE_IFCHR || + archive_entry_filetype(entry) == AE_IFBLK)) archive_entry_set_rdev(entry, st->st_rdev); - if ((parsed_kws & (MTREE_HAS_GID | MTREE_HAS_GNAME)) == 0 || - (parsed_kws & MTREE_HAS_NOCHANGE) != 0) + if ((parsed_kws & (MTREE_HAS_GID | MTREE_HAS_GNAME)) + == 0 || + (parsed_kws & MTREE_HAS_NOCHANGE) != 0) archive_entry_set_gid(entry, st->st_gid); - if ((parsed_kws & (MTREE_HAS_UID | MTREE_HAS_UNAME)) == 0 || - (parsed_kws & MTREE_HAS_NOCHANGE) != 0) + if ((parsed_kws & (MTREE_HAS_UID | MTREE_HAS_UNAME)) + == 0 || + (parsed_kws & MTREE_HAS_NOCHANGE) != 0) archive_entry_set_uid(entry, st->st_uid); if ((parsed_kws & MTREE_HAS_MTIME) == 0 || - (parsed_kws & MTREE_HAS_NOCHANGE) != 0) { + (parsed_kws & MTREE_HAS_NOCHANGE) != 0) { #if HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC archive_entry_set_mtime(entry, st->st_mtime, st->st_mtimespec.tv_nsec); @@ -1265,23 +1270,24 @@ parse_file(struct archive_read *a, struct archive_entry *entry, #endif } if ((parsed_kws & MTREE_HAS_NLINK) == 0 || - (parsed_kws & MTREE_HAS_NOCHANGE) != 0) + (parsed_kws & MTREE_HAS_NOCHANGE) != 0) archive_entry_set_nlink(entry, st->st_nlink); if ((parsed_kws & MTREE_HAS_PERM) == 0 || - (parsed_kws & MTREE_HAS_NOCHANGE) != 0) + (parsed_kws & MTREE_HAS_NOCHANGE) != 0) archive_entry_set_perm(entry, st->st_mode); if ((parsed_kws & MTREE_HAS_SIZE) == 0 || - (parsed_kws & MTREE_HAS_NOCHANGE) != 0) + (parsed_kws & MTREE_HAS_NOCHANGE) != 0) archive_entry_set_size(entry, st->st_size); archive_entry_set_ino(entry, st->st_ino); archive_entry_set_dev(entry, st->st_dev); - archive_entry_linkify(mtree->resolver, &entry, &sparse_entry); + archive_entry_linkify(mtree->resolver, &entry, + &sparse_entry); } else if (parsed_kws & MTREE_HAS_OPTIONAL) { /* * Couldn't open the entry, stat it or the on-disk type - * didn't match. If this entry is optional, just ignore it - * and read the next header entry. + * didn't match. If this entry is optional, just + * ignore it and read the next header entry. */ *use_next = 1; return ARCHIVE_OK; @@ -1370,7 +1376,7 @@ parse_device(dev_t *pdev, struct archive *a, char *val) "Missing number"); return ARCHIVE_WARN; } - numbers[argc++] = mtree_atol(&p); + numbers[argc++] = (unsigned long)mtree_atol(&p); if (argc > MAX_PACK_ARGS) { archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, "Too many arguments"); @@ -1583,32 +1589,38 @@ parse_keyword(struct archive_read *a, struct mtree *mtree, } case 'c': if (strcmp(val, "char") == 0) { - archive_entry_set_filetype(entry, AE_IFCHR); + archive_entry_set_filetype(entry, + AE_IFCHR); break; } case 'd': if (strcmp(val, "dir") == 0) { - archive_entry_set_filetype(entry, AE_IFDIR); + archive_entry_set_filetype(entry, + AE_IFDIR); break; } case 'f': if (strcmp(val, "fifo") == 0) { - archive_entry_set_filetype(entry, AE_IFIFO); + archive_entry_set_filetype(entry, + AE_IFIFO); break; } if (strcmp(val, "file") == 0) { - archive_entry_set_filetype(entry, AE_IFREG); + archive_entry_set_filetype(entry, + AE_IFREG); break; } case 'l': if (strcmp(val, "link") == 0) { - archive_entry_set_filetype(entry, AE_IFLNK); + archive_entry_set_filetype(entry, + AE_IFLNK); break; } default: archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, - "Unrecognized file type \"%s\"; assuming \"file\"", val); + "Unrecognized file type \"%s\"; " + "assuming \"file\"", val); archive_entry_set_filetype(entry, AE_IFREG); return (ARCHIVE_WARN); } @@ -1635,7 +1647,8 @@ parse_keyword(struct archive_read *a, struct mtree *mtree, } static int -read_data(struct archive_read *a, const void **buff, size_t *size, int64_t *offset) +read_data(struct archive_read *a, const void **buff, size_t *size, + int64_t *offset) { size_t bytes_to_read; ssize_t bytes_read; @@ -1761,6 +1774,10 @@ parse_escapes(char *src, struct mtree_entry *mentry) c = '\v'; ++src; break; + case '\\': + c = '\\'; + ++src; + break; } } *dest++ = c; @@ -1898,14 +1915,14 @@ mtree_atol(char **p) * point to first character of line. */ static ssize_t -readline(struct archive_read *a, struct mtree *mtree, char **start, ssize_t limit) +readline(struct archive_read *a, struct mtree *mtree, char **start, + ssize_t limit) { ssize_t bytes_read; ssize_t total_size = 0; ssize_t find_off = 0; const void *t; - const char *s; - void *p; + void *nl; char *u; /* Accumulate line in a line buffer. */ @@ -1916,11 +1933,10 @@ readline(struct archive_read *a, struct mtree *mtree, char **start, ssize_t limi return (0); if (bytes_read < 0) return (ARCHIVE_FATAL); - s = t; /* Start of line? */ - p = memchr(t, '\n', bytes_read); - /* If we found '\n', trim the read. */ - if (p != NULL) { - bytes_read = 1 + ((const char *)p) - s; + nl = memchr(t, '\n', bytes_read); + /* If we found '\n', trim the read to end exactly there. */ + if (nl != NULL) { + bytes_read = ((const char *)nl) - ((const char *)t) + 1; } if (total_size + bytes_read + 1 > limit) { archive_set_error(&a->archive, @@ -1934,38 +1950,34 @@ readline(struct archive_read *a, struct mtree *mtree, char **start, ssize_t limi "Can't allocate working buffer"); return (ARCHIVE_FATAL); } + /* Append new bytes to string. */ memcpy(mtree->line.s + total_size, t, bytes_read); __archive_read_consume(a, bytes_read); total_size += bytes_read; - /* Null terminate. */ mtree->line.s[total_size] = '\0'; - /* If we found an unescaped '\n', clean up and return. */ + for (u = mtree->line.s + find_off; *u; ++u) { if (u[0] == '\n') { + /* Ends with unescaped newline. */ *start = mtree->line.s; return total_size; - } - if (u[0] == '#') { - if (p == NULL) + } else if (u[0] == '#') { + /* Ends with comment sequence #...\n */ + if (nl == NULL) { + /* But we've not found the \n yet */ break; - *start = mtree->line.s; - return total_size; - } - if (u[0] != '\\') - continue; - if (u[1] == '\\') { - ++u; - continue; - } - if (u[1] == '\n') { - memmove(u, u + 1, - total_size - (u - mtree->line.s) + 1); - --total_size; - ++u; - break; + } + } else if (u[0] == '\\') { + if (u[1] == '\n') { + /* Trim escaped newline. */ + total_size -= 2; + mtree->line.s[total_size] = '\0'; + break; + } else if (u[1] != '\0') { + /* Skip the two-char escape sequence */ + ++u; + } } - if (u[1] == '\0') - break; } find_off = u - mtree->line.s; } diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c index 4c56834..35ac7cf 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c @@ -186,6 +186,7 @@ struct huffman_code { struct huffman_tree_node *tree; int numentries; + int numallocatedentries; int minlength; int maxlength; int tablesize; @@ -225,6 +226,7 @@ struct rar mode_t mode; char *filename; char *filename_save; + size_t filename_save_size; size_t filename_allocated; /* File header optional entries */ @@ -1000,8 +1002,8 @@ archive_read_format_rar_read_data(struct archive_read *a, const void **buff, rar->bytes_unconsumed = 0; } + *buff = NULL; if (rar->entry_eof || rar->offset_seek >= rar->unp_size) { - *buff = NULL; *size = 0; *offset = rar->offset; if (*offset < rar->unp_size) @@ -1201,10 +1203,8 @@ archive_read_format_rar_seek_data(struct archive_read *a, int64_t offset, ret -= rar->dbo[0].start_offset; /* Always restart reading the file after a seek */ - a->read_data_block = NULL; - a->read_data_offset = 0; - a->read_data_output_offset = 0; - a->read_data_remaining = 0; + __archive_reset_read_data(&a->archive); + rar->bytes_unconsumed = 0; rar->offset = 0; @@ -1530,6 +1530,7 @@ read_header(struct archive_read *a, struct archive_entry *entry, /* Split file in multivolume RAR. No more need to process header. */ if (rar->filename_save && + filename_size == rar->filename_save_size && !memcmp(rar->filename, rar->filename_save, filename_size + 1)) { __archive_read_consume(a, header_size - 7); @@ -1559,6 +1560,7 @@ read_header(struct archive_read *a, struct archive_entry *entry, rar->filename_save = (char*)realloc(rar->filename_save, filename_size + 1); memcpy(rar->filename_save, rar->filename, filename_size + 1); + rar->filename_save_size = filename_size; /* Set info for seeking */ free(rar->dbo); @@ -2406,6 +2408,8 @@ create_code(struct archive_read *a, struct huffman_code *code, { int i, j, codebits = 0, symbolsleft = numsymbols; + code->numentries = 0; + code->numallocatedentries = 0; if (new_node(code) < 0) { archive_set_error(&a->archive, ENOMEM, "Unable to allocate memory for node data."); @@ -2534,11 +2538,17 @@ static int new_node(struct huffman_code *code) { void *new_tree; - - new_tree = realloc(code->tree, (code->numentries + 1) * sizeof(*code->tree)); - if (new_tree == NULL) - return (-1); - code->tree = (struct huffman_tree_node *)new_tree; + if (code->numallocatedentries == code->numentries) { + int new_num_entries = 256; + if (code->numentries > 0) { + new_num_entries = code->numentries * 2; + } + new_tree = realloc(code->tree, new_num_entries * sizeof(*code->tree)); + if (new_tree == NULL) + return (-1); + code->tree = (struct huffman_tree_node *)new_tree; + code->numallocatedentries = new_num_entries; + } code->tree[code->numentries].branches[0] = -1; code->tree[code->numentries].branches[1] = -2; return 1; @@ -2895,8 +2905,8 @@ rar_read_ahead(struct archive_read *a, size_t min, ssize_t *avail) int ret; if (avail) { - if (a->read_data_is_posix_read && *avail > (ssize_t)a->read_data_requested) - *avail = a->read_data_requested; + if (a->archive.read_data_is_posix_read && *avail > (ssize_t)a->archive.read_data_requested) + *avail = a->archive.read_data_requested; if (*avail > rar->bytes_remaining) *avail = (ssize_t)rar->bytes_remaining; if (*avail < 0) diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c index 734424d..01d85cf 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c @@ -456,6 +456,7 @@ archive_read_format_tar_read_header(struct archive_read *a, static int default_dev; struct tar *tar; const char *p; + const wchar_t *wp; int r; size_t l, unconsumed = 0; @@ -506,27 +507,22 @@ archive_read_format_tar_read_header(struct archive_read *a, } } - if (r == ARCHIVE_OK) { + if (r == ARCHIVE_OK && archive_entry_filetype(entry) == AE_IFREG) { /* * "Regular" entry with trailing '/' is really * directory: This is needed for certain old tar * variants and even for some broken newer ones. */ - const wchar_t *wp; - wp = archive_entry_pathname_w(entry); - if (wp != NULL) { + if ((wp = archive_entry_pathname_w(entry)) != NULL) { l = wcslen(wp); - if (archive_entry_filetype(entry) == AE_IFREG - && wp[l-1] == L'/') + if (l > 0 && wp[l - 1] == L'/') { archive_entry_set_filetype(entry, AE_IFDIR); - } else { - p = archive_entry_pathname(entry); - if (p == NULL) - return (ARCHIVE_FAILED); + } + } else if ((p = archive_entry_pathname(entry)) != NULL) { l = strlen(p); - if (archive_entry_filetype(entry) == AE_IFREG - && p[l-1] == '/') + if (l > 0 && p[l - 1] == '/') { archive_entry_set_filetype(entry, AE_IFDIR); + } } } return (r); @@ -599,13 +595,27 @@ static int archive_read_format_tar_skip(struct archive_read *a) { int64_t bytes_skipped; + int64_t request; + struct sparse_block *p; struct tar* tar; tar = (struct tar *)(a->format->data); - bytes_skipped = __archive_read_consume(a, - tar->entry_bytes_remaining + tar->entry_padding + - tar->entry_bytes_unconsumed); + /* Do not consume the hole of a sparse file. */ + request = 0; + for (p = tar->sparse_list; p != NULL; p = p->next) { + if (!p->hole) { + if (p->remaining >= INT64_MAX - request) { + return ARCHIVE_FATAL; + } + request += p->remaining; + } + } + if (request > tar->entry_bytes_remaining) + request = tar->entry_bytes_remaining; + request += tar->entry_padding + tar->entry_bytes_unconsumed; + + bytes_skipped = __archive_read_consume(a, request); if (bytes_skipped < 0) return (ARCHIVE_FATAL); @@ -2117,6 +2127,10 @@ gnu_add_sparse_entry(struct archive_read *a, struct tar *tar, else tar->sparse_list = p; tar->sparse_last = p; + if (remaining < 0 || offset < 0) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "Malformed sparse map data"); + return (ARCHIVE_FATAL); + } p->offset = offset; p->remaining = remaining; return (ARCHIVE_OK); diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c new file mode 100644 index 0000000..57534f3 --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c @@ -0,0 +1,794 @@ +/*- + * Copyright (c) 2014 Sebastian Freundt + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "archive_platform.h" +__FBSDID("$FreeBSD$"); + +/** + * WARC is standardised by ISO TC46/SC4/WG12 and currently available as + * ISO 28500:2009. + * For the purposes of this file we used the final draft from: + * http://bibnum.bnf.fr/warc/WARC_ISO_28500_version1_latestdraft.pdf + * + * Todo: + * [ ] real-world warcs can contain resources at endpoints ending in / + * e.g. http://bibnum.bnf.fr/warc/ + * if you're lucky their response contains a Content-Location: header + * pointing to a unix-compliant filename, in the example above it's + * Content-Location: http://bibnum.bnf.fr/warc/index.html + * however, that's not mandated and github for example doesn't follow + * this convention. + * We need a set of archive options to control what to do with + * entries like these, at the moment care is taken to skip them. + * + **/ + +#ifdef HAVE_SYS_STAT_H +#include <sys/stat.h> +#endif +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif +#ifdef HAVE_STRING_H +#include <string.h> +#endif +#ifdef HAVE_LIMITS_H +#include <limits.h> +#endif +#ifdef HAVE_CTYPE_H +#include <ctype.h> +#endif +#ifdef HAVE_TIME_H +#include <time.h> +#endif + +#include "archive.h" +#include "archive_entry.h" +#include "archive_private.h" +#include "archive_read_private.h" + +typedef enum { + WT_NONE, + /* warcinfo */ + WT_INFO, + /* metadata */ + WT_META, + /* resource */ + WT_RSRC, + /* request, unsupported */ + WT_REQ, + /* response, unsupported */ + WT_RSP, + /* revisit, unsupported */ + WT_RVIS, + /* conversion, unsupported */ + WT_CONV, + /* continutation, unsupported at the moment */ + WT_CONT, + /* invalid type */ + LAST_WT +} warc_type_t; + +typedef struct { + size_t len; + const char *str; +} warc_string_t; + +typedef struct { + size_t len; + char *str; +} warc_strbuf_t; + +struct warc_s { + /* content length ahead */ + size_t cntlen; + /* and how much we've processed so far */ + size_t cntoff; + /* and how much we need to consume between calls */ + size_t unconsumed; + + /* string pool */ + warc_strbuf_t pool; + /* previous version */ + unsigned int pver; + /* stringified format name */ + struct archive_string sver; +}; + +static int _warc_bid(struct archive_read *a, int); +static int _warc_cleanup(struct archive_read *a); +static int _warc_read(struct archive_read*, const void**, size_t*, int64_t*); +static int _warc_skip(struct archive_read *a); +static int _warc_rdhdr(struct archive_read *a, struct archive_entry *e); + +/* private routines */ +static unsigned int _warc_rdver(const char buf[10], size_t bsz); +static unsigned int _warc_rdtyp(const char *buf, size_t bsz); +static warc_string_t _warc_rduri(const char *buf, size_t bsz); +static ssize_t _warc_rdlen(const char *buf, size_t bsz); +static time_t _warc_rdrtm(const char *buf, size_t bsz); +static time_t _warc_rdmtm(const char *buf, size_t bsz); +static const char *_warc_find_eoh(const char *buf, size_t bsz); + + +int +archive_read_support_format_warc(struct archive *_a) +{ + struct archive_read *a = (struct archive_read *)_a; + struct warc_s *w; + int r; + + archive_check_magic(_a, ARCHIVE_READ_MAGIC, + ARCHIVE_STATE_NEW, "archive_read_support_format_warc"); + + if ((w = malloc(sizeof(*w))) == NULL) { + archive_set_error(&a->archive, ENOMEM, + "Can't allocate warc data"); + return (ARCHIVE_FATAL); + } + memset(w, 0, sizeof(*w)); + + r = __archive_read_register_format( + a, w, "warc", + _warc_bid, NULL, _warc_rdhdr, _warc_read, + _warc_skip, NULL, _warc_cleanup, NULL, NULL); + + if (r != ARCHIVE_OK) { + free(w); + return (r); + } + return (ARCHIVE_OK); +} + +static int +_warc_cleanup(struct archive_read *a) +{ + struct warc_s *w = a->format->data; + + if (w->pool.len > 0U) { + free(w->pool.str); + } + archive_string_free(&w->sver); + free(w); + a->format->data = NULL; + return (ARCHIVE_OK); +} + +static int +_warc_bid(struct archive_read *a, int best_bid) +{ + const char *hdr; + ssize_t nrd; + unsigned int ver; + + (void)best_bid; /* UNUSED */ + + /* check first line of file, it should be a record already */ + if ((hdr = __archive_read_ahead(a, 12U, &nrd)) == NULL) { + /* no idea what to do */ + return -1; + } else if (nrd < 12) { + /* nah, not for us, our magic cookie is at least 12 bytes */ + return -1; + } + + /* otherwise snarf the record's version number */ + ver = _warc_rdver(hdr, nrd); + if (ver == 0U || ver > 10000U) { + /* oh oh oh, best not to wager ... */ + return -1; + } + + /* otherwise be confident */ + return (64); +} + +static int +_warc_rdhdr(struct archive_read *a, struct archive_entry *entry) +{ +#define HDR_PROBE_LEN (12U) + struct warc_s *w = a->format->data; + unsigned int ver; + const char *buf; + ssize_t nrd; + const char *eoh; + /* for the file name, saves some strndup()'ing */ + warc_string_t fnam; + /* warc record type, not that we really use it a lot */ + warc_type_t ftyp; + /* content-length+error monad */ + ssize_t cntlen; + /* record time is the WARC-Date time we reinterpret it as ctime */ + time_t rtime; + /* mtime is the Last-Modified time which will be the entry's mtime */ + time_t mtime; + +start_over: + /* just use read_ahead() they keep track of unconsumed + * bits and bobs for us; no need to put an extra shift in + * and reproduce that functionality here */ + buf = __archive_read_ahead(a, HDR_PROBE_LEN, &nrd); + + if (nrd < 0) { + /* no good */ + archive_set_error( + &a->archive, ARCHIVE_ERRNO_MISC, + "Bad record header"); + return (ARCHIVE_FATAL); + } else if (buf == NULL) { + /* there should be room for at least WARC/bla\r\n + * must be EOF therefore */ + return (ARCHIVE_EOF); + } + /* looks good so far, try and find the end of the header now */ + eoh = _warc_find_eoh(buf, nrd); + if (eoh == NULL) { + /* still no good, the header end might be beyond the + * probe we've requested, but then again who'd cram + * so much stuff into the header *and* be 28500-compliant */ + archive_set_error( + &a->archive, ARCHIVE_ERRNO_MISC, + "Bad record header"); + return (ARCHIVE_FATAL); + } else if ((ver = _warc_rdver(buf, eoh - buf)) > 10000U) { + /* nawww, I wish they promised backward compatibility + * anyhoo, in their infinite wisdom the 28500 guys might + * come up with something we can't possibly handle so + * best end things here */ + archive_set_error( + &a->archive, ARCHIVE_ERRNO_MISC, + "Unsupported record version"); + return (ARCHIVE_FATAL); + } else if ((cntlen = _warc_rdlen(buf, eoh - buf)) < 0) { + /* nightmare! the specs say content-length is mandatory + * so I don't feel overly bad stopping the reader here */ + archive_set_error( + &a->archive, EINVAL, + "Bad content length"); + return (ARCHIVE_FATAL); + } else if ((rtime = _warc_rdrtm(buf, eoh - buf)) == (time_t)-1) { + /* record time is mandatory as per WARC/1.0, + * so just barf here, fast and loud */ + archive_set_error( + &a->archive, EINVAL, + "Bad record time"); + return (ARCHIVE_FATAL); + } + + /* let the world know we're a WARC archive */ + a->archive.archive_format = ARCHIVE_FORMAT_WARC; + if (ver != w->pver) { + /* stringify this entry's version */ + archive_string_sprintf(&w->sver, + "WARC/%u.%u", ver / 10000, ver % 10000); + /* remember the version */ + w->pver = ver; + } + /* start off with the type */ + ftyp = _warc_rdtyp(buf, eoh - buf); + /* and let future calls know about the content */ + w->cntlen = cntlen; + w->cntoff = 0U; + mtime = 0;/* Avoid compiling error on some platform. */ + + switch (ftyp) { + case WT_RSRC: + case WT_RSP: + /* only try and read the filename in the cases that are + * guaranteed to have one */ + fnam = _warc_rduri(buf, eoh - buf); + /* check the last character in the URI to avoid creating + * directory endpoints as files, see Todo above */ + if (fnam.len == 0 || fnam.str[fnam.len - 1] == '/') { + /* break here for now */ + fnam.len = 0U; + fnam.str = NULL; + break; + } + /* bang to our string pool, so we save a + * malloc()+free() roundtrip */ + if (fnam.len + 1U > w->pool.len) { + w->pool.len = ((fnam.len + 64U) / 64U) * 64U; + w->pool.str = realloc(w->pool.str, w->pool.len); + } + memcpy(w->pool.str, fnam.str, fnam.len); + w->pool.str[fnam.len] = '\0'; + /* let noone else know about the pool, it's a secret, shhh */ + fnam.str = w->pool.str; + + /* snarf mtime or deduce from rtime + * this is a custom header added by our writer, it's quite + * hard to believe anyone else would go through with it + * (apart from being part of some http responses of course) */ + if ((mtime = _warc_rdmtm(buf, eoh - buf)) == (time_t)-1) { + mtime = rtime; + } + break; + default: + fnam.len = 0U; + fnam.str = NULL; + break; + } + + /* now eat some of those delicious buffer bits */ + __archive_read_consume(a, eoh - buf); + + switch (ftyp) { + case WT_RSRC: + case WT_RSP: + if (fnam.len > 0U) { + /* populate entry object */ + archive_entry_set_filetype(entry, AE_IFREG); + archive_entry_copy_pathname(entry, fnam.str); + archive_entry_set_size(entry, cntlen); + archive_entry_set_perm(entry, 0644); + /* rtime is the new ctime, mtime stays mtime */ + archive_entry_set_ctime(entry, rtime, 0L); + archive_entry_set_mtime(entry, mtime, 0L); + break; + } + /* FALLTHROUGH */ + default: + /* consume the content and start over */ + _warc_skip(a); + goto start_over; + } + return (ARCHIVE_OK); +} + +static int +_warc_read(struct archive_read *a, const void **buf, size_t *bsz, int64_t *off) +{ + struct warc_s *w = a->format->data; + const char *rab; + ssize_t nrd; + + if (w->cntoff >= w->cntlen) { + eof: + /* it's our lucky day, no work, we can leave early */ + *buf = NULL; + *bsz = 0U; + *off = w->cntoff + 4U/*for \r\n\r\n separator*/; + w->unconsumed = 0U; + return (ARCHIVE_EOF); + } + + rab = __archive_read_ahead(a, 1U, &nrd); + if (nrd < 0) { + *bsz = 0U; + /* big catastrophe */ + return (int)nrd; + } else if (nrd == 0) { + goto eof; + } else if ((size_t)nrd > w->cntlen - w->cntoff) { + /* clamp to content-length */ + nrd = w->cntlen - w->cntoff; + } + *off = w->cntoff; + *bsz = nrd; + *buf = rab; + + w->cntoff += nrd; + w->unconsumed = (size_t)nrd; + return (ARCHIVE_OK); +} + +static int +_warc_skip(struct archive_read *a) +{ + struct warc_s *w = a->format->data; + + __archive_read_consume(a, w->cntlen + 4U/*\r\n\r\n separator*/); + w->cntlen = 0U; + w->cntoff = 0U; + return (ARCHIVE_OK); +} + + +/* private routines */ +static void* +deconst(const void *c) +{ + return (char *)0x1 + (((const char *)c) - (const char *)0x1); +} + +static char* +xmemmem(const char *hay, const size_t hz_, const char *ndl, const size_t nz) +{ + const char *const eoh = hay + hz_; + const char *const eon = ndl + nz; + const char *hp; + const char *np; + const char *cand; + unsigned int hsum; + unsigned int nsum; + unsigned int eqp; + + /* trivial checks first + * a 0-sized needle is defined to be found anywhere in haystack + * then run strchr() to find a candidate in HAYSTACK (i.e. a portion + * that happens to begin with *NEEDLE) */ + if (nz == 0UL) { + return deconst(hay); + } else if ((hay = memchr(hay, *ndl, hz_)) == NULL) { + /* trivial */ + return NULL; + } + + /* First characters of haystack and needle are the same now. Both are + * guaranteed to be at least one character long. Now computes the sum + * of characters values of needle together with the sum of the first + * needle_len characters of haystack. */ + for (hp = hay + 1U, np = ndl + 1U, hsum = *hay, nsum = *hay, eqp = 1U; + hp < eoh && np < eon; + hsum ^= *hp, nsum ^= *np, eqp &= *hp == *np, hp++, np++); + + /* HP now references the (NZ + 1)-th character. */ + if (np < eon) { + /* haystack is smaller than needle, :O */ + return NULL; + } else if (eqp) { + /* found a match */ + return deconst(hay); + } + + /* now loop through the rest of haystack, + * updating the sum iteratively */ + for (cand = hay; hp < eoh; hp++) { + hsum ^= *cand++; + hsum ^= *hp; + + /* Since the sum of the characters is already known to be + * equal at that point, it is enough to check just NZ - 1 + * characters for equality, + * also CAND is by design < HP, so no need for range checks */ + if (hsum == nsum && memcmp(cand, ndl, nz - 1U) == 0) { + return deconst(cand); + } + } + return NULL; +} + +static int +strtoi_lim(const char *str, const char **ep, int llim, int ulim) +{ + int res = 0; + const char *sp; + /* we keep track of the number of digits via rulim */ + int rulim; + + for (sp = str, rulim = ulim > 10 ? ulim : 10; + res * 10 <= ulim && rulim && *sp >= '0' && *sp <= '9'; + sp++, rulim /= 10) { + res *= 10; + res += *sp - '0'; + } + if (sp == str) { + res = -1; + } else if (res < llim || res > ulim) { + res = -2; + } + *ep = (const char*)sp; + return res; +} + +static time_t +time_from_tm(struct tm *t) +{ +#if HAVE_TIMEGM + /* Use platform timegm() if available. */ + return (timegm(t)); +#elif HAVE__MKGMTIME64 + return (_mkgmtime64(t)); +#else + /* Else use direct calculation using POSIX assumptions. */ + /* First, fix up tm_yday based on the year/month/day. */ + if (mktime(t) == (time_t)-1) + return ((time_t)-1); + /* Then we can compute timegm() from first principles. */ + return (t->tm_sec + + t->tm_min * 60 + + t->tm_hour * 3600 + + t->tm_yday * 86400 + + (t->tm_year - 70) * 31536000 + + ((t->tm_year - 69) / 4) * 86400 + - ((t->tm_year - 1) / 100) * 86400 + + ((t->tm_year + 299) / 400) * 86400); +#endif +} + +static time_t +xstrpisotime(const char *s, char **endptr) +{ +/** like strptime() but strictly for ISO 8601 Zulu strings */ + struct tm tm; + time_t res = (time_t)-1; + + /* make sure tm is clean */ + memset(&tm, 0, sizeof(tm)); + + /* as a courtesy to our callers, and since this is a non-standard + * routine, we skip leading whitespace */ + for (; isspace(*s); s++); + + /* read year */ + if ((tm.tm_year = strtoi_lim(s, &s, 1583, 4095)) < 0 || *s++ != '-') { + goto out; + } + /* read month */ + if ((tm.tm_mon = strtoi_lim(s, &s, 1, 12)) < 0 || *s++ != '-') { + goto out; + } + /* read day-of-month */ + if ((tm.tm_mday = strtoi_lim(s, &s, 1, 31)) < 0 || *s++ != 'T') { + goto out; + } + /* read hour */ + if ((tm.tm_hour = strtoi_lim(s, &s, 0, 23)) < 0 || *s++ != ':') { + goto out; + } + /* read minute */ + if ((tm.tm_min = strtoi_lim(s, &s, 0, 59)) < 0 || *s++ != ':') { + goto out; + } + /* read second */ + if ((tm.tm_sec = strtoi_lim(s, &s, 0, 60)) < 0 || *s++ != 'Z') { + goto out; + } + + /* massage TM to fulfill some of POSIX' contraints */ + tm.tm_year -= 1900; + tm.tm_mon--; + + /* now convert our custom tm struct to a unix stamp using UTC */ + res = time_from_tm(&tm); + +out: + if (endptr != NULL) { + *endptr = deconst(s); + } + return res; +} + +static unsigned int +_warc_rdver(const char buf[10], size_t bsz) +{ + static const char magic[] = "WARC/"; + unsigned int ver; + + (void)bsz; /* UNUSED */ + + if (memcmp(buf, magic, sizeof(magic) - 1U) != 0) { + /* nope */ + return 99999U; + } + /* looks good so far, read the version number for a laugh */ + buf += sizeof(magic) - 1U; + /* most common case gets a quick-check here */ + if (memcmp(buf, "1.0\r\n", 5U) == 0) { + ver = 10000U; + } else { + switch (*buf) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + if (buf[1U] == '.') { + char *on; + + /* set up major version */ + ver = (buf[0U] - '0') * 10000U; + /* minor version, anyone? */ + ver += (strtol(buf + 2U, &on, 10)) * 100U; + /* don't parse anything else */ + if (on > buf + 2U) { + break; + } + } + /* FALLTHROUGH */ + case '9': + default: + /* just make the version ridiculously high */ + ver = 999999U; + break; + } + } + return ver; +} + +static unsigned int +_warc_rdtyp(const char *buf, size_t bsz) +{ + static const char _key[] = "\r\nWARC-Type:"; + const char *const eob = buf + bsz; + const char *val; + + if ((val = xmemmem(buf, bsz, _key, sizeof(_key) - 1U)) == NULL) { + /* no bother */ + return WT_NONE; + } + /* overread whitespace */ + for (val += sizeof(_key) - 1U; val < eob && isspace(*val); val++); + + if (val + 8U > eob) { + ; + } else if (memcmp(val, "resource", 8U) == 0) { + return WT_RSRC; + } else if (memcmp(val, "warcinfo", 8U) == 0) { + return WT_INFO; + } else if (memcmp(val, "metadata", 8U) == 0) { + return WT_META; + } else if (memcmp(val, "request", 7U) == 0) { + return WT_REQ; + } else if (memcmp(val, "response", 8U) == 0) { + return WT_RSP; + } else if (memcmp(val, "conversi", 8U) == 0) { + return WT_CONV; + } else if (memcmp(val, "continua", 8U) == 0) { + return WT_CONT; + } + return WT_NONE; +} + +static warc_string_t +_warc_rduri(const char *buf, size_t bsz) +{ + static const char _key[] = "\r\nWARC-Target-URI:"; + const char *const eob = buf + bsz; + const char *val; + const char *uri; + const char *eol; + warc_string_t res = {0U, NULL}; + + if ((val = xmemmem(buf, bsz, _key, sizeof(_key) - 1U)) == NULL) { + /* no bother */ + return res; + } + /* overread whitespace */ + for (val += sizeof(_key) - 1U; val < eob && isspace(*val); val++); + + /* overread URL designators */ + if ((uri = xmemmem(val, eob - val, "://", 3U)) == NULL) { + /* not touching that! */ + return res; + } else if ((eol = memchr(uri, '\n', eob - uri)) == NULL) { + /* no end of line? :O */ + return res; + } + + /* massage uri to point to after :// */ + uri += 3U; + /* also massage eol to point to the first whitespace + * after the last non-whitespace character before + * the end of the line */ + for (; eol > uri && isspace(eol[-1]); eol--); + + /* now then, inspect the URI */ + if (memcmp(val, "file", 4U) == 0) { + /* perfect, nothing left to do here */ + + } else if (memcmp(val, "http", 4U) == 0 || + memcmp(val, "ftp", 3U) == 0) { + /* overread domain, and the first / */ + while (uri < eol && *uri++ != '/'); + } else { + /* not sure what to do? best to bugger off */ + return res; + } + res.str = uri; + res.len = eol - uri; + return res; +} + +static ssize_t +_warc_rdlen(const char *buf, size_t bsz) +{ + static const char _key[] = "\r\nContent-Length:"; + const char *val; + char *on = NULL; + long int len; + + if ((val = xmemmem(buf, bsz, _key, sizeof(_key) - 1U)) == NULL) { + /* no bother */ + return -1; + } + + /* strtol kindly overreads whitespace for us, so use that */ + val += sizeof(_key) - 1U; + len = strtol(val, &on, 10); + if (on == NULL || !isspace(*on)) { + /* hm, can we trust that number? Best not. */ + return -1; + } + return (size_t)len; +} + +static time_t +_warc_rdrtm(const char *buf, size_t bsz) +{ + static const char _key[] = "\r\nWARC-Date:"; + const char *val; + char *on = NULL; + time_t res; + + if ((val = xmemmem(buf, bsz, _key, sizeof(_key) - 1U)) == NULL) { + /* no bother */ + return (time_t)-1; + } + + /* xstrpisotime() kindly overreads whitespace for us, so use that */ + val += sizeof(_key) - 1U; + res = xstrpisotime(val, &on); + if (on == NULL || !isspace(*on)) { + /* hm, can we trust that number? Best not. */ + return (time_t)-1; + } + return res; +} + +static time_t +_warc_rdmtm(const char *buf, size_t bsz) +{ + static const char _key[] = "\r\nLast-Modified:"; + const char *val; + char *on = NULL; + time_t res; + + if ((val = xmemmem(buf, bsz, _key, sizeof(_key) - 1U)) == NULL) { + /* no bother */ + return (time_t)-1; + } + + /* xstrpisotime() kindly overreads whitespace for us, so use that */ + val += sizeof(_key) - 1U; + res = xstrpisotime(val, &on); + if (on == NULL || !isspace(*on)) { + /* hm, can we trust that number? Best not. */ + return (time_t)-1; + } + return res; +} + +static const char* +_warc_find_eoh(const char *buf, size_t bsz) +{ + static const char _marker[] = "\r\n\r\n"; + const char *hit = xmemmem(buf, bsz, _marker, sizeof(_marker) - 1U); + + if (hit != NULL) { + hit += sizeof(_marker) - 1U; + } + return hit; +} + +/* archive_read_support_format_warc.c ends here */ diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_xar.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_xar.c index 68485d1..bbef99f 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_xar.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_xar.c @@ -51,7 +51,7 @@ __FBSDID("$FreeBSD$"); #endif #include "archive.h" -#include "archive_crypto_private.h" +#include "archive_digest_private.h" #include "archive_endian.h" #include "archive_entry.h" #include "archive_entry_locale.h" @@ -1107,20 +1107,23 @@ static time_t time_from_tm(struct tm *t) { #if HAVE_TIMEGM - /* Use platform timegm() if available. */ - return (timegm(t)); + /* Use platform timegm() if available. */ + return (timegm(t)); #elif HAVE__MKGMTIME64 - return (_mkgmtime64(t)); + return (_mkgmtime64(t)); #else - /* Else use direct calculation using POSIX assumptions. */ - /* First, fix up tm_yday based on the year/month/day. */ - mktime(t); - /* Then we can compute timegm() from first principles. */ - return (t->tm_sec + t->tm_min * 60 + t->tm_hour * 3600 - + t->tm_yday * 86400 + (t->tm_year - 70) * 31536000 - + ((t->tm_year - 69) / 4) * 86400 - - ((t->tm_year - 1) / 100) * 86400 - + ((t->tm_year + 299) / 400) * 86400); + /* Else use direct calculation using POSIX assumptions. */ + /* First, fix up tm_yday based on the year/month/day. */ + mktime(t); + /* Then we can compute timegm() from first principles. */ + return (t->tm_sec + + t->tm_min * 60 + + t->tm_hour * 3600 + + t->tm_yday * 86400 + + (t->tm_year - 70) * 31536000 + + ((t->tm_year - 69) / 4) * 86400 + - ((t->tm_year - 1) / 100) * 86400 + + ((t->tm_year + 299) / 400) * 86400); #endif } @@ -3189,9 +3192,8 @@ xml2_read_toc(struct archive_read *a) case XML_READER_TYPE_ELEMENT: empty = xmlTextReaderIsEmptyElement(reader); r = xml2_xmlattr_setup(a, &list, reader); - if (r != ARCHIVE_OK) - return (r); - r = xml_start(a, name, &list); + if (r == ARCHIVE_OK) + r = xml_start(a, name, &list); xmlattr_cleanup(&list); if (r != ARCHIVE_OK) return (r); diff --git a/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c b/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c index 5ef2952..62bf5e3 100644 --- a/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c +++ b/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c @@ -1,6 +1,6 @@ /*- * Copyright (c) 2004-2013 Tim Kientzle - * Copyright (c) 2011-2012 Michihiro NAKAJIMA + * Copyright (c) 2011-2012,2014 Michihiro NAKAJIMA * Copyright (c) 2013 Konrad Kleine * All rights reserved. * @@ -53,9 +53,12 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_format_zip.c 201102 #endif #include "archive.h" +#include "archive_digest_private.h" +#include "archive_cryptor_private.h" #include "archive_endian.h" #include "archive_entry.h" #include "archive_entry_locale.h" +#include "archive_hmac_private.h" #include "archive_private.h" #include "archive_rb.h" #include "archive_read_private.h" @@ -64,10 +67,6 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_format_zip.c 201102 #include "archive_crc32.h" #endif -#if defined(_WIN32) && !defined(__CYGWIN__) -# define snprintf _snprintf -#endif - struct zip_entry { struct archive_rb_node node; struct zip_entry *next; @@ -86,6 +85,25 @@ struct zip_entry { unsigned char compression; unsigned char system; /* From "version written by" */ unsigned char flags; /* Our extra markers. */ + unsigned char decdat;/* Used for Decryption check */ + + /* WinZip AES encryption extra field should be available + * when compression is 99. */ + struct { + /* Vendor version: AE-1 - 0x0001, AE-2 - 0x0002 */ + unsigned vendor; +#define AES_VENDOR_AE_1 0x0001 +#define AES_VENDOR_AE_2 0x0002 + /* AES encryption strength: + * 1 - 128 bits, 2 - 192 bits, 2 - 256 bits. */ + unsigned strength; + /* Actual compression method. */ + unsigned char compression; + } aes_extra; +}; + +struct trad_enc_ctx { + uint32_t keys[3]; }; /* Bits used in zip_flags. */ @@ -101,9 +119,20 @@ struct zip_entry { #define LA_USED_ZIP64 (1 << 0) #define LA_FROM_CENTRAL_DIRECTORY (1 << 1) +/* + * See "WinZip - AES Encryption Information" + * http://www.winzip.com/aes_info.htm + */ +/* Value used in compression method. */ +#define WINZIP_AES_ENCRYPTION 99 +/* Authentication code size. */ +#define AUTH_CODE_SIZE 10 +/**/ +#define MAX_DERIVED_KEY_BUF_SIZE (AES_MAX_KEY_SIZE * 2 + 2) + struct zip { /* Structural information about the archive. */ - char format_name[64]; + struct archive_string format_name; int64_t central_directory_offset; size_t central_directory_entries_total; size_t central_directory_entries_on_this_disk; @@ -127,7 +156,8 @@ struct zip { /* Running CRC32 of the decompressed data */ unsigned long entry_crc32; - unsigned long (*crc32func)(unsigned long, const void *, size_t); + unsigned long (*crc32func)(unsigned long, const void *, + size_t); char ignore_crc32; /* Flags to mark progress of decompression. */ @@ -146,6 +176,38 @@ struct zip { struct archive_string_conv *sconv_utf8; int init_default_conversion; int process_mac_extensions; + + char init_decryption; + + /* Decryption buffer. */ + unsigned char *decrypted_buffer; + unsigned char *decrypted_ptr; + size_t decrypted_buffer_size; + size_t decrypted_bytes_remaining; + size_t decrypted_unconsumed_bytes; + + /* Traditional PKWARE decryption. */ + struct trad_enc_ctx tctx; + char tctx_valid; + + /* WinZip AES decyption. */ + /* Contexts used for AES decryption. */ + archive_crypto_ctx cctx; + char cctx_valid; + archive_hmac_sha1_ctx hctx; + char hctx_valid; + + /* Strong encryption's decryption header information. */ + unsigned iv_size; + unsigned alg_id; + unsigned bit_len; + unsigned flags; + unsigned erd_size; + unsigned v_size; + unsigned v_crc32; + uint8_t *iv; + uint8_t *erd; + uint8_t *v_data; }; /* Many systems define min or MIN, but not all. */ @@ -154,6 +216,106 @@ struct zip { /* ------------------------------------------------------------------------ */ /* + Traditional PKWARE Decryption functions. + */ + +static void +trad_enc_update_keys(struct trad_enc_ctx *ctx, uint8_t c) +{ + uint8_t t; +#define CRC32(c, b) (crc32(c ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL) + + ctx->keys[0] = CRC32(ctx->keys[0], c); + ctx->keys[1] = (ctx->keys[1] + (ctx->keys[0] & 0xff)) * 134775813L + 1; + t = (ctx->keys[1] >> 24) & 0xff; + ctx->keys[2] = CRC32(ctx->keys[2], t); +#undef CRC32 +} + +static uint8_t +trad_enc_decypt_byte(struct trad_enc_ctx *ctx) +{ + unsigned temp = ctx->keys[2] | 2; + return (uint8_t)((temp * (temp ^ 1)) >> 8) & 0xff; +} + +static void +trad_enc_decrypt_update(struct trad_enc_ctx *ctx, const uint8_t *in, + size_t in_len, uint8_t *out, size_t out_len) +{ + unsigned i, max; + + max = (unsigned)((in_len < out_len)? in_len: out_len); + + for (i = 0; i < max; i++) { + uint8_t t = in[i] ^ trad_enc_decypt_byte(ctx); + out[i] = t; + trad_enc_update_keys(ctx, t); + } +} + +static int +trad_enc_init(struct trad_enc_ctx *ctx, const char *pw, size_t pw_len, + const uint8_t *key, size_t key_len, uint8_t *crcchk) +{ + uint8_t header[12]; + + if (key_len < 12) { + *crcchk = 0xff; + return -1; + } + + ctx->keys[0] = 305419896L; + ctx->keys[1] = 591751049L; + ctx->keys[2] = 878082192L; + + for (;pw_len; --pw_len) + trad_enc_update_keys(ctx, *pw++); + + trad_enc_decrypt_update(ctx, key, 12, header, 12); + /* Return the last byte for CRC check. */ + *crcchk = header[11]; + return 0; +} + +#if 0 +static void +crypt_derive_key_sha1(const void *p, int size, unsigned char *key, + int key_size) +{ +#define MD_SIZE 20 + archive_sha1_ctx ctx; + unsigned char md1[MD_SIZE]; + unsigned char md2[MD_SIZE * 2]; + unsigned char mkb[64]; + int i; + + archive_sha1_init(&ctx); + archive_sha1_update(&ctx, p, size); + archive_sha1_final(&ctx, md1); + + memset(mkb, 0x36, sizeof(mkb)); + for (i = 0; i < MD_SIZE; i++) + mkb[i] ^= md1[i]; + archive_sha1_init(&ctx); + archive_sha1_update(&ctx, mkb, sizeof(mkb)); + archive_sha1_final(&ctx, md2); + + memset(mkb, 0x5C, sizeof(mkb)); + for (i = 0; i < MD_SIZE; i++) + mkb[i] ^= md1[i]; + archive_sha1_init(&ctx); + archive_sha1_update(&ctx, mkb, sizeof(mkb)); + archive_sha1_final(&ctx, md2 + MD_SIZE); + + if (key_size > 32) + key_size = 32; + memcpy(key, md2, key_size); +#undef MD_SIZE +} +#endif + +/* * Common code for streaming or seeking modes. * * Includes code to read local file headers, decompress data @@ -163,9 +325,10 @@ struct zip { static unsigned long real_crc32(unsigned long crc, const void *buff, size_t len) { - return crc32(crc, buff, len); + return crc32(crc, buff, (unsigned int)len); } +/* Used by "ignorecrc32" option to speed up tests. */ static unsigned long fake_crc32(unsigned long crc, const void *buff, size_t len) { @@ -185,33 +348,36 @@ static struct { {3, "reduced-2"}, /* The file is Reduced with compression factor 2 */ {4, "reduced-3"}, /* The file is Reduced with compression factor 3 */ {5, "reduced-4"}, /* The file is Reduced with compression factor 4 */ - {6, "imploded"}, /* The file is Imploded */ - {7, "reserved"}, /* Reserved for Tokenizing compression algorithm */ + {6, "imploded"}, /* The file is Imploded */ + {7, "reserved"}, /* Reserved for Tokenizing compression algorithm */ {8, "deflation"}, /* The file is Deflated */ {9, "deflation-64-bit"}, /* Enhanced Deflating using Deflate64(tm) */ - {10, "ibm-terse"}, /* PKWARE Data Compression Library Imploding (old IBM TERSE) */ + {10, "ibm-terse"},/* PKWARE Data Compression Library Imploding + * (old IBM TERSE) */ {11, "reserved"}, /* Reserved by PKWARE */ - {12, "bzip"}, /* File is compressed using BZIP2 algorithm */ + {12, "bzip"}, /* File is compressed using BZIP2 algorithm */ {13, "reserved"}, /* Reserved by PKWARE */ - {14, "lzma"}, /* LZMA (EFS) */ + {14, "lzma"}, /* LZMA (EFS) */ {15, "reserved"}, /* Reserved by PKWARE */ {16, "reserved"}, /* Reserved by PKWARE */ {17, "reserved"}, /* Reserved by PKWARE */ {18, "ibm-terse-new"}, /* File is compressed using IBM TERSE (new) */ - {19, "ibm-lz777"}, /* IBM LZ77 z Architecture (PFS) */ + {19, "ibm-lz777"},/* IBM LZ77 z Architecture (PFS) */ {97, "wav-pack"}, /* WavPack compressed data */ - {98, "ppmd-1"} /* PPMd version I, Rev 1 */ + {98, "ppmd-1"}, /* PPMd version I, Rev 1 */ + {99, "aes"} /* WinZip AES encryption */ }; static const char * compression_name(const int compression) { - static const int num_compression_methods = sizeof(compression_methods)/sizeof(compression_methods[0]); + static const int num_compression_methods = + sizeof(compression_methods)/sizeof(compression_methods[0]); int i=0; + while(compression >= 0 && i < num_compression_methods) { - if (compression_methods[i].id == compression) { + if (compression_methods[i].id == compression) return compression_methods[i].name; - } i++; } return "??"; @@ -248,15 +414,15 @@ process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) { unsigned offset = 0; - while (offset < extra_length - 4) - { + while (offset < extra_length - 4) { unsigned short headerid = archive_le16dec(p + offset); unsigned short datasize = archive_le16dec(p + offset + 2); + offset += 4; if (offset + datasize > extra_length) break; #ifdef DEBUG - fprintf(stderr, "Header id 0x%x, length %d\n", + fprintf(stderr, "Header id 0x%04x, length %d\n", headerid, datasize); #endif switch (headerid) { @@ -291,6 +457,23 @@ process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) * on which file starts, but we don't handle * multi-volume Zip files. */ break; +#ifdef DEBUG + case 0x0017: + { + /* Strong encryption field. */ + if (archive_le16dec(p + offset) == 2) { + unsigned algId = + archive_le16dec(p + offset + 2); + unsigned bitLen = + archive_le16dec(p + offset + 4); + int flags = + archive_le16dec(p + offset + 6); + fprintf(stderr, "algId=0x%04x, bitLen=%u, " + "flgas=%d\n", algId, bitLen,flags); + } + break; + } +#endif case 0x5455: { /* Extended time field "UT". */ @@ -345,16 +528,34 @@ process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) } break; } - case 0x6c65: + case 0x6c78: { - /* Experimental 'el' field */ + /* Experimental 'xl' field */ /* * Introduced Dec 2013 to provide a way to - * include external file attributes in local file - * header. This provides file type and permission - * information necessary to support full streaming - * extraction. Currently being discussed with - * other Zip developers... subject to change. + * include external file attributes (and other + * fields that ordinarily appear only in + * central directory) in local file header. + * This provides file type and permission + * information necessary to support full + * streaming extraction. Currently being + * discussed with other Zip developers + * ... subject to change. + * + * Format: + * The field starts with a bitmap that specifies + * which additional fields are included. The + * bitmap is variable length and can be extended in + * the future. + * + * n bytes - feature bitmap: first byte has low-order + * 7 bits. If high-order bit is set, a subsequent + * byte holds the next 7 bits, etc. + * + * if bitmap & 1, 2 byte "version made by" + * if bitmap & 2, 2 byte "internal file attributes" + * if bitmap & 4, 4 byte "external file attributes" + * if bitmap * 7, 2 byte comment length + n byte comment */ int bitmap, bitmap_last; @@ -373,7 +574,7 @@ process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) } if (bitmap & 1) { - // 2 byte "version made by" + /* 2 byte "version made by" */ if (datasize < 2) break; zip_entry->system @@ -382,19 +583,19 @@ process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) datasize -= 2; } if (bitmap & 2) { - // 2 byte "internal file attributes" + /* 2 byte "internal file attributes" */ uint32_t internal_attributes; if (datasize < 2) break; internal_attributes = archive_le16dec(p + offset); - // Not used by libarchive at present. + /* Not used by libarchive at present. */ (void)internal_attributes; /* UNUSED */ offset += 2; datasize -= 2; } if (bitmap & 4) { - // 4 byte "external file attributes" + /* 4 byte "external file attributes" */ uint32_t external_attributes; if (datasize < 4) break; @@ -408,7 +609,7 @@ process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) datasize -= 4; } if (bitmap & 8) { - // 2 byte comment length + comment + /* 2 byte comment length + comment */ uint32_t comment_length; if (datasize < 2) break; @@ -419,7 +620,7 @@ process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) if (datasize < comment_length) break; - // Comment is not supported by libarchive + /* Comment is not supported by libarchive */ offset += comment_length; datasize -= comment_length; } @@ -447,7 +648,7 @@ process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) if (datasize >= 1 && p[offset] == 1) {/* version=1 */ if (datasize >= 4) { /* get a uid size. */ - uidsize = p[offset+1]; + uidsize = 0xff & (int)p[offset+1]; if (uidsize == 2) zip_entry->uid = archive_le16dec( @@ -459,7 +660,7 @@ process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) } if (datasize >= (2 + uidsize + 3)) { /* get a gid size. */ - gidsize = p[offset+2+uidsize]; + gidsize = 0xff & (int)p[offset+2+uidsize]; if (gidsize == 2) zip_entry->gid = archive_le16dec( @@ -473,6 +674,19 @@ process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) } break; } + case 0x9901: + /* WinZIp AES extra data field. */ + if (p[offset + 2] == 'A' && p[offset + 3] == 'E') { + /* Vendor version. */ + zip_entry->aes_extra.vendor = + archive_le16dec(p + offset); + /* AES encryption strength. */ + zip_entry->aes_extra.strength = p[offset + 4]; + /* Actual compression method. */ + zip_entry->aes_extra.compression = + p[offset + 5]; + } + break; default: break; } @@ -544,9 +758,14 @@ zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry, return ARCHIVE_FATAL; } } + zip->init_decryption = (zip_entry->zip_flags & ZIP_ENCRYPTED); zip_entry->compression = (char)archive_le16dec(p + 8); zip_entry->mtime = zip_time(p + 10); zip_entry->crc32 = archive_le32dec(p + 14); + if (zip_entry->zip_flags & ZIP_LENGTH_AT_END) + zip_entry->decdat = p[11]; + else + zip_entry->decdat = p[17]; zip_entry->compressed_size = archive_le32dec(p + 18); zip_entry->uncompressed_size = archive_le32dec(p + 22); filename_length = archive_le16dec(p + 26); @@ -687,7 +906,15 @@ zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry, archive_entry_set_atime(entry, zip_entry->atime, 0); if ((zip->entry->mode & AE_IFMT) == AE_IFLNK) { - size_t linkname_length = zip_entry->compressed_size; + size_t linkname_length; + + if (zip_entry->compressed_size > 64 * 1024) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Zip file with oversized link entry"); + return ARCHIVE_FATAL; + } + + linkname_length = (size_t)zip_entry->compressed_size; archive_entry_set_size(entry, 0); p = __archive_read_ahead(a, linkname_length, NULL); @@ -696,11 +923,6 @@ zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry, "Truncated Zip file"); return ARCHIVE_FATAL; } - if (__archive_read_consume(a, linkname_length) < 0) { - archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, - "Read error skipping symlink target name"); - return ARCHIVE_FATAL; - } sconv = zip->sconv; if (sconv == NULL && (zip->entry->zip_flags & ZIP_UTF8_NAME)) @@ -735,6 +957,12 @@ zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry, } } zip_entry->uncompressed_size = zip_entry->compressed_size = 0; + + if (__archive_read_consume(a, linkname_length) < 0) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Read error skipping symlink target name"); + return ARCHIVE_FATAL; + } } else if (0 == (zip_entry->zip_flags & ZIP_LENGTH_AT_END) || zip_entry->uncompressed_size > 0) { /* Set the size only if it's meaningful. */ @@ -748,14 +976,51 @@ zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry, zip->end_of_entry = 1; /* Set up a more descriptive format name. */ - snprintf(zip->format_name, sizeof(zip->format_name), "ZIP %d.%d (%s)", + archive_string_sprintf(&zip->format_name, "ZIP %d.%d (%s)", version / 10, version % 10, compression_name(zip->entry->compression)); - a->archive.archive_format_name = zip->format_name; + a->archive.archive_format_name = zip->format_name.s; return (ret); } +static int +check_authentication_code(struct archive_read *a, const void *_p) +{ + struct zip *zip = (struct zip *)(a->format->data); + + /* Check authentication code. */ + if (zip->hctx_valid) { + const void *p; + uint8_t hmac[20]; + size_t hmac_len = 20; + int cmp; + + archive_hmac_sha1_final(&zip->hctx, hmac, &hmac_len); + if (_p == NULL) { + /* Read authentication code. */ + p = __archive_read_ahead(a, AUTH_CODE_SIZE, NULL); + if (p == NULL) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, + "Truncated ZIP file data"); + return (ARCHIVE_FATAL); + } + } else { + p = _p; + } + cmp = memcmp(hmac, p, AUTH_CODE_SIZE); + __archive_read_consume(a, AUTH_CODE_SIZE); + if (cmp != 0) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_MISC, + "ZIP bad Authentication code"); + return (ARCHIVE_WARN); + } + } + return (ARCHIVE_OK); +} + /* * Read "uncompressed" data. There are three cases: * 1) We know the size of the data. This is always true for the @@ -787,6 +1052,7 @@ zip_read_data_none(struct archive_read *a, const void **_buff, struct zip *zip; const char *buff; ssize_t bytes_avail; + int r; (void)offset; /* UNUSED */ @@ -794,10 +1060,13 @@ zip_read_data_none(struct archive_read *a, const void **_buff, if (zip->entry->zip_flags & ZIP_LENGTH_AT_END) { const char *p; + ssize_t grabbing_bytes = 24; + if (zip->hctx_valid) + grabbing_bytes += AUTH_CODE_SIZE; /* Grab at least 24 bytes. */ - buff = __archive_read_ahead(a, 24, &bytes_avail); - if (bytes_avail < 24) { + buff = __archive_read_ahead(a, grabbing_bytes, &bytes_avail); + if (bytes_avail < grabbing_bytes) { /* Zip archives have end-of-archive markers that are longer than this, so a failure to get at least 24 bytes really does indicate a truncated @@ -810,21 +1079,34 @@ zip_read_data_none(struct archive_read *a, const void **_buff, /* Check for a complete PK\007\010 signature, followed * by the correct 4-byte CRC. */ p = buff; + if (zip->hctx_valid) + p += AUTH_CODE_SIZE; if (p[0] == 'P' && p[1] == 'K' && p[2] == '\007' && p[3] == '\010' && (archive_le32dec(p + 4) == zip->entry_crc32 - || zip->ignore_crc32)) { + || zip->ignore_crc32 + || (zip->hctx_valid + && zip->entry->aes_extra.vendor == AES_VENDOR_AE_2))) { if (zip->entry->flags & LA_USED_ZIP64) { zip->entry->crc32 = archive_le32dec(p + 4); - zip->entry->compressed_size = archive_le64dec(p + 8); - zip->entry->uncompressed_size = archive_le64dec(p + 16); + zip->entry->compressed_size = + archive_le64dec(p + 8); + zip->entry->uncompressed_size = + archive_le64dec(p + 16); zip->unconsumed = 24; } else { zip->entry->crc32 = archive_le32dec(p + 4); - zip->entry->compressed_size = archive_le32dec(p + 8); - zip->entry->uncompressed_size = archive_le32dec(p + 12); + zip->entry->compressed_size = + archive_le32dec(p + 8); + zip->entry->uncompressed_size = + archive_le32dec(p + 12); zip->unconsumed = 16; } + if (zip->hctx_valid) { + r = check_authentication_code(a, buff); + if (r != ARCHIVE_OK) + return (r); + } zip->end_of_entry = 1; return (ARCHIVE_OK); } @@ -841,6 +1123,8 @@ zip_read_data_none(struct archive_read *a, const void **_buff, else if (p[3] == '\007') { p += 1; } else if (p[3] == '\010' && p[2] == '\007' && p[1] == 'K' && p[0] == 'P') { + if (zip->hctx_valid) + p -= AUTH_CODE_SIZE; break; } else { p += 4; } } @@ -848,6 +1132,11 @@ zip_read_data_none(struct archive_read *a, const void **_buff, } else { if (zip->entry_bytes_remaining == 0) { zip->end_of_entry = 1; + if (zip->hctx_valid) { + r = check_authentication_code(a, NULL); + if (r != ARCHIVE_OK) + return (r); + } return (ARCHIVE_OK); } /* Grab a bunch of bytes. */ @@ -861,6 +1150,26 @@ zip_read_data_none(struct archive_read *a, const void **_buff, if (bytes_avail > zip->entry_bytes_remaining) bytes_avail = (ssize_t)zip->entry_bytes_remaining; } + if (zip->tctx_valid || zip->cctx_valid) { + size_t dec_size = bytes_avail; + + if (dec_size > zip->decrypted_buffer_size) + dec_size = zip->decrypted_buffer_size; + if (zip->tctx_valid) { + trad_enc_decrypt_update(&zip->tctx, + (const uint8_t *)buff, dec_size, + zip->decrypted_buffer, dec_size); + } else { + size_t dsize = dec_size; + archive_hmac_sha1_update(&zip->hctx, + (const uint8_t *)buff, dec_size); + archive_decrypto_aes_ctr_update(&zip->cctx, + (const uint8_t *)buff, dec_size, + zip->decrypted_buffer, &dsize); + } + bytes_avail = dec_size; + buff = (const char *)zip->decrypted_buffer; + } *size = bytes_avail; zip->entry_bytes_remaining -= bytes_avail; zip->entry_uncompressed_bytes_read += bytes_avail; @@ -902,7 +1211,7 @@ zip_read_data_deflate(struct archive_read *a, const void **buff, { struct zip *zip; ssize_t bytes_avail; - const void *compressed_buff; + const void *compressed_buff, *sp; int r; (void)offset; /* UNUSED */ @@ -931,7 +1240,7 @@ zip_read_data_deflate(struct archive_read *a, const void **buff, * available bytes; asking for more than that forces the * decompressor to combine reads by copying data. */ - compressed_buff = __archive_read_ahead(a, 1, &bytes_avail); + compressed_buff = sp = __archive_read_ahead(a, 1, &bytes_avail); if (0 == (zip->entry->zip_flags & ZIP_LENGTH_AT_END) && bytes_avail > zip->entry_bytes_remaining) { bytes_avail = (ssize_t)zip->entry_bytes_remaining; @@ -942,6 +1251,51 @@ zip_read_data_deflate(struct archive_read *a, const void **buff, return (ARCHIVE_FATAL); } + if (zip->tctx_valid || zip->cctx_valid) { + if (zip->decrypted_bytes_remaining < (size_t)bytes_avail) { + size_t buff_remaining = zip->decrypted_buffer_size + - (zip->decrypted_ptr - zip->decrypted_buffer); + + if (buff_remaining > (size_t)bytes_avail) + buff_remaining = (size_t)bytes_avail; + + if (0 == (zip->entry->zip_flags & ZIP_LENGTH_AT_END) && + zip->entry_bytes_remaining > 0) { + if ((int64_t)(zip->decrypted_bytes_remaining + + buff_remaining) + > zip->entry_bytes_remaining) { + if (zip->entry_bytes_remaining < + (int64_t)zip->decrypted_bytes_remaining) + buff_remaining = 0; + else + buff_remaining = + (size_t)zip->entry_bytes_remaining + - zip->decrypted_bytes_remaining; + } + } + if (buff_remaining > 0) { + if (zip->tctx_valid) { + trad_enc_decrypt_update(&zip->tctx, + compressed_buff, buff_remaining, + zip->decrypted_ptr + + zip->decrypted_bytes_remaining, + buff_remaining); + } else { + size_t dsize = buff_remaining; + archive_decrypto_aes_ctr_update( + &zip->cctx, + compressed_buff, buff_remaining, + zip->decrypted_ptr + + zip->decrypted_bytes_remaining, + &dsize); + } + zip->decrypted_bytes_remaining += buff_remaining; + } + } + bytes_avail = zip->decrypted_bytes_remaining; + compressed_buff = (const char *)zip->decrypted_ptr; + } + /* * A bug in zlib.h: stream.next_in should be marked 'const' * but isn't (the library never alters data through the @@ -974,6 +1328,16 @@ zip_read_data_deflate(struct archive_read *a, const void **buff, /* Consume as much as the compressor actually used. */ bytes_avail = zip->stream.total_in; + if (zip->tctx_valid || zip->cctx_valid) { + zip->decrypted_bytes_remaining -= bytes_avail; + if (zip->decrypted_bytes_remaining == 0) + zip->decrypted_ptr = zip->decrypted_buffer; + else + zip->decrypted_ptr += bytes_avail; + } + /* Calculate compressed data as much as we used.*/ + if (zip->hctx_valid) + archive_hmac_sha1_update(&zip->hctx, sp, bytes_avail); __archive_read_consume(a, bytes_avail); zip->entry_bytes_remaining -= bytes_avail; zip->entry_compressed_bytes_read += bytes_avail; @@ -982,6 +1346,12 @@ zip_read_data_deflate(struct archive_read *a, const void **buff, zip->entry_uncompressed_bytes_read += zip->stream.total_out; *buff = zip->uncompressed_buffer; + if (zip->end_of_entry && zip->hctx_valid) { + r = check_authentication_code(a, NULL); + if (r != ARCHIVE_OK) + return (r); + } + if (zip->end_of_entry && (zip->entry->zip_flags & ZIP_LENGTH_AT_END)) { const char *p; @@ -1015,13 +1385,392 @@ zip_read_data_deflate(struct archive_read *a, const void **buff, #endif static int +read_decryption_header(struct archive_read *a) +{ + struct zip *zip = (struct zip *)(a->format->data); + const char *p; + unsigned int remaining_size; + unsigned int ts; + + /* + * Read an initialization vector data field. + */ + p = __archive_read_ahead(a, 2, NULL); + if (p == NULL) + goto truncated; + ts = zip->iv_size; + zip->iv_size = archive_le16dec(p); + __archive_read_consume(a, 2); + if (ts < zip->iv_size) { + free(zip->iv); + zip->iv = NULL; + } + p = __archive_read_ahead(a, zip->iv_size, NULL); + if (p == NULL) + goto truncated; + if (zip->iv == NULL) { + zip->iv = malloc(zip->iv_size); + if (zip->iv == NULL) + goto nomem; + } + memcpy(zip->iv, p, zip->iv_size); + __archive_read_consume(a, zip->iv_size); + + /* + * Read a size of remaining decryption header field. + */ + p = __archive_read_ahead(a, 14, NULL); + if (p == NULL) + goto truncated; + remaining_size = archive_le32dec(p); + if (remaining_size < 16 || remaining_size > (1 << 18)) + goto corrupted; + + /* Check if format version is supported. */ + if (archive_le16dec(p+4) != 3) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, + "Unsupported encryption format version: %u", + archive_le16dec(p+4)); + return (ARCHIVE_FAILED); + } + + /* + * Read an encryption algorithm field. + */ + zip->alg_id = archive_le16dec(p+6); + switch (zip->alg_id) { + case 0x6601:/* DES */ + case 0x6602:/* RC2 */ + case 0x6603:/* 3DES 168 */ + case 0x6609:/* 3DES 112 */ + case 0x660E:/* AES 128 */ + case 0x660F:/* AES 192 */ + case 0x6610:/* AES 256 */ + case 0x6702:/* RC2 (version >= 5.2) */ + case 0x6720:/* Blowfish */ + case 0x6721:/* Twofish */ + case 0x6801:/* RC4 */ + /* Suuported encryption algorithm. */ + break; + default: + archive_set_error(&a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, + "Unknown encryption algorithm: %u", zip->alg_id); + return (ARCHIVE_FAILED); + } + + /* + * Read a bit length field. + */ + zip->bit_len = archive_le16dec(p+8); + + /* + * Read a flags field. + */ + zip->flags = archive_le16dec(p+10); + switch (zip->flags & 0xf000) { + case 0x0001: /* Password is required to decrypt. */ + case 0x0002: /* Certificates only. */ + case 0x0003: /* Password or certificate required to decrypt. */ + break; + default: + archive_set_error(&a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, + "Unknown encryption flag: %u", zip->flags); + return (ARCHIVE_FAILED); + } + if ((zip->flags & 0xf000) == 0 || + (zip->flags & 0xf000) == 0x4000) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, + "Unknown encryption flag: %u", zip->flags); + return (ARCHIVE_FAILED); + } + + /* + * Read an encrypted random data field. + */ + ts = zip->erd_size; + zip->erd_size = archive_le16dec(p+12); + __archive_read_consume(a, 14); + if ((zip->erd_size & 0xf) != 0 || + (zip->erd_size + 16) > remaining_size || + (zip->erd_size + 16) < zip->erd_size) + goto corrupted; + + if (ts < zip->erd_size) { + free(zip->erd); + zip->erd = NULL; + } + p = __archive_read_ahead(a, zip->erd_size, NULL); + if (p == NULL) + goto truncated; + if (zip->erd == NULL) { + zip->erd = malloc(zip->erd_size); + if (zip->erd == NULL) + goto nomem; + } + memcpy(zip->erd, p, zip->erd_size); + __archive_read_consume(a, zip->erd_size); + + /* + * Read a reserved data field. + */ + p = __archive_read_ahead(a, 4, NULL); + if (p == NULL) + goto truncated; + /* Reserved data size should be zero. */ + if (archive_le32dec(p) != 0) + goto corrupted; + __archive_read_consume(a, 4); + + /* + * Read a password validation data field. + */ + p = __archive_read_ahead(a, 2, NULL); + if (p == NULL) + goto truncated; + ts = zip->v_size; + zip->v_size = archive_le16dec(p); + __archive_read_consume(a, 2); + if ((zip->v_size & 0x0f) != 0 || + (zip->erd_size + zip->v_size + 16) > remaining_size || + (zip->erd_size + zip->v_size + 16) < (zip->erd_size + zip->v_size)) + goto corrupted; + if (ts < zip->v_size) { + free(zip->v_data); + zip->v_data = NULL; + } + p = __archive_read_ahead(a, zip->v_size, NULL); + if (p == NULL) + goto truncated; + if (zip->v_data == NULL) { + zip->v_data = malloc(zip->v_size); + if (zip->v_data == NULL) + goto nomem; + } + memcpy(zip->v_data, p, zip->v_size); + __archive_read_consume(a, zip->v_size); + + p = __archive_read_ahead(a, 4, NULL); + if (p == NULL) + goto truncated; + zip->v_crc32 = archive_le32dec(p); + __archive_read_consume(a, 4); + + /*return (ARCHIVE_OK); + * This is not fully implemnted yet.*/ + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Encrypted file is unsupported"); + return (ARCHIVE_FAILED); +truncated: + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Truncated ZIP file data"); + return (ARCHIVE_FATAL); +corrupted: + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Corrupted ZIP file data"); + return (ARCHIVE_FATAL); +nomem: + archive_set_error(&a->archive, ENOMEM, + "No memory for ZIP decryption"); + return (ARCHIVE_FATAL); +} + +static int +zip_alloc_decryption_buffer(struct archive_read *a) +{ + struct zip *zip = (struct zip *)(a->format->data); + size_t bs = 256 * 1024; + + if (zip->decrypted_buffer == NULL) { + zip->decrypted_buffer_size = bs; + zip->decrypted_buffer = malloc(bs); + if (zip->decrypted_buffer == NULL) { + archive_set_error(&a->archive, ENOMEM, + "No memory for ZIP decryption"); + return (ARCHIVE_FATAL); + } + } + zip->decrypted_ptr = zip->decrypted_buffer; + return (ARCHIVE_OK); +} + +static int +init_traditional_PKWARE_decryption(struct archive_read *a) +{ + struct zip *zip = (struct zip *)(a->format->data); + const void *p; + int retry; + int r; + + if (zip->tctx_valid) + return (ARCHIVE_OK); + + /* + Read the 12 bytes encryption header stored at + the start of the data area. + */ +#define ENC_HEADER_SIZE 12 + if (0 == (zip->entry->zip_flags & ZIP_LENGTH_AT_END) + && zip->entry_bytes_remaining < ENC_HEADER_SIZE) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Truncated Zip encrypted body: only %jd bytes available", + (intmax_t)zip->entry_bytes_remaining); + return (ARCHIVE_FATAL); + } + + p = __archive_read_ahead(a, ENC_HEADER_SIZE, NULL); + if (p == NULL) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Truncated ZIP file data"); + return (ARCHIVE_FATAL); + } + + for (retry = 0;; retry++) { + const char *passphrase; + uint8_t crcchk; + + passphrase = __archive_read_next_passphrase(a); + if (passphrase == NULL) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + (retry > 0)? + "Incorrect passphrase": + "Passphrase required for this entry"); + return (ARCHIVE_FAILED); + } + + /* + * Initialize ctx for Traditional PKWARE Decyption. + */ + r = trad_enc_init(&zip->tctx, passphrase, strlen(passphrase), + p, ENC_HEADER_SIZE, &crcchk); + if (r == 0 && crcchk == zip->entry->decdat) + break;/* The passphrase is OK. */ + if (retry > 10000) { + /* Avoid infinity loop. */ + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Too many incorrect passphrases"); + return (ARCHIVE_FAILED); + } + } + + __archive_read_consume(a, ENC_HEADER_SIZE); + zip->tctx_valid = 1; + if (0 == (zip->entry->zip_flags & ZIP_LENGTH_AT_END)) { + zip->entry_bytes_remaining -= ENC_HEADER_SIZE; + } + /*zip->entry_uncompressed_bytes_read += ENC_HEADER_SIZE;*/ + zip->entry_compressed_bytes_read += ENC_HEADER_SIZE; + zip->decrypted_bytes_remaining = 0; + + return (zip_alloc_decryption_buffer(a)); +#undef ENC_HEADER_SIZE +} + +static int +init_WinZip_AES_decryption(struct archive_read *a) +{ + struct zip *zip = (struct zip *)(a->format->data); + const void *p; + const uint8_t *pv; + size_t key_len, salt_len; + uint8_t derived_key[MAX_DERIVED_KEY_BUF_SIZE]; + int retry; + int r; + + if (zip->cctx_valid || zip->hctx_valid) + return (ARCHIVE_OK); + + switch (zip->entry->aes_extra.strength) { + case 1: salt_len = 8; key_len = 16; break; + case 2: salt_len = 12; key_len = 24; break; + case 3: salt_len = 16; key_len = 32; break; + default: goto corrupted; + } + p = __archive_read_ahead(a, salt_len + 2, NULL); + if (p == NULL) + goto truncated; + + for (retry = 0;; retry++) { + const char *passphrase; + + passphrase = __archive_read_next_passphrase(a); + if (passphrase == NULL) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + (retry > 0)? + "Incorrect passphrase": + "Passphrase required for this entry"); + return (ARCHIVE_FAILED); + } + memset(derived_key, 0, sizeof(derived_key)); + r = archive_pbkdf2_sha1(passphrase, strlen(passphrase), + p, salt_len, 1000, derived_key, key_len * 2 + 2); + if (r != 0) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Decryption is unsupported due to lack of " + "crypto library"); + return (ARCHIVE_FAILED); + } + + /* Check password verification value. */ + pv = ((const uint8_t *)p) + salt_len; + if (derived_key[key_len * 2] == pv[0] && + derived_key[key_len * 2 + 1] == pv[1]) + break;/* The passphrase is OK. */ + if (retry > 10000) { + /* Avoid infinity loop. */ + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Too many incorrect passphrases"); + return (ARCHIVE_FAILED); + } + } + + r = archive_decrypto_aes_ctr_init(&zip->cctx, derived_key, key_len); + if (r != 0) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Decryption is unsupported due to lack of crypto library"); + return (ARCHIVE_FAILED); + } + r = archive_hmac_sha1_init(&zip->hctx, derived_key + key_len, key_len); + if (r != 0) { + archive_decrypto_aes_ctr_release(&zip->cctx); + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Failed to initialize HMAC-SHA1"); + return (ARCHIVE_FAILED); + } + zip->cctx_valid = zip->hctx_valid = 1; + __archive_read_consume(a, salt_len + 2); + zip->entry_bytes_remaining -= salt_len + 2 + AUTH_CODE_SIZE; + if (0 == (zip->entry->zip_flags & ZIP_LENGTH_AT_END) + && zip->entry_bytes_remaining < 0) + goto corrupted; + zip->entry_compressed_bytes_read += salt_len + 2 + AUTH_CODE_SIZE; + zip->decrypted_bytes_remaining = 0; + + zip->entry->compression = zip->entry->aes_extra.compression; + return (zip_alloc_decryption_buffer(a)); + +truncated: + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Truncated ZIP file data"); + return (ARCHIVE_FATAL); +corrupted: + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Corrupted ZIP file data"); + return (ARCHIVE_FATAL); +} + +static int archive_read_format_zip_read_data(struct archive_read *a, const void **buff, size_t *size, int64_t *offset) { int r; struct zip *zip = (struct zip *)(a->format->data); - if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { + if (zip->has_encrypted_entries == + ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { zip->has_encrypted_entries = 0; } @@ -1037,16 +1786,22 @@ archive_read_format_zip_read_data(struct archive_read *a, if (AE_IFREG != (zip->entry->mode & AE_IFMT)) return (ARCHIVE_EOF); - if (zip->entry->zip_flags & (ZIP_ENCRYPTED | ZIP_STRONG_ENCRYPTED)) { - zip->has_encrypted_entries = 1; - archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, - "Encrypted file is unsupported"); - return (ARCHIVE_FAILED); - } - __archive_read_consume(a, zip->unconsumed); zip->unconsumed = 0; + if (zip->init_decryption) { + zip->has_encrypted_entries = 1; + if (zip->entry->zip_flags & ZIP_STRONG_ENCRYPTED) + r = read_decryption_header(a); + else if (zip->entry->compression == WINZIP_AES_ENCRYPTION) + r = init_WinZip_AES_decryption(a); + else + r = init_traditional_PKWARE_decryption(a); + if (r != ARCHIVE_OK) + return (r); + zip->init_decryption = 0; + } + switch(zip->entry->compression) { case 0: /* No compression. */ r = zip_read_data_none(a, buff, size, offset); @@ -1096,7 +1851,9 @@ archive_read_format_zip_read_data(struct archive_read *a, return (ARCHIVE_WARN); } /* Check computed CRC against header */ - if (zip->entry->crc32 != zip->entry_crc32 + if ((!zip->hctx_valid || + zip->entry->aes_extra.vendor != AES_VENDOR_AE_2) && + zip->entry->crc32 != zip->entry_crc32 && !zip->ignore_crc32) { archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "ZIP bad CRC: 0x%lx should be 0x%lx", @@ -1130,6 +1887,15 @@ archive_read_format_zip_cleanup(struct archive_read *a) zip_entry = next_zip_entry; } } + free(zip->decrypted_buffer); + if (zip->cctx_valid) + archive_decrypto_aes_ctr_release(&zip->cctx); + if (zip->hctx_valid) + archive_hmac_sha1_cleanup(&zip->hctx); + free(zip->iv); + free(zip->erd); + free(zip->v_data); + archive_string_free(&zip->format_name); free(zip); (a->format->data) = NULL; return (ARCHIVE_OK); @@ -1217,7 +1983,8 @@ static int archive_read_support_format_zip_capabilities_streamable(struct archive_read * a) { (void)a; /* UNUSED */ - return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA | ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA); + return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA | + ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA); } static int @@ -1275,9 +2042,9 @@ archive_read_format_zip_streamable_read_header(struct archive_read *a, * archive_read_data(), so be it. We'll do the same check there * as well. */ - if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { + if (zip->has_encrypted_entries == + ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) zip->has_encrypted_entries = 0; - } /* Make sure we have a zip_entry structure to use. */ if (zip->zip_entries == NULL) { @@ -1291,6 +2058,13 @@ archive_read_format_zip_streamable_read_header(struct archive_read *a, zip->entry = zip->zip_entries; memset(zip->entry, 0, sizeof(struct zip_entry)); + if (zip->cctx_valid) + archive_decrypto_aes_ctr_release(&zip->cctx); + if (zip->hctx_valid) + archive_hmac_sha1_cleanup(&zip->hctx); + zip->tctx_valid = zip->cctx_valid = zip->hctx_valid = 0; + __archive_read_reset_passphrase(a); + /* Search ahead for the next local file header. */ __archive_read_consume(a, zip->unconsumed); zip->unconsumed = 0; @@ -1363,12 +2137,28 @@ archive_read_format_zip_read_data_skip_streamable(struct archive_read *a) if (0 == (zip->entry->zip_flags & ZIP_LENGTH_AT_END) || zip->entry->compressed_size > 0) { /* We know the compressed length, so we can just skip. */ - bytes_skipped = __archive_read_consume(a, zip->entry_bytes_remaining); + bytes_skipped = __archive_read_consume(a, + zip->entry_bytes_remaining); if (bytes_skipped < 0) return (ARCHIVE_FATAL); return (ARCHIVE_OK); } + if (zip->init_decryption) { + int r; + + zip->has_encrypted_entries = 1; + if (zip->entry->zip_flags & ZIP_STRONG_ENCRYPTED) + r = read_decryption_header(a); + else if (zip->entry->compression == WINZIP_AES_ENCRYPTION) + r = init_WinZip_AES_decryption(a); + else + r = init_traditional_PKWARE_decryption(a); + if (r != ARCHIVE_OK) + return (r); + zip->init_decryption = 0; + } + /* We're streaming and we don't know the length. */ /* If the body is compressed and we know the format, we can * find an exact end-of-entry by decompressing it. */ @@ -1406,9 +2196,11 @@ archive_read_format_zip_read_data_skip_streamable(struct archive_read *a) else if (p[3] == '\010' && p[2] == '\007' && p[1] == 'K' && p[0] == 'P') { if (zip->entry->flags & LA_USED_ZIP64) - __archive_read_consume(a, p - buff + 24); + __archive_read_consume(a, + p - buff + 24); else - __archive_read_consume(a, p - buff + 16); + __archive_read_consume(a, + p - buff + 16); return ARCHIVE_OK; } else { p += 4; } } @@ -1427,13 +2219,12 @@ archive_read_support_format_zip_streamable(struct archive *_a) archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, "archive_read_support_format_zip"); - zip = (struct zip *)malloc(sizeof(*zip)); + zip = (struct zip *)calloc(1, sizeof(*zip)); if (zip == NULL) { archive_set_error(&a->archive, ENOMEM, "Can't allocate zip data"); return (ARCHIVE_FATAL); } - memset(zip, 0, sizeof(*zip)); /* Streamable reader doesn't support mac extensions. */ zip->process_mac_extensions = 0; @@ -1473,7 +2264,8 @@ static int archive_read_support_format_zip_capabilities_seekable(struct archive_read * a) { (void)a; /* UNUSED */ - return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA | ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA); + return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA | + ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA); } /* @@ -1514,7 +2306,11 @@ read_eocd(struct zip *zip, const char *p, int64_t current_offset) return 32; } -static int +/* + * Examine Zip64 EOCD locator: If it's valid, store the information + * from it. + */ +static void read_zip64_eocd(struct archive_read *a, struct zip *zip, const char *p) { int64_t eocd64_offset; @@ -1524,37 +2320,35 @@ read_zip64_eocd(struct archive_read *a, struct zip *zip, const char *p) /* Central dir must be on first volume. */ if (archive_le32dec(p + 4) != 0) - return 0; + return; /* Must be only a single volume. */ if (archive_le32dec(p + 16) != 1) - return 0; + return; /* Find the Zip64 EOCD record. */ eocd64_offset = archive_le64dec(p + 8); if (__archive_read_seek(a, eocd64_offset, SEEK_SET) < 0) - return 0; + return; if ((p = __archive_read_ahead(a, 56, NULL)) == NULL) - return 0; + return; /* Make sure we can read all of it. */ eocd64_size = archive_le64dec(p + 4) + 12; if (eocd64_size < 56 || eocd64_size > 16384) - return 0; - if ((p = __archive_read_ahead(a, eocd64_size, NULL)) == NULL) - return 0; + return; + if ((p = __archive_read_ahead(a, (size_t)eocd64_size, NULL)) == NULL) + return; /* Sanity-check the EOCD64 */ if (archive_le32dec(p + 16) != 0) /* Must be disk #0 */ - return 0; + return; if (archive_le32dec(p + 20) != 0) /* CD must be on disk #0 */ - return 0; + return; /* CD can't be split. */ if (archive_le64dec(p + 24) != archive_le64dec(p + 32)) - return 0; + return; /* Save the central directory offset for later use. */ zip->central_directory_offset = archive_le64dec(p + 48); - - return 32; } static int @@ -1575,40 +2369,39 @@ archive_read_format_zip_seekable_bid(struct archive_read *a, int best_bid) return 0; /* Search last 16k of file for end-of-central-directory - * record (which starts with PK\005\006) or Zip64 locator - * record (which begins with PK\006\007) */ - tail = zipmin(1024 * 16, file_size); + * record (which starts with PK\005\006) */ + tail = (int)zipmin(1024 * 16, file_size); current_offset = __archive_read_seek(a, -tail, SEEK_END); if (current_offset < 0) return 0; if ((p = __archive_read_ahead(a, (size_t)tail, NULL)) == NULL) return 0; - /* TODO: Rework this to search backwards from the end. We - * normally expect the EOCD record to be at the very end, so - * that should be significantly faster. Tricky part: Make - * sure we still prefer the Zip64 locator if it's present. */ - for (i = 0; i <= tail - 22;) { - switch (p[i + 3]) { - case 'P': i += 3; break; - case 'K': i += 2; break; - case 005: i += 1; break; - case 006: + /* Boyer-Moore search backwards from the end, since we want + * to match the last EOCD in the file (there can be more than + * one if there is an uncompressed Zip archive as a member + * within this Zip archive). */ + for (i = tail - 22; i > 0;) { + switch (p[i]) { + case 'P': if (memcmp(p + i, "PK\005\006", 4) == 0) { - int ret = read_eocd(zip, p + i, current_offset + i); - if (ret > 0) - return (ret); - } - i += 1; /* Look for PK\006\007 next */ - break; - case 007: - if (memcmp(p + i, "PK\006\007", 4) == 0) { - int ret = read_zip64_eocd(a, zip, p + i); - if (ret > 0) + int ret = read_eocd(zip, p + i, + current_offset + i); + if (ret > 0) { + /* Zip64 EOCD locator precedes + * regular EOCD if present. */ + if (i >= 20 + && memcmp(p + i - 20, "PK\006\007", 4) == 0) { + read_zip64_eocd(a, zip, p + i - 20); + } return (ret); + } } - i += 4; + i -= 4; break; - default: i += 4; break; + case 'K': i -= 1; break; + case 005: i -= 2; break; + case 006: i -= 3; break; + default: i -= 4; break; } } return 0; @@ -1760,7 +2553,8 @@ slurp_central_directory(struct archive_read *a, struct zip *zip) } __archive_read_consume(a, i); } - correction = archive_filter_bytes(&a->archive, 0) - zip->central_directory_offset; + correction = archive_filter_bytes(&a->archive, 0) + - zip->central_directory_offset; __archive_rb_tree_init(&zip->tree, &rb_ops); __archive_rb_tree_init(&zip->tree_rsrc, &rb_rsrc_ops); @@ -1795,12 +2589,17 @@ slurp_central_directory(struct archive_read *a, struct zip *zip) zip_entry->system = p[5]; /* version_required = archive_le16dec(p + 6); */ zip_entry->zip_flags = archive_le16dec(p + 8); - if (zip_entry->zip_flags & (ZIP_ENCRYPTED | ZIP_STRONG_ENCRYPTED)){ + if (zip_entry->zip_flags + & (ZIP_ENCRYPTED | ZIP_STRONG_ENCRYPTED)){ zip->has_encrypted_entries = 1; } zip_entry->compression = (char)archive_le16dec(p + 10); zip_entry->mtime = zip_time(p + 12); zip_entry->crc32 = archive_le32dec(p + 16); + if (zip_entry->zip_flags & ZIP_LENGTH_AT_END) + zip_entry->decdat = p[13]; + else + zip_entry->decdat = p[19]; zip_entry->compressed_size = archive_le32dec(p + 20); zip_entry->uncompressed_size = archive_le32dec(p + 24); filename_length = archive_le16dec(p + 28); @@ -1823,9 +2622,11 @@ slurp_central_directory(struct archive_read *a, struct zip *zip) /* We're done with the regular data; get the filename and * extra data. */ __archive_read_consume(a, 46); - if ((p = __archive_read_ahead(a, filename_length + extra_length, NULL)) - == NULL) { - archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + p = __archive_read_ahead(a, filename_length + extra_length, + NULL); + if (p == NULL) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, "Truncated ZIP file header"); return ARCHIVE_FATAL; } @@ -1850,26 +2651,30 @@ slurp_central_directory(struct archive_read *a, struct zip *zip) * resource fork file to expose it. */ if (name[filename_length-1] != '/' && (r - name < 3 || r[0] != '.' || r[1] != '_')) { - __archive_rb_tree_insert_node(&zip->tree, - &zip_entry->node); + __archive_rb_tree_insert_node( + &zip->tree, &zip_entry->node); /* Expose its parent directories. */ - expose_parent_dirs(zip, name, filename_length); + expose_parent_dirs(zip, name, + filename_length); } else { /* This file is a resource fork file or * a directory. */ - archive_strncpy(&(zip_entry->rsrcname), name, - filename_length); - __archive_rb_tree_insert_node(&zip->tree_rsrc, - &zip_entry->node); + archive_strncpy(&(zip_entry->rsrcname), + name, filename_length); + __archive_rb_tree_insert_node( + &zip->tree_rsrc, &zip_entry->node); } } else { - /* Generate resource fork name to find its resource - * file at zip->tree_rsrc. */ - archive_strcpy(&(zip_entry->rsrcname), "__MACOSX/"); - archive_strncat(&(zip_entry->rsrcname), name, r - name); + /* Generate resource fork name to find its + * resource file at zip->tree_rsrc. */ + archive_strcpy(&(zip_entry->rsrcname), + "__MACOSX/"); + archive_strncat(&(zip_entry->rsrcname), + name, r - name); archive_strcat(&(zip_entry->rsrcname), "._"); archive_strncat(&(zip_entry->rsrcname), - name + (r - name), filename_length - (r - name)); + name + (r - name), + filename_length - (r - name)); /* Register an entry to RB tree to sort it by * file offset. */ __archive_rb_tree_insert_node(&zip->tree, @@ -2060,9 +2865,9 @@ archive_read_format_zip_seekable_read_header(struct archive_read *a, * archive_read_data(), so be it. We'll do the same check there * as well. */ - if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { + if (zip->has_encrypted_entries == + ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) zip->has_encrypted_entries = 0; - } a->archive.archive_format = ARCHIVE_FORMAT_ZIP; if (a->archive.archive_format_name == NULL) @@ -2091,6 +2896,13 @@ archive_read_format_zip_seekable_read_header(struct archive_read *a, else rsrc = NULL; + if (zip->cctx_valid) + archive_decrypto_aes_ctr_release(&zip->cctx); + if (zip->hctx_valid) + archive_hmac_sha1_cleanup(&zip->hctx); + zip->tctx_valid = zip->cctx_valid = zip->hctx_valid = 0; + __archive_read_reset_passphrase(a); + /* File entries are sorted by the header offset, we should mostly * use __archive_read_consume to advance a read point to avoid redundant * data reading. */ @@ -2099,7 +2911,8 @@ archive_read_format_zip_seekable_read_header(struct archive_read *a, __archive_read_consume(a, zip->entry->local_header_offset - offset); else if (offset != zip->entry->local_header_offset) { - __archive_read_seek(a, zip->entry->local_header_offset, SEEK_SET); + __archive_read_seek(a, zip->entry->local_header_offset, + SEEK_SET); } zip->unconsumed = 0; r = zip_read_local_file_header(a, entry, zip); @@ -2137,13 +2950,12 @@ archive_read_support_format_zip_seekable(struct archive *_a) archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, "archive_read_support_format_zip_seekable"); - zip = (struct zip *)malloc(sizeof(*zip)); + zip = (struct zip *)calloc(1, sizeof(*zip)); if (zip == NULL) { archive_set_error(&a->archive, ENOMEM, "Can't allocate zip data"); return (ARCHIVE_FATAL); } - memset(zip, 0, sizeof(*zip)); #ifdef HAVE_COPYFILE_H /* Set this by default on Mac OS. */ diff --git a/Utilities/cmlibarchive/libarchive/archive_string.c b/Utilities/cmlibarchive/libarchive/archive_string.c index 87f9288..3d4be82 100644 --- a/Utilities/cmlibarchive/libarchive/archive_string.c +++ b/Utilities/cmlibarchive/libarchive/archive_string.c @@ -71,6 +71,10 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_string.c 201095 2009-12-28 02:33 #define wmemcpy(a,b,i) (wchar_t *)memcpy((a), (b), (i) * sizeof(wchar_t)) #endif +#if !defined(HAVE_WMEMMOVE) && !defined(wmemmove) +#define wmemmove(a,b,i) (wchar_t *)memmove((a), (b), (i) * sizeof(wchar_t)) +#endif + struct archive_string_conv { struct archive_string_conv *next; char *from_charset; @@ -127,12 +131,7 @@ struct archive_string_conv { #define UNICODE_MAX 0x10FFFF #define UNICODE_R_CHAR 0xFFFD /* Replacement character. */ /* Set U+FFFD(Replacement character) in UTF-8. */ -#define UTF8_SET_R_CHAR(outp) do { \ - (outp)[0] = 0xef; \ - (outp)[1] = 0xbf; \ - (outp)[2] = 0xbd; \ -} while (0) -#define UTF8_R_CHAR_SIZE 3 +static const char utf8_replacement_char[] = {0xef, 0xbf, 0xbd}; static struct archive_string_conv *find_sconv_object(struct archive *, const char *, const char *); @@ -203,7 +202,7 @@ archive_string_append(struct archive_string *as, const char *p, size_t s) { if (archive_string_ensure(as, as->length + s + 1) == NULL) return (NULL); - memcpy(as->s + as->length, p, s); + memmove(as->s + as->length, p, s); as->length += s; as->s[as->length] = 0; return (as); @@ -214,7 +213,7 @@ archive_wstring_append(struct archive_wstring *as, const wchar_t *p, size_t s) { if (archive_wstring_ensure(as, as->length + s + 1) == NULL) return (NULL); - wmemcpy(as->s + as->length, p, s); + wmemmove(as->s + as->length, p, s); as->length += s; as->s[as->length] = 0; return (as); @@ -2037,7 +2036,7 @@ iconv_strncat_in_locale(struct archive_string *as, const void *_p, if (sc->flag & (SCONV_TO_UTF8 | SCONV_TO_UTF16)) { size_t rbytes; if (sc->flag & SCONV_TO_UTF8) - rbytes = UTF8_R_CHAR_SIZE; + rbytes = sizeof(utf8_replacement_char); else rbytes = 2; @@ -2053,7 +2052,7 @@ iconv_strncat_in_locale(struct archive_string *as, const void *_p, - as->length - to_size; } if (sc->flag & SCONV_TO_UTF8) - UTF8_SET_R_CHAR(outp); + memcpy(outp, utf8_replacement_char, sizeof(utf8_replacement_char)); else if (sc->flag & SCONV_TO_UTF16BE) archive_be16enc(outp, UNICODE_R_CHAR); else @@ -2202,9 +2201,7 @@ best_effort_strncat_in_locale(struct archive_string *as, const void *_p, size_t length, struct archive_string_conv *sc) { size_t remaining; - char *otp; const uint8_t *itp; - size_t avail; int return_value = 0; /* success */ /* @@ -2223,46 +2220,25 @@ best_effort_strncat_in_locale(struct archive_string *as, const void *_p, * byte sequence 0xEF 0xBD 0xBD, which are code point U+FFFD, * a Replacement Character in Unicode. */ - if (archive_string_ensure(as, as->length + length + 1) == NULL) - return (-1); remaining = length; itp = (const uint8_t *)_p; - otp = as->s + as->length; - avail = as->buffer_length - as->length -1; while (*itp && remaining > 0) { - if (*itp > 127 && (sc->flag & SCONV_TO_UTF8)) { - if (avail < UTF8_R_CHAR_SIZE) { - as->length = otp - as->s; - if (NULL == archive_string_ensure(as, - as->buffer_length + remaining + - UTF8_R_CHAR_SIZE)) - return (-1); - otp = as->s + as->length; - avail = as->buffer_length - as->length -1; + if (*itp > 127) { + // Non-ASCII: Substitute with suitable replacement + if (sc->flag & SCONV_TO_UTF8) { + if (archive_string_append(as, utf8_replacement_char, sizeof(utf8_replacement_char)) == NULL) { + __archive_errx(1, "Out of memory"); + } + } else { + archive_strappend_char(as, '?'); } - /* - * When coping a string in UTF-8, unknown character - * should be U+FFFD (replacement character). - */ - UTF8_SET_R_CHAR(otp); - otp += UTF8_R_CHAR_SIZE; - avail -= UTF8_R_CHAR_SIZE; - itp++; - remaining--; - return_value = -1; - } else if (*itp > 127) { - *otp++ = '?'; - itp++; - remaining--; return_value = -1; } else { - *otp++ = (char)*itp++; - remaining--; + archive_strappend_char(as, *itp); } + ++itp; } - as->length = otp - as->s; - as->s[as->length] = '\0'; return (return_value); } @@ -2488,6 +2464,9 @@ unicode_to_utf8(char *p, size_t remaining, uint32_t uc) { char *_p = p; + /* Invalid Unicode char maps to Replacement character */ + if (uc > UNICODE_MAX) + uc = UNICODE_R_CHAR; /* Translate code point to UTF8 */ if (uc <= 0x7f) { if (remaining == 0) @@ -2504,22 +2483,13 @@ unicode_to_utf8(char *p, size_t remaining, uint32_t uc) *p++ = 0xe0 | ((uc >> 12) & 0x0f); *p++ = 0x80 | ((uc >> 6) & 0x3f); *p++ = 0x80 | (uc & 0x3f); - } else if (uc <= UNICODE_MAX) { + } else { if (remaining < 4) return (0); *p++ = 0xf0 | ((uc >> 18) & 0x07); *p++ = 0x80 | ((uc >> 12) & 0x3f); *p++ = 0x80 | ((uc >> 6) & 0x3f); *p++ = 0x80 | (uc & 0x3f); - } else { - /* - * Undescribed code point should be U+FFFD - * (replacement character). - */ - if (remaining < UTF8_R_CHAR_SIZE) - return (0); - UTF8_SET_R_CHAR(p); - p += UTF8_R_CHAR_SIZE; } return (p - _p); } @@ -3887,7 +3857,7 @@ archive_mstring_get_utf8(struct archive *a, struct archive_mstring *aes, sc = archive_string_conversion_to_charset(a, "UTF-8", 1); if (sc == NULL) return (-1);/* Couldn't allocate memory for sc. */ - r = archive_strncpy_l(&(aes->aes_mbs), aes->aes_mbs.s, + r = archive_strncpy_l(&(aes->aes_utf8), aes->aes_mbs.s, aes->aes_mbs.length, sc); if (a == NULL) free_sconv_object(sc); @@ -4062,6 +4032,19 @@ archive_mstring_copy_wcs(struct archive_mstring *aes, const wchar_t *wcs) } int +archive_mstring_copy_utf8(struct archive_mstring *aes, const char *utf8) +{ + if (utf8 == NULL) { + aes->aes_set = 0; + } + aes->aes_set = AES_SET_UTF8; + archive_string_empty(&(aes->aes_mbs)); + archive_string_empty(&(aes->aes_wcs)); + archive_strncpy(&(aes->aes_utf8), utf8, strlen(utf8)); + return (int)strlen(utf8); +} + +int archive_mstring_copy_wcs_len(struct archive_mstring *aes, const wchar_t *wcs, size_t len) { diff --git a/Utilities/cmlibarchive/libarchive/archive_util.c b/Utilities/cmlibarchive/libarchive/archive_util.c index d136498..5f31edf 100644 --- a/Utilities/cmlibarchive/libarchive/archive_util.c +++ b/Utilities/cmlibarchive/libarchive/archive_util.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2009-2012 Michihiro NAKAJIMA + * Copyright (c) 2009-2012,2014 Michihiro NAKAJIMA * Copyright (c) 2003-2007 Tim Kientzle * All rights reserved. * @@ -54,9 +54,13 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_util.c 201098 2009-12-28 02:58:1 #ifdef HAVE_BZLIB_H #include <cm_bzlib.h> #endif +#ifdef HAVE_LZ4_H +#include <lz4.h> +#endif #include "archive.h" #include "archive_private.h" +#include "archive_random_private.h" #include "archive_string.h" #ifndef O_CLOEXEC @@ -113,7 +117,11 @@ archive_version_details(void) archive_strncat(&str, p, sep - p); } #endif - } +#if defined(HAVE_LZ4_H) && defined(HAVE_LIBLZ4) + archive_string_sprintf(&str, " liblz4/%d.%d.%d", + LZ4_VERSION_MAJOR, LZ4_VERSION_MINOR, LZ4_VERSION_RELEASE); +#endif + } return str.s; } @@ -465,7 +473,6 @@ __archive_mktemp(const char *tmpdir) struct stat st; int fd; char *tp, *ep; - unsigned seed; fd = -1; archive_string_init(&temp_name); @@ -489,21 +496,15 @@ __archive_mktemp(const char *tmpdir) archive_strcat(&temp_name, "XXXXXXXXXX"); ep = temp_name.s + archive_strlen(&temp_name); - fd = open("/dev/random", O_RDONLY | O_CLOEXEC); - __archive_ensure_cloexec_flag(fd); - if (fd < 0) - seed = time(NULL); - else { - if (read(fd, &seed, sizeof(seed)) < 0) - seed = time(NULL); - close(fd); - } do { char *p; p = tp; - while (p < ep) - *p++ = num[((unsigned)rand_r(&seed)) % sizeof(num)]; + archive_random(p, ep - p); + while (p < ep) { + int d = *((unsigned char *)p) % sizeof(num); + *p++ = num[d]; + } fd = open(temp_name.s, O_CREAT | O_EXCL | O_RDWR | O_CLOEXEC, 0600); } while (fd < 0 && errno == EEXIST); @@ -551,62 +552,70 @@ __archive_ensure_cloexec_flag(int fd) static int archive_utility_string_sort_helper(char **strings, unsigned int n) { - unsigned int i, lesser_count, greater_count; - char **lesser, **greater, **tmp, *pivot; - int retval1, retval2; - - /* A list of 0 or 1 elements is already sorted */ - if (n <= 1) - return (ARCHIVE_OK); - - lesser_count = greater_count = 0; - lesser = greater = NULL; - pivot = strings[0]; - for (i = 1; i < n; i++) - { - if (strcmp(strings[i], pivot) < 0) - { - lesser_count++; - tmp = (char **)realloc(lesser, lesser_count * sizeof(char *)); - if (!tmp) - return (ARCHIVE_FATAL); - lesser = tmp; - lesser[lesser_count - 1] = strings[i]; - } - else - { - greater_count++; - tmp = (char **)realloc(greater, greater_count * sizeof(char *)); - if (!tmp) - return (ARCHIVE_FATAL); - greater = tmp; - greater[greater_count - 1] = strings[i]; - } - } - - /* quicksort(lesser) */ - retval1 = archive_utility_string_sort_helper(lesser, lesser_count); - for (i = 0; i < lesser_count; i++) - strings[i] = lesser[i]; - free(lesser); - - /* pivot */ - strings[lesser_count] = pivot; - - /* quicksort(greater) */ - retval2 = archive_utility_string_sort_helper(greater, greater_count); - for (i = 0; i < greater_count; i++) - strings[lesser_count + 1 + i] = greater[i]; - free(greater); - - return (retval1 < retval2) ? retval1 : retval2; + unsigned int i, lesser_count, greater_count; + char **lesser, **greater, **tmp, *pivot; + int retval1, retval2; + + /* A list of 0 or 1 elements is already sorted */ + if (n <= 1) + return (ARCHIVE_OK); + + lesser_count = greater_count = 0; + lesser = greater = NULL; + pivot = strings[0]; + for (i = 1; i < n; i++) + { + if (strcmp(strings[i], pivot) < 0) + { + lesser_count++; + tmp = (char **)realloc(lesser, + lesser_count * sizeof(char *)); + if (!tmp) { + free(greater); + free(lesser); + return (ARCHIVE_FATAL); + } + lesser = tmp; + lesser[lesser_count - 1] = strings[i]; + } + else + { + greater_count++; + tmp = (char **)realloc(greater, + greater_count * sizeof(char *)); + if (!tmp) { + free(greater); + free(lesser); + return (ARCHIVE_FATAL); + } + greater = tmp; + greater[greater_count - 1] = strings[i]; + } + } + + /* quicksort(lesser) */ + retval1 = archive_utility_string_sort_helper(lesser, lesser_count); + for (i = 0; i < lesser_count; i++) + strings[i] = lesser[i]; + free(lesser); + + /* pivot */ + strings[lesser_count] = pivot; + + /* quicksort(greater) */ + retval2 = archive_utility_string_sort_helper(greater, greater_count); + for (i = 0; i < greater_count; i++) + strings[lesser_count + 1 + i] = greater[i]; + free(greater); + + return (retval1 < retval2) ? retval1 : retval2; } int archive_utility_string_sort(char **strings) { - unsigned int size = 0; - while (strings[size] != NULL) - size++; - return archive_utility_string_sort_helper(strings, size); + unsigned int size = 0; + while (strings[size] != NULL) + size++; + return archive_utility_string_sort_helper(strings, size); } diff --git a/Utilities/cmlibarchive/libarchive/archive_windows.h b/Utilities/cmlibarchive/libarchive/archive_windows.h index dc2f241..7c31a16 100644 --- a/Utilities/cmlibarchive/libarchive/archive_windows.h +++ b/Utilities/cmlibarchive/libarchive/archive_windows.h @@ -227,7 +227,9 @@ #define S_IRWXG _S_IRWXG #define S_IXGRP _S_IXGRP #define S_IWGRP _S_IWGRP +#ifndef S_IRGRP #define S_IRGRP _S_IRGRP +#endif #define S_IRWXO _S_IRWXO #define S_IXOTH _S_IXOTH #define S_IWOTH _S_IWOTH diff --git a/Utilities/cmlibarchive/libarchive/archive_write.3 b/Utilities/cmlibarchive/libarchive/archive_write.3 index 228bc2c..376d71d 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write.3 +++ b/Utilities/cmlibarchive/libarchive/archive_write.3 @@ -155,7 +155,7 @@ myopen(struct archive *a, void *client_data) return (ARCHIVE_FATAL); } -ssize_t +la_ssize_t mywrite(struct archive *a, void *client_data, const void *buff, size_t n) { struct mydata *mydata = client_data; @@ -186,8 +186,13 @@ write_archive(const char *outname, const char **filename) a = archive_write_new(); mydata->name = outname; - archive_write_add_filter_gzip(a); - archive_write_set_format_ustar(a); + /* Set archive format and filter according to output file extension. + * If it fails, set default format. Platform depended function. + * See supported formats in archive_write_set_format_filter_by_ext.c */ + if (archive_write_set_format_filter_by_ext(a, outname) != ARCHIVE_OK) { + archive_write_add_filter_gzip(a); + archive_write_set_format_ustar(a); + } archive_write_open(a, mydata, myopen, mywrite, myclose); while (*filename) { stat(*filename, &st); @@ -197,7 +202,7 @@ write_archive(const char *outname, const char **filename) archive_write_header(a, entry); if ((fd = open(*filename, O_RDONLY)) != -1) { len = read(fd, buff, sizeof(buff)); - while ( len > 0 ) { + while (len > 0) { archive_write_data(a, buff, len); len = read(fd, buff, sizeof(buff)); } @@ -213,7 +218,7 @@ int main(int argc, const char **argv) { const char *outname; argv++; - outname = argv++; + outname = *argv++; write_archive(outname, argv); return 0; } diff --git a/Utilities/cmlibarchive/libarchive/archive_write.c b/Utilities/cmlibarchive/libarchive/archive_write.c index 8997193..e3fa335 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write.c +++ b/Utilities/cmlibarchive/libarchive/archive_write.c @@ -444,6 +444,12 @@ archive_write_client_close(struct archive_write_filter *f) /* Clear the close handler myself not to be called again. */ f->close = NULL; a->client_data = NULL; + /* Clear passphrase. */ + if (a->passphrase != NULL) { + memset(a->passphrase, 0, strlen(a->passphrase)); + free(a->passphrase); + a->passphrase = NULL; + } return (ret); } @@ -592,6 +598,11 @@ _archive_write_free(struct archive *_a) /* Release various dynamic buffers. */ free((void *)(uintptr_t)(const void *)a->nulls); archive_string_free(&a->archive.error_string); + if (a->passphrase != NULL) { + /* A passphrase should be cleaned. */ + memset(a->passphrase, 0, strlen(a->passphrase)); + free(a->passphrase); + } a->archive.magic = 0; __archive_clean(&a->archive); free(a); diff --git a/Utilities/cmlibarchive/libarchive/archive_write_add_filter.c b/Utilities/cmlibarchive/libarchive/archive_write_add_filter.c index 81dd683..ad5dc83 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_add_filter.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_add_filter.c @@ -47,6 +47,7 @@ struct { int code; int (*setter)(struct archive *); } codes[] = { ARCHIVE_FILTER_COMPRESS, archive_write_add_filter_compress }, { ARCHIVE_FILTER_GRZIP, archive_write_add_filter_grzip }, { ARCHIVE_FILTER_LRZIP, archive_write_add_filter_lrzip }, + { ARCHIVE_FILTER_LZ4, archive_write_add_filter_lz4 }, { ARCHIVE_FILTER_LZIP, archive_write_add_filter_lzip }, { ARCHIVE_FILTER_LZMA, archive_write_add_filter_lzma }, { ARCHIVE_FILTER_LZOP, archive_write_add_filter_lzip }, diff --git a/Utilities/cmlibarchive/libarchive/archive_write_add_filter_by_name.c b/Utilities/cmlibarchive/libarchive/archive_write_add_filter_by_name.c index e4cba4a..eac4011 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_add_filter_by_name.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_add_filter_by_name.c @@ -51,6 +51,7 @@ struct { const char *name; int (*setter)(struct archive *); } names[] = { "grzip", archive_write_add_filter_grzip }, { "gzip", archive_write_add_filter_gzip }, { "lrzip", archive_write_add_filter_lrzip }, + { "lz4", archive_write_add_filter_lz4 }, { "lzip", archive_write_add_filter_lzip }, { "lzma", archive_write_add_filter_lzma }, { "lzop", archive_write_add_filter_lzop }, diff --git a/Utilities/cmlibarchive/libarchive/archive_write_add_filter_lz4.c b/Utilities/cmlibarchive/libarchive/archive_write_add_filter_lz4.c new file mode 100644 index 0000000..e23e5e9 --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_write_add_filter_lz4.c @@ -0,0 +1,646 @@ +/*- + * Copyright (c) 2014 Michihiro NAKAJIMA + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "archive_platform.h" + +__FBSDID("$FreeBSD$"); + +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif +#include <stdio.h> +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif +#ifdef HAVE_STRING_H +#include <string.h> +#endif +#ifdef HAVE_LZ4_H +#include <lz4.h> +#endif +#ifdef HAVE_LZ4HC_H +#include <lz4hc.h> +#endif + +#include "archive.h" +#include "archive_endian.h" +#include "archive_private.h" +#include "archive_write_private.h" +#include "archive_xxhash.h" + +#define LZ4_MAGICNUMBER 0x184d2204 + +struct private_data { + int compression_level; + unsigned header_written:1; + unsigned version_number:1; + unsigned block_independence:1; + unsigned block_checksum:1; + unsigned stream_size:1; + unsigned stream_checksum:1; + unsigned preset_dictionary:1; + unsigned block_maximum_size:3; +#if defined(HAVE_LIBLZ4) && LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 2 + int64_t total_in; + char *out; + char *out_buffer; + size_t out_buffer_size; + size_t out_block_size; + char *in; + char *in_buffer_allocated; + char *in_buffer; + size_t in_buffer_size; + size_t block_size; + + void *xxh32_state; + void *lz4_stream; +#else + struct archive_write_program_data *pdata; +#endif +}; + +static int archive_filter_lz4_close(struct archive_write_filter *); +static int archive_filter_lz4_free(struct archive_write_filter *); +static int archive_filter_lz4_open(struct archive_write_filter *); +static int archive_filter_lz4_options(struct archive_write_filter *, + const char *, const char *); +static int archive_filter_lz4_write(struct archive_write_filter *, + const void *, size_t); + +/* + * Add a lz4 compression filter to this write handle. + */ +int +archive_write_add_filter_lz4(struct archive *_a) +{ + struct archive_write *a = (struct archive_write *)_a; + struct archive_write_filter *f = __archive_write_allocate_filter(_a); + struct private_data *data; + + archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, + ARCHIVE_STATE_NEW, "archive_write_add_filter_lz4"); + + data = calloc(1, sizeof(*data)); + if (data == NULL) { + archive_set_error(&a->archive, ENOMEM, "Out of memory"); + return (ARCHIVE_FATAL); + } + + /* + * Setup default settings. + */ + data->compression_level = 1; + data->version_number = 0x01; + data->block_independence = 1; + data->block_checksum = 0; + data->stream_size = 0; + data->stream_checksum = 1; + data->preset_dictionary = 0; + data->block_maximum_size = 7; + + /* + * Setup a filter setting. + */ + f->data = data; + f->options = &archive_filter_lz4_options; + f->close = &archive_filter_lz4_close; + f->free = &archive_filter_lz4_free; + f->open = &archive_filter_lz4_open; + f->code = ARCHIVE_FILTER_LZ4; + f->name = "lz4"; +#if defined(HAVE_LIBLZ4) && LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 2 + return (ARCHIVE_OK); +#else + /* + * We don't have lz4 library, and execute external lz4 program + * instead. + */ + data->pdata = __archive_write_program_allocate(); + if (data->pdata == NULL) { + free(data); + archive_set_error(&a->archive, ENOMEM, "Out of memory"); + return (ARCHIVE_FATAL); + } + data->compression_level = 0; + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Using external lz4 program"); + return (ARCHIVE_WARN); +#endif +} + +/* + * Set write options. + */ +static int +archive_filter_lz4_options(struct archive_write_filter *f, + const char *key, const char *value) +{ + struct private_data *data = (struct private_data *)f->data; + + if (strcmp(key, "compression-level") == 0) { + if (value == NULL || !(value[0] >= '1' && value[0] <= '9') || + value[1] != '\0') + return (ARCHIVE_WARN); + data->compression_level = value[0] - '0'; + return (ARCHIVE_OK); + } + if (strcmp(key, "stream-checksum") == 0) { + data->stream_checksum = value != NULL; + return (ARCHIVE_OK); + } + if (strcmp(key, "block-checksum") == 0) { + data->block_checksum = value != NULL; + return (ARCHIVE_OK); + } + if (strcmp(key, "block-size") == 0) { + if (value == NULL || !(value[0] >= '4' && value[0] <= '7') || + value[1] != '\0') + return (ARCHIVE_WARN); + data->block_maximum_size = value[0] - '0'; + return (ARCHIVE_OK); + } + if (strcmp(key, "block-dependence") == 0) { + data->block_independence = value == NULL; + return (ARCHIVE_OK); + } + + /* Note: The "warn" return is just to inform the options + * supervisor that we didn't handle it. It will generate + * a suitable error if no one used this option. */ + return (ARCHIVE_WARN); +} + +#if defined(HAVE_LIBLZ4) && LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 2 +/* Don't compile this if we don't have liblz4. */ + +static int drive_compressor(struct archive_write_filter *, const char *, + size_t); +static int drive_compressor_independence(struct archive_write_filter *, + const char *, size_t); +static int drive_compressor_dependence(struct archive_write_filter *, + const char *, size_t); +static int lz4_write_stream_descriptor(struct archive_write_filter *); +static ssize_t lz4_write_one_block(struct archive_write_filter *, const char *, + size_t); + + +/* + * Setup callback. + */ +static int +archive_filter_lz4_open(struct archive_write_filter *f) +{ + struct private_data *data = (struct private_data *)f->data; + int ret; + size_t required_size; + static size_t bkmap[] = { 64 * 1024, 256 * 1024, 1 * 1024 * 1024, + 4 * 1024 * 1024 }; + size_t pre_block_size; + + ret = __archive_write_open_filter(f->next_filter); + if (ret != 0) + return (ret); + + if (data->block_maximum_size < 4) + data->block_size = bkmap[0]; + else + data->block_size = bkmap[data->block_maximum_size - 4]; + + required_size = 4 + 15 + 4 + data->block_size + 4 + 4; + if (data->out_buffer_size < required_size) { + size_t bs = required_size, bpb; + free(data->out_buffer); + if (f->archive->magic == ARCHIVE_WRITE_MAGIC) { + /* Buffer size should be a multiple number of + * the of bytes per block for performance. */ + bpb = archive_write_get_bytes_per_block(f->archive); + if (bpb > bs) + bs = bpb; + else if (bpb != 0) { + bs += bpb; + bs -= bs % bpb; + } + } + data->out_block_size = bs; + bs += required_size; + data->out_buffer = malloc(bs); + data->out = data->out_buffer; + data->out_buffer_size = bs; + } + + pre_block_size = (data->block_independence)? 0: 64 * 1024; + if (data->in_buffer_size < data->block_size + pre_block_size) { + free(data->in_buffer_allocated); + data->in_buffer_size = data->block_size; + data->in_buffer_allocated = + malloc(data->in_buffer_size + pre_block_size); + data->in_buffer = data->in_buffer_allocated + pre_block_size; + if (!data->block_independence && data->compression_level >= 3) + data->in_buffer = data->in_buffer_allocated; + data->in = data->in_buffer; + data->in_buffer_size = data->block_size; + } + + if (data->out_buffer == NULL || data->in_buffer_allocated == NULL) { + archive_set_error(f->archive, ENOMEM, + "Can't allocate data for compression buffer"); + return (ARCHIVE_FATAL); + } + + f->write = archive_filter_lz4_write; + + return (ARCHIVE_OK); +} + +/* + * Write data to the out stream. + * + * Returns ARCHIVE_OK if all data written, error otherwise. + */ +static int +archive_filter_lz4_write(struct archive_write_filter *f, + const void *buff, size_t length) +{ + struct private_data *data = (struct private_data *)f->data; + int ret = ARCHIVE_OK; + const char *p; + size_t remaining; + ssize_t size; + + /* If we haven't written a stream descriptor, we have to do it first. */ + if (!data->header_written) { + ret = lz4_write_stream_descriptor(f); + if (ret != ARCHIVE_OK) + return (ret); + data->header_written = 1; + } + + /* Update statistics */ + data->total_in += length; + + p = (const char *)buff; + remaining = length; + while (remaining) { + size_t l; + /* Compress input data to output buffer */ + size = lz4_write_one_block(f, p, remaining); + if (size < ARCHIVE_OK) + return (ARCHIVE_FATAL); + l = data->out - data->out_buffer; + if (l >= data->out_block_size) { + ret = __archive_write_filter(f->next_filter, + data->out_buffer, data->out_block_size); + l -= data->out_block_size; + memcpy(data->out_buffer, + data->out_buffer + data->out_block_size, l); + data->out = data->out_buffer + l; + if (ret < ARCHIVE_WARN) + break; + } + p += size; + remaining -= size; + } + + return (ret); +} + +/* + * Finish the compression. + */ +static int +archive_filter_lz4_close(struct archive_write_filter *f) +{ + struct private_data *data = (struct private_data *)f->data; + int ret, r1; + + /* Finish compression cycle. */ + ret = (int)lz4_write_one_block(f, NULL, 0); + if (ret >= 0) { + /* + * Write the last block and the end of the stream data. + */ + + /* Write End Of Stream. */ + memset(data->out, 0, 4); data->out += 4; + /* Write Stream checksum if needed. */ + if (data->stream_checksum) { + unsigned int checksum; + checksum = __archive_xxhash.XXH32_digest( + data->xxh32_state); + data->xxh32_state = NULL; + archive_le32enc(data->out, checksum); + data->out += 4; + } + ret = __archive_write_filter(f->next_filter, + data->out_buffer, data->out - data->out_buffer); + } + + r1 = __archive_write_close_filter(f->next_filter); + return (r1 < ret ? r1 : ret); +} + +static int +archive_filter_lz4_free(struct archive_write_filter *f) +{ + struct private_data *data = (struct private_data *)f->data; + + if (data->lz4_stream != NULL) { + if (data->compression_level < 3) +#if LZ4_VERSION_MINOR >= 3 + LZ4_freeStream(data->lz4_stream); +#else + LZ4_free(data->lz4_stream); +#endif + else + LZ4_freeHC(data->lz4_stream); + } + free(data->out_buffer); + free(data->in_buffer_allocated); + free(data->xxh32_state); + free(data); + f->data = NULL; + return (ARCHIVE_OK); +} + +static int +lz4_write_stream_descriptor(struct archive_write_filter *f) +{ + struct private_data *data = (struct private_data *)f->data; + uint8_t *sd; + + sd = (uint8_t *)data->out; + /* Write Magic Number. */ + archive_le32enc(&sd[0], LZ4_MAGICNUMBER); + /* FLG */ + sd[4] = (data->version_number << 6) + | (data->block_independence << 5) + | (data->block_checksum << 4) + | (data->stream_size << 3) + | (data->stream_checksum << 2) + | (data->preset_dictionary << 0); + /* BD */ + sd[5] = (data->block_maximum_size << 4); + sd[6] = (__archive_xxhash.XXH32(&sd[4], 2, 0) >> 8) & 0xff; + data->out += 7; + if (data->stream_checksum) + data->xxh32_state = __archive_xxhash.XXH32_init(0); + else + data->xxh32_state = NULL; + return (ARCHIVE_OK); +} + +static ssize_t +lz4_write_one_block(struct archive_write_filter *f, const char *p, + size_t length) +{ + struct private_data *data = (struct private_data *)f->data; + ssize_t r; + + if (p == NULL) { + /* Compress remaining uncompressed data. */ + if (data->in_buffer == data->in) + return 0; + else { + size_t l = data->in - data->in_buffer; + r = drive_compressor(f, data->in_buffer, l); + if (r == ARCHIVE_OK) + r = (ssize_t)l; + } + } else if ((data->block_independence || data->compression_level < 3) && + data->in_buffer == data->in && length >= data->block_size) { + r = drive_compressor(f, p, data->block_size); + if (r == ARCHIVE_OK) + r = (ssize_t)data->block_size; + } else { + size_t remaining_size = data->in_buffer_size - + (data->in - data->in_buffer); + size_t l = (remaining_size > length)? length: remaining_size; + memcpy(data->in, p, l); + data->in += l; + if (l == remaining_size) { + r = drive_compressor(f, data->in_buffer, + data->block_size); + if (r == ARCHIVE_OK) + r = (ssize_t)l; + data->in = data->in_buffer; + } else + r = (ssize_t)l; + } + + return (r); +} + + +/* + * Utility function to push input data through compressor, writing + * full output blocks as necessary. + * + * Note that this handles both the regular write case (finishing == + * false) and the end-of-archive case (finishing == true). + */ +static int +drive_compressor(struct archive_write_filter *f, const char *p, size_t length) +{ + struct private_data *data = (struct private_data *)f->data; + + if (data->stream_checksum) + __archive_xxhash.XXH32_update(data->xxh32_state, + p, (int)length); + if (data->block_independence) + return drive_compressor_independence(f, p, length); + else + return drive_compressor_dependence(f, p, length); +} + +static int +drive_compressor_independence(struct archive_write_filter *f, const char *p, + size_t length) +{ + struct private_data *data = (struct private_data *)f->data; + unsigned int outsize; + + if (data->compression_level < 4) + outsize = LZ4_compress_limitedOutput(p, data->out + 4, + (int)length, (int)data->block_size); + else + outsize = LZ4_compressHC2_limitedOutput(p, data->out + 4, + (int)length, (int)data->block_size, + data->compression_level); + + if (outsize) { + /* The buffer is compressed. */ + archive_le32enc(data->out, outsize); + data->out += 4; + } else { + /* The buffer is not compressed. The commpressed size was + * bigger than its uncompressed size. */ + archive_le32enc(data->out, length | 0x80000000); + data->out += 4; + memcpy(data->out, p, length); + outsize = length; + } + data->out += outsize; + if (data->block_checksum) { + unsigned int checksum = + __archive_xxhash.XXH32(data->out - outsize, outsize, 0); + archive_le32enc(data->out, checksum); + data->out += 4; + } + return (ARCHIVE_OK); +} + +static int +drive_compressor_dependence(struct archive_write_filter *f, const char *p, + size_t length) +{ + struct private_data *data = (struct private_data *)f->data; + int outsize; + + if (data->compression_level < 3) { + if (data->lz4_stream == NULL) { + data->lz4_stream = LZ4_createStream(); + if (data->lz4_stream == NULL) { + archive_set_error(f->archive, ENOMEM, + "Can't allocate data for compression" + " buffer"); + return (ARCHIVE_FATAL); + } + } + outsize = LZ4_compress_limitedOutput_continue( + data->lz4_stream, p, data->out + 4, (int)length, + (int)data->block_size); + } else { + if (data->lz4_stream == NULL) { + data->lz4_stream = + LZ4_createHC(data->in_buffer_allocated); + if (data->lz4_stream == NULL) { + archive_set_error(f->archive, ENOMEM, + "Can't allocate data for compression" + " buffer"); + return (ARCHIVE_FATAL); + } + } + outsize = LZ4_compressHC2_limitedOutput_continue( + data->lz4_stream, p, data->out + 4, (int)length, + (int)data->block_size, data->compression_level); + } + + if (outsize) { + /* The buffer is compressed. */ + archive_le32enc(data->out, outsize); + data->out += 4; + } else { + /* The buffer is not compressed. The commpressed size was + * bigger than its uncompressed size. */ + archive_le32enc(data->out, length | 0x80000000); + data->out += 4; + memcpy(data->out, p, length); + outsize = length; + } + data->out += outsize; + if (data->block_checksum) { + unsigned int checksum = + __archive_xxhash.XXH32(data->out - outsize, outsize, 0); + archive_le32enc(data->out, checksum); + data->out += 4; + } + + if (length == data->block_size) { +#define DICT_SIZE (64 * 1024) + if (data->compression_level < 3) + LZ4_saveDict(data->lz4_stream, + data->in_buffer_allocated, DICT_SIZE); + else { + LZ4_slideInputBufferHC(data->lz4_stream); + data->in_buffer = data->in_buffer_allocated + DICT_SIZE; + } +#undef DICT_SIZE + } + return (ARCHIVE_OK); +} + +#else /* HAVE_LIBLZ4 */ + +static int +archive_filter_lz4_open(struct archive_write_filter *f) +{ + struct private_data *data = (struct private_data *)f->data; + struct archive_string as; + int r; + + archive_string_init(&as); + archive_strcpy(&as, "lz4 -z -q -q"); + + /* Specify a compression level. */ + if (data->compression_level > 0) { + archive_strcat(&as, " -"); + archive_strappend_char(&as, '0' + data->compression_level); + } + /* Specify a block size. */ + archive_strcat(&as, " -B"); + archive_strappend_char(&as, '0' + data->block_maximum_size); + + if (data->block_checksum) + archive_strcat(&as, " -BX"); + if (data->stream_checksum == 0) + archive_strcat(&as, " -Sx"); + if (data->block_independence == 0) + archive_strcat(&as, " -BD"); + + f->write = archive_filter_lz4_write; + + r = __archive_write_program_open(f, data->pdata, as.s); + archive_string_free(&as); + return (r); +} + +static int +archive_filter_lz4_write(struct archive_write_filter *f, const void *buff, + size_t length) +{ + struct private_data *data = (struct private_data *)f->data; + + return __archive_write_program_write(f, data->pdata, buff, length); +} + +static int +archive_filter_lz4_close(struct archive_write_filter *f) +{ + struct private_data *data = (struct private_data *)f->data; + + return __archive_write_program_close(f, data->pdata); +} + +static int +archive_filter_lz4_free(struct archive_write_filter *f) +{ + struct private_data *data = (struct private_data *)f->data; + + __archive_write_program_free(data->pdata); + free(data); + return (ARCHIVE_OK); +} + +#endif /* HAVE_LIBLZ4 */ diff --git a/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c b/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c index a566732..4f849ce 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c @@ -100,6 +100,7 @@ archive_write_add_filter_lzip(struct archive *a) struct private_data { int compression_level; + uint32_t threads; lzma_stream stream; lzma_filter lzmafilters[2]; lzma_options_lzma lzma_opt; @@ -151,6 +152,7 @@ common_setup(struct archive_write_filter *f) } f->data = data; data->compression_level = LZMA_PRESET_DEFAULT; + data->threads = 1; f->open = &archive_compressor_xz_open; f->close = archive_compressor_xz_close; f->free = archive_compressor_xz_free; @@ -221,23 +223,37 @@ archive_compressor_xz_init_stream(struct archive_write_filter *f, { static const lzma_stream lzma_stream_init_data = LZMA_STREAM_INIT; int ret; +#ifdef HAVE_LZMA_STREAM_ENCODER_MT + lzma_mt mt_options; +#endif data->stream = lzma_stream_init_data; data->stream.next_out = data->compressed; data->stream.avail_out = data->compressed_buffer_size; - if (f->code == ARCHIVE_FILTER_XZ) - ret = lzma_stream_encoder(&(data->stream), - data->lzmafilters, LZMA_CHECK_CRC64); - else if (f->code == ARCHIVE_FILTER_LZMA) + if (f->code == ARCHIVE_FILTER_XZ) { +#ifdef HAVE_LZMA_STREAM_ENCODER_MT + if (data->threads != 1) { + bzero(&mt_options, sizeof(mt_options)); + mt_options.threads = data->threads; + mt_options.timeout = 300; + mt_options.filters = data->lzmafilters; + mt_options.check = LZMA_CHECK_CRC64; + ret = lzma_stream_encoder_mt(&(data->stream), + &mt_options); + } else +#endif + ret = lzma_stream_encoder(&(data->stream), + data->lzmafilters, LZMA_CHECK_CRC64); + } else if (f->code == ARCHIVE_FILTER_LZMA) { ret = lzma_alone_encoder(&(data->stream), &data->lzma_opt); - else { /* ARCHIVE_FILTER_LZIP */ + } else { /* ARCHIVE_FILTER_LZIP */ int dict_size = data->lzma_opt.dict_size; int ds, log2dic, wedges; /* Calculate a coded dictionary size */ if (dict_size < (1 << 12) || dict_size > (1 << 27)) { archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, - "Unacceptable dictionary dize for lzip: %d", + "Unacceptable dictionary size for lzip: %d", dict_size); return (ARCHIVE_FATAL); } @@ -373,6 +389,22 @@ archive_compressor_xz_options(struct archive_write_filter *f, if (data->compression_level > 6) data->compression_level = 6; return (ARCHIVE_OK); + } else if (strcmp(key, "threads") == 0) { + if (value == NULL) + return (ARCHIVE_WARN); + data->threads = (int)strtoul(value, NULL, 10); + if (data->threads == 0 && errno != 0) { + data->threads = 1; + return (ARCHIVE_WARN); + } + if (data->threads == 0) { +#ifdef HAVE_LZMA_STREAM_ENCODER_MT + data->threads = lzma_cputhreads(); +#else + data->threads = 1; +#endif + } + return (ARCHIVE_OK); } /* Note: The "warn" return is just to inform the options diff --git a/Utilities/cmlibarchive/libarchive/archive_write_data.3 b/Utilities/cmlibarchive/libarchive/archive_write_data.3 index cfd5cd5..0cdd25f 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_data.3 +++ b/Utilities/cmlibarchive/libarchive/archive_write_data.3 @@ -34,7 +34,7 @@ Streaming Archive Library (libarchive, -larchive) .Sh SYNOPSIS .In archive.h -.Ft ssize_t +.Ft la_ssize_t .Fn archive_write_data "struct archive *" "const void *" "size_t" .Sh DESCRIPTION Write data corresponding to the header just written. @@ -42,8 +42,7 @@ Write data corresponding to the header just written. .\" .Sh RETURN VALUES This function returns the number of bytes actually written, or -.Li -1 -on error. +a negative error code on error. .\" .Sh ERRORS Detailed error codes and textual descriptions are available from the @@ -52,6 +51,15 @@ and .Fn archive_error_string functions. .\" +.Sh BUGS +In libarchive 3.x, this function sometimes returns +zero on success instead of returning the number of bytes written. +Specifically, this occurs when writing to an +.Vt archive_write_disk +handle. +Clients should treat any value less than zero as an error +and consider any non-negative value as success. +.\" .Sh SEE ALSO .Xr tar 1 , .Xr libarchive 3 , diff --git a/Utilities/cmlibarchive/libarchive/archive_write_disk.3 b/Utilities/cmlibarchive/libarchive/archive_write_disk.3 index fa925cc..ba6c970 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_disk.3 +++ b/Utilities/cmlibarchive/libarchive/archive_write_disk.3 @@ -70,9 +70,9 @@ Streaming Archive Library (libarchive, -larchive) .Fc .Ft int .Fn archive_write_header "struct archive *" "struct archive_entry *" -.Ft ssize_t +.Ft la_ssize_t .Fn archive_write_data "struct archive *" "const void *" "size_t" -.Ft ssize_t +.Ft la_ssize_t .Fn archive_write_data_block "struct archive *" "const void *" "size_t size" "int64_t offset" .Ft int .Fn archive_write_finish_entry "struct archive *" @@ -177,10 +177,16 @@ The default is to not refuse such paths. Note that paths ending in .Pa .. always cause an error, regardless of this flag. +.It Cm ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS +Refuse to extract an absolute path. +The default is to not refuse such paths. .It Cm ARCHIVE_EXTRACT_SPARSE Scan data for blocks of NUL bytes and try to recreate them with holes. This results in sparse files, independent of whether the archive format supports or uses them. +.It Cm ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS +Before removing a file system object prior to replacing it, clear +platform-specific file flags which might prevent its removal. .El .It Xo .Fn archive_write_disk_set_group_lookup , diff --git a/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c b/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c index a3d350b..450ac75 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c @@ -343,6 +343,7 @@ static int restore_entry(struct archive_write_disk *); static int set_mac_metadata(struct archive_write_disk *, const char *, const void *, size_t); static int set_xattrs(struct archive_write_disk *); +static int clear_nochange_fflags(struct archive_write_disk *); static int set_fflags(struct archive_write_disk *); static int set_fflags_platform(struct archive_write_disk *, int fd, const char *name, mode_t mode, @@ -1467,10 +1468,14 @@ _archive_write_disk_data_block(struct archive *_a, return (r); if ((size_t)r < size) { archive_set_error(&a->archive, 0, - "Write request too large"); + "Too much data: Truncating file at %ju bytes", (uintmax_t)a->filesize); return (ARCHIVE_WARN); } +#if ARCHIVE_VERSION_NUMBER < 3999000 return (ARCHIVE_OK); +#else + return (size); +#endif } static ssize_t @@ -1842,6 +1847,8 @@ restore_entry(struct archive_write_disk *a) * object is a dir, but that doesn't mean the old * object isn't a dir. */ + if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS) + (void)clear_nochange_fflags(a); if (unlink(a->name) == 0) { /* We removed it, reset cached stat. */ a->pst = NULL; @@ -1869,6 +1876,13 @@ restore_entry(struct archive_write_disk *a) en = create_filesystem_object(a); } + if ((en == ENOENT) && (archive_entry_hardlink(a->entry) != NULL)) { + archive_set_error(&a->archive, en, + "Hard-link target '%s' does not exist.", + archive_entry_hardlink(a->entry)); + return (ARCHIVE_FAILED); + } + if ((en == EISDIR || en == EEXIST) && (a->flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) { /* If we're not overwriting, we're done. */ @@ -1940,6 +1954,8 @@ restore_entry(struct archive_write_disk *a) if (!S_ISDIR(a->st.st_mode)) { /* A non-dir is in the way, unlink it. */ + if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS) + (void)clear_nochange_fflags(a); if (unlink(a->name) != 0) { archive_set_error(&a->archive, errno, "Can't unlink already-existing object"); @@ -1950,6 +1966,8 @@ restore_entry(struct archive_write_disk *a) en = create_filesystem_object(a); } else if (!S_ISDIR(a->mode)) { /* A dir is in the way of a non-dir, rmdir it. */ + if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS) + (void)clear_nochange_fflags(a); if (rmdir(a->name) != 0) { archive_set_error(&a->archive, errno, "Can't replace existing directory with non-directory"); @@ -2505,8 +2523,9 @@ cleanup_pathname_win(struct archive_write_disk *a) /* * Canonicalize the pathname. In particular, this strips duplicate * '/' characters, '.' elements, and trailing '/'. It also raises an - * error for an empty path, a trailing '..' or (if _SECURE_NODOTDOT is - * set) any '..' in the path. + * error for an empty path, a trailing '..', (if _SECURE_NODOTDOT is + * set) any '..' in the path or (if ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS + * is set) if the path is absolute. */ static int cleanup_pathname(struct archive_write_disk *a) @@ -2525,8 +2544,15 @@ cleanup_pathname(struct archive_write_disk *a) cleanup_pathname_win(a); #endif /* Skip leading '/'. */ - if (*src == '/') + if (*src == '/') { + if (a->flags & ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Path is absolute"); + return (ARCHIVE_FAILED); + } + separator = *src++; + } /* Scan the pathname one element at a time. */ for (;;) { @@ -3056,9 +3082,23 @@ set_mode(struct archive_write_disk *a, int mode) * impact. */ if (lchmod(a->name, mode) != 0) { - archive_set_error(&a->archive, errno, - "Can't set permissions to 0%o", (int)mode); - r = ARCHIVE_WARN; + switch (errno) { + case ENOTSUP: + case ENOSYS: +#if ENOTSUP != EOPNOTSUPP + case EOPNOTSUPP: +#endif + /* + * if lchmod is defined but the platform + * doesn't support it, silently ignore + * error + */ + break; + default: + archive_set_error(&a->archive, errno, + "Can't set permissions to 0%o", (int)mode); + r = ARCHIVE_WARN; + } } #endif } else if (!S_ISDIR(a->mode)) { @@ -3159,6 +3199,36 @@ set_fflags(struct archive_write_disk *a) return (ARCHIVE_OK); } +static int +clear_nochange_fflags(struct archive_write_disk *a) +{ + int nochange_flags; + mode_t mode = archive_entry_mode(a->entry); + + /* Hopefully, the compiler will optimize this mess into a constant. */ + nochange_flags = 0; +#ifdef SF_IMMUTABLE + nochange_flags |= SF_IMMUTABLE; +#endif +#ifdef UF_IMMUTABLE + nochange_flags |= UF_IMMUTABLE; +#endif +#ifdef SF_APPEND + nochange_flags |= SF_APPEND; +#endif +#ifdef UF_APPEND + nochange_flags |= UF_APPEND; +#endif +#ifdef EXT2_APPEND_FL + nochange_flags |= EXT2_APPEND_FL; +#endif +#ifdef EXT2_IMMUTABLE_FL + nochange_flags |= EXT2_IMMUTABLE_FL; +#endif + + return (set_fflags_platform(a, a->fd, a->name, mode, 0, nochange_flags)); +} + #if ( defined(HAVE_LCHFLAGS) || defined(HAVE_CHFLAGS) || defined(HAVE_FCHFLAGS) ) && defined(HAVE_STRUCT_STAT_ST_FLAGS) /* @@ -3366,6 +3436,7 @@ copy_xattrs(struct archive_write_disk *a, int tmpfd, int dffd) } for (xattr_i = 0; xattr_i < xattr_size; xattr_i += strlen(xattr_names + xattr_i) + 1) { + char *xattr_val_saved; ssize_t s; int f; @@ -3376,11 +3447,13 @@ copy_xattrs(struct archive_write_disk *a, int tmpfd, int dffd) ret = ARCHIVE_WARN; goto exit_xattr; } + xattr_val_saved = xattr_val; xattr_val = realloc(xattr_val, s); if (xattr_val == NULL) { archive_set_error(&a->archive, ENOMEM, "Failed to get metadata(xattr)"); ret = ARCHIVE_WARN; + free(xattr_val_saved); goto exit_xattr; } s = fgetxattr(tmpfd, xattr_names + xattr_i, xattr_val, s, 0, 0); diff --git a/Utilities/cmlibarchive/libarchive/archive_write_disk_set_standard_lookup.c b/Utilities/cmlibarchive/libarchive/archive_write_disk_set_standard_lookup.c index e79008e..3b868fb 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_disk_set_standard_lookup.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_disk_set_standard_lookup.c @@ -67,7 +67,7 @@ static void cleanup(void *); * a simple cache to accelerate such lookups---into the archive_write_disk * object. This is in a separate file because getpwnam()/getgrnam() * can pull in a LOT of library code (including NIS/LDAP functions, which - * pull in DNS resolveers, etc). This can easily top 500kB, which makes + * pull in DNS resolvers, etc). This can easily top 500kB, which makes * it inappropriate for some space-constrained applications. * * Applications that are size-sensitive may want to just use the @@ -86,6 +86,11 @@ archive_write_disk_set_standard_lookup(struct archive *a) { struct bucket *ucache = malloc(cache_size * sizeof(struct bucket)); struct bucket *gcache = malloc(cache_size * sizeof(struct bucket)); + if (ucache == NULL || gcache == NULL) { + free(ucache); + free(gcache); + return (ARCHIVE_FATAL); + } memset(ucache, 0, cache_size * sizeof(struct bucket)); memset(gcache, 0, cache_size * sizeof(struct bucket)); archive_write_disk_set_group_lookup(a, gcache, lookup_gid, cleanup); diff --git a/Utilities/cmlibarchive/libarchive/archive_write_disk_windows.c b/Utilities/cmlibarchive/libarchive/archive_write_disk_windows.c index ed62009..800aa89 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_disk_windows.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_disk_windows.c @@ -330,8 +330,6 @@ file_information(struct archive_write_disk *a, wchar_t *path, break; case L'C': case L'c': if (((p[2] == L'M' || p[2] == L'm' ) && - (p[3] == L'D' || p[3] == L'd' )) || - ((p[2] == L'M' || p[2] == L'm' ) && (p[3] == L'D' || p[3] == L'd' ))) *mode |= S_IXUSR | S_IXGRP | S_IXOTH; break; @@ -1011,7 +1009,11 @@ _archive_write_disk_data_block(struct archive *_a, "Write request too large"); return (ARCHIVE_WARN); } +#if ARCHIVE_VERSION_NUMBER < 3999000 return (ARCHIVE_OK); +#else + return (size); +#endif } static ssize_t diff --git a/Utilities/cmlibarchive/libarchive/archive_write_filter.3 b/Utilities/cmlibarchive/libarchive/archive_write_filter.3 index 3ca248b..83bd2c6 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_filter.3 +++ b/Utilities/cmlibarchive/libarchive/archive_write_filter.3 @@ -24,46 +24,62 @@ .\" .\" $FreeBSD$ .\" -.Dd February 2, 2012 +.Dd August 14, 2014 .Dt ARCHIVE_WRITE_FILTER 3 .Os .Sh NAME +.Nm archive_write_add_filter_b64encode , .Nm archive_write_add_filter_bzip2 , .Nm archive_write_add_filter_compress , .Nm archive_write_add_filter_gzip , +.Nm archive_write_add_filter_lz4 , .Nm archive_write_add_filter_lzip , .Nm archive_write_add_filter_lzma , +.Nm archive_write_add_filter_lzop , .Nm archive_write_add_filter_none , .Nm archive_write_add_filter_program , +.Nm archive_write_add_filter_uuencode , .Nm archive_write_add_filter_xz .Sh LIBRARY Streaming Archive Library (libarchive, -larchive) .Sh SYNOPSIS .In archive.h .Ft int +.Fn archive_write_add_filter_b64encode "struct archive *" +.Ft int .Fn archive_write_add_filter_bzip2 "struct archive *" .Ft int .Fn archive_write_add_filter_compress "struct archive *" .Ft int .Fn archive_write_add_filter_gzip "struct archive *" .Ft int +.Fn archive_write_add_filter_lz4 "struct archive *" +.Ft int .Fn archive_write_add_filter_lzip "struct archive *" .Ft int .Fn archive_write_add_filter_lzma "struct archive *" .Ft int +.Fn archive_write_add_filter_lzop "struct archive *" +.Ft int .Fn archive_write_add_filter_none "struct archive *" .Ft int .Fn archive_write_add_filter_program "struct archive *" "const char * cmd" .Ft int +.Fn archive_write_add_filter_uuencode "struct archive *" +.Ft int .Fn archive_write_add_filter_xz "struct archive *" .Sh DESCRIPTION .Bl -tag -width indent .It Xo +.Fn archive_write_add_filter_b64encode , .Fn archive_write_add_filter_bzip2 , .Fn archive_write_add_filter_compress , .Fn archive_write_add_filter_gzip , +.Fn archive_write_add_filter_lz4 , .Fn archive_write_add_filter_lzip , .Fn archive_write_add_filter_lzma , +.Fn archive_write_add_filter_lzop , +.Fn archive_write_add_filter_uuencode , .Fn archive_write_add_filter_xz , .Xc The resulting archive will be compressed as specified. diff --git a/Utilities/cmlibarchive/libarchive/archive_write_finish_entry.3 b/Utilities/cmlibarchive/libarchive/archive_write_finish_entry.3 index d881c80..c5ef69e 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_finish_entry.3 +++ b/Utilities/cmlibarchive/libarchive/archive_write_finish_entry.3 @@ -41,7 +41,7 @@ Close out the entry just written. In particular, this writes out the final padding required by some formats. Ordinarily, clients never need to call this, as it is called automatically by -.Fn archive_write_next_header +.Fn archive_write_header and .Fn archive_write_close as needed. diff --git a/Utilities/cmlibarchive/libarchive/archive_write_format.3 b/Utilities/cmlibarchive/libarchive/archive_write_format.3 index 39d3006..4bd1163 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_format.3 +++ b/Utilities/cmlibarchive/libarchive/archive_write_format.3 @@ -34,7 +34,9 @@ .Nm archive_write_set_format_raw , .Nm archive_write_set_format_shar , .Nm archive_write_set_format_shar_dump , -.Nm archive_write_set_format_ustar +.Nm archive_write_set_format_ustar , +.Nm archive_write_set_format_filter_by_ext , +.Nm archive_write_set_format_filter_by_ext_def .Nd functions for creating archives .Sh LIBRARY Streaming Archive Library (libarchive, -larchive) @@ -54,6 +56,10 @@ Streaming Archive Library (libarchive, -larchive) .Fn archive_write_set_format_shar_dump "struct archive *" .Ft int .Fn archive_write_set_format_ustar "struct archive *" +.Ft int +.Fn archive_write_set_format_filter_by_ext "struct archive *" "const char *" +.Ft int +.Fn archive_write_set_format_filter_by_ext_def "struct archive *" "const char *" "const char *" .Sh DESCRIPTION These functions set the format that will be used for the archive. .Pp @@ -79,6 +85,14 @@ filenames, linknames, uids, sizes, etc. is the library default; this is the same as pax format, but suppresses the pax extended header for most normal files. In most cases, this will result in ordinary ustar archives. +.Bl -tag -width indent +.It Xo +.Fn archive_write_set_format_filter_by_ext , +.Fn archive_write_set_format_filter_by_ext_def +.Xc +Format and filter for archive can be set automatically, based on output file name extension. +The functions are platform dependent. +Supported extensions: .7z, .zip, .jar, .cpio, .iso, .a, .ar, .tar, .tgz, .tar.gz, .tar.bz2, .tar.xz .\" .Sh RETURN VALUES These functions return diff --git a/Utilities/cmlibarchive/libarchive/archive_write_open.3 b/Utilities/cmlibarchive/libarchive/archive_write_open.3 index 4037248..a52959b 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_open.3 +++ b/Utilities/cmlibarchive/libarchive/archive_write_open.3 @@ -154,7 +154,7 @@ to register an error code and message and return .Cm ARCHIVE_FATAL . .Bl -item -offset indent .It -.Ft typedef ssize_t +.Ft typedef la_ssize_t .Fo archive_write_callback .Fa "struct archive *" .Fa "void *client_data" diff --git a/Utilities/cmlibarchive/libarchive/archive_write_open_filename.c b/Utilities/cmlibarchive/libarchive/archive_write_open_filename.c index 196b770..66e0dfe 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_open_filename.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_open_filename.c @@ -243,7 +243,10 @@ file_close(struct archive *a, void *client_data) struct write_file_data *mine = (struct write_file_data *)client_data; (void)a; /* UNUSED */ - close(mine->fd); + + if (mine->fd >= 0) + close(mine->fd); + archive_mstring_clean(&mine->filename); free(mine); return (ARCHIVE_OK); diff --git a/Utilities/cmlibarchive/libarchive/archive_write_private.h b/Utilities/cmlibarchive/libarchive/archive_write_private.h index e600d54..0c3cc0c 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_private.h +++ b/Utilities/cmlibarchive/libarchive/archive_write_private.h @@ -26,8 +26,10 @@ */ #ifndef __LIBARCHIVE_BUILD +#ifndef __LIBARCHIVE_TEST #error This header is only to be used internally to libarchive. #endif +#endif #ifndef ARCHIVE_WRITE_PRIVATE_H_INCLUDED #define ARCHIVE_WRITE_PRIVATE_H_INCLUDED @@ -116,6 +118,14 @@ struct archive_write { const void *buff, size_t); int (*format_close)(struct archive_write *); int (*format_free)(struct archive_write *); + + + /* + * Encryption passphrase. + */ + char *passphrase; + archive_passphrase_callback *passphrase_callback; + void *passphrase_client_data; }; /* @@ -142,4 +152,9 @@ int __archive_write_program_close(struct archive_write_filter *, struct archive_write_program_data *); int __archive_write_program_write(struct archive_write_filter *, struct archive_write_program_data *, const void *, size_t); + +/* + * Get a encryption passphrase. + */ +const char * __archive_write_get_passphrase(struct archive_write *a); #endif diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_format.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format.c index 9055753..744302d 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_set_format.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format.c @@ -57,6 +57,7 @@ struct { int code; int (*setter)(struct archive *); } codes[] = { ARCHIVE_FORMAT_TAR_PAX_RESTRICTED, archive_write_set_format_pax_restricted }, { ARCHIVE_FORMAT_TAR_USTAR, archive_write_set_format_ustar }, + { ARCHIVE_FORMAT_WARC, archive_write_set_format_warc }, { ARCHIVE_FORMAT_XAR, archive_write_set_format_xar }, { ARCHIVE_FORMAT_ZIP, archive_write_set_format_zip }, { 0, NULL } diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_format_by_name.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_by_name.c index 4f3ce7d..a2ce7c6 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_by_name.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_by_name.c @@ -70,6 +70,7 @@ struct { const char *name; int (*setter)(struct archive *); } names[] = { "ustar", archive_write_set_format_ustar }, { "v7tar", archive_write_set_format_v7tar }, { "v7", archive_write_set_format_v7tar }, + { "warc", archive_write_set_format_warc }, { "xar", archive_write_set_format_xar }, { "zip", archive_write_set_format_zip }, { NULL, NULL } diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_format_filter_by_ext.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_filter_by_ext.c new file mode 100644 index 0000000..adec9b2 --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_filter_by_ext.c @@ -0,0 +1,142 @@ +/*- + * Copyright (c) 2003-2007 Tim Kientzle + * Copyright (c) 2015 Okhotnikov Kirill + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "archive_platform.h" +__FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_format_by_name.c 201168 2009-12-29 06:15:32Z kientzle $"); + +#ifdef HAVE_SYS_TYPES_H +#include <sys/types.h> +#endif + +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif +#ifdef HAVE_STRING_H +#include <string.h> +#endif + +#include "archive.h" +#include "archive_private.h" + +/* A table that maps names to functions. */ +static +struct { const char *name; int (*format)(struct archive *); int (*filter)(struct archive *); } names[] = +{ + { ".7z", archive_write_set_format_7zip, archive_write_add_filter_none}, + { ".zip", archive_write_set_format_zip, archive_write_add_filter_none}, + { ".jar", archive_write_set_format_zip, archive_write_add_filter_none}, + { ".cpio", archive_write_set_format_cpio, archive_write_add_filter_none}, + { ".iso", archive_write_set_format_iso9660, archive_write_add_filter_none}, +#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) + { ".a", archive_write_set_format_ar_bsd, archive_write_add_filter_none}, + { ".ar", archive_write_set_format_ar_bsd, archive_write_add_filter_none}, +#else + { ".a", archive_write_set_format_ar_svr4, archive_write_add_filter_none}, + { ".ar", archive_write_set_format_ar_svr4, archive_write_add_filter_none}, +#endif + { ".tar", archive_write_set_format_pax_restricted, archive_write_add_filter_none}, + { ".tgz", archive_write_set_format_pax_restricted, archive_write_add_filter_gzip}, + { ".tar.gz", archive_write_set_format_pax_restricted, archive_write_add_filter_gzip}, + { ".tar.bz2", archive_write_set_format_pax_restricted, archive_write_add_filter_bzip2}, + { ".tar.xz", archive_write_set_format_pax_restricted, archive_write_add_filter_xz}, + { NULL, NULL, NULL } +}; + +static +int cmpsuff(const char *str, const char *suffix) +{ + size_t length_str, length_suffix; + + if ((str == NULL) || (suffix == NULL)) + return -1; + + length_str = strlen(str); + length_suffix = strlen(suffix); + + if (length_str >= length_suffix) { + return strcmp(str + (length_str - length_suffix), suffix); + } else { + return -1; + } +} + +static int get_array_index(const char *name) +{ + int i; + + for (i = 0; names[i].name != NULL; i++) + { + if (cmpsuff(name, names[i].name) == 0) + return i; + } + return -1; + +} + +int +archive_write_set_format_filter_by_ext(struct archive *a, const char *filename) +{ + int names_index = get_array_index(filename); + + if (names_index >= 0) + { + int format_state = (names[names_index].format)(a); + if (format_state == ARCHIVE_OK) + return ((names[names_index].filter)(a)); + else + return format_state; + } + + archive_set_error(a, EINVAL, "No such format '%s'", filename); + a->state = ARCHIVE_STATE_FATAL; + return (ARCHIVE_FATAL); +} + +int +archive_write_set_format_filter_by_ext_def(struct archive *a, const char *filename, const char * def_ext) +{ + int names_index = get_array_index(filename); + + if (names_index < 0) + names_index = get_array_index(def_ext); + + if (names_index >= 0) + { + int format_state = (names[names_index].format)(a); + if (format_state == ARCHIVE_OK) + return ((names[names_index].filter)(a)); + else + return format_state; + } + + archive_set_error(a, EINVAL, "No such format '%s'", filename); + a->state = ARCHIVE_STATE_FATAL; + return (ARCHIVE_FATAL); +} + + + + diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c index e722625..576f4c2 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c @@ -2719,6 +2719,16 @@ extra_get_record(struct isoent *isoent, int *space, int *off, int *loc) rec->offset = 0; /* Insert `rec` into the tail of isoent->extr_rec_list */ rec->next = NULL; + /* + * Note: testing isoent->extr_rec_list.last == NULL + * here is really unneeded since it has been already + * initialized at isoent_new function but Clang Static + * Analyzer claims that it is dereference of null + * pointer. + */ + if (isoent->extr_rec_list.last == NULL) + isoent->extr_rec_list.last = + &(isoent->extr_rec_list.first); *isoent->extr_rec_list.last = rec; isoent->extr_rec_list.last = &(rec->next); } diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c index b0c8018..b686303 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_mtree.c @@ -35,7 +35,7 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_format_mtree.c 201171 #include <string.h> #include "archive.h" -#include "archive_crypto_private.h" +#include "archive_digest_private.h" #include "archive_entry.h" #include "archive_private.h" #include "archive_rb.h" @@ -639,7 +639,7 @@ attr_counter_inc(struct attr_counter **top, struct attr_counter *ac, *top = ac; ac->next->prev = ac; } - } else { + } else if (last != NULL) { ac = attr_counter_new(me, last); if (ac == NULL) return (-1); diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_format_warc.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_warc.c new file mode 100644 index 0000000..80abc6f --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_warc.c @@ -0,0 +1,439 @@ +/*- + * Copyright (c) 2014 Sebastian Freundt + * Author: Sebastian Freundt <devel@fresse.org> + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "archive_platform.h" +__FBSDID("$FreeBSD$"); + +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif +#include <stdio.h> +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif +#ifdef HAVE_STRING_H +#include <string.h> +#endif +#ifdef HAVE_TIME_H +#include <time.h> +#endif + +#include "archive.h" +#include "archive_entry.h" +#include "archive_entry_locale.h" +#include "archive_private.h" +#include "archive_random_private.h" +#include "archive_write_private.h" + +struct warc_s { + unsigned int omit_warcinfo:1; + + time_t now; + mode_t typ; + unsigned int rng; + /* populated size */ + uint64_t populz; +}; + +static const char warcinfo[] = + "software: libarchive/" ARCHIVE_VERSION_ONLY_STRING "\r\n" + "format: WARC file version 1.0\r\n"; + +typedef enum { + WT_NONE, + /* warcinfo */ + WT_INFO, + /* metadata */ + WT_META, + /* resource */ + WT_RSRC, + /* request, unsupported */ + WT_REQ, + /* response, unsupported */ + WT_RSP, + /* revisit, unsupported */ + WT_RVIS, + /* conversion, unsupported */ + WT_CONV, + /* continutation, unsupported at the moment */ + WT_CONT, + /* invalid type */ + LAST_WT +} warc_type_t; + +typedef struct { + warc_type_t type; + const char *tgturi; + const char *recid; + time_t rtime; + time_t mtime; + const char *cnttyp; + uint64_t cntlen; +} warc_essential_hdr_t; + +typedef struct { + unsigned int u[4U]; +} warc_uuid_t; + +static int _warc_options(struct archive_write*, const char *key, const char *v); +static int _warc_header(struct archive_write *a, struct archive_entry *entry); +static ssize_t _warc_data(struct archive_write *a, const void *buf, size_t sz); +static int _warc_finish_entry(struct archive_write *a); +static int _warc_close(struct archive_write *a); +static int _warc_free(struct archive_write *a); + +/* private routines */ +static ssize_t _popul_ehdr(struct archive_string *t, size_t z, warc_essential_hdr_t); +static int _gen_uuid(warc_uuid_t *tgt); + + +/* + * Set output format to ISO 28500 (aka WARC) format. + */ +int +archive_write_set_format_warc(struct archive *_a) +{ + struct archive_write *a = (struct archive_write *)_a; + struct warc_s *w; + + archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, + ARCHIVE_STATE_NEW, "archive_write_set_format_warc"); + + /* If another format was already registered, unregister it. */ + if (a->format_free != NULL) { + (a->format_free)(a); + } + + w = malloc(sizeof(*w)); + if (w == NULL) { + archive_set_error(&a->archive, ENOMEM, + "Can't allocate warc data"); + return (ARCHIVE_FATAL); + } + /* by default we're emitting a file wide header */ + w->omit_warcinfo = 0U; + /* obtain current time for date fields */ + w->now = time(NULL); + /* reset file type info */ + w->typ = 0; + /* also initialise our rng */ + w->rng = (unsigned int)w->now; + + a->format_data = w; + a->format_name = "WARC/1.0"; + a->format_options = _warc_options; + a->format_write_header = _warc_header; + a->format_write_data = _warc_data; + a->format_close = _warc_close; + a->format_free = _warc_free; + a->format_finish_entry = _warc_finish_entry; + a->archive.archive_format = ARCHIVE_FORMAT_WARC; + a->archive.archive_format_name = "WARC/1.0"; + return (ARCHIVE_OK); +} + + +/* archive methods */ +static int +_warc_options(struct archive_write *a, const char *key, const char *val) +{ + struct warc_s *w = a->format_data; + + if (strcmp(key, "omit-warcinfo") == 0) { + if (val == NULL || strcmp(val, "true") == 0) { + /* great */ + w->omit_warcinfo = 1U; + return (ARCHIVE_OK); + } + } + + /* Note: The "warn" return is just to inform the options + * supervisor that we didn't handle it. It will generate + * a suitable error if no one used this option. */ + return (ARCHIVE_WARN); +} + +static int +_warc_header(struct archive_write *a, struct archive_entry *entry) +{ + struct warc_s *w = a->format_data; + struct archive_string hdr; +#define MAX_HDR_SIZE 512 + + /* check whether warcinfo record needs outputting */ + if (!w->omit_warcinfo) { + warc_essential_hdr_t wi = { + WT_INFO, + /*uri*/NULL, + /*urn*/NULL, + /*rtm*/w->now, + /*mtm*/w->now, + /*cty*/"application/warc-fields", + /*len*/sizeof(warcinfo) - 1U, + }; + ssize_t r; + + archive_string_init(&hdr); + r = _popul_ehdr(&hdr, MAX_HDR_SIZE, wi); + if (r >= 0) { + /* jackpot! */ + /* now also use HDR buffer for the actual warcinfo */ + archive_strncat(&hdr, warcinfo, sizeof(warcinfo) -1); + + /* append end-of-record indicator */ + archive_strncat(&hdr, "\r\n\r\n", 4); + + /* write to output stream */ + __archive_write_output(a, hdr.s, archive_strlen(&hdr)); + } + /* indicate we're done with file header writing */ + w->omit_warcinfo = 1U; + archive_string_free(&hdr); + } + + if (archive_entry_pathname(entry) == NULL) { + archive_set_error(&a->archive, EINVAL, + "Invalid filename"); + return (ARCHIVE_WARN); + } + + w->typ = archive_entry_filetype(entry); + w->populz = 0U; + if (w->typ == AE_IFREG) { + warc_essential_hdr_t rh = { + WT_RSRC, + /*uri*/archive_entry_pathname(entry), + /*urn*/NULL, + /*rtm*/w->now, + /*mtm*/archive_entry_mtime(entry), + /*cty*/NULL, + /*len*/(size_t)archive_entry_size(entry), + }; + ssize_t r; + + archive_string_init(&hdr); + r = _popul_ehdr(&hdr, MAX_HDR_SIZE, rh); + if (r < 0) { + /* don't bother */ + archive_set_error( + &a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, + "cannot archive file"); + return (ARCHIVE_WARN); + } + /* otherwise append to output stream */ + __archive_write_output(a, hdr.s, r); + /* and let subsequent calls to _data() know about the size */ + w->populz = rh.cntlen; + archive_string_free(&hdr); + return (ARCHIVE_OK); + } + /* just resort to erroring as per Tim's advice */ + archive_set_error( + &a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, + "WARC can only process regular files"); + return (ARCHIVE_FAILED); +} + +static ssize_t +_warc_data(struct archive_write *a, const void *buf, size_t len) +{ + struct warc_s *w = a->format_data; + + if (w->typ == AE_IFREG) { + int rc; + + /* never write more bytes than announced */ + if (len > w->populz) { + len = (size_t)w->populz; + } + + /* now then, out we put the whole shebang */ + rc = __archive_write_output(a, buf, len); + if (rc != ARCHIVE_OK) { + return rc; + } + } + return len; +} + +static int +_warc_finish_entry(struct archive_write *a) +{ + static const char _eor[] = "\r\n\r\n"; + struct warc_s *w = a->format_data; + + if (w->typ == AE_IFREG) { + int rc = __archive_write_output(a, _eor, sizeof(_eor) - 1U); + + if (rc != ARCHIVE_OK) { + return rc; + } + } + /* reset type info */ + w->typ = 0; + return (ARCHIVE_OK); +} + +static int +_warc_close(struct archive_write *a) +{ + (void)a; /* UNUSED */ + return (ARCHIVE_OK); +} + +static int +_warc_free(struct archive_write *a) +{ + struct warc_s *w = a->format_data; + + free(w); + a->format_data = NULL; + return (ARCHIVE_OK); +} + + +/* private routines */ +static void +xstrftime(struct archive_string *as, const char *fmt, time_t t) +{ +/** like strftime(3) but for time_t objects */ + struct tm *rt; +#if defined(HAVE_GMTIME_R) || defined(HAVE__GMTIME64_S) + struct tm time; +#endif + char strtime[100]; + size_t len; + +#ifdef HAVE_GMTIME_R + if ((rt = gmtime_r(&t, &time)) == NULL) + return; +#elif defined(HAVE__GMTIME64_S) + _gmtime64_s(&time, &t); +#else + if ((rt = gmtime(&t)) == NULL) + return; +#endif + /* leave the hard yacker to our role model strftime() */ + len = strftime(strtime, sizeof(strtime)-1, fmt, rt); + archive_strncat(as, strtime, len); +} + +static ssize_t +_popul_ehdr(struct archive_string *tgt, size_t tsz, warc_essential_hdr_t hdr) +{ + static const char _ver[] = "WARC/1.0\r\n"; + static const char *_typ[LAST_WT] = { + NULL, "warcinfo", "metadata", "resource", NULL + }; + char std_uuid[48U]; + + if (hdr.type == WT_NONE || hdr.type > WT_RSRC) { + /* brilliant, how exactly did we get here? */ + return -1; + } + + archive_strcpy(tgt, _ver); + + archive_string_sprintf(tgt, "WARC-Type: %s\r\n", _typ[hdr.type]); + + if (hdr.tgturi != NULL) { + /* check if there's a xyz:// */ + static const char _uri[] = ""; + static const char _fil[] = "file://"; + const char *u; + char *chk = strchr(hdr.tgturi, ':'); + + if (chk != NULL && chk[1U] == '/' && chk[2U] == '/') { + /* yep, it's definitely a URI */ + u = _uri; + } else { + /* hm, best to prepend file:// then */ + u = _fil; + } + archive_string_sprintf(tgt, + "WARC-Target-URI: %s%s\r\n", u, hdr.tgturi); + } + + /* record time is usually when the http is sent off, + * just treat the archive writing as such for a moment */ + xstrftime(tgt, "WARC-Date: %Y-%m-%dT%H:%M:%SZ\r\n", hdr.rtime); + + /* while we're at it, record the mtime */ + xstrftime(tgt, "Last-Modified: %Y-%m-%dT%H:%M:%SZ\r\n", hdr.mtime); + + if (hdr.recid == NULL) { + /* generate one, grrrr */ + warc_uuid_t u; + + _gen_uuid(&u); + /* Unfortunately, archive_string_sprintf does not + * handle the minimum number following '%'. + * So we have to use snprintf function here instead + * of archive_string_snprintf function. */ +#if defined(_WIN32) && !defined(__CYGWIN__) +#define snprintf _snprintf +#endif + snprintf( + std_uuid, sizeof(std_uuid), + "<urn:uuid:%08x-%04x-%04x-%04x-%04x%08x>", + u.u[0U], + u.u[1U] >> 16U, u.u[1U] & 0xffffU, + u.u[2U] >> 16U, u.u[2U] & 0xffffU, + u.u[3U]); + hdr.recid = std_uuid; + } + + /* record-id is mandatory, fingers crossed we won't fail */ + archive_string_sprintf(tgt, "WARC-Record-ID: %s\r\n", hdr.recid); + + if (hdr.cnttyp != NULL) { + archive_string_sprintf(tgt, "Content-Type: %s\r\n", hdr.cnttyp); + } + + /* next one is mandatory */ + archive_string_sprintf(tgt, "Content-Length: %ju\r\n", (uintmax_t)hdr.cntlen); + /**/ + archive_strncat(tgt, "\r\n", 2); + + return (archive_strlen(tgt) >= tsz)? -1: (ssize_t)archive_strlen(tgt); +} + +static int +_gen_uuid(warc_uuid_t *tgt) +{ + archive_random(tgt->u, sizeof(tgt->u)); + /* obey uuid version 4 rules */ + tgt->u[1U] &= 0xffff0fffU; + tgt->u[1U] |= 0x4000U; + tgt->u[2U] &= 0x3fffffffU; + tgt->u[2U] |= 0x80000000U; + return 0; +} + +/* archive_write_set_format_warc.c ends here */ diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_format_xar.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_xar.c index 4cd2b9d..a47c53c 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_xar.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_xar.c @@ -47,7 +47,7 @@ __FBSDID("$FreeBSD$"); #endif #include "archive.h" -#include "archive_crypto_private.h" +#include "archive_digest_private.h" #include "archive_endian.h" #include "archive_entry.h" #include "archive_entry_locale.h" @@ -114,7 +114,7 @@ enum sumalg { #define MAX_SUM_SIZE 20 #define MD5_NAME "md5" #define SHA1_NAME "sha1" - + enum enctype { NONE, GZIP, @@ -242,6 +242,7 @@ struct xar { enum sumalg opt_sumalg; enum enctype opt_compression; int opt_compression_level; + uint32_t opt_threads; struct chksumwork a_sumwrk; /* archived checksum. */ struct chksumwork e_sumwrk; /* extracted checksum. */ @@ -317,7 +318,7 @@ static int compression_end_bzip2(struct archive *, struct la_zstream *); static int compression_init_encoder_lzma(struct archive *, struct la_zstream *, int); static int compression_init_encoder_xz(struct archive *, - struct la_zstream *, int); + struct la_zstream *, int, int); #if defined(HAVE_LZMA_H) static int compression_code_lzma(struct archive *, struct la_zstream *, enum la_zaction); @@ -380,9 +381,10 @@ archive_write_set_format_xar(struct archive *_a) /* Set default checksum type. */ xar->opt_toc_sumalg = CKSUM_SHA1; xar->opt_sumalg = CKSUM_SHA1; - /* Set default compression type and level. */ + /* Set default compression type, level, and number of threads. */ xar->opt_compression = GZIP; xar->opt_compression_level = 6; + xar->opt_threads = 1; a->format_data = xar; @@ -493,6 +495,26 @@ xar_options(struct archive_write *a, const char *key, const char *value) } return (ARCHIVE_OK); } + if (strcmp(key, "threads") == 0) { + if (value == NULL) + return (ARCHIVE_FAILED); + xar->opt_threads = (int)strtoul(value, NULL, 10); + if (xar->opt_threads == 0 && errno != 0) { + xar->opt_threads = 1; + archive_set_error(&(a->archive), + ARCHIVE_ERRNO_MISC, + "Illegal value `%s'", + value); + return (ARCHIVE_FAILED); + } + if (xar->opt_threads == 0) { +#ifdef HAVE_LZMA_STREAM_ENCODER_MT + xar->opt_threads = lzma_cputhreads(); +#else + xar->opt_threads = 1; +#endif + } + } /* Note: The "warn" return is just to inform the options * supervisor that we didn't handle it. It will generate @@ -805,7 +827,7 @@ xmlwrite_string(struct archive_write *a, xmlTextWriterPtr writer, if (value == NULL) return (ARCHIVE_OK); - + r = xmlTextWriterStartElement(writer, BAD_CAST_CONST(key)); if (r < 0) { archive_set_error(&a->archive, @@ -1875,7 +1897,7 @@ file_cmp_node(const struct archive_rb_node *n1, return (strcmp(f1->basename.s, f2->basename.s)); } - + static int file_cmp_key(const struct archive_rb_node *n, const void *key) { @@ -2154,7 +2176,7 @@ file_gen_utility_names(struct archive_write *a, struct file *file) file->parentdir.length = len; archive_string_copy(&(file->basename), &(file->parentdir)); archive_string_empty(&(file->parentdir)); - file->parentdir.s = '\0'; + *file->parentdir.s = '\0'; return (r); } @@ -2494,7 +2516,7 @@ file_init_hardlinks(struct xar *xar) static const struct archive_rb_tree_ops rb_ops = { file_hd_cmp_node, file_hd_cmp_key, }; - + __archive_rb_tree_init(&(xar->hardlink_rbtree), &rb_ops); } @@ -2848,13 +2870,18 @@ compression_init_encoder_lzma(struct archive *a, static int compression_init_encoder_xz(struct archive *a, - struct la_zstream *lastrm, int level) + struct la_zstream *lastrm, int level, int threads) { static const lzma_stream lzma_init_data = LZMA_STREAM_INIT; lzma_stream *strm; lzma_filter *lzmafilters; lzma_options_lzma lzma_opt; int r; +#ifdef HAVE_LZMA_STREAM_ENCODER_MT + lzma_mt mt_options; +#endif + + (void)threads; /* UNUSED (if multi-threaded LZMA library not avail) */ if (lastrm->valid) compression_end(a, lastrm); @@ -2879,7 +2906,17 @@ compression_init_encoder_xz(struct archive *a, lzmafilters[1].id = LZMA_VLI_UNKNOWN;/* Terminate */ *strm = lzma_init_data; - r = lzma_stream_encoder(strm, lzmafilters, LZMA_CHECK_CRC64); +#ifdef HAVE_LZMA_STREAM_ENCODER_MT + if (threads > 1) { + bzero(&mt_options, sizeof(mt_options)); + mt_options.threads = threads; + mt_options.timeout = 300; + mt_options.filters = lzmafilters; + mt_options.check = LZMA_CHECK_CRC64; + r = lzma_stream_encoder_mt(strm, &mt_options); + } else +#endif + r = lzma_stream_encoder(strm, lzmafilters, LZMA_CHECK_CRC64); switch (r) { case LZMA_OK: lastrm->real_stream = strm; @@ -2979,10 +3016,11 @@ compression_init_encoder_lzma(struct archive *a, } static int compression_init_encoder_xz(struct archive *a, - struct la_zstream *lastrm, int level) + struct la_zstream *lastrm, int level, int threads) { (void) level; /* UNUSED */ + (void) threads; /* UNUSED */ if (lastrm->valid) compression_end(a, lastrm); return (compression_unsupported_encoder(a, lastrm, "xz")); @@ -3015,7 +3053,7 @@ xar_compression_init_encoder(struct archive_write *a) case XZ: r = compression_init_encoder_xz( &(a->archive), &(xar->stream), - xar->opt_compression_level); + xar->opt_compression_level, xar->opt_threads); break; default: r = ARCHIVE_OK; @@ -3178,4 +3216,3 @@ getalgname(enum sumalg sumalg) } #endif /* Support xar format */ - diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_format_zip.c b/Utilities/cmlibarchive/libarchive/archive_write_set_format_zip.c index 3b07e35..0636f46 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_set_format_zip.c +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_format_zip.c @@ -1,7 +1,7 @@ /*- * Copyright (c) 2008 Anselm Strauss * Copyright (c) 2009 Joerg Sonnenberger - * Copyright (c) 2011-2012 Michihiro NAKAJIMA + * Copyright (c) 2011-2012,2014 Michihiro NAKAJIMA * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -49,20 +49,23 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_format_zip.c 201168 20 #endif #include "archive.h" +#include "archive_cryptor_private.h" #include "archive_endian.h" #include "archive_entry.h" #include "archive_entry_locale.h" +#include "archive_hmac_private.h" #include "archive_private.h" +#include "archive_random_private.h" #include "archive_write_private.h" #ifndef HAVE_ZLIB_H #include "archive_crc32.h" #endif +#define ZIP_ENTRY_FLAG_ENCRYPTED (1<<0) #define ZIP_ENTRY_FLAG_LENGTH_AT_END (1<<3) #define ZIP_ENTRY_FLAG_UTF8_NAME (1 << 11) - enum compression { COMPRESSION_UNSPECIFIED = -1, COMPRESSION_STORE = 0, @@ -75,6 +78,32 @@ enum compression { #define COMPRESSION_DEFAULT COMPRESSION_STORE #endif +enum encryption { + ENCRYPTION_NONE = 0, + ENCRYPTION_TRADITIONAL, /* Traditional PKWARE encryption. */ + ENCRYPTION_WINZIP_AES128, /* WinZIP AES-128 encryption. */ + ENCRYPTION_WINZIP_AES256, /* WinZIP AES-256 encryption. */ +}; + +#define TRAD_HEADER_SIZE 12 +/* + * See "WinZip - AES Encryption Information" + * http://www.winzip.com/aes_info.htm + */ +/* Value used in compression method. */ +#define WINZIP_AES_ENCRYPTION 99 +/* A WinZip AES header size which is stored at the beginning of + * file contents. */ +#define WINZIP_AES128_HEADER_SIZE (8 + 2) +#define WINZIP_AES256_HEADER_SIZE (16 + 2) +/* AES vendor version. */ +#define AES_VENDOR_AE_1 0x0001 +#define AES_VENDOR_AE_2 0x0002 +/* Authentication code size. */ +#define AUTH_CODE_SIZE 10 +/**/ +#define MAX_DERIVED_KEY_BUF_SIZE (AES_MAX_KEY_SIZE * 2 + 2) + struct cd_segment { struct cd_segment *next; size_t buff_size; @@ -82,9 +111,9 @@ struct cd_segment { unsigned char *p; }; -/* Bits used to enable/disable certain experimental features. */ -#define EXPERIMENT_LA 1 -#define EXPERIMENTS_ALL 0xffff +struct trad_enc_ctx { + uint32_t keys[3]; +}; struct zip { @@ -97,9 +126,18 @@ struct zip { struct archive_entry *entry; uint32_t entry_crc32; enum compression entry_compression; + enum encryption entry_encryption; int entry_flags; int entry_uses_zip64; int experiments; + struct trad_enc_ctx tctx; + char tctx_valid; + unsigned char trad_chkdat; + unsigned aes_vendor; + archive_crypto_ctx cctx; + char cctx_valid; + archive_hmac_sha1_ctx hctx; + char hctx_valid; unsigned char *file_header; size_t file_header_extra_offset; @@ -115,18 +153,20 @@ struct zip { struct archive_string_conv *opt_sconv; struct archive_string_conv *sconv_default; enum compression requested_compression; + int deflate_compression_level; int init_default_conversion; + enum encryption encryption_type; #define ZIP_FLAG_AVOID_ZIP64 1 #define ZIP_FLAG_FORCE_ZIP64 2 -#define ZIP_FLAG_EXPERIMENT_EL 4 +#define ZIP_FLAG_EXPERIMENT_xl 4 int flags; #ifdef HAVE_ZLIB_H z_stream stream; +#endif size_t len_buf; unsigned char *buf; -#endif }; /* Don't call this min or MIN, since those are already defined @@ -147,6 +187,13 @@ static size_t path_length(struct archive_entry *); static int write_path(struct archive_entry *, struct archive_write *); static void copy_path(struct archive_entry *, unsigned char *); static struct archive_string_conv *get_sconv(struct archive_write *, struct zip *); +static int trad_enc_init(struct trad_enc_ctx *, const char *, size_t); +static unsigned trad_enc_encrypt_update(struct trad_enc_ctx *, const uint8_t *, + size_t, uint8_t *, size_t); +static int init_traditional_pkware_encryption(struct archive_write *); +static int is_traditional_pkware_encryption_supported(void); +static int init_winzip_aes_encryption(struct archive_write *); +static int is_winzip_aes_encryption_supported(int encryption); static unsigned char * cd_alloc(struct zip *zip, size_t length) @@ -186,7 +233,7 @@ cd_alloc(struct zip *zip, size_t length) static unsigned long real_crc32(unsigned long crc, const void *buff, size_t len) { - return crc32(crc, buff, len); + return crc32(crc, buff, (unsigned int)len); } static unsigned long @@ -227,11 +274,70 @@ archive_write_zip_options(struct archive_write *a, const char *key, ret = ARCHIVE_OK; } return (ret); + } else if (strcmp(key, "compression-level") == 0) { + if (val == NULL || !(val[0] >= '0' && val[0] <= '9') || val[1] != '\0') { + return ARCHIVE_WARN; + } + + if (val[0] == '0') { + zip->requested_compression = COMPRESSION_STORE; + return ARCHIVE_OK; + } else { +#ifdef HAVE_ZLIB_H + zip->requested_compression = COMPRESSION_DEFLATE; + zip->deflate_compression_level = val[0] - '0'; + return ARCHIVE_OK; +#else + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "deflate compression not supported"); +#endif + } + } else if (strcmp(key, "encryption") == 0) { + if (val == NULL) { + zip->encryption_type = ENCRYPTION_NONE; + ret = ARCHIVE_OK; + } else if (val[0] == '1' || strcmp(val, "traditional") == 0 + || strcmp(val, "zipcrypt") == 0 + || strcmp(val, "ZipCrypt") == 0) { + if (is_traditional_pkware_encryption_supported()) { + zip->encryption_type = ENCRYPTION_TRADITIONAL; + ret = ARCHIVE_OK; + } else { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_MISC, + "encryption not supported"); + } + } else if (strcmp(val, "aes128") == 0) { + if (is_winzip_aes_encryption_supported( + ENCRYPTION_WINZIP_AES128)) { + zip->encryption_type = ENCRYPTION_WINZIP_AES128; + ret = ARCHIVE_OK; + } else { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_MISC, + "encryption not supported"); + } + } else if (strcmp(val, "aes256") == 0) { + if (is_winzip_aes_encryption_supported( + ENCRYPTION_WINZIP_AES256)) { + zip->encryption_type = ENCRYPTION_WINZIP_AES256; + ret = ARCHIVE_OK; + } else { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_MISC, + "encryption not supported"); + } + } else { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "%s: unknown encryption '%s'", + a->format_name, val); + } + return (ret); } else if (strcmp(key, "experimental") == 0) { if (val == NULL || val[0] == 0) { - zip->flags &= ~ ZIP_FLAG_EXPERIMENT_EL; + zip->flags &= ~ ZIP_FLAG_EXPERIMENT_xl; } else { - zip->flags |= ZIP_FLAG_EXPERIMENT_EL; + zip->flags |= ZIP_FLAG_EXPERIMENT_xl; } return (ARCHIVE_OK); } else if (strcmp(key, "fakecrc32") == 0) { @@ -357,9 +463,12 @@ archive_write_set_format_zip(struct archive *_a) /* "Unspecified" lets us choose the appropriate compression. */ zip->requested_compression = COMPRESSION_UNSPECIFIED; +#ifdef HAVE_ZLIB_H + zip->deflate_compression_level = Z_DEFAULT_COMPRESSION; +#endif zip->crc32func = real_crc32; -#ifdef HAVE_ZLIB_H + /* A buffer used for both compression and encryption. */ zip->len_buf = 65536; zip->buf = malloc(zip->len_buf); if (zip->buf == NULL) { @@ -368,7 +477,6 @@ archive_write_set_format_zip(struct archive *_a) "Can't allocate compression buffer"); return (ARCHIVE_FATAL); } -#endif a->format_data = zip; a->format_name = "zip"; @@ -400,7 +508,7 @@ static int archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) { unsigned char local_header[32]; - unsigned char local_extra[128]; + unsigned char local_extra[144]; struct zip *zip = a->format_data; unsigned char *e; unsigned char *cd_extra; @@ -409,7 +517,6 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) size_t slink_size = 0; struct archive_string_conv *sconv = get_sconv(a, zip); int ret, ret2 = ARCHIVE_OK; - int64_t size; mode_t type; int version_needed = 10; @@ -425,13 +532,14 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) if (zip->flags & ZIP_FLAG_AVOID_ZIP64) { /* Reject entries over 4GB. */ if (archive_entry_size_is_set(entry) - && (archive_entry_size(entry) > 0xffffffff)) { + && (archive_entry_size(entry) > + ARCHIVE_LITERAL_LL(0xffffffff))) { archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "Files > 4GB require Zip64 extensions"); return ARCHIVE_FAILED; } /* Reject entries if archive is > 4GB. */ - if (zip->written_bytes > 0xffffffff) { + if (zip->written_bytes > ARCHIVE_LITERAL_LL(0xffffffff)) { archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "Archives > 4GB require Zip64 extensions"); return ARCHIVE_FAILED; @@ -453,11 +561,34 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) zip->entry_flags = 0; zip->entry_uses_zip64 = 0; zip->entry_crc32 = zip->crc32func(0, NULL, 0); + zip->entry_encryption = 0; if (zip->entry != NULL) { archive_entry_free(zip->entry); zip->entry = NULL; } + if (zip->cctx_valid) + archive_encrypto_aes_ctr_release(&zip->cctx); + if (zip->hctx_valid) + archive_hmac_sha1_cleanup(&zip->hctx); + zip->tctx_valid = zip->cctx_valid = zip->hctx_valid = 0; + + if (type == AE_IFREG + &&(!archive_entry_size_is_set(entry) + || archive_entry_size(entry) > 0)) { + switch (zip->encryption_type) { + case ENCRYPTION_TRADITIONAL: + case ENCRYPTION_WINZIP_AES128: + case ENCRYPTION_WINZIP_AES256: + zip->entry_flags |= ZIP_ENTRY_FLAG_ENCRYPTED; + zip->entry_encryption = zip->encryption_type; + break; + default: + break; + } + } + + #if defined(_WIN32) && !defined(__CYGWIN__) /* Make sure the path separators in pahtname, hardlink and symlink * are all slash '/', not the Windows path separator '\'. */ @@ -543,10 +674,11 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) } else if (type != AE_IFREG) { zip->entry_compression = COMPRESSION_STORE; zip->entry_uncompressed_limit = 0; - size = 0; version_needed = 20; } else if (archive_entry_size_is_set(zip->entry)) { - size = archive_entry_size(zip->entry); + int64_t size = archive_entry_size(zip->entry); + int64_t additional_size = 0; + zip->entry_uncompressed_limit = size; zip->entry_compression = zip->requested_compression; if (zip->entry_compression == COMPRESSION_UNSPECIFIED) { @@ -560,8 +692,46 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) zip->entry_uncompressed_size = size; version_needed = 20; } - if ((zip->flags & ZIP_FLAG_FORCE_ZIP64) /* User asked. */ - || (zip->entry_uncompressed_size > ARCHIVE_LITERAL_LL(0xffffffff))) { /* Large entry. */ + + if (zip->entry_flags & ZIP_ENTRY_FLAG_ENCRYPTED) { + switch (zip->entry_encryption) { + case ENCRYPTION_TRADITIONAL: + additional_size = TRAD_HEADER_SIZE; + version_needed = 20; + break; + case ENCRYPTION_WINZIP_AES128: + additional_size = WINZIP_AES128_HEADER_SIZE + + AUTH_CODE_SIZE; + version_needed = 20; + break; + case ENCRYPTION_WINZIP_AES256: + additional_size = WINZIP_AES256_HEADER_SIZE + + AUTH_CODE_SIZE; + version_needed = 20; + break; + default: + break; + } + if (zip->entry_compression == COMPRESSION_STORE) + zip->entry_compressed_size += additional_size; + } + + /* + * Set Zip64 extension in any of the following cases + * (this was suggested by discussion on info-zip-dev + * mailing list): + * = Zip64 is being forced by user + * = File is over 4GiB uncompressed + * (including encryption header, if any) + * = File is close to 4GiB and is being compressed + * (compression might make file larger) + */ + if ((zip->flags & ZIP_FLAG_FORCE_ZIP64) + || (zip->entry_uncompressed_size + additional_size > + ARCHIVE_LITERAL_LL(0xffffffff)) + || (zip->entry_uncompressed_size > + ARCHIVE_LITERAL_LL(0xff000000) + && zip->entry_compression != COMPRESSION_STORE)) { zip->entry_uses_zip64 = 1; version_needed = 45; } @@ -569,9 +739,11 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) /* We may know the size, but never the CRC. */ zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END; } else { - /* Prefer deflate if it's available, because deflate - * has a clear end-of-data marker that makes - * length-at-end more reliable. */ + /* We don't know the size. In this case, we prefer + * deflate (it has a clear end-of-data marker which + * makes length-at-end more reliable) and will + * enable Zip64 extensions unless we're told not to. + */ zip->entry_compression = COMPRESSION_DEFAULT; zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END; if ((zip->flags & ZIP_FLAG_AVOID_ZIP64) == 0) { @@ -582,6 +754,19 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) } else { version_needed = 20; } + + if (zip->entry_flags & ZIP_ENTRY_FLAG_ENCRYPTED) { + switch (zip->entry_encryption) { + case ENCRYPTION_TRADITIONAL: + case ENCRYPTION_WINZIP_AES128: + case ENCRYPTION_WINZIP_AES256: + if (version_needed < 20) + version_needed = 20; + break; + default: + break; + } + } } /* Format the local header. */ @@ -589,8 +774,13 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) memcpy(local_header, "PK\003\004", 4); archive_le16enc(local_header + 4, version_needed); archive_le16enc(local_header + 6, zip->entry_flags); - archive_le16enc(local_header + 8, zip->entry_compression); - archive_le32enc(local_header + 10, dos_time(archive_entry_mtime(zip->entry))); + if (zip->entry_encryption == ENCRYPTION_WINZIP_AES128 + || zip->entry_encryption == ENCRYPTION_WINZIP_AES256) + archive_le16enc(local_header + 8, WINZIP_AES_ENCRYPTION); + else + archive_le16enc(local_header + 8, zip->entry_compression); + archive_le32enc(local_header + 10, + dos_time(archive_entry_mtime(zip->entry))); archive_le32enc(local_header + 14, zip->entry_crc32); if (zip->entry_uses_zip64) { /* Zip64 data in the local header "must" include both @@ -601,10 +791,17 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) archive_le32enc(local_header + 18, ARCHIVE_LITERAL_LL(0xffffffff)); archive_le32enc(local_header + 22, ARCHIVE_LITERAL_LL(0xffffffff)); } else { - archive_le32enc(local_header + 18, zip->entry_compressed_size); - archive_le32enc(local_header + 22, zip->entry_uncompressed_size); + archive_le32enc(local_header + 18, (uint32_t)zip->entry_compressed_size); + archive_le32enc(local_header + 22, (uint32_t)zip->entry_uncompressed_size); + } + archive_le16enc(local_header + 26, (uint16_t)filename_length); + + if (zip->entry_encryption == ENCRYPTION_TRADITIONAL) { + if (zip->entry_flags & ZIP_ENTRY_FLAG_LENGTH_AT_END) + zip->trad_chkdat = local_header[11]; + else + zip->trad_chkdat = local_header[17]; } - archive_le16enc(local_header + 26, filename_length); /* Format as much of central directory file header as we can: */ zip->file_header = cd_alloc(zip, 46); @@ -616,9 +813,14 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) archive_le16enc(zip->file_header + 4, 3 * 256 + version_needed); archive_le16enc(zip->file_header + 6, version_needed); archive_le16enc(zip->file_header + 8, zip->entry_flags); - archive_le16enc(zip->file_header + 10, zip->entry_compression); - archive_le32enc(zip->file_header + 12, dos_time(archive_entry_mtime(zip->entry))); - archive_le16enc(zip->file_header + 28, filename_length); + if (zip->entry_encryption == ENCRYPTION_WINZIP_AES128 + || zip->entry_encryption == ENCRYPTION_WINZIP_AES256) + archive_le16enc(zip->file_header + 10, WINZIP_AES_ENCRYPTION); + else + archive_le16enc(zip->file_header + 10, zip->entry_compression); + archive_le32enc(zip->file_header + 12, + dos_time(archive_entry_mtime(zip->entry))); + archive_le16enc(zip->file_header + 28, (uint16_t)filename_length); /* Following Info-Zip, store mode in the "external attributes" field. */ archive_le32enc(zip->file_header + 38, ((uint32_t)archive_entry_mode(zip->entry)) << 16); @@ -670,7 +872,33 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) archive_le32enc(e, (uint32_t)archive_entry_gid(entry)); e += 4; - /* Copy UT and ux into central directory as well. */ + /* AES extra data field: WinZIP AES information, ID=0x9901 */ + if ((zip->entry_flags & ZIP_ENTRY_FLAG_ENCRYPTED) + && (zip->entry_encryption == ENCRYPTION_WINZIP_AES128 + || zip->entry_encryption == ENCRYPTION_WINZIP_AES256)) { + + memcpy(e, "\001\231\007\000\001\000AE", 8); + /* AES vendoer version AE-2 does not store a CRC. + * WinZip 11 uses AE-1, which does store the CRC, + * but it does not store the CRC when the file size + * is less than 20 bytes. So we simulate what + * WinZip 11 does. + * NOTE: WinZip 9.0 and 10.0 uses AE-2 by default. */ + if (archive_entry_size_is_set(zip->entry) + && archive_entry_size(zip->entry) < 20) { + archive_le16enc(e+4, AES_VENDOR_AE_2); + zip->aes_vendor = AES_VENDOR_AE_2;/* no CRC. */ + } else + zip->aes_vendor = AES_VENDOR_AE_1; + e += 8; + /* AES encryption strength. */ + *e++ = (zip->entry_encryption == ENCRYPTION_WINZIP_AES128)?1:3; + /* Actual compression method. */ + archive_le16enc(e, zip->entry_compression); + e += 2; + } + + /* Copy UT ,ux, and AES-extra into central directory as well. */ zip->file_header_extra_offset = zip->central_directory_bytes; cd_extra = cd_alloc(zip, e - local_extra); memcpy(cd_extra, local_extra, e - local_extra); @@ -692,14 +920,14 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) e += 8; archive_le64enc(e, zip->entry_compressed_size); e += 8; - archive_le16enc(zip64_start + 2, e - (zip64_start + 4)); + archive_le16enc(zip64_start + 2, (uint16_t)(e - (zip64_start + 4))); } - if (zip->flags & ZIP_FLAG_EXPERIMENT_EL) { - /* Experimental 'el' extension to improve streaming. */ + if (zip->flags & ZIP_FLAG_EXPERIMENT_xl) { + /* Experimental 'xl' extension to improve streaming. */ unsigned char *external_info = e; int included = 7; - memcpy(e, "el\000\000", 4); // 0x6c65 + 2-byte length + memcpy(e, "xl\000\000", 4); // 0x6c65 + 2-byte length e += 4; e[0] = included; /* bitmap of included fields */ e += 1; @@ -720,11 +948,11 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) if (included & 8) { // Libarchive does not currently support file comments. } - archive_le16enc(external_info + 2, e - (external_info + 4)); + archive_le16enc(external_info + 2, (uint16_t)(e - (external_info + 4))); } /* Update local header with size of extra data and write it all out: */ - archive_le16enc(local_header + 28, e - local_extra); + archive_le16enc(local_header + 28, (uint16_t)(e - local_extra)); ret = __archive_write_output(a, local_header, 30); if (ret != ARCHIVE_OK) @@ -758,7 +986,7 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) zip->stream.opaque = Z_NULL; zip->stream.next_out = zip->buf; zip->stream.avail_out = (uInt)zip->len_buf; - if (deflateInit2(&zip->stream, Z_DEFAULT_COMPRESSION, + if (deflateInit2(&zip->stream, zip->deflate_compression_level, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) { archive_set_error(&a->archive, ENOMEM, "Can't init deflate compressor"); @@ -782,13 +1010,72 @@ archive_write_zip_data(struct archive_write *a, const void *buff, size_t s) if (s == 0) return 0; + if (zip->entry_flags & ZIP_ENTRY_FLAG_ENCRYPTED) { + switch (zip->entry_encryption) { + case ENCRYPTION_TRADITIONAL: + /* Initialize traditoinal PKWARE encryption context. */ + if (!zip->tctx_valid) { + ret = init_traditional_pkware_encryption(a); + if (ret != ARCHIVE_OK) + return (ret); + zip->tctx_valid = 1; + } + break; + case ENCRYPTION_WINZIP_AES128: + case ENCRYPTION_WINZIP_AES256: + if (!zip->cctx_valid) { + ret = init_winzip_aes_encryption(a); + if (ret != ARCHIVE_OK) + return (ret); + zip->cctx_valid = zip->hctx_valid = 1; + } + break; + default: + break; + } + } + switch (zip->entry_compression) { case COMPRESSION_STORE: - ret = __archive_write_output(a, buff, s); - if (ret != ARCHIVE_OK) - return (ret); - zip->written_bytes += s; - zip->entry_compressed_written += s; + if (zip->tctx_valid || zip->cctx_valid) { + const uint8_t *rb = (const uint8_t *)buff; + const uint8_t * const re = rb + s; + + while (rb < re) { + size_t l; + + if (zip->tctx_valid) { + l = trad_enc_encrypt_update(&zip->tctx, + rb, re - rb, + zip->buf, zip->len_buf); + } else { + l = zip->len_buf; + ret = archive_encrypto_aes_ctr_update( + &zip->cctx, + rb, re - rb, zip->buf, &l); + if (ret < 0) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_MISC, + "Failed to encrypt file"); + return (ARCHIVE_FAILED); + } + archive_hmac_sha1_update(&zip->hctx, + zip->buf, l); + } + ret = __archive_write_output(a, zip->buf, l); + if (ret != ARCHIVE_OK) + return (ret); + zip->entry_compressed_written += l; + zip->written_bytes += l; + rb += l; + } + } else { + ret = __archive_write_output(a, buff, s); + if (ret != ARCHIVE_OK) + return (ret); + zip->written_bytes += s; + zip->entry_compressed_written += s; + } break; #if HAVE_ZLIB_H case COMPRESSION_DEFLATE: @@ -799,6 +1086,25 @@ archive_write_zip_data(struct archive_write *a, const void *buff, size_t s) if (ret == Z_STREAM_ERROR) return (ARCHIVE_FATAL); if (zip->stream.avail_out == 0) { + if (zip->tctx_valid) { + trad_enc_encrypt_update(&zip->tctx, + zip->buf, zip->len_buf, + zip->buf, zip->len_buf); + } else if (zip->cctx_valid) { + size_t outl = zip->len_buf; + ret = archive_encrypto_aes_ctr_update( + &zip->cctx, + zip->buf, zip->len_buf, + zip->buf, &outl); + if (ret < 0) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_MISC, + "Failed to encrypt file"); + return (ARCHIVE_FAILED); + } + archive_hmac_sha1_update(&zip->hctx, + zip->buf, zip->len_buf); + } ret = __archive_write_output(a, zip->buf, zip->len_buf); if (ret != ARCHIVE_OK) @@ -819,7 +1125,9 @@ archive_write_zip_data(struct archive_write *a, const void *buff, size_t s) } zip->entry_uncompressed_limit -= s; - zip->entry_crc32 = zip->crc32func(zip->entry_crc32, buff, (unsigned)s); + if (!zip->cctx_valid || zip->aes_vendor != AES_VENDOR_AE_2) + zip->entry_crc32 = + zip->crc32func(zip->entry_crc32, buff, (unsigned)s); return (s); } @@ -834,10 +1142,28 @@ archive_write_zip_finish_entry(struct archive_write *a) if (zip->entry_compression == COMPRESSION_DEFLATE) { for (;;) { size_t remainder; + ret = deflate(&zip->stream, Z_FINISH); if (ret == Z_STREAM_ERROR) return (ARCHIVE_FATAL); remainder = zip->len_buf - zip->stream.avail_out; + if (zip->tctx_valid) { + trad_enc_encrypt_update(&zip->tctx, + zip->buf, remainder, zip->buf, remainder); + } else if (zip->cctx_valid) { + size_t outl = remainder; + ret = archive_encrypto_aes_ctr_update( + &zip->cctx, zip->buf, remainder, + zip->buf, &outl); + if (ret < 0) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_MISC, + "Failed to encrypt file"); + return (ARCHIVE_FAILED); + } + archive_hmac_sha1_update(&zip->hctx, + zip->buf, remainder); + } ret = __archive_write_output(a, zip->buf, remainder); if (ret != ARCHIVE_OK) return (ret); @@ -851,20 +1177,38 @@ archive_write_zip_finish_entry(struct archive_write *a) deflateEnd(&zip->stream); } #endif + if (zip->hctx_valid) { + uint8_t hmac[20]; + size_t hmac_len = 20; + + archive_hmac_sha1_final(&zip->hctx, hmac, &hmac_len); + ret = __archive_write_output(a, hmac, AUTH_CODE_SIZE); + if (ret != ARCHIVE_OK) + return (ret); + zip->entry_compressed_written += AUTH_CODE_SIZE; + zip->written_bytes += AUTH_CODE_SIZE; + } /* Write trailing data descriptor. */ if ((zip->entry_flags & ZIP_ENTRY_FLAG_LENGTH_AT_END) != 0) { char d[24]; memcpy(d, "PK\007\010", 4); - archive_le32enc(d + 4, zip->entry_crc32); + if (zip->cctx_valid && zip->aes_vendor == AES_VENDOR_AE_2) + archive_le32enc(d + 4, 0);/* no CRC.*/ + else + archive_le32enc(d + 4, zip->entry_crc32); if (zip->entry_uses_zip64) { - archive_le64enc(d + 8, (uint64_t)zip->entry_compressed_written); - archive_le64enc(d + 16, (uint64_t)zip->entry_uncompressed_written); + archive_le64enc(d + 8, + (uint64_t)zip->entry_compressed_written); + archive_le64enc(d + 16, + (uint64_t)zip->entry_uncompressed_written); ret = __archive_write_output(a, d, 24); zip->written_bytes += 24; } else { - archive_le32enc(d + 8, (uint32_t)zip->entry_compressed_written); - archive_le32enc(d + 12, (uint32_t)zip->entry_uncompressed_written); + archive_le32enc(d + 8, + (uint32_t)zip->entry_compressed_written); + archive_le32enc(d + 12, + (uint32_t)zip->entry_uncompressed_written); ret = __archive_write_output(a, d, 16); zip->written_bytes += 16; } @@ -892,7 +1236,7 @@ archive_write_zip_finish_entry(struct archive_write *a) archive_le64enc(z, zip->entry_offset); z += 8; } - archive_le16enc(zip64 + 2, z - (zip64 + 4)); + archive_le16enc(zip64 + 2, (uint16_t)(z - (zip64 + 4))); zd = cd_alloc(zip, z - zip64); if (zd == NULL) { archive_set_error(&a->archive, ENOMEM, @@ -906,15 +1250,21 @@ archive_write_zip_finish_entry(struct archive_write *a) } /* Fix up central directory file header. */ - archive_le32enc(zip->file_header + 16, zip->entry_crc32); + if (zip->cctx_valid && zip->aes_vendor == AES_VENDOR_AE_2) + archive_le32enc(zip->file_header + 16, 0);/* no CRC.*/ + else + archive_le32enc(zip->file_header + 16, zip->entry_crc32); archive_le32enc(zip->file_header + 20, - zipmin(zip->entry_compressed_written, ARCHIVE_LITERAL_LL(0xffffffff))); + (uint32_t)zipmin(zip->entry_compressed_written, + ARCHIVE_LITERAL_LL(0xffffffff))); archive_le32enc(zip->file_header + 24, - zipmin(zip->entry_uncompressed_written, ARCHIVE_LITERAL_LL(0xffffffff))); + (uint32_t)zipmin(zip->entry_uncompressed_written, + ARCHIVE_LITERAL_LL(0xffffffff))); archive_le16enc(zip->file_header + 30, - zip->central_directory_bytes - zip->file_header_extra_offset); + (uint16_t)(zip->central_directory_bytes - zip->file_header_extra_offset)); archive_le32enc(zip->file_header + 42, - zipmin(zip->entry_offset, ARCHIVE_LITERAL_LL(0xffffffff))); + (uint32_t)zipmin(zip->entry_offset, + ARCHIVE_LITERAL_LL(0xffffffff))); return (ARCHIVE_OK); } @@ -977,10 +1327,16 @@ archive_write_zip_close(struct archive_write *a) /* Format and write end of central directory. */ memset(buff, 0, sizeof(buff)); memcpy(buff, "PK\005\006", 4); - archive_le16enc(buff + 8, zipmin(0xffffU, zip->central_directory_entries)); - archive_le16enc(buff + 10, zipmin(0xffffU, zip->central_directory_entries)); - archive_le32enc(buff + 12, (uint32_t)zipmin(ARCHIVE_LITERAL_LL(0xffffffff), (offset_end - offset_start))); - archive_le32enc(buff + 16, (uint32_t)zipmin(ARCHIVE_LITERAL_LL(0xffffffff), offset_start)); + archive_le16enc(buff + 8, (uint16_t)zipmin(0xffffU, + zip->central_directory_entries)); + archive_le16enc(buff + 10, (uint16_t)zipmin(0xffffU, + zip->central_directory_entries)); + archive_le32enc(buff + 12, + (uint32_t)zipmin(ARCHIVE_LITERAL_LL(0xffffffff), + (offset_end - offset_start))); + archive_le32enc(buff + 16, + (uint32_t)zipmin(ARCHIVE_LITERAL_LL(0xffffffff), + offset_start)); ret = __archive_write_output(a, buff, 22); if (ret != ARCHIVE_OK) return (ARCHIVE_FATAL); @@ -1001,10 +1357,12 @@ archive_write_zip_free(struct archive_write *a) free(segment->buff); free(segment); } -#ifdef HAVE_ZLIB_H free(zip->buf); -#endif archive_entry_free(zip->entry); + if (zip->cctx_valid) + archive_encrypto_aes_ctr_release(&zip->cctx); + if (zip->hctx_valid) + archive_hmac_sha1_cleanup(&zip->hctx); /* TODO: Free opt_sconv, sconv_default */ free(zip); @@ -1124,3 +1482,199 @@ get_sconv(struct archive_write *a, struct zip *zip) } return (zip->sconv_default); } + +/* + Traditional PKWARE Decryption functions. + */ + +static void +trad_enc_update_keys(struct trad_enc_ctx *ctx, uint8_t c) +{ + uint8_t t; +#define CRC32(c, b) (crc32(c ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL) + + ctx->keys[0] = CRC32(ctx->keys[0], c); + ctx->keys[1] = (ctx->keys[1] + (ctx->keys[0] & 0xff)) * 134775813L + 1; + t = (ctx->keys[1] >> 24) & 0xff; + ctx->keys[2] = CRC32(ctx->keys[2], t); +#undef CRC32 +} + +static uint8_t +trad_enc_decypt_byte(struct trad_enc_ctx *ctx) +{ + unsigned temp = ctx->keys[2] | 2; + return (uint8_t)((temp * (temp ^ 1)) >> 8) & 0xff; +} + +static unsigned +trad_enc_encrypt_update(struct trad_enc_ctx *ctx, const uint8_t *in, + size_t in_len, uint8_t *out, size_t out_len) +{ + unsigned i, max; + + max = (unsigned)((in_len < out_len)? in_len: out_len); + + for (i = 0; i < max; i++) { + uint8_t t = in[i]; + out[i] = t ^ trad_enc_decypt_byte(ctx); + trad_enc_update_keys(ctx, t); + } + return i; +} + +static int +trad_enc_init(struct trad_enc_ctx *ctx, const char *pw, size_t pw_len) +{ + + ctx->keys[0] = 305419896L; + ctx->keys[1] = 591751049L; + ctx->keys[2] = 878082192L; + + for (;pw_len; --pw_len) + trad_enc_update_keys(ctx, *pw++); + return 0; +} + +static int +is_traditional_pkware_encryption_supported(void) +{ + uint8_t key[TRAD_HEADER_SIZE]; + + if (archive_random(key, sizeof(key)-1) != ARCHIVE_OK) + return (0); + return (1); +} + +static int +init_traditional_pkware_encryption(struct archive_write *a) +{ + struct zip *zip = a->format_data; + const char *passphrase; + uint8_t key[TRAD_HEADER_SIZE]; + uint8_t key_encrypted[TRAD_HEADER_SIZE]; + int ret; + + passphrase = __archive_write_get_passphrase(a); + if (passphrase == NULL) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Encryption needs passphrase"); + return ARCHIVE_FAILED; + } + if (archive_random(key, sizeof(key)-1) != ARCHIVE_OK) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Can't generate random number for encryption"); + return ARCHIVE_FATAL; + } + trad_enc_init(&zip->tctx, passphrase, strlen(passphrase)); + /* Set the last key code which will be used as a check code + * for verifying passphrase in decryption. */ + key[TRAD_HEADER_SIZE-1] = zip->trad_chkdat; + trad_enc_encrypt_update(&zip->tctx, key, TRAD_HEADER_SIZE, + key_encrypted, TRAD_HEADER_SIZE); + /* Write encrypted keys in the top of the file content. */ + ret = __archive_write_output(a, key_encrypted, TRAD_HEADER_SIZE); + if (ret != ARCHIVE_OK) + return (ret); + zip->written_bytes += TRAD_HEADER_SIZE; + zip->entry_compressed_written += TRAD_HEADER_SIZE; + return (ret); +} + +static int +init_winzip_aes_encryption(struct archive_write *a) +{ + struct zip *zip = a->format_data; + const char *passphrase; + size_t key_len, salt_len; + uint8_t salt[16 + 2]; + uint8_t derived_key[MAX_DERIVED_KEY_BUF_SIZE]; + int ret; + + passphrase = __archive_write_get_passphrase(a); + if (passphrase == NULL) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Encryption needs passphrase"); + return (ARCHIVE_FAILED); + } + if (zip->entry_encryption == ENCRYPTION_WINZIP_AES128) { + salt_len = 8; + key_len = 16; + } else { + /* AES 256 */ + salt_len = 16; + key_len = 32; + } + if (archive_random(salt, salt_len) != ARCHIVE_OK) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Can't generate random number for encryption"); + return (ARCHIVE_FATAL); + } + archive_pbkdf2_sha1(passphrase, strlen(passphrase), + salt, salt_len, 1000, derived_key, key_len * 2 + 2); + + ret = archive_encrypto_aes_ctr_init(&zip->cctx, derived_key, key_len); + if (ret != 0) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Decryption is unsupported due to lack of crypto library"); + return (ARCHIVE_FAILED); + } + ret = archive_hmac_sha1_init(&zip->hctx, derived_key + key_len, + key_len); + if (ret != 0) { + archive_encrypto_aes_ctr_release(&zip->cctx); + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Failed to initialize HMAC-SHA1"); + return (ARCHIVE_FAILED); + } + + /* Set a passowrd verification value after the 'salt'. */ + salt[salt_len] = derived_key[key_len * 2]; + salt[salt_len + 1] = derived_key[key_len * 2 + 1]; + + /* Write encrypted keys in the top of the file content. */ + ret = __archive_write_output(a, salt, salt_len + 2); + if (ret != ARCHIVE_OK) + return (ret); + zip->written_bytes += salt_len + 2; + zip->entry_compressed_written += salt_len + 2; + + return (ARCHIVE_OK); +} + +static int +is_winzip_aes_encryption_supported(int encryption) +{ + size_t key_len, salt_len; + uint8_t salt[16 + 2]; + uint8_t derived_key[MAX_DERIVED_KEY_BUF_SIZE]; + archive_crypto_ctx cctx; + archive_hmac_sha1_ctx hctx; + int ret; + + if (encryption == ENCRYPTION_WINZIP_AES128) { + salt_len = 8; + key_len = 16; + } else { + /* AES 256 */ + salt_len = 16; + key_len = 32; + } + if (archive_random(salt, salt_len) != ARCHIVE_OK) + return (0); + ret = archive_pbkdf2_sha1("p", 1, salt, salt_len, 1000, + derived_key, key_len * 2 + 2); + if (ret != 0) + return (0); + + ret = archive_encrypto_aes_ctr_init(&cctx, derived_key, key_len); + if (ret != 0) + return (0); + ret = archive_hmac_sha1_init(&hctx, derived_key + key_len, + key_len); + archive_encrypto_aes_ctr_release(&cctx); + if (ret != 0) + return (0); + archive_hmac_sha1_cleanup(&hctx); + return (1); +} diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_options.3 b/Utilities/cmlibarchive/libarchive/archive_write_set_options.3 index f8fb039..a2f4b57 100644 --- a/Utilities/cmlibarchive/libarchive/archive_write_set_options.3 +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_options.3 @@ -397,6 +397,48 @@ Specifies a filename that should not be compressed when using This option can be provided multiple times to suppress compression on many files. .El +.It Format zip +.Bl -tag -compact -width indent +.It Cm compression +The value is either +.Dq store +or +.Dq deflate +to indicate how the following entries should be compressed. +Note that this setting is ignored for directories, symbolic links, +and other special entries. +.It Cm experimental +This boolean option enables or disables experimental Zip features +that may not be compatible with other Zip implementations. +.It Cm fakecrc32 +This boolean option disables CRC calculations. +All CRC fields are set to zero. +It should not be used except for testing purposes. +.It Cm hdrcharset +This sets the character set used for filenames. +.It Cm zip64 +Zip64 extensions provide additional file size information +for entries larger than 4 GiB. +They also provide extended file offset and archive size information +when archives exceed 4 GiB. +By default, the Zip writer selectively enables these extensions only as needed. +In particular, if the file size is unknown, the Zip writer will +include Zip64 extensions to guard against the possibility that the +file might be larger than 4 GiB. +.Pp +Setting this boolean option will force the writer to use Zip64 extensions +even for small files that would not otherwise require them. +This is primarily useful for testing. +.Pp +Disabling this option with +.Cm !zip64 +will force the Zip writer to avoid Zip64 extensions: +It will reject files with size greater than 4 GiB, +it will reject any new entries once the total archive size reaches 4 GiB, +and it will not use Zip64 extensions for files with unknown size. +In particular, this can improve compatibility when generating archives +where the entry sizes are not known in advance. +.El .El .Sh EXAMPLES The following example creates an archive write handle to diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_passphrase.3 b/Utilities/cmlibarchive/libarchive/archive_write_set_passphrase.3 new file mode 100644 index 0000000..2585595 --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_passphrase.3 @@ -0,0 +1,74 @@ +.\" Copyright (c) 2014 Michihiro NAKAJIMA +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $FreeBSD$ +.\" +.Dd September 21, 2014 +.Dt ARCHIVE_WRITE_SET_PASSPHRASE 3 +.Os +.Sh NAME +.Nm archive_write_set_passphrase , +.Nm archive_write_set_passphrase_callback +.Nd functions for writing encrypted archives +.Sh LIBRARY +Streaming Archive Library (libarchive, -larchive) +.Sh SYNOPSIS +.In archive.h +.Ft int +.Fo archive_write_set_passphrase +.Fa "struct archive *" +.Fa "const char *passphrase" +.Fc +.Ft int +.Fo archive_write_set_passphrase_callback +.Fa "struct archive *" +.Fa "void *client_data" +.Fa "archive_passphrase_callback *" +.Fc +.Sh DESCRIPTION +.Bl -tag -width indent +.It Fn archive_write_set_passphrase +Set a passphrase for writing an encryption archive. +If +.Ar passphrase +is +.Dv NULL +or empty, this function will do nothing and +.Cm ARCHIVE_FAILED +will be returned. +Otherwise, +.Cm ARCHIVE_OK +will be returned. +.It Fn archive_write_set_passphrase_callback +Register callback function that will be invoked to get a passphrase +for encrption if the passphrase was not set by the +.Fn archive_write_set_passphrase +function. +.El +.\" .Sh ERRORS +.Sh SEE ALSO +.Xr tar 1 , +.Xr libarchive 3 , +.Xr archive_write 3 , +.Xr archive_write_set_options 3 diff --git a/Utilities/cmlibarchive/libarchive/archive_write_set_passphrase.c b/Utilities/cmlibarchive/libarchive/archive_write_set_passphrase.c new file mode 100644 index 0000000..710ecba --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_write_set_passphrase.c @@ -0,0 +1,95 @@ +/*- + * Copyright (c) 2014 Michihiro NAKAJIMA + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "archive_platform.h" +__FBSDID("$FreeBSD$"); + +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif +#include "archive_write_private.h" + +int +archive_write_set_passphrase(struct archive *_a, const char *p) +{ + struct archive_write *a = (struct archive_write *)_a; + + archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, + "archive_write_set_passphrase"); + + if (p == NULL || p[0] == '\0') { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Empty passphrase is unacceptable"); + return (ARCHIVE_FAILED); + } + free(a->passphrase); + a->passphrase = strdup(p); + if (a->passphrase == NULL) { + archive_set_error(&a->archive, ENOMEM, + "Can't allocate data for passphrase"); + return (ARCHIVE_FATAL); + } + return (ARCHIVE_OK); +} + + +int +archive_write_set_passphrase_callback(struct archive *_a, void *client_data, + archive_passphrase_callback *cb) +{ + struct archive_write *a = (struct archive_write *)_a; + + archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, + "archive_write_set_passphrase_callback"); + + a->passphrase_callback = cb; + a->passphrase_client_data = client_data; + return (ARCHIVE_OK); +} + + +const char * +__archive_write_get_passphrase(struct archive_write *a) +{ + + if (a->passphrase != NULL) + return (a->passphrase); + + if (a->passphrase_callback != NULL) { + const char *p; + p = a->passphrase_callback(&a->archive, + a->passphrase_client_data); + if (p != NULL) { + a->passphrase = strdup(p); + if (a->passphrase == NULL) { + archive_set_error(&a->archive, ENOMEM, + "Can't allocate data for passphrase"); + return (NULL); + } + return (a->passphrase); + } + } + return (NULL); +} diff --git a/Utilities/cmlibarchive/libarchive/archive_xxhash.h b/Utilities/cmlibarchive/libarchive/archive_xxhash.h new file mode 100644 index 0000000..4272416 --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/archive_xxhash.h @@ -0,0 +1,47 @@ +/*- + * Copyright (c) 2014 Michihiro NAKAJIMA + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef __LIBARCHIVE_BUILD +#error This header is only to be used internally to libarchive. +#endif + +#ifndef ARCHIVE_XXHASH_H +#define ARCHIVE_XXHASH_H + +typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode; + +struct archive_xxhash { + unsigned int (*XXH32)(const void* input, unsigned int len, + unsigned int seed); + void* (*XXH32_init)(unsigned int seed); + XXH_errorcode (*XXH32_update)(void* state, const void* input, + unsigned int len); + unsigned int (*XXH32_digest)(void* state); +}; + +extern const struct archive_xxhash __archive_xxhash; + +#endif diff --git a/Utilities/cmlibarchive/libarchive/libarchive.3 b/Utilities/cmlibarchive/libarchive/libarchive.3 index 3a9a841..c6894d2 100644 --- a/Utilities/cmlibarchive/libarchive/libarchive.3 +++ b/Utilities/cmlibarchive/libarchive/libarchive.3 @@ -146,11 +146,11 @@ pages for each API or utility function. .\" .Sh READING AN ARCHIVE See -.Xr libarchive_read 3 . +.Xr archive_read 3 . .\" .Sh WRITING AN ARCHIVE See -.Xr libarchive_write 3 . +.Xr archive_write 3 . .\" .Sh WRITING ENTRIES TO DISK The diff --git a/Utilities/cmlibarchive/libarchive/libarchive_internals.3 b/Utilities/cmlibarchive/libarchive/libarchive_internals.3 index 4aa09f9..8275d66 100644 --- a/Utilities/cmlibarchive/libarchive/libarchive_internals.3 +++ b/Utilities/cmlibarchive/libarchive/libarchive_internals.3 @@ -347,11 +347,11 @@ Fortunately, such archives are very rare, and libarchive can read most ZIP archives, though it cannot always extract as much information as a dedicated ZIP program. .Sh SEE ALSO -.Xr archive 3 , .Xr archive_entry 3 , .Xr archive_read 3 , .Xr archive_write 3 , .Xr archive_write_disk 3 +.Xr libarchive 3 , .Sh HISTORY The .Nm libarchive diff --git a/Utilities/cmlibarchive/libarchive/mtree.5 b/Utilities/cmlibarchive/libarchive/mtree.5 index 8c45a7d..16c8abe 100644 --- a/Utilities/cmlibarchive/libarchive/mtree.5 +++ b/Utilities/cmlibarchive/libarchive/mtree.5 @@ -56,14 +56,6 @@ corresponding character. .Pp Each line is interpreted independently as one of the following types: .Bl -tag -width Cm -.It Signature -The first line of any mtree file must begin with -.Dq #mtree . -If a file contains any full path entries, the first line should -begin with -.Dq #mtree v2.0 , -otherwise, the first line should begin with -.Dq #mtree v1.0 . .It Blank Blank lines are ignored. .It Comment @@ -302,16 +294,6 @@ The file owner as a symbolic name. .Xr find 1 , .Xr mtree 8 .Sh BUGS -The -.Fx -implementation of mtree does not currently support -the -.Nm -2.0 -format. -The requirement for a -.Dq #mtree -signature line is new and not yet widely implemented. .Sh HISTORY The .Nm diff --git a/Utilities/cmlibarchive/libarchive/tar.5 b/Utilities/cmlibarchive/libarchive/tar.5 index 688bb92..6e6f0c0 100644 --- a/Utilities/cmlibarchive/libarchive/tar.5 +++ b/Utilities/cmlibarchive/libarchive/tar.5 @@ -935,7 +935,7 @@ and formed the basis of (circa 1988). Joerg Shilling's .Nm star -archiver is another open-source (GPL) archiver (originally developed +archiver is another open-source (CDDL) archiver (originally developed circa 1985) which features complete support for pax interchange format. .Pp diff --git a/Utilities/cmlibarchive/libarchive/xxhash.c b/Utilities/cmlibarchive/libarchive/xxhash.c new file mode 100644 index 0000000..f7647a5 --- /dev/null +++ b/Utilities/cmlibarchive/libarchive/xxhash.c @@ -0,0 +1,500 @@ +/* +xxHash - Fast Hash algorithm +Copyright (C) 2012-2014, Yann Collet. +BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +* Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +You can contact the author at : +- xxHash source repository : http://code.google.com/p/xxhash/ +*/ + +#include "archive_platform.h" +#ifdef HAVE_LIBLZ4 + +/*************************************** +** Tuning parameters +****************************************/ +/* Unaligned memory access is automatically enabled for "common" CPU, such as x86. +** For others CPU, the compiler will be more cautious, and insert extra code to ensure aligned access is respected. +** If you know your target CPU supports unaligned memory access, you want to force this option manually to improve performance. +** You can also enable this parameter if you know your input data will always be aligned (boundaries of 4, for U32). +*/ +#if defined(__ARM_FEATURE_UNALIGNED) || defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64) +# define XXH_USE_UNALIGNED_ACCESS 1 +#endif + +/* XXH_ACCEPT_NULL_INPUT_POINTER : +** If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer. +** When this option is enabled, xxHash output for null input pointers will be the same as a null-length input. +** This option has a very small performance cost (only measurable on small inputs). +** By default, this option is disabled. To enable it, uncomment below define : +** #define XXH_ACCEPT_NULL_INPUT_POINTER 1 + +** XXH_FORCE_NATIVE_FORMAT : +** By default, xxHash library provides endian-independant Hash values, based on little-endian convention. +** Results are therefore identical for little-endian and big-endian CPU. +** This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format. +** Should endian-independance be of no importance for your application, you may set the #define below to 1. +** It will improve speed for Big-endian CPU. +** This option has no impact on Little_Endian CPU. +*/ +#define XXH_FORCE_NATIVE_FORMAT 0 + +/*************************************** +** Compiler Specific Options +****************************************/ +/* Disable some Visual warning messages */ +#ifdef _MSC_VER /* Visual Studio */ +# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ +#endif + +#ifdef _MSC_VER /* Visual Studio */ +# define FORCE_INLINE __forceinline +#else +# ifdef __GNUC__ +# define FORCE_INLINE inline __attribute__((always_inline)) +# else +# define FORCE_INLINE inline +# endif +#endif + +/*************************************** +** Includes & Memory related functions +****************************************/ +#include "archive_xxhash.h" +#include <stdlib.h> +#define XXH_malloc malloc +#define XXH_free free +#include <string.h> +#define XXH_memcpy memcpy + + +static unsigned int XXH32 (const void*, unsigned int, unsigned int); +static void* XXH32_init (unsigned int); +static XXH_errorcode XXH32_update (void*, const void*, unsigned int); +static unsigned int XXH32_digest (void*); +/*static int XXH32_sizeofState(void);*/ +static XXH_errorcode XXH32_resetState(void*, unsigned int); +#define XXH32_SIZEOFSTATE 48 +typedef struct { long long ll[(XXH32_SIZEOFSTATE+(sizeof(long long)-1))/sizeof(long long)]; } XXH32_stateSpace_t; +static unsigned int XXH32_intermediateDigest (void*); + +/*************************************** +** Basic Types +****************************************/ +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ +# include <stdint.h> + typedef uint8_t BYTE; + typedef uint16_t U16; + typedef uint32_t U32; + typedef int32_t S32; + typedef uint64_t U64; +#else + typedef unsigned char BYTE; + typedef unsigned short U16; + typedef unsigned int U32; + typedef signed int S32; + typedef unsigned long long U64; +#endif + +#if defined(__GNUC__) && !defined(XXH_USE_UNALIGNED_ACCESS) +# define _PACKED __attribute__ ((packed)) +#else +# define _PACKED +#endif + +#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__) +# ifdef __IBMC__ +# pragma pack(1) +# else +# pragma pack(push, 1) +# endif +#endif + +typedef struct _U32_S { U32 v; } _PACKED U32_S; + +#if !defined(XXH_USE_UNALIGNED_ACCESS) && !defined(__GNUC__) +# pragma pack(pop) +#endif + +#define A32(x) (((const U32_S *)(x))->v) + + +/**************************************** +** Compiler-specific Functions and Macros +*****************************************/ +#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) + +/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */ +#if defined(_MSC_VER) +# define XXH_rotl32(x,r) _rotl(x,r) +#else +# define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r))) +#endif + +#if defined(_MSC_VER) /* Visual Studio */ +# define XXH_swap32 _byteswap_ulong +#elif GCC_VERSION >= 403 +# define XXH_swap32 __builtin_bswap32 +#else +static inline U32 XXH_swap32 (U32 x) { + return ((x << 24) & 0xff000000 ) | + ((x << 8) & 0x00ff0000 ) | + ((x >> 8) & 0x0000ff00 ) | + ((x >> 24) & 0x000000ff );} +#endif + + +/*************************************** +** Constants +****************************************/ +#define PRIME32_1 2654435761U +#define PRIME32_2 2246822519U +#define PRIME32_3 3266489917U +#define PRIME32_4 668265263U +#define PRIME32_5 374761393U + + +/*************************************** +** Architecture Macros +****************************************/ +typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess; +#ifndef XXH_CPU_LITTLE_ENDIAN /* It is possible to define XXH_CPU_LITTLE_ENDIAN externally, for example using a compiler switch */ + static const int one = 1; +# define XXH_CPU_LITTLE_ENDIAN (*(const char*)(&one)) +#endif + + +/*************************************** +** Macros +****************************************/ +#define XXH_STATIC_ASSERT(c) { enum { XXH_static_assert = 1/(!!(c)) }; } /* use only *after* variable declarations */ + + +/***************************** +** Memory reads +******************************/ +typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment; + +static +FORCE_INLINE U32 XXH_readLE32_align(const U32* ptr, XXH_endianess endian, XXH_alignment align) +{ + if (align==XXH_unaligned) + return endian==XXH_littleEndian ? A32(ptr) : XXH_swap32(A32(ptr)); + else + return endian==XXH_littleEndian ? *ptr : XXH_swap32(*ptr); +} + +static +FORCE_INLINE U32 XXH_readLE32(const U32* ptr, XXH_endianess endian) { return XXH_readLE32_align(ptr, endian, XXH_unaligned); } + + +/***************************** +** Simple Hash Functions +******************************/ +static +FORCE_INLINE U32 XXH32_endian_align(const void* input, unsigned int len, U32 seed, XXH_endianess endian, XXH_alignment align) +{ + const BYTE* p = (const BYTE*)input; + const BYTE* bEnd = p + len; + U32 h32; +#define XXH_get32bits(p) XXH_readLE32_align((const U32*)p, endian, align) + +#ifdef XXH_ACCEPT_NULL_INPUT_POINTER + if (p==NULL) { len=0; bEnd=p=(const BYTE*)(size_t)16; } +#endif + + if (len>=16) + { + const BYTE* const limit = bEnd - 16; + U32 v1 = seed + PRIME32_1 + PRIME32_2; + U32 v2 = seed + PRIME32_2; + U32 v3 = seed + 0; + U32 v4 = seed - PRIME32_1; + + do + { + v1 += XXH_get32bits(p) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4; + v2 += XXH_get32bits(p) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4; + v3 += XXH_get32bits(p) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4; + v4 += XXH_get32bits(p) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4; + } while (p<=limit); + + h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18); + } + else + { + h32 = seed + PRIME32_5; + } + + h32 += (U32) len; + + while (p<=bEnd-4) + { + h32 += XXH_get32bits(p) * PRIME32_3; + h32 = XXH_rotl32(h32, 17) * PRIME32_4 ; + p+=4; + } + + while (p<bEnd) + { + h32 += (*p) * PRIME32_5; + h32 = XXH_rotl32(h32, 11) * PRIME32_1 ; + p++; + } + + h32 ^= h32 >> 15; + h32 *= PRIME32_2; + h32 ^= h32 >> 13; + h32 *= PRIME32_3; + h32 ^= h32 >> 16; + + return h32; +} + + +U32 XXH32(const void* input, unsigned int len, U32 seed) +{ +#if 0 + // Simple version, good for code maintenance, but unfortunately slow for small inputs + void* state = XXH32_init(seed); + XXH32_update(state, input, len); + return XXH32_digest(state); +#else + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + +# if !defined(XXH_USE_UNALIGNED_ACCESS) + if ((((size_t)input) & 3) == 0) /* Input is aligned, let's leverage the speed advantage */ + { + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned); + else + return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned); + } +# endif + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned); + else + return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned); +#endif +} + +/***************************** +** Advanced Hash Functions +******************************/ + +struct XXH_state32_t +{ + U64 total_len; + U32 seed; + U32 v1; + U32 v2; + U32 v3; + U32 v4; + int memsize; + char memory[16]; +}; + +#if 0 +static +int XXH32_sizeofState(void) +{ + XXH_STATIC_ASSERT(XXH32_SIZEOFSTATE >= sizeof(struct XXH_state32_t)); /* A compilation error here means XXH32_SIZEOFSTATE is not large enough */ + return sizeof(struct XXH_state32_t); +} +#endif + +static +XXH_errorcode XXH32_resetState(void* state_in, U32 seed) +{ + struct XXH_state32_t * state = (struct XXH_state32_t *) state_in; + state->seed = seed; + state->v1 = seed + PRIME32_1 + PRIME32_2; + state->v2 = seed + PRIME32_2; + state->v3 = seed + 0; + state->v4 = seed - PRIME32_1; + state->total_len = 0; + state->memsize = 0; + return XXH_OK; +} + +static +void* XXH32_init (U32 seed) +{ + void* state = XXH_malloc (sizeof(struct XXH_state32_t)); + XXH32_resetState(state, seed); + return state; +} + +static +FORCE_INLINE XXH_errorcode XXH32_update_endian (void* state_in, const void* input, int len, XXH_endianess endian) +{ + struct XXH_state32_t * state = (struct XXH_state32_t *) state_in; + const BYTE* p = (const BYTE*)input; + const BYTE* const bEnd = p + len; + +#ifdef XXH_ACCEPT_NULL_INPUT_POINTER + if (input==NULL) return XXH_ERROR; +#endif + + state->total_len += len; + + if (state->memsize + len < 16) /* fill in tmp buffer */ + { + XXH_memcpy(state->memory + state->memsize, input, len); + state->memsize += len; + return XXH_OK; + } + + if (state->memsize) /* some data left from previous update */ + { + XXH_memcpy(state->memory + state->memsize, input, 16-state->memsize); + { + const U32* p32 = (const U32*)state->memory; + state->v1 += XXH_readLE32(p32, endian) * PRIME32_2; state->v1 = XXH_rotl32(state->v1, 13); state->v1 *= PRIME32_1; p32++; + state->v2 += XXH_readLE32(p32, endian) * PRIME32_2; state->v2 = XXH_rotl32(state->v2, 13); state->v2 *= PRIME32_1; p32++; + state->v3 += XXH_readLE32(p32, endian) * PRIME32_2; state->v3 = XXH_rotl32(state->v3, 13); state->v3 *= PRIME32_1; p32++; + state->v4 += XXH_readLE32(p32, endian) * PRIME32_2; state->v4 = XXH_rotl32(state->v4, 13); state->v4 *= PRIME32_1; p32++; + } + p += 16-state->memsize; + state->memsize = 0; + } + + if (p <= bEnd-16) + { + const BYTE* const limit = bEnd - 16; + U32 v1 = state->v1; + U32 v2 = state->v2; + U32 v3 = state->v3; + U32 v4 = state->v4; + + do + { + v1 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4; + v2 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4; + v3 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4; + v4 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4; + } while (p<=limit); + + state->v1 = v1; + state->v2 = v2; + state->v3 = v3; + state->v4 = v4; + } + + if (p < bEnd) + { + XXH_memcpy(state->memory, p, bEnd-p); + state->memsize = (int)(bEnd-p); + } + + return XXH_OK; +} + +static +XXH_errorcode XXH32_update (void* state_in, const void* input, unsigned int len) +{ + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_update_endian(state_in, input, len, XXH_littleEndian); + else + return XXH32_update_endian(state_in, input, len, XXH_bigEndian); +} + + + +static +FORCE_INLINE U32 XXH32_intermediateDigest_endian (void* state_in, XXH_endianess endian) +{ + struct XXH_state32_t * state = (struct XXH_state32_t *) state_in; + const BYTE * p = (const BYTE*)state->memory; + BYTE* bEnd = (BYTE*)state->memory + state->memsize; + U32 h32; + + if (state->total_len >= 16) + { + h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18); + } + else + { + h32 = state->seed + PRIME32_5; + } + + h32 += (U32) state->total_len; + + while (p<=bEnd-4) + { + h32 += XXH_readLE32((const U32*)p, endian) * PRIME32_3; + h32 = XXH_rotl32(h32, 17) * PRIME32_4; + p+=4; + } + + while (p<bEnd) + { + h32 += (*p) * PRIME32_5; + h32 = XXH_rotl32(h32, 11) * PRIME32_1; + p++; + } + + h32 ^= h32 >> 15; + h32 *= PRIME32_2; + h32 ^= h32 >> 13; + h32 *= PRIME32_3; + h32 ^= h32 >> 16; + + return h32; +} + +static +U32 XXH32_intermediateDigest (void* state_in) +{ + XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; + + if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) + return XXH32_intermediateDigest_endian(state_in, XXH_littleEndian); + else + return XXH32_intermediateDigest_endian(state_in, XXH_bigEndian); +} + +static +U32 XXH32_digest (void* state_in) +{ + U32 h32 = XXH32_intermediateDigest(state_in); + + XXH_free(state_in); + + return h32; +} + +const +struct archive_xxhash __archive_xxhash = { + XXH32, + XXH32_init, + XXH32_update, + XXH32_digest +}; +#endif /* HAVE_LIBLZ4 */ @@ -259,8 +259,8 @@ CMAKE_CXX_SOURCES="\ cmPropertyMap \ cmPropertyDefinition \ cmPropertyDefinitionMap \ - cmMakeDepend \ cmMakefile \ + cmExportBuildFileGenerator \ cmExportFileGenerator \ cmExportInstallFileGenerator \ cmExportTryCompileFileGenerator \ @@ -373,12 +373,6 @@ KWSYS_FILES="\ SystemTools.hxx \ Terminal.h" -KWSYS_IOS_FILES=" - fstream \ - iosfwd \ - iostream \ - sstream" - KWIML_FILES=' ABI.h INT.h @@ -498,31 +492,8 @@ cmake_kwsys_config_replace_string () s/@KWSYS_LFS_AVAILABLE@/${KWSYS_LFS_AVAILABLE}/g; s/@KWSYS_LFS_REQUESTED@/${KWSYS_LFS_REQUESTED}/g; s/@KWSYS_NAME_IS_KWSYS@/${KWSYS_NAME_IS_KWSYS}/g; - s/@KWSYS_IOS_USE_ANSI@/${KWSYS_IOS_USE_ANSI}/g; - s/@KWSYS_IOS_HAVE_STD@/${KWSYS_IOS_HAVE_STD}/g; - s/@KWSYS_IOS_USE_SSTREAM@/${KWSYS_IOS_USE_SSTREAM}/g; - s/@KWSYS_IOS_USE_STRSTREAM_H@/${KWSYS_IOS_USE_STRSTREAM_H}/g; - s/@KWSYS_IOS_USE_STRSTREA_H@/${KWSYS_IOS_USE_STRSTREA_H}/g; - s/@KWSYS_IOS_HAVE_BINARY@/${KWSYS_IOS_HAVE_BINARY}/g; - s/@KWSYS_STL_HAVE_STD@/${KWSYS_STL_HAVE_STD}/g; - s/@KWSYS_STL_STRING_HAVE_ISTREAM@/${KWSYS_STL_STRING_HAVE_ISTREAM}/g; - s/@KWSYS_STL_STRING_HAVE_OSTREAM@/${KWSYS_STL_STRING_HAVE_OSTREAM}/g; - s/@KWSYS_STL_STRING_HAVE_NEQ_CHAR@/${KWSYS_STL_STRING_HAVE_NEQ_CHAR}/g; - s/@KWSYS_STL_HAS_ITERATOR_TRAITS@/${KWSYS_STL_HAS_ITERATOR_TRAITS}/g; - s/@KWSYS_STL_HAS_ITERATOR_CATEGORY@/${KWSYS_STL_HAS_ITERATOR_CATEGORY}/g; - s/@KWSYS_STL_HAS___ITERATOR_CATEGORY@/${KWSYS_STL_HAS___ITERATOR_CATEGORY}/g; - s/@KWSYS_STL_HAS_ALLOCATOR_TEMPLATE@/${KWSYS_STL_HAS_ALLOCATOR_TEMPLATE}/g; - s/@KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE@/${KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE}/g; - s/@KWSYS_STL_HAS_ALLOCATOR_REBIND@/${KWSYS_STL_HAS_ALLOCATOR_REBIND}/g; - s/@KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT@/${KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT}/g; - s/@KWSYS_STL_HAS_ALLOCATOR_OBJECTS@/${KWSYS_STL_HAS_ALLOCATOR_OBJECTS}/g; s/@KWSYS_STL_HAS_WSTRING@/${KWSYS_STL_HAS_WSTRING}/g; - s/@KWSYS_CXX_HAS_CSTDDEF@/${KWSYS_CXX_HAS_CSTDDEF}/g; - s/@KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS@/${KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS}/g; - s/@KWSYS_CXX_HAS_MEMBER_TEMPLATES@/${KWSYS_CXX_HAS_MEMBER_TEMPLATES}/g; - s/@KWSYS_CXX_HAS_FULL_SPECIALIZATION@/${KWSYS_CXX_HAS_FULL_SPECIALIZATION}/g; - s/@KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP@/${KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP}/g; - s/@KWSYS_STAT_HAS_ST_MTIM@/${KWSYS_STAT_HAS_ST_MTIM}/g;}" >> "${OUTFILE}${_tmp}" + }" >> "${OUTFILE}${_tmp}" if [ -f "${OUTFILE}${_tmp}" ]; then if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then #echo "Files are the same" @@ -601,7 +572,7 @@ cmake_try_run () echo "Test produced non-zero return code" return 3 fi - echo "Test succeded" + echo "Test succeeded" return 0 } @@ -731,13 +702,6 @@ if [ ! -d "cmsys" ]; then cmake_error 4 "Cannot create directory ${cmake_bootstrap_dir}/cmsys" fi -for a in stl ios; do - [ -d "cmsys/${a}" ] || mkdir "cmsys/${a}" - if [ ! -d "cmsys/${a}" ]; then - cmake_error 5 "Cannot create directory ${cmake_bootstrap_dir}/cmsys/${a}" - fi -done - [ -d "cmIML" ] || mkdir "cmIML" if [ ! -d "cmIML" ]; then cmake_error 12 "Cannot create directory ${cmake_bootstrap_dir}/cmIML" @@ -1202,38 +1166,12 @@ KWSYS_NAME_IS_KWSYS=0 KWSYS_BUILD_SHARED=0 KWSYS_LFS_AVAILABLE=0 KWSYS_LFS_REQUESTED=0 -KWSYS_IOS_USE_STRSTREAM_H=0 -KWSYS_IOS_USE_STRSTREA_H=0 -KWSYS_IOS_HAVE_STD=0 -KWSYS_IOS_USE_SSTREAM=0 -KWSYS_IOS_USE_ANSI=0 -KWSYS_IOS_HAVE_BINARY=0 -KWSYS_STL_HAVE_STD=0 -KWSYS_STAT_HAS_ST_MTIM=0 -KWSYS_STL_STRING_HAVE_NEQ_CHAR=0 -KWSYS_STL_HAS_ITERATOR_TRAITS=0 -KWSYS_STL_HAS_ITERATOR_CATEGORY=0 -KWSYS_STL_HAS___ITERATOR_CATEGORY=0 -KWSYS_STL_HAS_ALLOCATOR_TEMPLATE=0 -KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE=0 -KWSYS_STL_HAS_ALLOCATOR_REBIND=0 -KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT=0 -KWSYS_STL_HAS_ALLOCATOR_OBJECTS=0 KWSYS_STL_HAS_WSTRING=0 KWSYS_CXX_HAS_SETENV=0 KWSYS_CXX_HAS_UNSETENV=0 KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=0 KWSYS_CXX_HAS_UTIMENSAT=0 KWSYS_CXX_HAS_UTIMES=0 -KWSYS_CXX_HAS_CSTDDEF=0 -KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS=0 -KWSYS_CXX_HAS_MEMBER_TEMPLATES=0 -KWSYS_CXX_HAS_FULL_SPECIALIZATION=0 -KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP=0 - -# Hardcode these kwsys features. They work on all known UNIX compilers anyway. -KWSYS_STL_STRING_HAVE_ISTREAM=1 -KWSYS_STL_STRING_HAVE_OSTREAM=1 if cmake_try_run "${cmake_cxx_compiler}" \ "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_SETENV" \ @@ -1263,151 +1201,7 @@ else fi if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAVE_STD" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STL_HAVE_STD=1 - echo "${cmake_cxx_compiler} has STL in std:: namespace" -else - echo "${cmake_cxx_compiler} does not have STL in std:: namespace" -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_IOS_USE_ANSI" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_IOS_USE_ANSI=1 - echo "${cmake_cxx_compiler} has ANSI streams" -else - echo "${cmake_cxx_compiler} does not have ANSI streams" -fi - -if [ "x$KWSYS_IOS_USE_ANSI" = "x1" ]; then - if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_IOS_HAVE_STD" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_IOS_HAVE_STD=1 - echo "${cmake_cxx_compiler} has streams in std:: namespace" - else - echo "${cmake_cxx_compiler} does not have streams in std:: namespace" - fi - if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_IOS_USE_SSTREAM" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_IOS_USE_SSTREAM=1 - echo "${cmake_cxx_compiler} has sstream" - else - echo "${cmake_cxx_compiler} does not have sstream" - fi -fi - -if [ "x$KWSYS_IOS_USE_SSTREAM" = "x0" ]; then - if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_IOS_USE_STRSTREAM_H" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_IOS_USE_STRSTREAM_H=1 - echo "${cmake_cxx_compiler} has strstream.h" - else - echo "${cmake_cxx_compiler} does not have strstream.h" - fi - if [ "x$KWSYS_IOS_USE_STRSTREAM_H" = "x0" ]; then - if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_IOS_USE_STRSTREA_H" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_IOS_USE_STRSTREA_H=1 - echo "${cmake_cxx_compiler} has strstrea.h" - else - echo "${cmake_cxx_compiler} does not have strstrea.h" - fi - fi -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STL_STRING_HAVE_NEQ_CHAR=1 - echo "${cmake_cxx_compiler} has operator!=(string, char*)" -else - echo "${cmake_cxx_compiler} does not have operator!=(string, char*)" -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ITERATOR_TRAITS -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STL_HAS_ITERATOR_TRAITS=1 - echo "${cmake_cxx_compiler} has stl iterator_traits" -else - echo "${cmake_cxx_compiler} does not have stl iterator_traits" -fi - -if [ "x${KWSYS_STL_HAS_ITERATOR_TRAITS}" = "x0" ]; then - if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ITERATOR_CATEGORY -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STL_HAS_ITERATOR_CATEGORY=1 - echo "${cmake_cxx_compiler} has old iterator_category" - else - echo "${cmake_cxx_compiler} does not have old iterator_category" - fi - if [ "x${KWSYS_STL_HAS_ITERATOR_CATEGORY}" = "x0" ]; then - if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS___ITERATOR_CATEGORY -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STL_HAS___ITERATOR_CATEGORY=1 - echo "${cmake_cxx_compiler} has old __iterator_category" - else - echo "${cmake_cxx_compiler} does not have old __iterator_category" - fi - fi -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STL_HAS_ALLOCATOR_TEMPLATE=1 - echo "${cmake_cxx_compiler} has standard template allocator" -else - echo "${cmake_cxx_compiler} does not have standard template allocator" -fi - -if [ "x${KWSYS_STL_HAS_ALLOCATOR_TEMPLATE}" = "x1" ]; then - if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ALLOCATOR_REBIND -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STL_HAS_ALLOCATOR_REBIND=1 - echo "${cmake_cxx_compiler} has allocator<>::rebind<>" - else - echo "${cmake_cxx_compiler} does not have allocator<>::rebind<>" - fi - - if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT=1 - echo "${cmake_cxx_compiler} has non-standard allocator<>::max_size argument" - else - echo "${cmake_cxx_compiler} does not have non-standard allocator<>::max_size argument" - fi -else - if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE=1 - echo "${cmake_cxx_compiler} has old non-template allocator" - else - echo "${cmake_cxx_compiler} does not have old non-template allocator" - fi -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STL_HAS_ALLOCATOR_OBJECTS=1 - echo "${cmake_cxx_compiler} has stl containers supporting allocator objects" -else - echo "${cmake_cxx_compiler} does not have stl containers supporting allocator objects" -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_WSTRING -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_WSTRING" \ "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then KWSYS_STL_HAS_WSTRING=1 echo "${cmake_cxx_compiler} has stl wstring" @@ -1415,69 +1209,6 @@ else echo "${cmake_cxx_compiler} does not have stl wstring" fi -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_CSTDDEF" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_CXX_HAS_CSTDDEF=1 - echo "${cmake_cxx_compiler} has header cstddef" -else - echo "${cmake_cxx_compiler} does not have header cstddef" -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - echo "${cmake_cxx_compiler} does not require template friends to use <>" -else - KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS=1 - echo "${cmake_cxx_compiler} requires template friends to use <>" -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_CXX_HAS_MEMBER_TEMPLATES=1 - echo "${cmake_cxx_compiler} supports member templates" -else - echo "${cmake_cxx_compiler} does not support member templates" -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_CXX_HAS_FULL_SPECIALIZATION=1 - echo "${cmake_cxx_compiler} has standard template specialization syntax" -else - echo "${cmake_cxx_compiler} does not have standard template specialization syntax" -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP=1 - echo "${cmake_cxx_compiler} has argument dependent lookup" -else - echo "${cmake_cxx_compiler} does not have argument dependent lookup" -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_STAT_HAS_ST_MTIM" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_STAT_HAS_ST_MTIM=1 - echo "${cmake_cxx_compiler} has struct stat with st_mtim member" -else - echo "${cmake_cxx_compiler} does not have struct stat with st_mtim member" -fi - -if cmake_try_run "${cmake_cxx_compiler}" \ - "${cmake_cxx_flags} -DTEST_KWSYS_IOS_HAVE_BINARY -DKWSYS_IOS_USE_ANSI=${KWSYS_IOS_USE_ANSI} -DKWSYS_IOS_HAVE_STD=${KWSYS_IOS_HAVE_STD}" \ - "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then - KWSYS_IOS_HAVE_BINARY=1 - echo "${cmake_cxx_compiler} has ios::binary openmode" -else - echo "${cmake_cxx_compiler} does not have ios::binary openmode" -fi - # Just to be safe, let us store compiler and flags to the header file cmake_bootstrap_version='$Revision$' @@ -1549,22 +1280,6 @@ for a in ${KWSYS_FILES}; do "${cmake_bootstrap_dir}/cmsys/${a}" KWSYS_NAMESPACE cmsys done -for a in ${KWSYS_IOS_FILES}; do - cmake_replace_string "${cmake_source_dir}/Source/kwsys/kwsys_ios_${a}.h.in" \ - "${cmake_bootstrap_dir}/cmsys/ios/${a}" KWSYS_NAMESPACE cmsys -done - -cmake_replace_string "${cmake_source_dir}/Source/kwsys/kwsys_stl.hxx.in" \ - "${cmake_bootstrap_dir}/cmsys/stl/stl.hxx_a" KWSYS_STL_HEADER_EXTRA "" - -cmake_replace_string "${cmake_bootstrap_dir}/cmsys/stl/stl.hxx_a" \ - "${cmake_bootstrap_dir}/cmsys/stl/stl.hxx_b" KWSYS_NAMESPACE cmsys - -for a in string vector set map algorithm; do - cmake_replace_string "${cmake_bootstrap_dir}/cmsys/stl/stl.hxx_b" \ - "${cmake_bootstrap_dir}/cmsys/stl/${a}" KWSYS_STL_HEADER ${a} -done - for a in ${KWIML_FILES}; do cmake_replace_string "${cmake_source_dir}/Utilities/KWIML/${a}.in" \ "${cmake_bootstrap_dir}/cmIML/${a}" KWIML cmIML |
