diff options
286 files changed, 4224 insertions, 3432 deletions
diff --git a/.gitattributes b/.gitattributes index 24fd9c2..3854b73 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,4 +1,4 @@ -.gitattributes export-ignore +.git* export-ignore .hooks* export-ignore # Custom attribute to mark sources as using our C code style. diff --git a/CMakeLists.txt b/CMakeLists.txt index 399e79c..75ac8bf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -429,10 +429,7 @@ macro (CMAKE_BUILD_UTILITIES) set(_CMAKE_USE_OPENSSL_DEFAULT OFF) if(NOT DEFINED CMAKE_USE_OPENSSL AND NOT WIN32 AND NOT APPLE AND CMAKE_SYSTEM_NAME MATCHES "(Linux|FreeBSD)") - find_package(OpenSSL QUIET) - if(OPENSSL_FOUND) - set(_CMAKE_USE_OPENSSL_DEFAULT ON) - endif() + set(_CMAKE_USE_OPENSSL_DEFAULT ON) endif() option(CMAKE_USE_OPENSSL "Use OpenSSL." ${_CMAKE_USE_OPENSSL_DEFAULT}) mark_as_advanced(CMAKE_USE_OPENSSL) @@ -629,8 +626,7 @@ endif() # The main section of the CMakeLists file # #----------------------------------------------------------------------- -# Compute CMake_VERSION, etc. -include(Source/CMakeVersionCompute.cmake) +include(Source/CMakeVersion.cmake) # Include the standard Dart testing module enable_testing() diff --git a/Help/command/find_package.rst b/Help/command/find_package.rst index 6e1d232..2186bd8 100644 --- a/Help/command/find_package.rst +++ b/Help/command/find_package.rst @@ -293,13 +293,15 @@ enabled. The package root variables are maintained as a stack so if called from within a find module, root paths from the parent's find module will also be searched after paths for the current package. - This can be skipped if ``NO_PACKAGE_ROOT_PATH`` is passed. + This can be skipped if ``NO_PACKAGE_ROOT_PATH`` is passed or by setting + the :variable:`CMAKE_FIND_USE_PACKAGE_ROOT_PATH` to ``FALSE``. See policy :policy:`CMP0074`. 2. Search paths specified in cmake-specific cache variables. These are intended to be used on the command line with a ``-DVAR=value``. The values are interpreted as :ref:`semicolon-separated lists <CMake Language Lists>`. - This can be skipped if ``NO_CMAKE_PATH`` is passed:: + This can be skipped if ``NO_CMAKE_PATH`` is passed or by setting the + :variable:`CMAKE_FIND_USE_CMAKE_PATH` to ``FALSE``:: CMAKE_PREFIX_PATH CMAKE_FRAMEWORK_PATH @@ -309,7 +311,8 @@ enabled. These are intended to be set in the user's shell configuration, and therefore use the host's native path separator (``;`` on Windows and ``:`` on UNIX). - This can be skipped if ``NO_CMAKE_ENVIRONMENT_PATH`` is passed:: + This can be skipped if ``NO_CMAKE_ENVIRONMENT_PATH`` is passed or by setting + the :variable:`CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH` to ``FALSE``:: <PackageName>_DIR CMAKE_PREFIX_PATH @@ -322,7 +325,8 @@ enabled. be specified with the ``PATHS`` option. 5. Search the standard system environment variables. This can be - skipped if ``NO_SYSTEM_ENVIRONMENT_PATH`` is passed. Path entries + skipped if ``NO_SYSTEM_ENVIRONMENT_PATH`` is passed or by setting the + :variable:`CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH` to ``FALSE``. Path entries ending in ``/bin`` or ``/sbin`` are automatically converted to their parent directories:: @@ -339,7 +343,8 @@ enabled. 7. Search cmake variables defined in the Platform files for the current system. This can be skipped if ``NO_CMAKE_SYSTEM_PATH`` is - passed:: + passed or by setting the :variable:`CMAKE_FIND_USE_CMAKE_SYSTEM_PATH` + to ``FALSE``:: CMAKE_SYSTEM_PREFIX_PATH CMAKE_SYSTEM_FRAMEWORK_PATH diff --git a/Help/command/message.rst b/Help/command/message.rst index 5dca6b4..3002842 100644 --- a/Help/command/message.rst +++ b/Help/command/message.rst @@ -60,6 +60,11 @@ messages one at a time on a status line and other messages in an interactive pop-up box. The ``--loglevel`` command-line option to each of these tools can be used to control which messages will be shown. +Messages of log levels ``NOTICE`` and below will also have each line preceded +by the content of the :variable:`CMAKE_MESSAGE_INDENT` variable (converted to +a single string by concatenating its list items). For ``STATUS`` to ``TRACE`` +messages, this indenting content will be inserted after the hyphens. + CMake Warning and Error message text displays using a simple markup language. Non-indented text is formatted in line-wrapped paragraphs delimited by newlines. Indented text is considered pre-formatted. diff --git a/Help/command/string.rst b/Help/command/string.rst index 2e89d7b..81a2061 100644 --- a/Help/command/string.rst +++ b/Help/command/string.rst @@ -22,8 +22,8 @@ Synopsis string(`PREPEND`_ <string-var> [<input>...]) string(`CONCAT`_ <out-var> [<input>...]) string(`JOIN`_ <glue> <out-var> [<input>...]) - string(`TOLOWER`_ <string1> <out-var>) - string(`TOUPPER`_ <string1> <out-var>) + string(`TOLOWER`_ <string> <out-var>) + string(`TOUPPER`_ <string> <out-var>) string(`LENGTH`_ <string> <out-var>) string(`SUBSTRING`_ <string> <begin> <length> <out-var>) string(`STRIP`_ <string> <out-var>) @@ -38,7 +38,7 @@ Synopsis `Generation`_ string(`ASCII`_ <number>... <out-var>) - string(`CONFIGURE`_ <string1> <out-var> [...]) + string(`CONFIGURE`_ <string> <out-var> [...]) string(`MAKE_C_IDENTIFIER`_ <string> <out-var>) string(`RANDOM`_ [<option>...] <out-var>) string(`TIMESTAMP`_ <out-var> [<format string>] [UTC]) @@ -51,23 +51,28 @@ Search and Replace .. code-block:: cmake - string(FIND <string> <substring> <output variable> [REVERSE]) + string(FIND <string> <substring> <output_variable> [REVERSE]) -Return the position where the given substring was found in -the supplied string. If the ``REVERSE`` flag was used, the command 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. +``<substring>``. If the ``<substring>`` is not found, a position of -1 is +returned. + +The ``string(FIND)`` subcommand treats all strings as ASCII-only characters. +The index stored in ``<output_variable>`` will also be counted in bytes, +so strings containing multi-byte characters may lead to unexpected results. .. _REPLACE: .. code-block:: cmake string(REPLACE <match_string> - <replace_string> <output variable> + <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. +Replace all occurrences of ``<match_string>`` in the ``<input>`` +with ``<replace_string>`` and store the result in the ``<output_variable>``. Regular Expressions ^^^^^^^^^^^^^^^^^^^ @@ -77,9 +82,10 @@ Regular Expressions .. code-block:: cmake string(REGEX MATCH <regular_expression> - <output variable> <input> [<input>...]) + <output_variable> <input> [<input>...]) -Match the regular expression once and store the match in the output variable. +Match the ``<regular_expression>`` once and store the match in the +``<output_variable>``. All ``<input>`` arguments are concatenated before matching. .. _`REGEX MATCHALL`: @@ -87,10 +93,10 @@ All ``<input>`` arguments are concatenated before matching. .. code-block:: cmake string(REGEX MATCHALL <regular_expression> - <output variable> <input> [<input>...]) + <output_variable> <input> [<input>...]) -Match the regular expression as many times as possible and store the matches -in the output variable as a list. +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. .. _`REGEX REPLACE`: @@ -98,16 +104,17 @@ All ``<input>`` arguments are concatenated before matching. .. code-block:: cmake string(REGEX REPLACE <regular_expression> - <replace_expression> <output variable> + <replacement_expression> <output_variable> <input> [<input>...]) -Match the regular expression as many times as possible and substitute the -replacement expression for the match in the output. +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. +The ``<replacement_expression>`` may refer to parenthesis-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`: @@ -180,103 +187,109 @@ Manipulation .. code-block:: cmake - string(APPEND <string variable> [<input>...]) + string(APPEND <string_variable> [<input>...]) -Append all the input arguments to the string. +Append all the ``<input>`` arguments to the string. .. _PREPEND: .. code-block:: cmake - string(PREPEND <string variable> [<input>...]) + string(PREPEND <string_variable> [<input>...]) -Prepend all the input arguments to the string. +Prepend all the ``<input>`` arguments to the string. .. _CONCAT: .. code-block:: cmake - string(CONCAT <output variable> [<input>...]) + string(CONCAT <output_variable> [<input>...]) -Concatenate all the input arguments together and store -the result in the named output variable. +Concatenate all the ``<input>`` arguments together and store +the result in the named ``<output_variable>``. .. _JOIN: .. code-block:: cmake - string(JOIN <glue> <output variable> [<input>...]) + string(JOIN <glue> <output_variable> [<input>...]) -Join all the input arguments together using the glue -string and store the result in the named output variable. +Join all the ``<input>`` arguments together using the ``<glue>`` +string and store the result in the named ``<output_variable>``. -To join list's elements, use preferably the ``JOIN`` operator -from :command:`list` command. This allows for the elements to have +To join a list's elements, prefer to use the ``JOIN`` operator +from the :command:`list` command. This allows for the elements to have special characters like ``;`` in them. .. _TOLOWER: .. code-block:: cmake - string(TOLOWER <string1> <output variable>) + string(TOLOWER <string> <output_variable>) -Convert string to lower characters. +Convert ``<string>`` to lower characters. .. _TOUPPER: .. code-block:: cmake - string(TOUPPER <string1> <output variable>) + string(TOUPPER <string> <output_variable>) -Convert string to upper characters. +Convert ``<string>`` to upper characters. .. _LENGTH: .. code-block:: cmake - string(LENGTH <string> <output variable>) + string(LENGTH <string> <output_variable>) -Store in an output variable a given string's length. +Store in an ``<output_variable>`` a given string's length in bytes. +Note that this means if ``<string>`` contains multi-byte characters, the +result stored in ``<output_variable>`` will *not* be the number of characters. .. _SUBSTRING: .. code-block:: cmake - string(SUBSTRING <string> <begin> <length> <output variable>) + 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 the +end of the string is used instead. -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. +Both ``<begin>`` and ``<length>`` are counted in bytes, so care must +be exercised if ``<string>`` could contain multi-byte characters. .. note:: - CMake 3.1 and below reported an error if length pointed past - the end of string. + CMake 3.1 and below reported an error if ``<length>`` pointed past + the end of ``<string>``. .. _STRIP: .. code-block:: cmake - string(STRIP <string> <output variable>) + string(STRIP <string> <output_variable>) -Store in an output variable a substring of a given string with leading and -trailing spaces removed. +Store in an ``<output_variable>`` a substring of a given ``<string>`` with +leading and trailing spaces removed. .. _GENEX_STRIP: .. code-block:: cmake - string(GENEX_STRIP <input string> <output variable>) + string(GENEX_STRIP <string> <output_variable>) Strip any :manual:`generator expressions <cmake-generator-expressions(7)>` -from the ``input string`` and store the result in the ``output variable``. +from the input ``<string>`` and store the result in the ``<output_variable>``. .. _REPEAT: .. code-block:: cmake - string(REPEAT <input string> <count> <output variable>) + string(REPEAT <string> <count> <output_variable>) -Produce the output string as repetion of ``input string`` ``count`` times. +Produce the output string as the input ``<string>`` repeated ``<count>`` times. Comparison ^^^^^^^^^^ @@ -285,14 +298,14 @@ Comparison .. code-block:: cmake - string(COMPARE LESS <string1> <string2> <output variable>) - string(COMPARE GREATER <string1> <string2> <output variable>) - string(COMPARE EQUAL <string1> <string2> <output variable>) - string(COMPARE NOTEQUAL <string1> <string2> <output variable>) - string(COMPARE LESS_EQUAL <string1> <string2> <output variable>) - string(COMPARE GREATER_EQUAL <string1> <string2> <output variable>) + string(COMPARE LESS <string1> <string2> <output_variable>) + string(COMPARE GREATER <string1> <string2> <output_variable>) + string(COMPARE EQUAL <string1> <string2> <output_variable>) + string(COMPARE NOTEQUAL <string1> <string2> <output_variable>) + string(COMPARE LESS_EQUAL <string1> <string2> <output_variable>) + string(COMPARE GREATER_EQUAL <string1> <string2> <output_variable>) -Compare the strings and store true or false in the output variable. +Compare the strings and store true or false in the ``<output_variable>``. .. _`Supported Hash Algorithms`: @@ -303,9 +316,9 @@ Hashing .. code-block:: cmake - string(<HASH> <output variable> <input>) + string(<HASH> <output_variable> <input>) -Compute a cryptographic hash of the input string. +Compute a cryptographic hash of the ``<input>`` string. The supported ``<HASH>`` algorithm names are: ``MD5`` @@ -336,7 +349,7 @@ Generation .. code-block:: cmake - string(ASCII <number> [<number> ...] <output variable>) + string(ASCII <number> [<number> ...] <output_variable>) Convert all numbers into corresponding ASCII characters. @@ -344,31 +357,31 @@ Convert all numbers into corresponding ASCII characters. .. code-block:: cmake - string(CONFIGURE <string1> <output variable> + string(CONFIGURE <string> <output_variable> [@ONLY] [ESCAPE_QUOTES]) -Transform a string like :command:`configure_file` transforms a file. +Transform a ``<string>`` like :command:`configure_file` transforms a file. .. _MAKE_C_IDENTIFIER: .. code-block:: cmake - string(MAKE_C_IDENTIFIER <input string> <output variable>) + string(MAKE_C_IDENTIFIER <string> <output_variable>) -Convert each non-alphanumeric character in the ``<input string>`` to an -underscore and store the result in the ``<output variable>``. If the first -character of the string is a digit, an underscore will also be prepended to -the result. +Convert each non-alphanumeric character in the input ``<string>`` to an +underscore and store the result in the ``<output_variable>``. If the first +character of the ``<string>`` is a digit, an underscore will also be prepended +to the result. .. _RANDOM: .. code-block:: cmake string(RANDOM [LENGTH <length>] [ALPHABET <alphabet>] - [RANDOM_SEED <seed>] <output variable>) + [RANDOM_SEED <seed>] <output_variable>) -Return a random string of given length consisting of -characters from the given alphabet. Default length is 5 characters +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. @@ -377,18 +390,18 @@ random number generator. .. code-block:: cmake - string(TIMESTAMP <output variable> [<format string>] [UTC]) + string(TIMESTAMP <output_variable> [<format_string>] [UTC]) Write a string representation of the current date -and/or time to the output variable. +and/or time to the ``<output_variable>``. -Should the command be unable to obtain a timestamp the output variable -will be set to the empty string "". +If the command is unable to obtain a timestamp, the ``<output_variable>`` +will be set to the empty string ``""``. The optional ``UTC`` flag requests the current date/time representation to be in Coordinated Universal Time (UTC) rather than local time. -The optional ``<format string>`` may contain the following format +The optional ``<format_string>`` may contain the following format specifiers: :: @@ -415,7 +428,7 @@ specifiers: Unknown format specifiers will be ignored and copied to the output as-is. -If no explicit ``<format string>`` is given it will default to: +If no explicit ``<format_string>`` is given, it will default to: :: @@ -432,7 +445,7 @@ If no explicit ``<format string>`` is given it will default to: .. code-block:: cmake - string(UUID <output variable> NAMESPACE <namespace> NAME <name> + string(UUID <output_variable> NAMESPACE <namespace> NAME <name> TYPE <MD5|SHA1> [UPPER]) Create a universally unique identifier (aka GUID) as per RFC4122 @@ -441,6 +454,6 @@ based on the hash of the combined values of ``<namespace>`` The hash algorithm can be either ``MD5`` (Version 3 UUID) or ``SHA1`` (Version 5 UUID). A UUID has the format ``xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`` -where each `x` represents a lower case hexadecimal character. -Where required an uppercase representation can be requested +where each ``x`` represents a lower case hexadecimal character. +Where required, an uppercase representation can be requested with the optional ``UPPER`` flag. diff --git a/Help/dev/maint.rst b/Help/dev/maint.rst index 1153a09..37a1d3a 100644 --- a/Help/dev/maint.rst +++ b/Help/dev/maint.rst @@ -92,6 +92,45 @@ Publish both ``master`` and ``release`` simultaneously: .. _`CMake Review Process`: review.rst .. _`CMake CDash Page`: https://open.cdash.org/index.php?project=CMake +Create Release Version +====================== + +When the ``release`` branch is ready to create a new release, follow the +steps in the above `Maintain Current Release`_ section to checkout a local +``release-$ver`` branch, where ``$ver`` is the version number of the +current release in the form ``$major.$minor``. + +Edit ``Source/CMakeVersion.cmake`` to set the full version: + +.. code-block:: cmake + + # CMake version number components. + set(CMake_VERSION_MAJOR $major) + set(CMake_VERSION_MINOR $minor) + set(CMake_VERSION_PATCH $patch) + #set(CMake_VERSION_RC $rc) # uncomment for release candidates + +In the following we use the placeholder ``$fullver`` for the full version +number of the new release with the form ``$major.$minor.$patch[-rc$rc]``. +If the version is not a release candidate, comment out the RC version +component above and leave off the ``-rc$rc`` suffix from ``$fullver``. + +Commit the release version with the **exact** message ``CMake $fullver``: + +.. code-block:: shell + + git commit -m "CMake $fullver" + +Tag the release using an annotated tag with the same message as the +commit and named with the **exact** form ``v$fullver``: + +.. code-block:: shell + + git tag -s -m "CMake $fullver" "v$fullver" + +Follow the steps in the above `Maintain Current Release`_ section to +merge the ``release-$ver`` branch into ``master`` and publish both. + Branch a New Release ==================== @@ -178,7 +217,7 @@ Commit with a message such as:: the CMake Release Notes index page. Update ``Source/CMakeVersion.cmake`` to set the version to -``$major.$minor.0-rc1``: +``$major.$minor.0-rc0``: .. code-block:: cmake @@ -186,7 +225,7 @@ Update ``Source/CMakeVersion.cmake`` to set the version to set(CMake_VERSION_MAJOR $major) set(CMake_VERSION_MINOR $minor) set(CMake_VERSION_PATCH 0) - set(CMake_VERSION_RC 1) + set(CMake_VERSION_RC 0) Update uses of ``DEVEL_CMAKE_VERSION`` in the source tree to mention the actual version number: @@ -197,7 +236,7 @@ actual version number: Commit with a message such as:: - CMake $major.$minor.0-rc1 version update + Begin $ver release versioning Merge the ``release-$ver`` branch to ``master``: @@ -225,7 +264,7 @@ Update ``Source/CMakeVersion.cmake`` to set the version to set(CMake_VERSION_MAJOR $major) set(CMake_VERSION_MINOR $minor) set(CMake_VERSION_PATCH $date) - #set(CMake_VERSION_RC 1) + #set(CMake_VERSION_RC 0) Commit with a message such as:: diff --git a/Help/guide/tutorial/Complete/CMakeLists.txt b/Help/guide/tutorial/Complete/CMakeLists.txt index e84f932..4541392 100644 --- a/Help/guide/tutorial/Complete/CMakeLists.txt +++ b/Help/guide/tutorial/Complete/CMakeLists.txt @@ -1,7 +1,17 @@ -cmake_minimum_required(VERSION 3.3) +cmake_minimum_required(VERSION 3.15) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +add_library(tutorial_compiler_flags INTERFACE) +target_compile_features(tutorial_compiler_flags INTERFACE cxx_std_11) + +# add compiler warning flags just when building this project via +# the BUILD_INTERFACE genex +set(gcc_like_cxx "$<COMPILE_LANG_AND_ID:CXX,ARMClang,AppleClang,Clang,GNU>") +set(msvc_cxx "$<COMPILE_LANG_AND_ID:CXX,MSVC>") +target_compile_options(tutorial_compiler_flags INTERFACE + "$<${gcc_like_cxx}:$<BUILD_INTERFACE:-Wall;-Wextra;-Wshadow;-Wformat=2;-Wunused>>" + "$<${msvc_cxx}:$<BUILD_INTERFACE:-W3>>" +) # set the version number set(Tutorial_VERSION_MAJOR 1) diff --git a/Help/guide/tutorial/Complete/MathFunctions/CMakeLists.txt b/Help/guide/tutorial/Complete/MathFunctions/CMakeLists.txt index 63c0f5f..c12955d 100644 --- a/Help/guide/tutorial/Complete/MathFunctions/CMakeLists.txt +++ b/Help/guide/tutorial/Complete/MathFunctions/CMakeLists.txt @@ -21,6 +21,7 @@ if(USE_MYMATH) # first we add the executable that generates the table add_executable(MakeTable MakeTable.cxx) + target_link_libraries(MakeTable tutorial_compiler_flags) # add the command to generate the source code add_custom_command( @@ -44,14 +45,18 @@ if(USE_MYMATH) POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS} ) - target_compile_definitions(SqrtLibrary PRIVATE - "$<$<BOOL:${HAVE_LOG}>:HAVE_LOG>" - "$<$<BOOL:${HAVE_EXP}>:HAVE_EXP>" - ) + target_link_libraries(SqrtLibrary PUBLIC tutorial_compiler_flags) + + + target_compile_definitions(MathFunctions PRIVATE "USE_MYMATH") + if(HAVE_LOG AND HAVE_EXP) + target_compile_definitions(SqrtLibrary + PRIVATE "HAVE_LOG" "HAVE_EXP") + endif() target_link_libraries(MathFunctions PRIVATE SqrtLibrary) endif() -target_compile_definitions(MathFunctions PRIVATE "$<$<BOOL:${USE_MYMATH}>:USE_MYMATH>") +target_link_libraries(MathFunctions PUBLIC tutorial_compiler_flags) # define the symbol stating we are using the declspec(dllexport) when # building on windows @@ -62,7 +67,7 @@ set_property(TARGET MathFunctions PROPERTY VERSION "1.0.0") set_property(TARGET MathFunctions PROPERTY SOVERSION "1") # install rules -install(TARGETS MathFunctions +install(TARGETS MathFunctions tutorial_compiler_flags DESTINATION lib EXPORT MathFunctionsTargets) install(FILES MathFunctions.h DESTINATION include) diff --git a/Help/guide/tutorial/Consumer/CMakeLists.txt b/Help/guide/tutorial/Consumer/CMakeLists.txt index 5097917..4033b4d 100644 --- a/Help/guide/tutorial/Consumer/CMakeLists.txt +++ b/Help/guide/tutorial/Consumer/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.3) if(NOT DEFINED CMAKE_CXX_STANDARD) - set(CMAKE_CXX_STANDARD 14) + set(CMAKE_CXX_STANDARD 11) + set(CMAKE_CXX_STANDARD_REQUIRED True) endif() diff --git a/Help/guide/tutorial/MultiPackage/CMakeLists.txt b/Help/guide/tutorial/MultiPackage/CMakeLists.txt index 067e807..bea611c 100644 --- a/Help/guide/tutorial/MultiPackage/CMakeLists.txt +++ b/Help/guide/tutorial/MultiPackage/CMakeLists.txt @@ -1,19 +1,26 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -# control how we mark up Debug libraries compared to Release libraries -set(CMAKE_DEBUG_POSTFIX "-d") +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# set the version number +set(Tutorial_VERSION_MAJOR 1) +set(Tutorial_VERSION_MINOR 0) # control where the static and shared libraries are built so that on windows # we don't need to tinker with the path to run the executable set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}") option(BUILD_SHARED_LIBS "Build using shared libraries" ON) -# the version number. -set(Tutorial_VERSION_MAJOR 1) -set(Tutorial_VERSION_MINOR 0) +if(APPLE) + set(CMAKE_INSTALL_RPATH "@executable_path/../lib") +elseif(UNIX) + set(CMAKE_INSTALL_RPATH "$ORIGIN/../lib") +endif() # configure a header file to pass the version number only configure_file( diff --git a/Help/guide/tutorial/MultiPackage/MathFunctions/CMakeLists.txt b/Help/guide/tutorial/MultiPackage/MathFunctions/CMakeLists.txt index 161ad64..63c0f5f 100644 --- a/Help/guide/tutorial/MultiPackage/MathFunctions/CMakeLists.txt +++ b/Help/guide/tutorial/MultiPackage/MathFunctions/CMakeLists.txt @@ -1,4 +1,3 @@ - # add the library that runs add_library(MathFunctions MathFunctions.cxx) @@ -62,6 +61,7 @@ target_compile_definitions(MathFunctions PRIVATE "EXPORTING_MYMATH") set_property(TARGET MathFunctions PROPERTY VERSION "1.0.0") set_property(TARGET MathFunctions PROPERTY SOVERSION "1") +# install rules install(TARGETS MathFunctions DESTINATION lib EXPORT MathFunctionsTargets) diff --git a/Help/guide/tutorial/Step10/CMakeLists.txt b/Help/guide/tutorial/Step10/CMakeLists.txt index 5819272..25bc0c1 100644 --- a/Help/guide/tutorial/Step10/CMakeLists.txt +++ b/Help/guide/tutorial/Step10/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) # Set the version number set(Tutorial_VERSION_MAJOR 1) diff --git a/Help/guide/tutorial/Step11/CMakeLists.txt b/Help/guide/tutorial/Step11/CMakeLists.txt index 2e5cb15..e54bdde 100644 --- a/Help/guide/tutorial/Step11/CMakeLists.txt +++ b/Help/guide/tutorial/Step11/CMakeLists.txt @@ -1,7 +1,17 @@ -cmake_minimum_required(VERSION 3.3) +cmake_minimum_required(VERSION 3.15) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +add_library(tutorial_compiler_flags INTERFACE) +target_compile_features(tutorial_compiler_flags INTERFACE cxx_std_11) + +# add compiler warning flags just when building this project via +# the BUILD_INTERFACE genex +set(gcc_like_cxx "$<COMPILE_LANG_AND_ID:CXX,ARMClang,AppleClang,Clang,GNU>") +set(msvc_cxx "$<COMPILE_LANG_AND_ID:CXX,MSVC>") +target_compile_options(tutorial_compiler_flags INTERFACE + "$<${gcc_like_cxx}:$<BUILD_INTERFACE:-Wall;-Wextra;-Wshadow;-Wformat=2;-Wunused>>" + "$<${msvc_cxx}:$<BUILD_INTERFACE:-W3>>" +) # set the version number set(Tutorial_VERSION_MAJOR 1) diff --git a/Help/guide/tutorial/Step11/MathFunctions/CMakeLists.txt b/Help/guide/tutorial/Step11/MathFunctions/CMakeLists.txt index ea42770..daaaa55 100644 --- a/Help/guide/tutorial/Step11/MathFunctions/CMakeLists.txt +++ b/Help/guide/tutorial/Step11/MathFunctions/CMakeLists.txt @@ -19,6 +19,7 @@ if(USE_MYMATH) # first we add the executable that generates the table add_executable(MakeTable MakeTable.cxx) + target_link_libraries(MakeTable tutorial_compiler_flags) # add the command to generate the source code add_custom_command( @@ -42,14 +43,17 @@ if(USE_MYMATH) POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS} ) - target_compile_definitions(SqrtLibrary PRIVATE - "$<$<BOOL:${HAVE_LOG}>:HAVE_LOG>" - "$<$<BOOL:${HAVE_EXP}>:HAVE_EXP>" - ) + target_link_libraries(SqrtLibrary PUBLIC tutorial_compiler_flags) + + target_compile_definitions(MathFunctions PRIVATE "USE_MYMATH") + if(HAVE_LOG AND HAVE_EXP) + target_compile_definitions(SqrtLibrary + PRIVATE "HAVE_LOG" "HAVE_EXP") + endif() target_link_libraries(MathFunctions PRIVATE SqrtLibrary) endif() -target_compile_definitions(MathFunctions PRIVATE "$<$<BOOL:${USE_MYMATH}>:USE_MYMATH>") +target_link_libraries(MathFunctions PUBLIC tutorial_compiler_flags) # define the symbol stating we are using the declspec(dllexport) when #building on windows diff --git a/Help/guide/tutorial/Step2/CMakeLists.txt b/Help/guide/tutorial/Step2/CMakeLists.txt index 1f43b2b..059b89a 100644 --- a/Help/guide/tutorial/Step2/CMakeLists.txt +++ b/Help/guide/tutorial/Step2/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) # set the version number set(Tutorial_VERSION_MAJOR 1) diff --git a/Help/guide/tutorial/Step3/CMakeLists.txt b/Help/guide/tutorial/Step3/CMakeLists.txt index 966c38a..9804abf 100644 --- a/Help/guide/tutorial/Step3/CMakeLists.txt +++ b/Help/guide/tutorial/Step3/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) # should we use our own math functions option(USE_MYMATH "Use tutorial provided math implementation" ON) diff --git a/Help/guide/tutorial/Step4/CMakeLists.txt b/Help/guide/tutorial/Step4/CMakeLists.txt index a157bda..0ae2648 100644 --- a/Help/guide/tutorial/Step4/CMakeLists.txt +++ b/Help/guide/tutorial/Step4/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) # should we use our own math functions option(USE_MYMATH "Use tutorial provided math implementation" ON) diff --git a/Help/guide/tutorial/Step5/CMakeLists.txt b/Help/guide/tutorial/Step5/CMakeLists.txt index 76b9179..dac9b45 100644 --- a/Help/guide/tutorial/Step5/CMakeLists.txt +++ b/Help/guide/tutorial/Step5/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) # should we use our own math functions option(USE_MYMATH "Use tutorial provided math implementation" ON) diff --git a/Help/guide/tutorial/Step6/CMakeLists.txt b/Help/guide/tutorial/Step6/CMakeLists.txt index 5829891..1465e46 100644 --- a/Help/guide/tutorial/Step6/CMakeLists.txt +++ b/Help/guide/tutorial/Step6/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) # set the version number set(Tutorial_VERSION_MAJOR 1) diff --git a/Help/guide/tutorial/Step7/CMakeLists.txt b/Help/guide/tutorial/Step7/CMakeLists.txt index 17e6a60..a1efa77 100644 --- a/Help/guide/tutorial/Step7/CMakeLists.txt +++ b/Help/guide/tutorial/Step7/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) # set the version number set(Tutorial_VERSION_MAJOR 1) diff --git a/Help/guide/tutorial/Step8/CMakeLists.txt b/Help/guide/tutorial/Step8/CMakeLists.txt index 86725e8..a0316a0 100644 --- a/Help/guide/tutorial/Step8/CMakeLists.txt +++ b/Help/guide/tutorial/Step8/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) # set the version number set(Tutorial_VERSION_MAJOR 1) diff --git a/Help/guide/tutorial/Step9/CMakeLists.txt b/Help/guide/tutorial/Step9/CMakeLists.txt index 07ab90a..e610b99 100644 --- a/Help/guide/tutorial/Step9/CMakeLists.txt +++ b/Help/guide/tutorial/Step9/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.3) project(Tutorial) -set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) # set the version number set(Tutorial_VERSION_MAJOR 1) diff --git a/Help/guide/tutorial/index.rst b/Help/guide/tutorial/index.rst index db8e7a0..068499e 100644 --- a/Help/guide/tutorial/index.rst +++ b/Help/guide/tutorial/index.rst @@ -228,7 +228,8 @@ remove our uses of the ``EXTRA_INCLUDES`` variable from the top-level CMakeLists. Once this is done, run **cmake** or **cmake-gui** to configure the project -and then build it with your chosen build tool. +and then build it with your chosen build tool or by using ``cmake --build .`` +from the build directory. Installing and Testing (Step 4) =============================== @@ -258,14 +259,15 @@ And the to top-level ``CMakeLists.txt`` we add: That is all that is needed to create a basic local install of the tutorial. Run **cmake** or **cmake-gui** to configure the project and then build it -with your chosen build tool. Build the ``install`` target by typing -``make install`` from the command line or build the ``INSTALL`` target from -an IDE. This will install the appropriate header files, libraries, and -executables. +with your chosen build tool. Run the install step by typing +``cmake --install .`` or from the command line, or build the ``INSTALL`` +target from an IDE. This will install the appropriate header files, libraries, +and executables. Verify that the installed Tutorial runs. Note: The CMake variable ``CMAKE_INSTALL_PREFIX`` is used to determine the root of where the files will -be installed. +be installed. If using ``cmake --install`` a custom installation directory can +be given via ``--prefix`` argument. Testing Support --------------- @@ -596,27 +598,47 @@ expressions are the 0 and 1 expressions. A ``$<0:...>`` results in the empty string, and ``<1:...>`` results in the content of "...". They can also be nested. -For example: +A common usage of generator expressions is to conditionally add compiler +flags, such as those as language levels or warnings. A nice pattern is +to associate this information to an ``INTERFACE`` target allowing this +information to propagate. Lets start by constructing an ``INTERFACE`` +target and specifying the required C++ standard level of ``11`` instead +of using ``CMAKE_CXX_STANDARD``. -.. code-block:: cmake +So the following code: + +.. literalinclude:: Step10/CMakeLists.txt + :language: cmake + :start-after: project(Tutorial) + :end-before: # Set the version number - if(HAVE_LOG AND HAVE_EXP) - target_compile_definitions(SqrtLibrary - PRIVATE "HAVE_LOG" "HAVE_EXP") - endif() +Would be replaced with: -Can be rewritten with generator expressions: +.. literalinclude:: Step11/CMakeLists.txt + :language: cmake + :start-after: project(Tutorial) + :end-before: # add compiler warning flags just when building this project via + + +Next we add the desired compiler warning flags that we want for our +project. As warning flags vary based on the compiler we use +the ``COMPILE_LANG_AND_ID`` generator expression to control which +flags to apply given a language and a set of compiler ids as seen +below: + +.. literalinclude:: Step11/CMakeLists.txt + :language: cmake + :start-after: # the BUILD_INTERFACE genex + :end-before: # set the version number + +Looking at this we see that the warning flags are encapsulated inside a +``BUILD_INTERFACE`` condition. This is done so that consumers of our installed +project will not inherit our warning flags. -.. code-block:: cmake - target_compile_definitions(SqrtLibrary PRIVATE - "$<$<BOOL:${HAVE_LOG}>:HAVE_LOG>" - "$<$<BOOL:${HAVE_EXP}>:HAVE_EXP>" - ) +**Exercise**: Modify ``MathFunctions/CMakeLists.txt`` so that +all targets have a ``target_link_libraries()`` call to ``tutorial_compiler_flags``. -Note that ``${HAVE_LOG}`` is evaluated at CMake configure time while -``$<$<BOOL:${HAVE_LOG}>:HAVE_LOG>`` is evaluated at build system generation -time. Adding Export Configuration (Step 11) ===================================== diff --git a/Help/manual/cmake-policies.7.rst b/Help/manual/cmake-policies.7.rst index 6bdabaf..44ea1a8 100644 --- a/Help/manual/cmake-policies.7.rst +++ b/Help/manual/cmake-policies.7.rst @@ -57,6 +57,7 @@ Policies Introduced by CMake 3.16 .. toctree:: :maxdepth: 1 + CMP0097: ExternalProject_Add with GIT_SUBMODULES "" initializes no submodules. </policy/CMP0097> CMP0096: project() preserves leading zeros in version components. </policy/CMP0096> CMP0095: RPATH entries are properly escaped in the intermediary CMake install script. </policy/CMP0095> diff --git a/Help/manual/cmake-properties.7.rst b/Help/manual/cmake-properties.7.rst index ae4be3e..62d23c7 100644 --- a/Help/manual/cmake-properties.7.rst +++ b/Help/manual/cmake-properties.7.rst @@ -228,6 +228,7 @@ Properties on Targets /prop_tgt/IMPORT_SUFFIX /prop_tgt/INCLUDE_DIRECTORIES /prop_tgt/INSTALL_NAME_DIR + /prop_tgt/INSTALL_REMOVE_ENVIRONMENT_RPATH /prop_tgt/INSTALL_RPATH /prop_tgt/INSTALL_RPATH_USE_LINK_PATH /prop_tgt/INTERFACE_AUTOUIC_OPTIONS diff --git a/Help/manual/cmake-toolchains.7.rst b/Help/manual/cmake-toolchains.7.rst index 7435d9a..f233d08 100644 --- a/Help/manual/cmake-toolchains.7.rst +++ b/Help/manual/cmake-toolchains.7.rst @@ -399,8 +399,10 @@ Configure use of an Android NDK with the following variables: be false unless using a NDK that does not provide unified headers. :variable:`CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION` - Set to the version of the NDK toolchain to be selected as the compiler. - If not specified, the default will be the latest available GCC toolchain. + On NDK r19 or above, this variable must be unset or set to ``clang``. + On NDK r18 or below, set this to the version of the NDK toolchain to + be selected as the compiler. If not specified, the default will be + the latest available GCC toolchain. :variable:`CMAKE_ANDROID_STL_TYPE` Set to specify which C++ standard library to use. If not specified, diff --git a/Help/manual/cmake-variables.7.rst b/Help/manual/cmake-variables.7.rst index e0ce6f7..432d7fc 100644 --- a/Help/manual/cmake-variables.7.rst +++ b/Help/manual/cmake-variables.7.rst @@ -69,6 +69,7 @@ Variables that Provide Information /variable/CMAKE_MAKE_PROGRAM /variable/CMAKE_MATCH_COUNT /variable/CMAKE_MATCH_n + /variable/CMAKE_MESSAGE_INDENT /variable/CMAKE_MINIMUM_REQUIRED_VERSION /variable/CMAKE_MINOR_VERSION /variable/CMAKE_NETRC @@ -371,6 +372,7 @@ Variables that Control the Build /variable/CMAKE_INCLUDE_CURRENT_DIR /variable/CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE /variable/CMAKE_INSTALL_NAME_DIR + /variable/CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH /variable/CMAKE_INSTALL_RPATH /variable/CMAKE_INSTALL_RPATH_USE_LINK_PATH /variable/CMAKE_INTERPROCEDURAL_OPTIMIZATION @@ -609,7 +611,6 @@ Variables for CPack /variable/CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION /variable/CPACK_INCLUDE_TOPLEVEL_DIRECTORY /variable/CPACK_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS - /variable/CPACK_INSTALL_SCRIPT /variable/CPACK_PACKAGING_INSTALL_PREFIX /variable/CPACK_SET_DESTDIR /variable/CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION diff --git a/Help/policy/CMP0097.rst b/Help/policy/CMP0097.rst new file mode 100644 index 0000000..8a5ff88 --- /dev/null +++ b/Help/policy/CMP0097.rst @@ -0,0 +1,23 @@ +CMP0097 +------- + +:command:`ExternalProject_Add` with ``GIT_SUBMODULES ""`` initializes no +submodules. + +The module provides a ``GIT_SUBMODULES`` option which controls what submodules +to initialize and update. Starting with CMake 3.16, explicitly setting +``GIT_SUBMODULES`` to an empty string means no submodules will be initialized +or updated. + +This policy provides compatibility for projects that have not been updated +to expect the new behavior. + +The ``OLD`` behavior for this policy is for ``GIT_SUBMODULES`` when set to +an empty string to initialize and update all git submodules. +The ``New`` behavior for this policy is for ``GIT_SUBMODULES`` when set to +an empty string to initialize and update no git submodules. + +This policy was introduced in CMake version 3.16. Use the +:command:`cmake_policy` command to set it to ``OLD`` or ``NEW`` explicitly. +Unlike most policies, CMake version |release| does *not* warn +when this policy is not set and simply uses ``OLD`` behavior. diff --git a/Help/prop_tgt/INSTALL_REMOVE_ENVIRONMENT_RPATH.rst b/Help/prop_tgt/INSTALL_REMOVE_ENVIRONMENT_RPATH.rst new file mode 100644 index 0000000..a474fc6 --- /dev/null +++ b/Help/prop_tgt/INSTALL_REMOVE_ENVIRONMENT_RPATH.rst @@ -0,0 +1,10 @@ +INSTALL_REMOVE_ENVIRONMENT_RPATH +-------------------------------- + +Removes compiler defined rpaths durimg installation. + +``INSTALL_REMOVE_ENVIRONMENT_RPATH`` is a boolean that if set to ``True`` will +remove compiler defined rpaths from the project if the user also defines rpath +with :prop_tgt:`INSTALL_RPATH`. This property is initialized by whether the +value of :variable:`CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH` is set when a +target is created. diff --git a/Help/release/3.15.rst b/Help/release/3.15.rst index 2cff419..4f53466 100644 --- a/Help/release/3.15.rst +++ b/Help/release/3.15.rst @@ -345,3 +345,20 @@ Other Changes * The :command:`file(REMOVE)` and :command:`file(REMOVE_RECURSE)` commands were changed to ignore empty arguments with a warning instead of treating them as a relative path and removing the contents of the current directory. + +Updates +======= + +Changes made since CMake 3.15.0 include the following. + +3.15.1 +------ + +* In CMake 3.15.0 support for the GNU-like ``Clang`` compiler targeting the + MSVC ABI implemented :variable:`CMAKE_CXX_STANDARD` values 98 and 11 using + the corresponding ``-std=`` flags. However, these modes do not work with + the MSVC standard library. Therefore CMake 3.15.1 passes C++14 standard + flags even for C++98 and C++11. This is consistent with MSVC itself which + always runs in a mode aware of C++14. + +* Preliminary Swift support added in 3.15.0 has been updated. diff --git a/Help/release/dev/add-install-remove-environment-rpath.rst b/Help/release/dev/add-install-remove-environment-rpath.rst new file mode 100644 index 0000000..156106c --- /dev/null +++ b/Help/release/dev/add-install-remove-environment-rpath.rst @@ -0,0 +1,6 @@ +add-install-remove-environment-rpath +------------------------------------ + +* A new target property, :prop_tgt:`INSTALL_REMOVE_ENVIRONMENT_RPATH`, was + added which removes compiler-defined rpaths from a target. This property is + initialized by :variable:`CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH`. diff --git a/Help/release/dev/cpack-install-scripts.rst b/Help/release/dev/cpack-install-scripts.rst new file mode 100644 index 0000000..7b80d33 --- /dev/null +++ b/Help/release/dev/cpack-install-scripts.rst @@ -0,0 +1,5 @@ +cpack-install-scripts +--------------------- + +* The ``CPACK_INSTALL_SCRIPT`` variable has been deprecated in favor of the + new, more accurately named :variable:`CPACK_INSTALL_SCRIPTS` variable. diff --git a/Help/release/dev/external-project-support-no-git-submodules.rst b/Help/release/dev/external-project-support-no-git-submodules.rst new file mode 100644 index 0000000..1d4be66 --- /dev/null +++ b/Help/release/dev/external-project-support-no-git-submodules.rst @@ -0,0 +1,6 @@ +external-project-support-no-git-submodules +------------------------------------------ + +* The :module:`ExternalProject` module's ``ExternalProject_Add`` command + has been updated so that ``GIT_SUBMODULES ""`` initializes no submodules. See + policy :policy:`CMP0097`. diff --git a/Help/release/dev/global-controls-over-find-locations.rst b/Help/release/dev/global-controls-over-find-locations.rst index 79bc869..1c0b226 100644 --- a/Help/release/dev/global-controls-over-find-locations.rst +++ b/Help/release/dev/global-controls-over-find-locations.rst @@ -2,8 +2,8 @@ global-controls-over-find-locations ----------------------------------- * The :command:`find_file`, :command:`find_library`, :command:`find_path`, - and :command:`find_program` commands have learned to check the following - variables to control searching + :command:`find_package`, and :command:`find_program` commands have learned to + check the following variables to control searching * :variable:`CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH` - Controls the searching the cmake-specific environment variables. diff --git a/Help/release/dev/message-indent.rst b/Help/release/dev/message-indent.rst new file mode 100644 index 0000000..b170708 --- /dev/null +++ b/Help/release/dev/message-indent.rst @@ -0,0 +1,5 @@ +message-indent +-------------- + +* The :command:`message` command learned indentation control with the new + :variable:`CMAKE_MESSAGE_INDENT` variable. diff --git a/Help/variable/CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION.rst b/Help/variable/CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION.rst index 5ae55d1..22808e3 100644 --- a/Help/variable/CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION.rst +++ b/Help/variable/CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION.rst @@ -3,7 +3,11 @@ CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION When :ref:`Cross Compiling for Android with the NDK`, this variable may be set to specify the version of the toolchain to be used -as the compiler. The variable must be set to one of these forms: +as the compiler. + +On NDK r19 or above, this variable must be unset or set to ``clang``. + +On NDK r18 or below, this variable must be set to one of these forms: * ``<major>.<minor>``: GCC of specified version * ``clang<major>.<minor>``: Clang of specified version diff --git a/Help/variable/CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH.rst b/Help/variable/CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH.rst index 33514a0..2db5081 100644 --- a/Help/variable/CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH.rst +++ b/Help/variable/CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH.rst @@ -3,7 +3,7 @@ CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH Controls the searching the cmake-specific environment variables by the :command:`find_program`, :command:`find_library`, :command:`find_file`, -and :command:`find_path` commands. +:command:`find_path`, and command:`find_package` commands. This is useful in cross-compiling environments. By default this variable is not set, which is equivalent to it having diff --git a/Help/variable/CMAKE_FIND_USE_CMAKE_PATH.rst b/Help/variable/CMAKE_FIND_USE_CMAKE_PATH.rst index cefc645..4ca7ad1 100644 --- a/Help/variable/CMAKE_FIND_USE_CMAKE_PATH.rst +++ b/Help/variable/CMAKE_FIND_USE_CMAKE_PATH.rst @@ -3,7 +3,7 @@ CMAKE_FIND_USE_CMAKE_PATH Controls the searching the cmake-specific cache variables by the :command:`find_program`, :command:`find_library`, :command:`find_file`, -and :command:`find_path` commands. +:command:`find_path`, and command:`find_package` commands. This is useful in cross-compiling environments. By default this variable is not set, which is equivalent to it having diff --git a/Help/variable/CMAKE_FIND_USE_CMAKE_SYSTEM_PATH.rst b/Help/variable/CMAKE_FIND_USE_CMAKE_SYSTEM_PATH.rst index 2aa544d..d3259ae 100644 --- a/Help/variable/CMAKE_FIND_USE_CMAKE_SYSTEM_PATH.rst +++ b/Help/variable/CMAKE_FIND_USE_CMAKE_SYSTEM_PATH.rst @@ -3,7 +3,7 @@ CMAKE_FIND_USE_CMAKE_SYSTEM_PATH Controls the searching cmake platform specific variables by the :command:`find_program`, :command:`find_library`, :command:`find_file`, -and :command:`find_path` commands. +:command:`find_path`, and command:`find_package` commands. This is useful in cross-compiling environments. By default this variable is not set, which is equivalent to it having diff --git a/Help/variable/CMAKE_FIND_USE_PACKAGE_ROOT_PATH.rst b/Help/variable/CMAKE_FIND_USE_PACKAGE_ROOT_PATH.rst index 899e62e..e17fdcc 100644 --- a/Help/variable/CMAKE_FIND_USE_PACKAGE_ROOT_PATH.rst +++ b/Help/variable/CMAKE_FIND_USE_PACKAGE_ROOT_PATH.rst @@ -3,7 +3,7 @@ CMAKE_FIND_USE_PACKAGE_ROOT_PATH Controls the searching of :variable:`<PackageName>_ROOT` variables by the :command:`find_program`, :command:`find_library`, :command:`find_file`, -and :command:`find_path` commands. +:command:`find_path`, and command:`find_package` commands. This is useful in cross-compiling environments. By default this variable is not set, which is equivalent to it having diff --git a/Help/variable/CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH.rst b/Help/variable/CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH.rst index 604c710..71432f6 100644 --- a/Help/variable/CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH.rst +++ b/Help/variable/CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH.rst @@ -3,7 +3,7 @@ CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH Controls the searching the standard system environment variables by the :command:`find_program`, :command:`find_library`, :command:`find_file`, -and :command:`find_path` commands. +:command:`find_path`, and command:`find_package` commands. This is useful in cross-compiling environments. By default this variable is not set, which is equivalent to it having diff --git a/Help/variable/CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH.rst b/Help/variable/CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH.rst new file mode 100644 index 0000000..19ae5f3 --- /dev/null +++ b/Help/variable/CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH.rst @@ -0,0 +1,9 @@ +CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH +-------------------------------------- + +Removes compiler defined rpaths durimg installation. + +``CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH`` is a boolean that if set to ``true`` +removes compiler defined rpaths from the project if the user also defines rpath +with :prop_tgt:`INSTALL_RPATH`. This is used to initialize the target property +:prop_tgt:`INSTALL_REMOVE_ENVIRONMENT_RPATH` for all targets. diff --git a/Help/variable/CMAKE_MESSAGE_INDENT.rst b/Help/variable/CMAKE_MESSAGE_INDENT.rst new file mode 100644 index 0000000..f7975ab --- /dev/null +++ b/Help/variable/CMAKE_MESSAGE_INDENT.rst @@ -0,0 +1,30 @@ +CMAKE_MESSAGE_INDENT +-------------------- + +The :command:`message` command joins the strings from this list and for +log levels of ``NOTICE`` and below, it prepends the resultant string to +each line of the message. + +Example: + +.. code-block:: cmake + + list(APPEND listVar one two three) + + message(VERBOSE [[Collected items in the "listVar":]]) + list(APPEND CMAKE_MESSAGE_INDENT " ") + + foreach(item IN LISTS listVar) + message(VERBOSE ${item}) + endforeach() + + list(POP_BACK CMAKE_MESSAGE_INDENT) + message(VERBOSE "No more indent") + +Which results in the following output: + + -- Collected items in the "listVar": + -- one + -- two + -- tree + -- No more indent diff --git a/Help/variable/CPACK_INSTALL_SCRIPT.rst b/Help/variable/CPACK_INSTALL_SCRIPT.rst deleted file mode 100644 index 12a48a4..0000000 --- a/Help/variable/CPACK_INSTALL_SCRIPT.rst +++ /dev/null @@ -1,8 +0,0 @@ -CPACK_INSTALL_SCRIPT --------------------- - -Extra CMake script provided by the user. - -If set this CMake script will be executed by CPack during its local -[CPack-private] installation which is done right before packaging the -files. The script is not called by e.g.: ``make install``. diff --git a/Modules/CPack.cmake b/Modules/CPack.cmake index c9008db..8a6a712 100644 --- a/Modules/CPack.cmake +++ b/Modules/CPack.cmake @@ -325,7 +325,21 @@ The following variables are for advanced uses of CPack: .. variable:: CPACK_INSTALL_COMMANDS - Extra commands to install components. + Extra commands to install components. The environment variable + ``CMAKE_INSTALL_PREFIX`` is set to the temporary install directory + during execution. + +.. variable:: CPACK_INSTALL_SCRIPTS + + Extra CMake scripts executed by CPack during its local staging + installation, which is done right before packaging the files. + The scripts are not called by a standalone install (e.g.: ``make install``). + For every script, the following variables will be set: + :variable:`CMAKE_CURRENT_SOURCE_DIR`, :variable:`CMAKE_CURRENT_BINARY_DIR` + and :variable:`CMAKE_INSTALL_PREFIX` (which is set to the staging install + directory). The singular form ``CMAKE_INSTALL_SCRIPT`` is supported as + an alternative variable for historical reasons, but its value is ignored if + ``CMAKE_INSTALL_SCRIPTS`` is set and a warning will be issued. .. variable:: CPACK_INSTALLED_DIRECTORIES diff --git a/Modules/CheckCXXSymbolExists.cmake b/Modules/CheckCXXSymbolExists.cmake index b112094..5c9079d 100644 --- a/Modules/CheckCXXSymbolExists.cmake +++ b/Modules/CheckCXXSymbolExists.cmake @@ -27,6 +27,17 @@ Check if a symbol exists as a function, variable, or macro in ``C++``. not be recognized: consider using the :module:`CheckTypeSize` or :module:`CheckCXXSourceCompiles` module instead. +.. note:: + + This command is unreliable when ``<symbol>`` is (potentially) an overloaded + function. Since there is no reliable way to predict whether a given function + in the system environment may be defined as an overloaded function or may be + an overloaded function on other systems or will become so in the future, it + is generally advised to use the :module:`CheckCXXSourceCompiles` module for + checking any function symbol (unless somehow you surely know the checked + function is not overloaded on other systems or will not be so in the + future). + The following variables may be set before calling this macro to modify the way the check is run: diff --git a/Modules/CheckSymbolExists.cmake b/Modules/CheckSymbolExists.cmake index c2f488a..1053383 100644 --- a/Modules/CheckSymbolExists.cmake +++ b/Modules/CheckSymbolExists.cmake @@ -99,8 +99,28 @@ macro(__CHECK_SYMBOL_EXISTS_IMPL SOURCEFILE SYMBOL FILES VARIABLE) string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT "#include <${FILE}>\n") endforeach() - string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT - "\nint main(int argc, char** argv)\n{\n (void)argv;\n#ifndef ${SYMBOL}\n return ((int*)(&${SYMBOL}))[argc];\n#else\n (void)argc;\n return 0;\n#endif\n}\n") + string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT " +int main(int argc, char** argv) +{ + (void)argv;") + set(_CSE_CHECK_NON_MACRO "return ((int*)(&${SYMBOL}))[argc];") + if("${SYMBOL}" MATCHES "^[a-zA-Z_][a-zA-Z0-9_]*$") + # The SYMBOL has a legal macro name. Test whether it exists as a macro. + string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT " +#ifndef ${SYMBOL} + ${_CSE_CHECK_NON_MACRO} +#else + (void)argc; + return 0; +#endif") + else() + # The SYMBOL cannot be a macro (e.g., a template function). + string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT " + ${_CSE_CHECK_NON_MACRO}") + endif() + string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT " +}") + unset(_CSE_CHECK_NON_MACRO) configure_file("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in" "${SOURCEFILE}" @ONLY) @@ -139,6 +159,7 @@ macro(__CHECK_SYMBOL_EXISTS_IMPL SOURCEFILE SYMBOL FILES VARIABLE) "${OUTPUT}\nFile ${SOURCEFILE}:\n" "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n") endif() + unset(CMAKE_CONFIGURABLE_FILE_CONTENT) endif() endmacro() diff --git a/Modules/Compiler/Clang-CXX.cmake b/Modules/Compiler/Clang-CXX.cmake index 17f3917..61709f8 100644 --- a/Modules/Compiler/Clang-CXX.cmake +++ b/Modules/Compiler/Clang-CXX.cmake @@ -58,6 +58,13 @@ if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU") unset(_clang_version_std17) if("x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") + # The MSVC standard library requires C++14, and MSVC itself has no + # notion of operating in a mode not aware of at least that standard. + set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++14") + set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++14") + set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++14") + set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++14") + # This clang++ is missing some features because of MSVC compatibility. unset(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT) unset(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT) diff --git a/Modules/ExternalProject.cmake b/Modules/ExternalProject.cmake index 20b37d2..14fc231 100644 --- a/Modules/ExternalProject.cmake +++ b/Modules/ExternalProject.cmake @@ -261,7 +261,9 @@ External Project Definition ``GIT_SUBMODULES <module>...`` Specific git submodules that should also be updated. If this option is - not provided, all git submodules will be updated. + not provided, all git submodules will be updated. When :policy:`CMP0097` + is set to ``NEW`` if this value is set to an empty string then no submodules + are initialized or updated. ``GIT_SHALLOW <bool>`` When this option is enabled, the ``git clone`` operation will be given @@ -1016,6 +1018,9 @@ function(_ep_parse_arguments f name ns args) endif() else() set(key "${arg}") + if(key MATCHES GIT) + get_property(have_key TARGET ${name} PROPERTY ${ns}${key} SET) + endif() endif() endforeach() endfunction() @@ -1060,7 +1065,7 @@ define_property(DIRECTORY PROPERTY "EP_UPDATE_DISCONNECTED" INHERITED "ExternalProject module." ) -function(_ep_write_gitclone_script script_filename source_dir git_EXECUTABLE git_repository git_tag git_remote_name git_submodules git_shallow git_progress git_config src_name work_dir gitclone_infofile gitclone_stampfile tls_verify) +function(_ep_write_gitclone_script script_filename source_dir git_EXECUTABLE git_repository git_tag git_remote_name init_submodules git_submodules git_shallow git_progress git_config src_name work_dir gitclone_infofile gitclone_stampfile tls_verify) if(NOT GIT_VERSION_STRING VERSION_LESS 1.8.5) # Use `git checkout <tree-ish> --` to avoid ambiguity with a local path. set(git_checkout_explicit-- "--") @@ -1145,11 +1150,14 @@ if(error_code) message(FATAL_ERROR \"Failed to checkout tag: '${git_tag}'\") endif() -execute_process( - COMMAND \"${git_EXECUTABLE}\" ${git_options} submodule update --recursive --init ${git_submodules} - WORKING_DIRECTORY \"${work_dir}/${src_name}\" - RESULT_VARIABLE error_code - ) +set(init_submodules ${init_submodules}) +if(init_submodules) + execute_process( + COMMAND \"${git_EXECUTABLE}\" ${git_options} submodule update --recursive --init ${git_submodules} + WORKING_DIRECTORY \"${work_dir}/${src_name}\" + RESULT_VARIABLE error_code + ) +endif() if(error_code) message(FATAL_ERROR \"Failed to update submodules in: '${work_dir}/${src_name}'\") endif() @@ -1226,7 +1234,7 @@ endif() endfunction() -function(_ep_write_gitupdate_script script_filename git_EXECUTABLE git_tag git_remote_name git_submodules git_repository work_dir) +function(_ep_write_gitupdate_script script_filename git_EXECUTABLE git_tag git_remote_name init_submodules git_submodules git_repository work_dir) if("${git_tag}" STREQUAL "") message(FATAL_ERROR "Tag for git checkout should not be empty.") endif() @@ -1383,11 +1391,14 @@ if(error_code OR is_remote_ref OR NOT (\"\${tag_sha}\" STREQUAL \"\${head_sha}\" endif() endif() - execute_process( - COMMAND \"${git_EXECUTABLE}\" submodule update --recursive --init ${git_submodules} - WORKING_DIRECTORY \"${work_dir}/${src_name}\" - RESULT_VARIABLE error_code - ) + set(init_submodules ${init_submodules}) + if(init_submodules) + execute_process( + COMMAND \"${git_EXECUTABLE}\" submodule update --recursive --init ${git_submodules} + WORKING_DIRECTORY \"${work_dir}/${src_name}\" + RESULT_VARIABLE error_code + ) + endif() if(error_code) message(FATAL_ERROR \"Failed to update submodules in: '${work_dir}/${src_name}'\") endif() @@ -1972,7 +1983,7 @@ endif() set(stderr_log "${logbase}-err.log") endif() set(code " -cmake_minimum_required(VERSION 3.13) +cmake_minimum_required(VERSION 3.15) ${code_cygpath_make} set(command \"${command}\") set(log_merged \"${log_merged}\") @@ -2420,7 +2431,15 @@ function(_ep_add_download_command name) if(NOT git_tag) set(git_tag "master") endif() - get_property(git_submodules TARGET ${name} PROPERTY _EP_GIT_SUBMODULES) + + set(git_init_submodules TRUE) + get_property(git_submodules_set TARGET ${name} PROPERTY _EP_GIT_SUBMODULES SET) + if(git_submodules_set) + get_property(git_submodules TARGET ${name} PROPERTY _EP_GIT_SUBMODULES) + if(git_submodules STREQUAL "" AND _EP_CMP0097 STREQUAL "NEW") + set(git_init_submodules FALSE) + endif() + endif() get_property(git_remote_name TARGET ${name} PROPERTY _EP_GIT_REMOTE_NAME) if(NOT git_remote_name) @@ -2458,7 +2477,7 @@ function(_ep_add_download_command name) # The script will delete the source directory and then call git clone. # _ep_write_gitclone_script(${tmp_dir}/${name}-gitclone.cmake ${source_dir} - ${GIT_EXECUTABLE} ${git_repository} ${git_tag} ${git_remote_name} "${git_submodules}" "${git_shallow}" "${git_progress}" "${git_config}" ${src_name} ${work_dir} + ${GIT_EXECUTABLE} ${git_repository} ${git_tag} ${git_remote_name} ${git_init_submodules} "${git_submodules}" "${git_shallow}" "${git_progress}" "${git_config}" ${src_name} ${work_dir} ${stamp_dir}/${name}-gitinfo.txt ${stamp_dir}/${name}-gitclone-lastrun.txt "${tls_verify}" ) set(comment "Performing download step (git clone) for '${name}'") @@ -2723,9 +2742,18 @@ function(_ep_add_update_command name) if(NOT git_remote_name) set(git_remote_name "origin") endif() - get_property(git_submodules TARGET ${name} PROPERTY _EP_GIT_SUBMODULES) + + set(git_init_submodules TRUE) + get_property(git_submodules_set TARGET ${name} PROPERTY _EP_GIT_SUBMODULES SET) + if(git_submodules_set) + get_property(git_submodules TARGET ${name} PROPERTY _EP_GIT_SUBMODULES) + if(git_submodules STREQUAL "" AND _EP_CMP0097 STREQUAL "NEW") + set(git_init_submodules FALSE) + endif() + endif() + _ep_write_gitupdate_script(${tmp_dir}/${name}-gitupdate.cmake - ${GIT_EXECUTABLE} ${git_tag} ${git_remote_name} "${git_submodules}" ${git_repository} ${work_dir} + ${GIT_EXECUTABLE} ${git_tag} ${git_remote_name} ${git_init_submodules} "${git_submodules}" ${git_repository} ${work_dir} ) set(cmd ${CMAKE_COMMAND} -P ${tmp_dir}/${name}-gitupdate.cmake) set(always 1) @@ -3138,6 +3166,10 @@ endfunction() function(ExternalProject_Add name) + cmake_policy(GET CMP0097 _EP_CMP0097 + PARENT_SCOPE # undocumented, do not use outside of CMake + ) + _ep_get_configuration_subdir_suffix(cfgdir) # Add a custom target for the external project. diff --git a/Modules/FindMPI.cmake b/Modules/FindMPI.cmake index 2ff6afe..a79758f 100644 --- a/Modules/FindMPI.cmake +++ b/Modules/FindMPI.cmake @@ -1147,9 +1147,7 @@ macro(_MPI_create_imported_target LANG) set_property(TARGET MPI::MPI_${LANG} PROPERTY INTERFACE_COMPILE_DEFINITIONS "${MPI_${LANG}_COMPILE_DEFINITIONS}") if(MPI_${LANG}_LINK_FLAGS) - separate_arguments(_MPI_${LANG}_LINK_FLAGS NATIVE_COMMAND "${MPI_${LANG}_LINK_FLAGS}") - set_property(TARGET MPI::MPI_${LANG} PROPERTY INTERFACE_LINK_OPTIONS "${_MPI_${LANG}_LINK_FLAGS}") - unset(_MPI_${LANG}_LINK_FLAGS) + set_property(TARGET MPI::MPI_${LANG} PROPERTY INTERFACE_LINK_OPTIONS "SHELL:${MPI_${LANG}_LINK_FLAGS}") endif() # If the compiler links MPI implicitly, no libraries will be found as they're contained within # CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES already. diff --git a/Modules/InstallRequiredSystemLibraries.cmake b/Modules/InstallRequiredSystemLibraries.cmake index 0a98895..e3eeea4 100644 --- a/Modules/InstallRequiredSystemLibraries.cmake +++ b/Modules/InstallRequiredSystemLibraries.cmake @@ -210,8 +210,8 @@ if(MSVC) set(_MSVC_IDE_VERSION "") if(MSVC_VERSION GREATER_EQUAL 2000) message(WARNING "MSVC ${MSVC_VERSION} not yet supported.") - elseif(MSVC_VERSION_VERSION GREATER_EQUAL 143) - message(WARNING "MSVC toolset v${MSVC_VERSION_VERSION} not yet supported.") + elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 143) + message(WARNING "MSVC toolset v${MSVC_TOOLSET_VERSION} not yet supported.") elseif(MSVC_TOOLSET_VERSION EQUAL 142) set(MSVC_REDIST_NAME VC142) set(_MSVC_DLL_VERSION 140) @@ -251,10 +251,18 @@ if(MSVC) endif() if(NOT vs VERSION_LESS 15) set(_vs_redist_paths "") - cmake_host_system_information(RESULT _vs_dir QUERY VS_${vs}_DIR) # undocumented query - if(IS_DIRECTORY "${_vs_dir}") - file(GLOB _vs_redist_paths "${_vs_dir}/VC/Redist/MSVC/*") - endif() + # The toolset and its redistributables may come with any VS version 15 or newer. + set(_MSVC_IDE_VERSIONS 16 15) + foreach(_vs_ver ${_MSVC_IDE_VERSIONS}) + set(_vs_glob_redist_paths "") + cmake_host_system_information(RESULT _vs_dir QUERY VS_${_vs_ver}_DIR) # undocumented query + if(IS_DIRECTORY "${_vs_dir}") + file(GLOB _vs_glob_redist_paths "${_vs_dir}/VC/Redist/MSVC/*") + list(APPEND _vs_redist_paths ${_vs_glob_redist_paths}) + endif() + unset(_vs_glob_redist_paths) + endforeach() + unset(_MSVC_IDE_VERSIONS) unset(_vs_dir) else() get_filename_component(_vs_dir diff --git a/Modules/Platform/Android-Clang.cmake b/Modules/Platform/Android-Clang.cmake index 9ed1e01..847178f 100644 --- a/Modules/Platform/Android-Clang.cmake +++ b/Modules/Platform/Android-Clang.cmake @@ -40,6 +40,9 @@ macro(__android_compiler_clang lang) endif() if(NOT CMAKE_${lang}_COMPILER_TARGET) set(CMAKE_${lang}_COMPILER_TARGET "${_ANDROID_ABI_CLANG_TARGET}") + if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED) + string(APPEND CMAKE_${lang}_COMPILER_TARGET "${CMAKE_SYSTEM_VERSION}") + endif() list(APPEND CMAKE_${lang}_COMPILER_PREDEFINES_COMMAND "--target=${CMAKE_${lang}_COMPILER_TARGET}") endif() endmacro() diff --git a/Modules/Platform/Android-Common.cmake b/Modules/Platform/Android-Common.cmake index f8b9346..1affcd0 100644 --- a/Modules/Platform/Android-Common.cmake +++ b/Modules/Platform/Android-Common.cmake @@ -47,7 +47,41 @@ if(CMAKE_ANDROID_NDK) endif() if(CMAKE_ANDROID_STL_TYPE) - if(CMAKE_ANDROID_NDK) + if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED) + if(CMAKE_ANDROID_STL_TYPE STREQUAL "system") + set(_ANDROID_STL_EXCEPTIONS 0) + set(_ANDROID_STL_RTTI 0) + macro(__android_stl lang) + string(APPEND CMAKE_${lang}_FLAGS_INIT " -stdlib=libstdc++") + endmacro() + elseif(CMAKE_ANDROID_STL_TYPE STREQUAL "c++_static") + set(_ANDROID_STL_EXCEPTIONS 1) + set(_ANDROID_STL_RTTI 1) + macro(__android_stl lang) + string(APPEND CMAKE_${lang}_FLAGS_INIT " -stdlib=libc++") + string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " -static-libstdc++") + endmacro() + elseif(CMAKE_ANDROID_STL_TYPE STREQUAL "c++_shared") + set(_ANDROID_STL_EXCEPTIONS 1) + set(_ANDROID_STL_RTTI 1) + macro(__android_stl lang) + string(APPEND CMAKE_${lang}_FLAGS_INIT " -stdlib=libc++") + endmacro() + elseif(CMAKE_ANDROID_STL_TYPE STREQUAL "none") + set(_ANDROID_STL_RTTI 0) + set(_ANDROID_STL_EXCEPTIONS 0) + macro(__android_stl lang) + # FIXME: Add a way to add project-wide language-specific compile-only flags. + set(CMAKE_CXX_COMPILE_OBJECT + "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT> -c <SOURCE> -nostdinc++") + string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " -nostdlib++") + endmacro() + else() + message(FATAL_ERROR + "Android: STL '${CMAKE_ANDROID_STL_TYPE}' not supported by this NDK." + ) + endif() + elseif(CMAKE_ANDROID_NDK) macro(__android_stl_inc lang dir req) if(EXISTS "${dir}") @@ -152,6 +186,10 @@ macro(__android_compiler_common lang) __android_stl(CXX) endif() + if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED) + string(APPEND CMAKE_${lang}_STANDARD_LIBRARIES " -latomic -lm") + endif() + # <ndk>/build/core/definitions.mk appends the sysroot's include directory # explicitly at the end of the command-line include path so that it # precedes the toolchain's builtin include directories. This is @@ -161,7 +199,7 @@ macro(__android_compiler_common lang) # # Do not do this for a standalone toolchain because it is already # tied to a specific API version. - if(CMAKE_ANDROID_NDK) + if(CMAKE_ANDROID_NDK AND NOT CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED) if(CMAKE_SYSROOT_COMPILE) set(_cmake_sysroot_compile "${CMAKE_SYSROOT_COMPILE}") else() @@ -170,7 +208,7 @@ macro(__android_compiler_common lang) if(NOT CMAKE_ANDROID_NDK_DEPRECATED_HEADERS) list(APPEND CMAKE_${lang}_STANDARD_INCLUDE_DIRECTORIES "${_cmake_sysroot_compile}/usr/include" - "${_cmake_sysroot_compile}/usr/include/${CMAKE_ANDROID_ARCH_HEADER_TRIPLE}" + "${_cmake_sysroot_compile}/usr/include/${CMAKE_ANDROID_ARCH_TRIPLE}" ) else() list(APPEND CMAKE_${lang}_STANDARD_INCLUDE_DIRECTORIES "${_cmake_sysroot_compile}/usr/include") diff --git a/Modules/Platform/Android-Determine.cmake b/Modules/Platform/Android-Determine.cmake index bb42eed..e7c1b48 100644 --- a/Modules/Platform/Android-Determine.cmake +++ b/Modules/Platform/Android-Determine.cmake @@ -198,32 +198,66 @@ if(NOT CMAKE_SYSTEM_VERSION MATCHES "^[0-9]+$") message(FATAL_ERROR "Android: The API specified by CMAKE_SYSTEM_VERSION='${CMAKE_SYSTEM_VERSION}' is not an integer.") endif() +if(CMAKE_ANDROID_NDK) + # Identify the host platform. + if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin") + if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "x86_64") + set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "darwin-x86_64") + else() + set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "darwin-x86") + endif() + elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux") + if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "x86_64") + set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "linux-x86_64") + else() + set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "linux-x86") + endif() + elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") + if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "AMD64") + set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "windows-x86_64") + else() + set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "windows") + endif() + else() + message(FATAL_ERROR "Android: Builds hosted on '${CMAKE_HOST_SYSTEM_NAME}' not supported.") + endif() + + # Look for a unified toolchain/sysroot provided with the NDK. + set(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED "${CMAKE_ANDROID_NDK}/toolchains/llvm/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}") + if(NOT IS_DIRECTORY "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/sysroot") + set(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED "") + endif() +else() + set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG "") + set(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED "") +endif() + # https://developer.android.com/ndk/guides/abis.html set(_ANDROID_ABI_arm64-v8a_PROC "aarch64") set(_ANDROID_ABI_arm64-v8a_ARCH "arm64") -set(_ANDROID_ABI_arm64-v8a_HEADER "aarch64-linux-android") +set(_ANDROID_ABI_arm64-v8a_TRIPLE "aarch64-linux-android") set(_ANDROID_ABI_armeabi-v7a_PROC "armv7-a") set(_ANDROID_ABI_armeabi-v7a_ARCH "arm") -set(_ANDROID_ABI_armeabi-v7a_HEADER "arm-linux-androideabi") +set(_ANDROID_ABI_armeabi-v7a_TRIPLE "arm-linux-androideabi") set(_ANDROID_ABI_armeabi-v6_PROC "armv6") set(_ANDROID_ABI_armeabi-v6_ARCH "arm") -set(_ANDROID_ABI_armeabi-v6_HEADER "arm-linux-androideabi") +set(_ANDROID_ABI_armeabi-v6_TRIPLE "arm-linux-androideabi") set(_ANDROID_ABI_armeabi_PROC "armv5te") set(_ANDROID_ABI_armeabi_ARCH "arm") -set(_ANDROID_ABI_armeabi_HEADER "arm-linux-androideabi") +set(_ANDROID_ABI_armeabi_TRIPLE "arm-linux-androideabi") set(_ANDROID_ABI_mips_PROC "mips") set(_ANDROID_ABI_mips_ARCH "mips") -set(_ANDROID_ABI_mips_HEADER "mipsel-linux-android") +set(_ANDROID_ABI_mips_TRIPLE "mipsel-linux-android") set(_ANDROID_ABI_mips64_PROC "mips64") set(_ANDROID_ABI_mips64_ARCH "mips64") -set(_ANDROID_ABI_mips64_HEADER "mips64el-linux-android") +set(_ANDROID_ABI_mips64_TRIPLE "mips64el-linux-android") set(_ANDROID_ABI_x86_PROC "i686") set(_ANDROID_ABI_x86_ARCH "x86") -set(_ANDROID_ABI_x86_HEADER "i686-linux-android") +set(_ANDROID_ABI_x86_TRIPLE "i686-linux-android") set(_ANDROID_ABI_x86_64_PROC "x86_64") set(_ANDROID_ABI_x86_64_ARCH "x86_64") -set(_ANDROID_ABI_x86_64_HEADER "x86_64-linux-android") +set(_ANDROID_ABI_x86_64_TRIPLE "x86_64-linux-android") set(_ANDROID_PROC_aarch64_ARCH_ABI "arm64-v8a") set(_ANDROID_PROC_armv7-a_ARCH_ABI "armeabi-v7a") @@ -308,7 +342,7 @@ if(_ANDROID_SYSROOT_ARCH AND NOT "x${_ANDROID_SYSROOT_ARCH}" STREQUAL "x${CMAKE_ "does not match architecture '${CMAKE_ANDROID_ARCH}' for the ABI '${CMAKE_ANDROID_ARCH_ABI}'." ) endif() -set(CMAKE_ANDROID_ARCH_HEADER_TRIPLE "${_ANDROID_ABI_${CMAKE_ANDROID_ARCH_ABI}_HEADER}") +set(CMAKE_ANDROID_ARCH_TRIPLE "${_ANDROID_ABI_${CMAKE_ANDROID_ARCH_ABI}_TRIPLE}") # Select a processor. if(NOT CMAKE_SYSTEM_PROCESSOR) @@ -321,7 +355,7 @@ if(NOT _ANDROID_ABI_${CMAKE_ANDROID_ARCH_ABI}_PROC STREQUAL CMAKE_SYSTEM_PROCESS endif() if(CMAKE_ANDROID_NDK AND NOT DEFINED CMAKE_ANDROID_NDK_DEPRECATED_HEADERS) - if(IS_DIRECTORY "${CMAKE_ANDROID_NDK}/sysroot/usr/include/${CMAKE_ANDROID_ARCH_HEADER_TRIPLE}") + if(IS_DIRECTORY "${CMAKE_ANDROID_NDK}/sysroot/usr/include/${CMAKE_ANDROID_ARCH_TRIPLE}") # Unified headers exist so we use them by default. set(CMAKE_ANDROID_NDK_DEPRECATED_HEADERS 0) else() @@ -340,8 +374,10 @@ set(CMAKE_ANDROID_ARCH_ABI \"${CMAKE_ANDROID_ARCH_ABI}\") if(CMAKE_ANDROID_NDK) string(APPEND CMAKE_SYSTEM_CUSTOM_CODE - "set(CMAKE_ANDROID_ARCH_HEADER_TRIPLE \"${CMAKE_ANDROID_ARCH_HEADER_TRIPLE}\")\n" + "set(CMAKE_ANDROID_ARCH_TRIPLE \"${CMAKE_ANDROID_ARCH_TRIPLE}\")\n" "set(CMAKE_ANDROID_NDK_DEPRECATED_HEADERS \"${CMAKE_ANDROID_NDK_DEPRECATED_HEADERS}\")\n" + "set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG \"${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}\")\n" + "set(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED \"${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}\")\n" ) endif() diff --git a/Modules/Platform/Android-Initialize.cmake b/Modules/Platform/Android-Initialize.cmake index a434f90..a5d2820 100644 --- a/Modules/Platform/Android-Initialize.cmake +++ b/Modules/Platform/Android-Initialize.cmake @@ -17,6 +17,13 @@ if(CMAKE_SYSTEM_VERSION EQUAL 1) return() endif() +set(CMAKE_BUILD_TYPE_INIT Debug) + +# Skip sysroot selection if the NDK has a unified toolchain. +if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED) + return() +endif() + if(NOT CMAKE_SYSROOT) if(CMAKE_ANDROID_NDK) set(CMAKE_SYSROOT "${CMAKE_ANDROID_NDK}/platforms/android-${CMAKE_SYSTEM_VERSION}/arch-${CMAKE_ANDROID_ARCH}") @@ -40,5 +47,3 @@ else() "Android: No CMAKE_SYSROOT was selected." ) endif() - -set(CMAKE_BUILD_TYPE_INIT Debug) diff --git a/Modules/Platform/Android/Determine-Compiler-NDK.cmake b/Modules/Platform/Android/Determine-Compiler-NDK.cmake index 5f2cc52..e009c10 100644 --- a/Modules/Platform/Android/Determine-Compiler-NDK.cmake +++ b/Modules/Platform/Android/Determine-Compiler-NDK.cmake @@ -1,6 +1,31 @@ # Distributed under the OSI-approved BSD 3-Clause License. See accompanying # file Copyright.txt or https://cmake.org/licensing for details. +# In Android NDK r19 and above there is a single clang toolchain. +if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED) + if(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION AND NOT CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION STREQUAL "clang") + message(FATAL_ERROR + "Android: The CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION value '${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}' " + "is not supported by this NDK. It must be 'clang' or not set at all." + ) + endif() + message(STATUS "Android: Selected unified Clang toolchain") + set(_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION "clang") + set(_ANDROID_TOOL_C_COMPILER "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/clang${_ANDROID_HOST_EXT}") + set(_ANDROID_TOOL_C_TOOLCHAIN_MACHINE "${CMAKE_ANDROID_ARCH_TRIPLE}") + set(_ANDROID_TOOL_C_TOOLCHAIN_VERSION "") + set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN "") + set(_ANDROID_TOOL_C_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/${CMAKE_ANDROID_ARCH_TRIPLE}-") + set(_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX "${_ANDROID_HOST_EXT}") + set(_ANDROID_TOOL_CXX_COMPILER "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/clang++${_ANDROID_HOST_EXT}") + set(_ANDROID_TOOL_CXX_TOOLCHAIN_MACHINE "${CMAKE_ANDROID_ARCH_TRIPLE}") + set(_ANDROID_TOOL_CXX_TOOLCHAIN_VERSION "") + set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "") + set(_ANDROID_TOOL_CXX_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/${CMAKE_ANDROID_ARCH_TRIPLE}-") + set(_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX "${_ANDROID_HOST_EXT}") + return() +endif() + # In Android NDK releases there is build system toolchain selection logic in # these files: # @@ -195,40 +220,16 @@ if(NOT _ANDROID_TOOL_PREFIX AND "${_ANDROID_TOOL_NAME}" MATCHES "^(.*-)[0-9.]+$" set(_ANDROID_TOOL_PREFIX "${CMAKE_MATCH_1}") endif() -# Identify the host platform. -if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin") - if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "x86_64") - set(_ANDROID_HOST_DIR "darwin-x86_64") - else() - set(_ANDROID_HOST_DIR "darwin-x86") - endif() -elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux") - if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "x86_64") - set(_ANDROID_HOST_DIR "linux-x86_64") - else() - set(_ANDROID_HOST_DIR "linux-x86") - endif() -elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") - if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "AMD64") - set(_ANDROID_HOST_DIR "windows-x86_64") - else() - set(_ANDROID_HOST_DIR "windows") - endif() -else() - message(FATAL_ERROR "Android: Builds hosted on '${CMAKE_HOST_SYSTEM_NAME}' not supported.") -endif() - # Help CMakeFindBinUtils locate things. set(_CMAKE_TOOLCHAIN_PREFIX "${_ANDROID_TOOL_PREFIX}") -set(_ANDROID_TOOL_NDK_TOOLCHAIN_HOST_TAG "${_ANDROID_HOST_DIR}") set(_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION "${_ANDROID_TOOL_VERS_NDK}") # _ANDROID_TOOL_PREFIX should now match `gcc -dumpmachine`. string(REGEX REPLACE "-$" "" _ANDROID_TOOL_C_TOOLCHAIN_MACHINE "${_ANDROID_TOOL_PREFIX}") set(_ANDROID_TOOL_C_TOOLCHAIN_VERSION "${_ANDROID_TOOL_VERS}") -set(_ANDROID_TOOL_C_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_NAME}/prebuilt/${_ANDROID_HOST_DIR}/bin/${_ANDROID_TOOL_PREFIX}") +set(_ANDROID_TOOL_C_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}/bin/${_ANDROID_TOOL_PREFIX}") set(_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX "${_ANDROID_HOST_EXT}") set(_ANDROID_TOOL_CXX_TOOLCHAIN_MACHINE "${_ANDROID_TOOL_C_TOOLCHAIN_MACHINE}") @@ -238,9 +239,9 @@ set(_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX "${_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX}") if(_ANDROID_TOOL_CLANG_NAME) message(STATUS "Android: Selected Clang toolchain '${_ANDROID_TOOL_CLANG_NAME}' with GCC toolchain '${_ANDROID_TOOL_NAME}'") - set(_ANDROID_TOOL_C_COMPILER "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_LLVM_NAME}/prebuilt/${_ANDROID_HOST_DIR}/bin/clang${_ANDROID_HOST_EXT}") - set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN ${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_NAME}/prebuilt/${_ANDROID_HOST_DIR}) - set(_ANDROID_TOOL_CXX_COMPILER "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_LLVM_NAME}/prebuilt/${_ANDROID_HOST_DIR}/bin/clang++${_ANDROID_HOST_EXT}") + set(_ANDROID_TOOL_C_COMPILER "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_LLVM_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}/bin/clang${_ANDROID_HOST_EXT}") + set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN ${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}) + set(_ANDROID_TOOL_CXX_COMPILER "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_LLVM_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}/bin/clang++${_ANDROID_HOST_EXT}") set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "${_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN}") else() message(STATUS "Android: Selected GCC toolchain '${_ANDROID_TOOL_NAME}'") @@ -267,4 +268,3 @@ unset(_ANDROID_TOOL_PREFIX) unset(_ANDROID_TOOL_CLANG_NAME) unset(_ANDROID_TOOL_CLANG_VERS) unset(_ANDROID_TOOL_LLVM_NAME) -unset(_ANDROID_HOST_DIR) diff --git a/Modules/Platform/Android/Determine-Compiler-Standalone.cmake b/Modules/Platform/Android/Determine-Compiler-Standalone.cmake index 4c1ac1f..5095aff 100644 --- a/Modules/Platform/Android/Determine-Compiler-Standalone.cmake +++ b/Modules/Platform/Android/Determine-Compiler-Standalone.cmake @@ -62,5 +62,4 @@ else() set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "") endif() -set(_ANDROID_TOOL_NDK_TOOLCHAIN_HOST_TAG "") set(_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION "") diff --git a/Modules/Platform/Android/Determine-Compiler.cmake b/Modules/Platform/Android/Determine-Compiler.cmake index a03ebcc..5c6b97b 100644 --- a/Modules/Platform/Android/Determine-Compiler.cmake +++ b/Modules/Platform/Android/Determine-Compiler.cmake @@ -40,7 +40,6 @@ if(CMAKE_ANDROID_NDK) elseif(CMAKE_ANDROID_STANDALONE_TOOLCHAIN) include(Platform/Android/Determine-Compiler-Standalone) else() - set(_ANDROID_TOOL_NDK_TOOLCHAIN_HOST_TAG "") set(_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION "") set(_ANDROID_TOOL_C_COMPILER "") set(_ANDROID_TOOL_C_TOOLCHAIN_MACHINE "") @@ -65,7 +64,6 @@ macro(__android_determine_compiler lang) # Save the Android-specific information in CMake${lang}Compiler.cmake. set(CMAKE_${lang}_COMPILER_CUSTOM_CODE " -set(CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG \"${_ANDROID_TOOL_NDK_TOOLCHAIN_HOST_TAG}\") set(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION \"${_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION}\") set(CMAKE_${lang}_ANDROID_TOOLCHAIN_MACHINE \"${_ANDROID_TOOL_${lang}_TOOLCHAIN_MACHINE}\") set(CMAKE_${lang}_ANDROID_TOOLCHAIN_VERSION \"${_ANDROID_TOOL_${lang}_TOOLCHAIN_VERSION}\") diff --git a/Modules/Platform/Android/abi-common.cmake b/Modules/Platform/Android/abi-common.cmake index 6bce3c7..b01ef61 100644 --- a/Modules/Platform/Android/abi-common.cmake +++ b/Modules/Platform/Android/abi-common.cmake @@ -3,7 +3,7 @@ string(APPEND _ANDROID_ABI_INIT_CFLAGS " -no-canonical-prefixes" ) -if(CMAKE_ANDROID_NDK AND NOT CMAKE_ANDROID_NDK_DEPRECATED_HEADERS) +if(CMAKE_ANDROID_NDK AND NOT CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED AND NOT CMAKE_ANDROID_NDK_DEPRECATED_HEADERS) string(APPEND _ANDROID_ABI_INIT_CFLAGS " -D__ANDROID_API__=${CMAKE_SYSTEM_VERSION}") endif() diff --git a/Source/.gitattributes b/Source/.gitattributes index 7c160cc..d0aedc2 100644 --- a/Source/.gitattributes +++ b/Source/.gitattributes @@ -1,2 +1,4 @@ +CMakeVersion.cmake export-subst + # Do not format third-party sources. /kwsys/** -format.clang-format-6.0 diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index 0316532..041c606 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -142,6 +142,7 @@ set(SRCS cmAffinity.cxx cmAffinity.h + cmAlgorithms.h cmArchiveWrite.cxx cmArgumentParser.cxx cmArgumentParser.h @@ -403,6 +404,7 @@ set(SRCS cmStateSnapshot.cxx cmStateSnapshot.h cmStateTypes.h + cmStringAlgorithms.h cmSystemTools.cxx cmSystemTools.h cmTarget.cxx @@ -662,8 +664,6 @@ set(SRCS cmTryCompileCommand.h cmTryRunCommand.cxx cmTryRunCommand.h - cmUnexpectedCommand.cxx - cmUnexpectedCommand.h cmUnsetCommand.cxx cmUnsetCommand.h cmUseMangledMesaCommand.cxx @@ -1161,6 +1161,21 @@ include (${CMake_BINARY_DIR}/Source/LocalUserOptions.cmake OPTIONAL) include (${CMake_SOURCE_DIR}/Source/LocalUserOptions.cmake OPTIONAL) if(WIN32) + # Compute the binary version that appears in the RC file. Version + # components in the RC file are 16-bit integers so we may have to + # split the patch component. + if(CMake_VERSION_PATCH MATCHES "^([0-9]+)([0-9][0-9][0-9][0-9])$") + set(CMake_RCVERSION_YEAR "${CMAKE_MATCH_1}") + set(CMake_RCVERSION_MONTH_DAY "${CMAKE_MATCH_2}") + string(REGEX REPLACE "^0+" "" CMake_RCVERSION_MONTH_DAY "${CMake_RCVERSION_MONTH_DAY}") + set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMake_RCVERSION_YEAR},${CMake_RCVERSION_MONTH_DAY}) + unset(CMake_RCVERSION_MONTH_DAY) + unset(CMake_RCVERSION_YEAR) + else() + set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMake_VERSION_PATCH}) + endif() + set(CMake_RCVERSION_STR ${CMake_VERSION}) + # Add Windows executable version information. configure_file("CMakeVersion.rc.in" "CMakeVersion.rc" @ONLY) diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake index 1a0e0d3..63a4207 100644 --- a/Source/CMakeVersion.cmake +++ b/Source/CMakeVersion.cmake @@ -1,5 +1,82 @@ # CMake version number components. set(CMake_VERSION_MAJOR 3) set(CMake_VERSION_MINOR 15) -set(CMake_VERSION_PATCH 20190720) -#set(CMake_VERSION_RC 1) +set(CMake_VERSION_PATCH 20190730) +#set(CMake_VERSION_RC 0) +set(CMake_VERSION_IS_DIRTY 0) + +# Start with the full version number used in tags. It has no dev info. +set(CMake_VERSION + "${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}.${CMake_VERSION_PATCH}") +if(DEFINED CMake_VERSION_RC) + set(CMake_VERSION "${CMake_VERSION}-rc${CMake_VERSION_RC}") +endif() + +# Releases define a small patch level. +if("${CMake_VERSION_PATCH}" VERSION_LESS 20000000) + set(CMake_VERSION_IS_RELEASE 1) +else() + set(CMake_VERSION_IS_RELEASE 0) +endif() + +if(EXISTS ${CMake_SOURCE_DIR}/.git) + find_package(Git QUIET) + if(GIT_FOUND) + macro(_git) + execute_process( + COMMAND ${GIT_EXECUTABLE} ${ARGN} + WORKING_DIRECTORY ${CMake_SOURCE_DIR} + RESULT_VARIABLE _git_res + OUTPUT_VARIABLE _git_out OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_VARIABLE _git_err ERROR_STRIP_TRAILING_WHITESPACE + ) + endmacro() + endif() +endif() + +# Try to identify the current development source version. +if(COMMAND _git) + # Get the commit checked out in this work tree. + _git(log -n 1 HEAD "--pretty=format:%h %s" --) + set(git_info "${_git_out}") +else() + # Get the commit exported by 'git archive'. + set(git_info [==[$Format:%h %s$]==]) +endif() + +# Extract commit information if available. +if(git_info MATCHES "^([0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]?[0-9a-f]?)[0-9a-f]* (.*)$") + # Have commit information. + set(git_hash "${CMAKE_MATCH_1}") + set(git_subject "${CMAKE_MATCH_2}") + + # If this is not the exact commit of a release, add dev info. + if(NOT "${git_subject}" MATCHES "^[Cc][Mm]ake ${CMake_VERSION}$") + set(CMake_VERSION "${CMake_VERSION}-g${git_hash}") + endif() + + # If this is a work tree, check whether it is dirty. + if(COMMAND _git) + _git(update-index -q --refresh) + _git(diff-index --name-only HEAD --) + if(_git_out) + set(CMake_VERSION_IS_DIRTY 1) + endif() + endif() +else() + # No commit information. + if(NOT CMake_VERSION_IS_RELEASE) + # Generic development version. + set(CMake_VERSION "${CMake_VERSION}-git") + endif() +endif() + +# Extract the version suffix component. +if(CMake_VERSION MATCHES "-(.*)$") + set(CMake_VERSION_SUFFIX "${CMAKE_MATCH_1}") +else() + set(CMake_VERSION_SUFFIX "") +endif() +if(CMake_VERSION_IS_DIRTY) + set(CMake_VERSION ${CMake_VERSION}-dirty) +endif() diff --git a/Source/CMakeVersionCompute.cmake b/Source/CMakeVersionCompute.cmake deleted file mode 100644 index 72a5800..0000000 --- a/Source/CMakeVersionCompute.cmake +++ /dev/null @@ -1,44 +0,0 @@ -# Load version number components. -include(${CMake_SOURCE_DIR}/Source/CMakeVersion.cmake) - -# Releases define a small patch level. -if("${CMake_VERSION_PATCH}" VERSION_LESS 20000000) - set(CMake_VERSION_IS_DIRTY 0) - set(CMake_VERSION_IS_RELEASE 1) - set(CMake_VERSION_SOURCE "") -else() - set(CMake_VERSION_IS_DIRTY 0) # may be set to 1 by CMakeVersionSource - set(CMake_VERSION_IS_RELEASE 0) - include(${CMake_SOURCE_DIR}/Source/CMakeVersionSource.cmake) -endif() - -# Compute the full version string. -set(CMake_VERSION ${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}.${CMake_VERSION_PATCH}) -if(CMake_VERSION_SOURCE) - set(CMake_VERSION_SUFFIX "${CMake_VERSION_SOURCE}") -elseif(CMake_VERSION_RC) - set(CMake_VERSION_SUFFIX "rc${CMake_VERSION_RC}") -else() - set(CMake_VERSION_SUFFIX "") -endif() -if(CMake_VERSION_SUFFIX) - set(CMake_VERSION ${CMake_VERSION}-${CMake_VERSION_SUFFIX}) -endif() -if(CMake_VERSION_IS_DIRTY) - set(CMake_VERSION ${CMake_VERSION}-dirty) -endif() - -# Compute the binary version that appears in the RC file. Version -# components in the RC file are 16-bit integers so we may have to -# split the patch component. -if(CMake_VERSION_PATCH MATCHES "^([0-9]+)([0-9][0-9][0-9][0-9])$") - set(CMake_RCVERSION_YEAR "${CMAKE_MATCH_1}") - set(CMake_RCVERSION_MONTH_DAY "${CMAKE_MATCH_2}") - string(REGEX REPLACE "^0+" "" CMake_RCVERSION_MONTH_DAY "${CMake_RCVERSION_MONTH_DAY}") - set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMake_RCVERSION_YEAR},${CMake_RCVERSION_MONTH_DAY}) - unset(CMake_RCVERSION_MONTH_DAY) - unset(CMake_RCVERSION_YEAR) -else() - set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMake_VERSION_PATCH}) -endif() -set(CMake_RCVERSION_STR ${CMake_VERSION}) diff --git a/Source/CMakeVersionSource.cmake b/Source/CMakeVersionSource.cmake deleted file mode 100644 index 5ea1de3..0000000 --- a/Source/CMakeVersionSource.cmake +++ /dev/null @@ -1,30 +0,0 @@ -# Try to identify the current development source version. -set(CMake_VERSION_SOURCE "") -if(EXISTS ${CMake_SOURCE_DIR}/.git/HEAD) - find_program(GIT_EXECUTABLE NAMES git git.cmd) - mark_as_advanced(GIT_EXECUTABLE) - if(GIT_EXECUTABLE) - execute_process( - COMMAND ${GIT_EXECUTABLE} rev-parse --verify -q --short=4 HEAD - OUTPUT_VARIABLE head - OUTPUT_STRIP_TRAILING_WHITESPACE - WORKING_DIRECTORY ${CMake_SOURCE_DIR} - ) - if(head) - set(CMake_VERSION_SOURCE "g${head}") - execute_process( - COMMAND ${GIT_EXECUTABLE} update-index -q --refresh - WORKING_DIRECTORY ${CMake_SOURCE_DIR} - ) - execute_process( - COMMAND ${GIT_EXECUTABLE} diff-index --name-only HEAD -- - OUTPUT_VARIABLE dirty - OUTPUT_STRIP_TRAILING_WHITESPACE - WORKING_DIRECTORY ${CMake_SOURCE_DIR} - ) - if(dirty) - set(CMake_VERSION_IS_DIRTY 1) - endif() - endif() - endif() -endif() diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx index 4a91698..512ac7a 100644 --- a/Source/CPack/cmCPackGenerator.cxx +++ b/Source/CPack/cmCPackGenerator.cxx @@ -235,7 +235,7 @@ int cmCPackGenerator::InstallProject() return 0; } - // If the CPackConfig file sets CPACK_INSTALL_SCRIPT then run them + // If the CPackConfig file sets CPACK_INSTALL_SCRIPT(S) then run them // as listed if (!this->InstallProjectViaInstallScript(setDestDir, tempInstallDirectory)) { @@ -448,7 +448,19 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories( int cmCPackGenerator::InstallProjectViaInstallScript( bool setDestDir, const std::string& tempInstallDirectory) { - const char* cmakeScripts = this->GetOption("CPACK_INSTALL_SCRIPT"); + const char* cmakeScripts = this->GetOption("CPACK_INSTALL_SCRIPTS"); + { + const char* const cmakeScript = this->GetOption("CPACK_INSTALL_SCRIPT"); + if (cmakeScript && cmakeScripts) { + cmCPackLogger( + cmCPackLog::LOG_WARNING, + "Both CPACK_INSTALL_SCRIPTS and CPACK_INSTALL_SCRIPT are set, " + "the latter will be ignored." + << std::endl); + } else if (cmakeScript && !cmakeScripts) { + cmakeScripts = cmakeScript; + } + } if (cmakeScripts && *cmakeScripts) { cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Install scripts: " << cmakeScripts << std::endl); @@ -747,7 +759,7 @@ int cmCPackGenerator::InstallCMakeProject( if (this->GetOption("CPACK_INSTALL_PREFIX")) { dir += this->GetOption("CPACK_INSTALL_PREFIX"); } - mf.AddDefinition("CMAKE_INSTALL_PREFIX", dir.c_str()); + mf.AddDefinition("CMAKE_INSTALL_PREFIX", dir); cmCPackLogger( cmCPackLog::LOG_DEBUG, @@ -787,7 +799,7 @@ int cmCPackGenerator::InstallCMakeProject( return 0; } } else { - mf.AddDefinition("CMAKE_INSTALL_PREFIX", tempInstallDirectory.c_str()); + mf.AddDefinition("CMAKE_INSTALL_PREFIX", tempInstallDirectory); if (!cmsys::SystemTools::MakeDirectory(tempInstallDirectory, default_dir_mode)) { @@ -806,11 +818,11 @@ int cmCPackGenerator::InstallCMakeProject( } if (!buildConfig.empty()) { - mf.AddDefinition("BUILD_TYPE", buildConfig.c_str()); + mf.AddDefinition("BUILD_TYPE", buildConfig); } std::string installComponentLowerCase = cmSystemTools::LowerCase(component); if (installComponentLowerCase != "all") { - mf.AddDefinition("CMAKE_INSTALL_COMPONENT", component.c_str()); + mf.AddDefinition("CMAKE_INSTALL_COMPONENT", component); } // strip on TRUE, ON, 1, one or several file names, but not on @@ -851,9 +863,8 @@ int cmCPackGenerator::InstallCMakeProject( // forward definition of CMAKE_ABSOLUTE_DESTINATION_FILES // to CPack (may be used by generators like CPack RPM or DEB) // in order to transparently handle ABSOLUTE PATH - if (mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")) { - mf.AddDefinition("CPACK_ABSOLUTE_DESTINATION_FILES", - mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")); + if (const char* def = mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")) { + mf.AddDefinition("CPACK_ABSOLUTE_DESTINATION_FILES", def); } // Now rebuild the list of files after installation diff --git a/Source/CPack/cmCPackNuGetGenerator.cxx b/Source/CPack/cmCPackNuGetGenerator.cxx index 76f0699..19a3a0a 100644 --- a/Source/CPack/cmCPackNuGetGenerator.cxx +++ b/Source/CPack/cmCPackNuGetGenerator.cxx @@ -2,9 +2,9 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmCPackNuGetGenerator.h" -#include "cmAlgorithms.h" #include "cmCPackComponentGroup.h" #include "cmCPackLog.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include <algorithm> diff --git a/Source/CPack/cpack.cxx b/Source/CPack/cpack.cxx index c6018cf..89c3b1c 100644 --- a/Source/CPack/cpack.cxx +++ b/Source/CPack/cpack.cxx @@ -270,7 +270,7 @@ int main(int argc, char const* const* argv) } if (!cpackBuildConfig.empty()) { - globalMF.AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig.c_str()); + globalMF.AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig); } if (cmSystemTools::FileExists(cpackConfigFile)) { @@ -292,24 +292,21 @@ int main(int argc, char const* const* argv) } if (!generator.empty()) { - globalMF.AddDefinition("CPACK_GENERATOR", generator.c_str()); + globalMF.AddDefinition("CPACK_GENERATOR", generator); } if (!cpackProjectName.empty()) { - globalMF.AddDefinition("CPACK_PACKAGE_NAME", cpackProjectName.c_str()); + globalMF.AddDefinition("CPACK_PACKAGE_NAME", cpackProjectName); } if (!cpackProjectVersion.empty()) { - globalMF.AddDefinition("CPACK_PACKAGE_VERSION", - cpackProjectVersion.c_str()); + globalMF.AddDefinition("CPACK_PACKAGE_VERSION", cpackProjectVersion); } if (!cpackProjectVendor.empty()) { - globalMF.AddDefinition("CPACK_PACKAGE_VENDOR", - cpackProjectVendor.c_str()); + globalMF.AddDefinition("CPACK_PACKAGE_VENDOR", cpackProjectVendor); } // if this is not empty it has been set on the command line // go for it. Command line override values set in config file. if (!cpackProjectDirectory.empty()) { - globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY", - cpackProjectDirectory.c_str()); + globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY", cpackProjectDirectory); } // The value has not been set on the command line else { @@ -318,11 +315,11 @@ int main(int argc, char const* const* argv) // use default value iff no value has been provided by the config file if (!globalMF.IsSet("CPACK_PACKAGE_DIRECTORY")) { globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY", - cpackProjectDirectory.c_str()); + cpackProjectDirectory); } } for (auto const& cd : definitions.Map) { - globalMF.AddDefinition(cd.first, cd.second.c_str()); + globalMF.AddDefinition(cd.first, cd.second); } const char* cpackModulesPath = globalMF.GetDefinition("CPACK_MODULE_PATH"); @@ -426,7 +423,7 @@ int main(int argc, char const* const* argv) std::ostringstream ostr; ostr << projVersionMajor << "." << projVersionMinor << "." << projVersionPatch; - mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str().c_str()); + mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str()); } int res = cpackGenerator->DoPackage(); diff --git a/Source/CTest/cmCTestBuildCommand.cxx b/Source/CTest/cmCTestBuildCommand.cxx index 2eacaf1..e71eafe 100644 --- a/Source/CTest/cmCTestBuildCommand.cxx +++ b/Source/CTest/cmCTestBuildCommand.cxx @@ -156,15 +156,14 @@ bool cmCTestBuildCommand::InitialPass(std::vector<std::string> const& args, if (this->Values[ctb_NUMBER_ERRORS] && *this->Values[ctb_NUMBER_ERRORS]) { std::ostringstream str; str << this->Handler->GetTotalErrors(); - this->Makefile->AddDefinition(this->Values[ctb_NUMBER_ERRORS], - str.str().c_str()); + this->Makefile->AddDefinition(this->Values[ctb_NUMBER_ERRORS], str.str()); } if (this->Values[ctb_NUMBER_WARNINGS] && *this->Values[ctb_NUMBER_WARNINGS]) { std::ostringstream str; str << this->Handler->GetTotalWarnings(); this->Makefile->AddDefinition(this->Values[ctb_NUMBER_WARNINGS], - str.str().c_str()); + str.str()); } return ret; } diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx index c8e4fa1..407e9f8 100644 --- a/Source/CTest/cmCTestBuildHandler.cxx +++ b/Source/CTest/cmCTestBuildHandler.cxx @@ -9,6 +9,7 @@ #include "cmGeneratedFileStream.h" #include "cmMakefile.h" #include "cmProcessOutput.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmXMLWriter.h" diff --git a/Source/CTest/cmCTestGIT.cxx b/Source/CTest/cmCTestGIT.cxx index 9d9761c..093017c 100644 --- a/Source/CTest/cmCTestGIT.cxx +++ b/Source/CTest/cmCTestGIT.cxx @@ -10,11 +10,11 @@ #include <time.h> #include <vector> -#include "cmAlgorithms.h" #include "cmCTest.h" #include "cmCTestVC.h" #include "cmProcessOutput.h" #include "cmProcessTools.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" static unsigned int cmCTestGITVersion(unsigned int epic, unsigned int major, diff --git a/Source/CTest/cmCTestHandlerCommand.cxx b/Source/CTest/cmCTestHandlerCommand.cxx index adf9553..8ceca08 100644 --- a/Source/CTest/cmCTestHandlerCommand.cxx +++ b/Source/CTest/cmCTestHandlerCommand.cxx @@ -4,6 +4,7 @@ #include "cmCTest.h" #include "cmCTestGenericHandler.h" +#include "cmExecutionStatus.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmSystemTools.h" @@ -13,8 +14,6 @@ #include <sstream> #include <stdlib.h> -class cmExecutionStatus; - cmCTestHandlerCommand::cmCTestHandlerCommand() { const size_t INIT_SIZE = 100; @@ -86,7 +85,7 @@ private: } bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& /*unused*/) + cmExecutionStatus& status) { // save error state and restore it if needed SaveRestoreErrorState errorState; @@ -113,20 +112,20 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args, foundBadArgument = true; } } - bool capureCMakeError = (this->Values[ct_CAPTURE_CMAKE_ERROR] && - *this->Values[ct_CAPTURE_CMAKE_ERROR]); + bool captureCMakeError = (this->Values[ct_CAPTURE_CMAKE_ERROR] && + *this->Values[ct_CAPTURE_CMAKE_ERROR]); // now that arguments are parsed check to see if there is a // CAPTURE_CMAKE_ERROR specified let the errorState object know. - if (capureCMakeError) { + if (captureCMakeError) { errorState.CaptureCMakeError(); } // if we found a bad argument then exit before running command if (foundBadArgument) { // store the cmake error - if (capureCMakeError) { + if (captureCMakeError) { this->Makefile->AddDefinition(this->Values[ct_CAPTURE_CMAKE_ERROR], "-1"); - std::string const err = this->GetName() + " " + this->GetError(); + std::string const err = this->GetName() + " " + status.GetError(); if (!cmSystemTools::FindLastString(err.c_str(), "unknown error.")) { cmCTestLog(this->CTest, ERROR_MESSAGE, err << " error from command\n"); } @@ -192,11 +191,11 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args, cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot instantiate test handler " << this->GetName() << std::endl); - if (capureCMakeError) { + if (captureCMakeError) { this->Makefile->AddDefinition(this->Values[ct_CAPTURE_CMAKE_ERROR], "-1"); - const char* err = this->GetError(); - if (err && !cmSystemTools::FindLastString(err, "unknown error.")) { + std::string const& err = status.GetError(); + if (!cmSystemTools::FindLastString(err.c_str(), "unknown error.")) { cmCTestLog(this->CTest, ERROR_MESSAGE, err << " error from command\n"); } return true; @@ -216,11 +215,11 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args, this->SetError("failed to change directory to " + this->CTest->GetCTestConfiguration("BuildDirectory") + " : " + std::strerror(workdir.GetLastResult())); - if (capureCMakeError) { + if (captureCMakeError) { this->Makefile->AddDefinition(this->Values[ct_CAPTURE_CMAKE_ERROR], "-1"); cmCTestLog(this->CTest, ERROR_MESSAGE, - this->GetName() << " " << this->GetError() << "\n"); + this->GetName() << " " << status.GetError() << "\n"); // return success because failure is recorded in CAPTURE_CMAKE_ERROR return true; } @@ -231,19 +230,18 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args, if (this->Values[ct_RETURN_VALUE] && *this->Values[ct_RETURN_VALUE]) { std::ostringstream str; str << res; - this->Makefile->AddDefinition(this->Values[ct_RETURN_VALUE], - str.str().c_str()); + this->Makefile->AddDefinition(this->Values[ct_RETURN_VALUE], str.str()); } this->ProcessAdditionalValues(handler); // log the error message if there was an error - if (capureCMakeError) { + if (captureCMakeError) { const char* returnString = "0"; if (cmSystemTools::GetErrorOccuredFlag()) { returnString = "-1"; - const char* err = this->GetError(); + std::string const& err = status.GetError(); // print out the error if it is not "unknown error" which means // there was no message - if (err && !cmSystemTools::FindLastString(err, "unknown error.")) { + if (!cmSystemTools::FindLastString(err.c_str(), "unknown error.")) { cmCTestLog(this->CTest, ERROR_MESSAGE, err); } } diff --git a/Source/CTest/cmCTestMemCheckCommand.cxx b/Source/CTest/cmCTestMemCheckCommand.cxx index 7dad1ce..d7d42bf 100644 --- a/Source/CTest/cmCTestMemCheckCommand.cxx +++ b/Source/CTest/cmCTestMemCheckCommand.cxx @@ -3,7 +3,6 @@ #include "cmCTestMemCheckCommand.h" #include <sstream> -#include <string> #include <vector> #include "cmCTest.h" @@ -47,7 +46,6 @@ void cmCTestMemCheckCommand::ProcessAdditionalValues( if (this->Values[ctm_DEFECT_COUNT] && *this->Values[ctm_DEFECT_COUNT]) { std::ostringstream str; str << static_cast<cmCTestMemCheckHandler*>(handler)->GetDefectCount(); - this->Makefile->AddDefinition(this->Values[ctm_DEFECT_COUNT], - str.str().c_str()); + this->Makefile->AddDefinition(this->Values[ctm_DEFECT_COUNT], str.str()); } } diff --git a/Source/CTest/cmCTestRunScriptCommand.cxx b/Source/CTest/cmCTestRunScriptCommand.cxx index a7e47d3..c03cffd 100644 --- a/Source/CTest/cmCTestRunScriptCommand.cxx +++ b/Source/CTest/cmCTestRunScriptCommand.cxx @@ -43,7 +43,7 @@ bool cmCTestRunScriptCommand::InitialPass(std::vector<std::string> const& args, args[i].c_str(), !np, &ret); std::ostringstream str; str << ret; - this->Makefile->AddDefinition(returnVariable, str.str().c_str()); + this->Makefile->AddDefinition(returnVariable, str.str()); } } return true; diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx index 85040dd..7a5b8d1 100644 --- a/Source/CTest/cmCTestScriptHandler.cxx +++ b/Source/CTest/cmCTestScriptHandler.cxx @@ -168,7 +168,7 @@ void cmCTestScriptHandler::UpdateElapsedTime() auto itime = cmDurationTo<unsigned int>(std::chrono::steady_clock::now() - this->ScriptStartTime); auto timeString = std::to_string(itime); - this->Makefile->AddDefinition("CTEST_ELAPSED_TIME", timeString.c_str()); + this->Makefile->AddDefinition("CTEST_ELAPSED_TIME", timeString); } } @@ -352,21 +352,21 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg) this->CreateCMake(); // set a variable with the path to the current script - this->Makefile->AddDefinition( - "CTEST_SCRIPT_DIRECTORY", cmSystemTools::GetFilenamePath(script).c_str()); - this->Makefile->AddDefinition( - "CTEST_SCRIPT_NAME", cmSystemTools::GetFilenameName(script).c_str()); + this->Makefile->AddDefinition("CTEST_SCRIPT_DIRECTORY", + cmSystemTools::GetFilenamePath(script)); + this->Makefile->AddDefinition("CTEST_SCRIPT_NAME", + cmSystemTools::GetFilenameName(script)); this->Makefile->AddDefinition("CTEST_EXECUTABLE_NAME", - cmSystemTools::GetCTestCommand().c_str()); + cmSystemTools::GetCTestCommand()); this->Makefile->AddDefinition("CMAKE_EXECUTABLE_NAME", - cmSystemTools::GetCMakeCommand().c_str()); - this->Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", true); + cmSystemTools::GetCMakeCommand()); + this->Makefile->AddDefinitionBool("CTEST_RUN_CURRENT_SCRIPT", true); this->SetRunCurrentScript(true); this->UpdateElapsedTime(); // add the script arg if defined if (!script_arg.empty()) { - this->Makefile->AddDefinition("CTEST_SCRIPT_ARG", script_arg.c_str()); + this->Makefile->AddDefinition("CTEST_SCRIPT_ARG", script_arg); } #if defined(__CYGWIN__) @@ -398,7 +398,7 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg) const std::map<std::string, std::string>& defs = this->CTest->GetDefinitions(); for (auto const& d : defs) { - this->Makefile->AddDefinition(d.first, d.second.c_str()); + this->Makefile->AddDefinition(d.first, d.second); } // finally read in the script diff --git a/Source/CTest/cmCTestSubmitCommand.cxx b/Source/CTest/cmCTestSubmitCommand.cxx index bf43d88..58c0a1b 100644 --- a/Source/CTest/cmCTestSubmitCommand.cxx +++ b/Source/CTest/cmCTestSubmitCommand.cxx @@ -143,7 +143,7 @@ bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args, if (this->Values[cts_BUILD_ID] && *this->Values[cts_BUILD_ID]) { this->Makefile->AddDefinition(this->Values[cts_BUILD_ID], - this->CTest->GetBuildID().c_str()); + this->CTest->GetBuildID()); } return ret; diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx index 54c4bae..2c6ff83 100644 --- a/Source/CTest/cmCTestSubmitHandler.cxx +++ b/Source/CTest/cmCTestSubmitHandler.cxx @@ -19,6 +19,7 @@ #include "cmDuration.h" #include "cmGeneratedFileStream.h" #include "cmState.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmXMLParser.h" #include "cmake.h" diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index c2748e1..67c24ca 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -20,7 +20,6 @@ #include "cm_memory.hxx" -#include "cmAlgorithms.h" #include "cmCTest.h" #include "cmCTestMultiProcessHandler.h" #include "cmCommand.h" @@ -30,6 +29,7 @@ #include "cmMakefile.h" #include "cmState.h" #include "cmStateSnapshot.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmWorkingDirectory.h" #include "cmXMLWriter.h" @@ -423,54 +423,11 @@ int cmCTestTestHandler::PostProcessHandler() return 1; } -// clearly it would be nice if this were broken up into a few smaller -// functions and commented... int cmCTestTestHandler::ProcessHandler() { - // Update internal data structure from generic one - this->SetTestsToRunInformation(this->GetOption("TestsToRunInformation")); - this->SetUseUnion(cmSystemTools::IsOn(this->GetOption("UseUnion"))); - if (cmSystemTools::IsOn(this->GetOption("ScheduleRandom"))) { - this->CTest->SetScheduleType("Random"); - } - if (this->GetOption("ParallelLevel")) { - this->CTest->SetParallelLevel(atoi(this->GetOption("ParallelLevel"))); - } - - const char* val; - val = this->GetOption("LabelRegularExpression"); - if (val) { - this->UseIncludeLabelRegExpFlag = true; - this->IncludeLabelRegExp = val; - } - val = this->GetOption("ExcludeLabelRegularExpression"); - if (val) { - this->UseExcludeLabelRegExpFlag = true; - this->ExcludeLabelRegExp = val; - } - val = this->GetOption("IncludeRegularExpression"); - if (val) { - this->UseIncludeRegExp(); - this->SetIncludeRegExp(val); - } - val = this->GetOption("ExcludeRegularExpression"); - if (val) { - this->UseExcludeRegExp(); - this->SetExcludeRegExp(val); - } - val = this->GetOption("ExcludeFixtureRegularExpression"); - if (val) { - this->ExcludeFixtureRegExp = val; - } - val = this->GetOption("ExcludeFixtureSetupRegularExpression"); - if (val) { - this->ExcludeFixtureSetupRegExp = val; - } - val = this->GetOption("ExcludeFixtureCleanupRegularExpression"); - if (val) { - this->ExcludeFixtureCleanupRegExp = val; + if (!this->ProcessOptions()) { + return -1; } - this->SetRerunFailed(cmSystemTools::IsOn(this->GetOption("RerunFailed"))); this->TestResults.clear(); @@ -490,7 +447,6 @@ int cmCTestTestHandler::ProcessHandler() std::vector<std::string> passed; std::vector<std::string> failed; - int total; // start the real time clock auto clock_start = std::chrono::steady_clock::now(); @@ -499,9 +455,7 @@ int cmCTestTestHandler::ProcessHandler() auto clock_finish = std::chrono::steady_clock::now(); - total = int(passed.size()) + int(failed.size()); - - if (total == 0) { + if (passed.size() + failed.size() == 0) { if (!this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels()) { cmCTestLog(this->CTest, ERROR_MESSAGE, "No tests were found!!!" << std::endl); @@ -519,9 +473,6 @@ int cmCTestTestHandler::ProcessHandler() } } - typedef std::set<cmCTestTestHandler::cmCTestTestResult, - cmCTestTestResultLess> - SetOfTests; SetOfTests resultsSet(this->TestResults.begin(), this->TestResults.end()); std::vector<cmCTestTestHandler::cmCTestTestResult> disabledTests; @@ -532,92 +483,182 @@ int cmCTestTestHandler::ProcessHandler() } } - float percent = float(passed.size()) * 100.0f / float(total); - if (!failed.empty() && percent > 99) { - percent = 99; - } + cmDuration durationInSecs = clock_finish - clock_start; + this->LogTestSummary(passed, failed, durationInSecs); - std::string passColorCode; - std::string failedColorCode; - if (failed.empty()) { - passColorCode = this->CTest->GetColorCode(cmCTest::Color::GREEN); - } else { - failedColorCode = this->CTest->GetColorCode(cmCTest::Color::RED); - } + this->LogDisabledTests(disabledTests); + + this->LogFailedTests(failed, resultsSet); + } + + if (!this->GenerateXML()) { + return 1; + } + + if (!this->PostProcessHandler()) { + this->LogFile = nullptr; + return -1; + } + + if (!failed.empty()) { + this->LogFile = nullptr; + return -1; + } + this->LogFile = nullptr; + return 0; +} + +bool cmCTestTestHandler::ProcessOptions() +{ + // Update internal data structure from generic one + this->SetTestsToRunInformation(this->GetOption("TestsToRunInformation")); + this->SetUseUnion(cmSystemTools::IsOn(this->GetOption("UseUnion"))); + if (cmSystemTools::IsOn(this->GetOption("ScheduleRandom"))) { + this->CTest->SetScheduleType("Random"); + } + if (this->GetOption("ParallelLevel")) { + this->CTest->SetParallelLevel(atoi(this->GetOption("ParallelLevel"))); + } + + const char* val; + val = this->GetOption("LabelRegularExpression"); + if (val) { + this->UseIncludeLabelRegExpFlag = true; + this->IncludeLabelRegExp = val; + } + val = this->GetOption("ExcludeLabelRegularExpression"); + if (val) { + this->UseExcludeLabelRegExpFlag = true; + this->ExcludeLabelRegExp = val; + } + val = this->GetOption("IncludeRegularExpression"); + if (val) { + this->UseIncludeRegExp(); + this->SetIncludeRegExp(val); + } + val = this->GetOption("ExcludeRegularExpression"); + if (val) { + this->UseExcludeRegExp(); + this->SetExcludeRegExp(val); + } + val = this->GetOption("ExcludeFixtureRegularExpression"); + if (val) { + this->ExcludeFixtureRegExp = val; + } + val = this->GetOption("ExcludeFixtureSetupRegularExpression"); + if (val) { + this->ExcludeFixtureSetupRegExp = val; + } + val = this->GetOption("ExcludeFixtureCleanupRegularExpression"); + if (val) { + this->ExcludeFixtureCleanupRegExp = val; + } + this->SetRerunFailed(cmSystemTools::IsOn(this->GetOption("RerunFailed"))); + + return true; +} + +void cmCTestTestHandler::LogTestSummary(const std::vector<std::string>& passed, + const std::vector<std::string>& failed, + const cmDuration& durationInSecs) +{ + std::size_t total = passed.size() + failed.size(); + + float percent = float(passed.size()) * 100.0f / float(total); + if (!failed.empty() && percent > 99) { + percent = 99; + } + + std::string passColorCode; + std::string failedColorCode; + if (failed.empty()) { + passColorCode = this->CTest->GetColorCode(cmCTest::Color::GREEN); + } else { + failedColorCode = this->CTest->GetColorCode(cmCTest::Color::RED); + } + cmCTestLog(this->CTest, HANDLER_OUTPUT, + std::endl + << passColorCode << std::lround(percent) << "% tests passed" + << this->CTest->GetColorCode(cmCTest::Color::CLEAR_COLOR) + << ", " << failedColorCode << failed.size() << " tests failed" + << this->CTest->GetColorCode(cmCTest::Color::CLEAR_COLOR) + << " out of " << total << std::endl); + if ((!this->CTest->GetLabelsForSubprojects().empty() && + this->CTest->GetSubprojectSummary())) { + this->PrintLabelOrSubprojectSummary(true); + } + if (this->CTest->GetLabelSummary()) { + this->PrintLabelOrSubprojectSummary(false); + } + char realBuf[1024]; + sprintf(realBuf, "%6.2f sec", durationInSecs.count()); + cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, + "\nTotal Test time (real) = " << realBuf << "\n", + this->Quiet); +} + +void cmCTestTestHandler::LogDisabledTests( + const std::vector<cmCTestTestResult>& disabledTests) +{ + if (!disabledTests.empty()) { + cmGeneratedFileStream ofs; cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl - << passColorCode << std::lround(percent) << "% tests passed" - << this->CTest->GetColorCode(cmCTest::Color::CLEAR_COLOR) - << ", " << failedColorCode << failed.size() << " tests failed" - << this->CTest->GetColorCode(cmCTest::Color::CLEAR_COLOR) - << " out of " << total << std::endl); - if ((!this->CTest->GetLabelsForSubprojects().empty() && - this->CTest->GetSubprojectSummary())) { - this->PrintLabelOrSubprojectSummary(true); - } - if (this->CTest->GetLabelSummary()) { - this->PrintLabelOrSubprojectSummary(false); - } - char realBuf[1024]; - cmDuration durationInSecs = clock_finish - clock_start; - sprintf(realBuf, "%6.2f sec", durationInSecs.count()); - cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, - "\nTotal Test time (real) = " << realBuf << "\n", - this->Quiet); + << "The following tests did not run:" << std::endl); + this->StartLogFile("TestsDisabled", ofs); - if (!disabledTests.empty()) { - cmGeneratedFileStream ofs; - cmCTestLog(this->CTest, HANDLER_OUTPUT, - std::endl - << "The following tests did not run:" << std::endl); - this->StartLogFile("TestsDisabled", ofs); - - const char* disabled_reason; - cmCTestLog(this->CTest, HANDLER_OUTPUT, - this->CTest->GetColorCode(cmCTest::Color::BLUE)); - for (cmCTestTestResult const& dt : disabledTests) { - ofs << dt.TestCount << ":" << dt.Name << std::endl; - if (dt.CompletionStatus == "Disabled") { - disabled_reason = "Disabled"; - } else { - disabled_reason = "Skipped"; - } - cmCTestLog(this->CTest, HANDLER_OUTPUT, - "\t" << std::setw(3) << dt.TestCount << " - " << dt.Name - << " (" << disabled_reason << ")" << std::endl); + const char* disabled_reason; + cmCTestLog(this->CTest, HANDLER_OUTPUT, + this->CTest->GetColorCode(cmCTest::Color::BLUE)); + for (cmCTestTestResult const& dt : disabledTests) { + ofs << dt.TestCount << ":" << dt.Name << std::endl; + if (dt.CompletionStatus == "Disabled") { + disabled_reason = "Disabled"; + } else { + disabled_reason = "Skipped"; } cmCTestLog(this->CTest, HANDLER_OUTPUT, - this->CTest->GetColorCode(cmCTest::Color::CLEAR_COLOR)); + "\t" << std::setw(3) << dt.TestCount << " - " << dt.Name + << " (" << disabled_reason << ")" << std::endl); } + cmCTestLog(this->CTest, HANDLER_OUTPUT, + this->CTest->GetColorCode(cmCTest::Color::CLEAR_COLOR)); + } +} - if (!failed.empty()) { - cmGeneratedFileStream ofs; - cmCTestLog(this->CTest, HANDLER_OUTPUT, - std::endl - << "The following tests FAILED:" << std::endl); - this->StartLogFile("TestsFailed", ofs); - - for (cmCTestTestResult const& ft : resultsSet) { - if (ft.Status != cmCTestTestHandler::COMPLETED && - !cmHasLiteralPrefix(ft.CompletionStatus, "SKIP_") && - ft.CompletionStatus != "Disabled") { - ofs << ft.TestCount << ":" << ft.Name << std::endl; - auto testColor = cmCTest::Color::RED; - if (this->GetTestStatus(ft) == "Not Run") { - testColor = cmCTest::Color::YELLOW; - } - cmCTestLog( - this->CTest, HANDLER_OUTPUT, - "\t" << this->CTest->GetColorCode(testColor) << std::setw(3) - << ft.TestCount << " - " << ft.Name << " (" - << this->GetTestStatus(ft) << ")" - << this->CTest->GetColorCode(cmCTest::Color::CLEAR_COLOR) - << std::endl); +void cmCTestTestHandler::LogFailedTests(const std::vector<std::string>& failed, + const SetOfTests& resultsSet) +{ + if (!failed.empty()) { + cmGeneratedFileStream ofs; + cmCTestLog(this->CTest, HANDLER_OUTPUT, + std::endl + << "The following tests FAILED:" << std::endl); + this->StartLogFile("TestsFailed", ofs); + + for (cmCTestTestResult const& ft : resultsSet) { + if (ft.Status != cmCTestTestHandler::COMPLETED && + !cmHasLiteralPrefix(ft.CompletionStatus, "SKIP_") && + ft.CompletionStatus != "Disabled") { + ofs << ft.TestCount << ":" << ft.Name << std::endl; + auto testColor = cmCTest::Color::RED; + if (this->GetTestStatus(ft) == "Not Run") { + testColor = cmCTest::Color::YELLOW; } + cmCTestLog( + this->CTest, HANDLER_OUTPUT, + "\t" << this->CTest->GetColorCode(testColor) << std::setw(3) + << ft.TestCount << " - " << ft.Name << " (" + << this->GetTestStatus(ft) << ")" + << this->CTest->GetColorCode(cmCTest::Color::CLEAR_COLOR) + << std::endl); } } } +} +bool cmCTestTestHandler::GenerateXML() +{ if (this->CTest->GetProduceXML()) { cmGeneratedFileStream xmlfile; if (!this->StartResultingXML( @@ -628,23 +669,13 @@ int cmCTestTestHandler::ProcessHandler() << (this->MemCheck ? "memory check" : "testing") << " XML file" << std::endl); this->LogFile = nullptr; - return 1; + return false; } cmXMLWriter xml(xmlfile); this->GenerateDartOutput(xml); } - if (!this->PostProcessHandler()) { - this->LogFile = nullptr; - return -1; - } - - if (!failed.empty()) { - this->LogFile = nullptr; - return -1; - } - this->LogFile = nullptr; - return 0; + return true; } void cmCTestTestHandler::PrintLabelOrSubprojectSummary(bool doSubProject) @@ -1683,8 +1714,7 @@ void cmCTestTestHandler::GetListOfTests() cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmMakefile mf(&gg, cm.GetCurrentSnapshot()); - mf.AddDefinition("CTEST_CONFIGURATION_TYPE", - this->CTest->GetConfigType().c_str()); + mf.AddDefinition("CTEST_CONFIGURATION_TYPE", this->CTest->GetConfigType()); // Add handler for ADD_TEST auto newCom1 = cm::make_unique<cmCTestAddTestCommand>(); diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h index 5bbc68e..9345185 100644 --- a/Source/CTest/cmCTestTestHandler.h +++ b/Source/CTest/cmCTestTestHandler.h @@ -191,12 +191,25 @@ public: typedef std::vector<cmCTestTestProperties> ListOfTests; protected: + typedef std::set<cmCTestTestHandler::cmCTestTestResult, + cmCTestTestResultLess> + SetOfTests; + // compute a final test list virtual int PreProcessHandler(); virtual int PostProcessHandler(); virtual void GenerateTestCommand(std::vector<std::string>& args, int test); int ExecuteCommands(std::vector<std::string>& vec); + bool ProcessOptions(); + void LogTestSummary(const std::vector<std::string>& passed, + const std::vector<std::string>& failed, + const cmDuration& durationInSecs); + void LogDisabledTests(const std::vector<cmCTestTestResult>& disabledTests); + void LogFailedTests(const std::vector<std::string>& failed, + const SetOfTests& resultsSet); + bool GenerateXML(); + void WriteTestResultHeader(cmXMLWriter& xml, cmCTestTestResult const& result); void WriteTestResultFooter(cmXMLWriter& xml, diff --git a/Source/CTest/cmParseGTMCoverage.cxx b/Source/CTest/cmParseGTMCoverage.cxx index 0722753..881bf2d 100644 --- a/Source/CTest/cmParseGTMCoverage.cxx +++ b/Source/CTest/cmParseGTMCoverage.cxx @@ -1,8 +1,8 @@ #include "cmParseGTMCoverage.h" -#include "cmAlgorithms.h" #include "cmCTest.h" #include "cmCTestCoverageHandler.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmsys/Directory.hxx" diff --git a/Source/LexerParser/cmCommandArgumentParser.cxx b/Source/LexerParser/cmCommandArgumentParser.cxx index b965b32..ae7fb42 100644 --- a/Source/LexerParser/cmCommandArgumentParser.cxx +++ b/Source/LexerParser/cmCommandArgumentParser.cxx @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.3.2. */ /* Bison implementation for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -40,11 +41,14 @@ define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "3.0.4" +#define YYBISON_VERSION "3.3.2" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -67,8 +71,8 @@ #define yynerrs cmCommandArgument_yynerrs -/* Copy the first part of user declarations. */ -#line 1 "cmCommandArgumentParser.y" /* yacc.c:339 */ +/* First part of user prologue. */ +#line 1 "cmCommandArgumentParser.y" /* yacc.c:337 */ /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ @@ -130,13 +134,16 @@ static void cmCommandArgument_yyerror(yyscan_t yyscanner, const char* message); # pragma GCC diagnostic ignored "-Wconversion" #endif -#line 134 "cmCommandArgumentParser.cxx" /* yacc.c:339 */ - +#line 138 "cmCommandArgumentParser.cxx" /* yacc.c:337 */ # ifndef YY_NULLPTR -# if defined __cplusplus && 201103L <= __cplusplus -# define YY_NULLPTR nullptr +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif # else -# define YY_NULLPTR 0 +# define YY_NULLPTR ((void*)0) # endif # endif @@ -201,9 +208,7 @@ int cmCommandArgument_yyparse (yyscan_t yyscanner); #endif /* !YY_CMCOMMANDARGUMENT_YY_CMCOMMANDARGUMENTPARSERTOKENS_H_INCLUDED */ -/* Copy the second part of user declarations. */ -#line 207 "cmCommandArgumentParser.cxx" /* yacc.c:358 */ #ifdef short # undef short @@ -224,13 +229,13 @@ typedef signed char yytype_int8; #ifdef YYTYPE_UINT16 typedef YYTYPE_UINT16 yytype_uint16; #else -typedef unsigned short int yytype_uint16; +typedef unsigned short yytype_uint16; #endif #ifdef YYTYPE_INT16 typedef YYTYPE_INT16 yytype_int16; #else -typedef short int yytype_int16; +typedef short yytype_int16; #endif #ifndef YYSIZE_T @@ -242,7 +247,7 @@ typedef short int yytype_int16; # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else -# define YYSIZE_T unsigned int +# define YYSIZE_T unsigned # endif #endif @@ -278,15 +283,6 @@ typedef short int yytype_int16; # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) #endif -#if !defined _Noreturn \ - && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) -# if defined _MSC_VER && 1200 <= _MSC_VER -# define _Noreturn __declspec (noreturn) -# else -# define _Noreturn YY_ATTRIBUTE ((__noreturn__)) -# endif -#endif - /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ # define YYUSE(E) ((void) (E)) @@ -294,7 +290,7 @@ typedef short int yytype_int16; # define YYUSE(E) /* empty */ #endif -#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ _Pragma ("GCC diagnostic push") \ @@ -456,16 +452,16 @@ union yyalloc /* YYNSTATES -- Number of states. */ #define YYNSTATES 33 -/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned - by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 #define YYMAXUTOK 269 +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ #define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM - as returned by yylex, without out-of-bounds checking. */ + as returned by yylex. */ static const yytype_uint8 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -513,7 +509,7 @@ static const yytype_uint8 yyrline[] = static const char *const yytname[] = { "$end", "error", "$undefined", "cal_ENVCURLY", "cal_NCURLY", - "cal_DCURLY", "\"$\"", "\"{\"", "\"}\"", "cal_NAME", R"("\\")", + "cal_DCURLY", "\"$\"", "\"{\"", "\"}\"", "cal_NAME", "\"\\\\\"", "cal_SYMBOL", "\"@\"", "cal_ERROR", "cal_ATNAME", "$accept", "Start", "GoalWithOptionalBackSlash", "Goal", "String", "OuterText", "Variable", "EnvVarName", "MultipleIds", "ID", YY_NULLPTR @@ -633,22 +629,22 @@ static const yytype_uint8 yyr2[] = #define YYRECOVERING() (!!yyerrstatus) -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - YYPOPSTACK (yylen); \ - yystate = *yyssp; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (yyscanner, YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (0) +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (yyscanner, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) /* Error token number */ #define YYTERROR 1 @@ -688,38 +684,38 @@ do { \ } while (0) -/*----------------------------------------. -| Print this symbol's value on YYOUTPUT. | -`----------------------------------------*/ +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ static void -yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) +yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) { - FILE *yyo = yyoutput; - YYUSE (yyo); + FILE *yyoutput = yyo; + YYUSE (yyoutput); YYUSE (yyscanner); if (!yyvaluep) return; # ifdef YYPRINT if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); + YYPRINT (yyo, yytoknum[yytype], *yyvaluep); # endif YYUSE (yytype); } -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ static void -yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) +yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) { - YYFPRINTF (yyoutput, "%s %s (", + YYFPRINTF (yyo, "%s %s (", yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); - yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner); - YYFPRINTF (yyoutput, ")"); + yy_symbol_value_print (yyo, yytype, yyvaluep, yyscanner); + YYFPRINTF (yyo, ")"); } /*------------------------------------------------------------------. @@ -753,7 +749,7 @@ do { \ static void yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yyscanner) { - unsigned long int yylno = yyrline[yyrule]; + unsigned long yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", @@ -764,7 +760,7 @@ yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yysca YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, yystos[yyssp[yyi + 1 - yynrhs]], - &(yyvsp[(yyi + 1) - (yynrhs)]) + &yyvsp[(yyi + 1) - (yynrhs)] , yyscanner); YYFPRINTF (stderr, "\n"); } @@ -868,7 +864,10 @@ yytnamerr (char *yyres, const char *yystr) case '\\': if (*++yyp != '\\') goto do_not_strip_quotes; - /* Fall through. */ + else + goto append; + + append: default: if (yyres) yyres[yyn] = *yyp; @@ -886,7 +885,7 @@ yytnamerr (char *yyres, const char *yystr) if (! yyres) return yystrlen (yystr); - return yystpcpy (yyres, yystr) - yyres; + return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres); } # endif @@ -964,10 +963,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yyarg[yycount++] = yytname[yyx]; { YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); - if (! (yysize <= yysize1 - && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } } } @@ -979,6 +978,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, case N: \ yyformat = S; \ break + default: /* Avoid compiler warnings. */ YYCASE_(0, YY_("syntax error")); YYCASE_(1, YY_("syntax error, unexpected %s")); YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); @@ -990,9 +990,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, { YYSIZE_T yysize1 = yysize + yystrlen (yyformat); - if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } if (*yymsg_alloc < yysize) @@ -1123,23 +1124,31 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); yychar = YYEMPTY; /* Cause a token to be read. */ goto yysetstate; + /*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | +| yynewstate -- push a new state, which is found in yystate. | `------------------------------------------------------------*/ - yynewstate: +yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; - yysetstate: - *yyssp = yystate; + +/*--------------------------------------------------------------------. +| yynewstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + *yyssp = (yytype_int16) yystate; if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + goto yyexhaustedlab; +#else { /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; + YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1); -#ifdef yyoverflow +# if defined yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into @@ -1155,14 +1164,10 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yystacksize); - yyss = yyss1; yyvs = yyvs1; } -#else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -# else +# else /* defined YYSTACK_RELOCATE */ /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab; @@ -1178,22 +1183,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); goto yyexhaustedlab; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); -# undef YYSTACK_RELOCATE +# undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif -#endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); + (unsigned long) yystacksize)); if (yyss + yystacksize - 1 <= yyssp) YYABORT; } +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ YYDPRINTF ((stderr, "Entering state %d\n", yystate)); @@ -1202,11 +1207,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); goto yybackup; + /*-----------. | yybackup. | `-----------*/ yybackup: - /* Do appropriate processing given the current state. Read a lookahead token if we need one and don't already have one. */ @@ -1279,7 +1284,7 @@ yydefault: /*-----------------------------. -| yyreduce -- Do a reduction. | +| yyreduce -- do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ @@ -1300,192 +1305,192 @@ yyreduce: switch (yyn) { case 2: -#line 99 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 99 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = 0; yyGetParser->SetResult((yyvsp[0].str)); } -#line 1309 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1314 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 3: -#line 105 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 105 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1317 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1322 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 4: -#line 108 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 108 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = yyGetParser->CombineUnions((yyvsp[-1].str), (yyvsp[0].str)); } -#line 1325 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1330 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 5: -#line 113 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 113 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = 0; } -#line 1333 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1338 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 6: -#line 116 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 116 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = yyGetParser->CombineUnions((yyvsp[-1].str), (yyvsp[0].str)); } -#line 1341 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1346 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 7: -#line 121 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 121 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1349 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1354 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 8: -#line 124 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 124 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1357 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1362 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 9: -#line 129 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 129 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1365 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1370 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 10: -#line 132 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 132 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1373 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1378 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 11: -#line 135 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 135 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1381 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1386 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 12: -#line 138 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 138 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1389 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1394 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 13: -#line 141 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 141 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1397 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1402 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 14: -#line 144 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 144 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1405 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1410 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 15: -#line 149 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 149 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = yyGetParser->ExpandSpecialVariable((yyvsp[-2].str), (yyvsp[-1].str)); } -#line 1413 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1418 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 16: -#line 152 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 152 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = yyGetParser->ExpandSpecialVariable((yyvsp[-2].str), (yyvsp[-1].str)); } -#line 1421 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1426 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 17: -#line 155 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 155 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = yyGetParser->ExpandVariable((yyvsp[-1].str)); } -#line 1429 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1434 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 18: -#line 158 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 158 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = yyGetParser->ExpandVariableForAt((yyvsp[0].str)); } -#line 1437 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1442 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 19: -#line 163 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 163 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1445 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1450 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 20: -#line 166 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 166 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[-1].str); } -#line 1453 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1458 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 21: -#line 171 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 171 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = 0; } -#line 1461 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1466 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 22: -#line 174 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 174 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = yyGetParser->CombineUnions((yyvsp[-1].str), (yyvsp[0].str)); } -#line 1469 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1474 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 23: -#line 179 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 179 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1477 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1482 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; case 24: -#line 182 "cmCommandArgumentParser.y" /* yacc.c:1646 */ +#line 182 "cmCommandArgumentParser.y" /* yacc.c:1652 */ { (yyval.str) = (yyvsp[0].str); } -#line 1485 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1490 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ break; -#line 1489 "cmCommandArgumentParser.cxx" /* yacc.c:1646 */ +#line 1494 "cmCommandArgumentParser.cxx" /* yacc.c:1652 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -1510,14 +1515,13 @@ yyreduce: /* Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTOKENS]; + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } goto yynewstate; @@ -1601,12 +1605,10 @@ yyerrlab: | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: - - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (/*CONSTCOND*/ 0) - goto yyerrorlab; + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ @@ -1669,6 +1671,7 @@ yyacceptlab: yyresult = 0; goto yyreturn; + /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ @@ -1676,6 +1679,7 @@ yyabortlab: yyresult = 1; goto yyreturn; + #if !defined yyoverflow || YYERROR_VERBOSE /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | @@ -1686,6 +1690,10 @@ yyexhaustedlab: /* Fall through. */ #endif + +/*-----------------------------------------------------. +| yyreturn -- parsing is finished, return the result. | +`-----------------------------------------------------*/ yyreturn: if (yychar != YYEMPTY) { @@ -1715,7 +1723,7 @@ yyreturn: #endif return yyresult; } -#line 187 "cmCommandArgumentParser.y" /* yacc.c:1906 */ +#line 187 "cmCommandArgumentParser.y" /* yacc.c:1918 */ /* End of grammar */ diff --git a/Source/LexerParser/cmCommandArgumentParserTokens.h b/Source/LexerParser/cmCommandArgumentParserTokens.h index 3172182..56c9794 100644 --- a/Source/LexerParser/cmCommandArgumentParserTokens.h +++ b/Source/LexerParser/cmCommandArgumentParserTokens.h @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.3.2. */ /* Bison interface for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -30,6 +31,9 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + #ifndef YY_CMCOMMANDARGUMENT_YY_CMCOMMANDARGUMENTPARSERTOKENS_H_INCLUDED # define YY_CMCOMMANDARGUMENT_YY_CMCOMMANDARGUMENTPARSERTOKENS_H_INCLUDED /* Debug traces. */ diff --git a/Source/LexerParser/cmDependsJavaParser.cxx b/Source/LexerParser/cmDependsJavaParser.cxx index e83afa9..6c1fb2c 100644 --- a/Source/LexerParser/cmDependsJavaParser.cxx +++ b/Source/LexerParser/cmDependsJavaParser.cxx @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.3.2. */ /* Bison implementation for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -40,11 +41,14 @@ define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "3.0.4" +#define YYBISON_VERSION "3.3.2" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -67,8 +71,8 @@ #define yynerrs cmDependsJava_yynerrs -/* Copy the first part of user declarations. */ -#line 1 "cmDependsJavaParser.y" /* yacc.c:339 */ +/* First part of user prologue. */ +#line 1 "cmDependsJavaParser.y" /* yacc.c:337 */ /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ @@ -119,13 +123,16 @@ static void cmDependsJava_yyerror(yyscan_t yyscanner, const char* message); # pragma GCC diagnostic ignored "-Wconversion" #endif -#line 123 "cmDependsJavaParser.cxx" /* yacc.c:339 */ - +#line 127 "cmDependsJavaParser.cxx" /* yacc.c:337 */ # ifndef YY_NULLPTR -# if defined __cplusplus && 201103L <= __cplusplus -# define YY_NULLPTR nullptr +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif # else -# define YY_NULLPTR 0 +# define YY_NULLPTR ((void*)0) # endif # endif @@ -372,9 +379,7 @@ int cmDependsJava_yyparse (yyscan_t yyscanner); #endif /* !YY_CMDEPENDSJAVA_YY_CMDEPENDSJAVAPARSERTOKENS_H_INCLUDED */ -/* Copy the second part of user declarations. */ -#line 378 "cmDependsJavaParser.cxx" /* yacc.c:358 */ #ifdef short # undef short @@ -395,13 +400,13 @@ typedef signed char yytype_int8; #ifdef YYTYPE_UINT16 typedef YYTYPE_UINT16 yytype_uint16; #else -typedef unsigned short int yytype_uint16; +typedef unsigned short yytype_uint16; #endif #ifdef YYTYPE_INT16 typedef YYTYPE_INT16 yytype_int16; #else -typedef short int yytype_int16; +typedef short yytype_int16; #endif #ifndef YYSIZE_T @@ -413,7 +418,7 @@ typedef short int yytype_int16; # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else -# define YYSIZE_T unsigned int +# define YYSIZE_T unsigned # endif #endif @@ -449,15 +454,6 @@ typedef short int yytype_int16; # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) #endif -#if !defined _Noreturn \ - && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) -# if defined _MSC_VER && 1200 <= _MSC_VER -# define _Noreturn __declspec (noreturn) -# else -# define _Noreturn YY_ATTRIBUTE ((__noreturn__)) -# endif -#endif - /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ # define YYUSE(E) ((void) (E)) @@ -465,7 +461,7 @@ typedef short int yytype_int16; # define YYUSE(E) /* empty */ #endif -#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ _Pragma ("GCC diagnostic push") \ @@ -627,16 +623,16 @@ union yyalloc /* YYNSTATES -- Number of states. */ #define YYNSTATES 575 -/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned - by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 #define YYMAXUTOK 360 +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ #define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM - as returned by yylex, without out-of-bounds checking. */ + as returned by yylex. */ static const yytype_uint8 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -1618,22 +1614,22 @@ static const yytype_uint8 yyr2[] = #define YYRECOVERING() (!!yyerrstatus) -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - YYPOPSTACK (yylen); \ - yystate = *yyssp; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (yyscanner, YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (0) +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (yyscanner, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) /* Error token number */ #define YYTERROR 1 @@ -1673,38 +1669,38 @@ do { \ } while (0) -/*----------------------------------------. -| Print this symbol's value on YYOUTPUT. | -`----------------------------------------*/ +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ static void -yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) +yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) { - FILE *yyo = yyoutput; - YYUSE (yyo); + FILE *yyoutput = yyo; + YYUSE (yyoutput); YYUSE (yyscanner); if (!yyvaluep) return; # ifdef YYPRINT if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); + YYPRINT (yyo, yytoknum[yytype], *yyvaluep); # endif YYUSE (yytype); } -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ static void -yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) +yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) { - YYFPRINTF (yyoutput, "%s %s (", + YYFPRINTF (yyo, "%s %s (", yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); - yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner); - YYFPRINTF (yyoutput, ")"); + yy_symbol_value_print (yyo, yytype, yyvaluep, yyscanner); + YYFPRINTF (yyo, ")"); } /*------------------------------------------------------------------. @@ -1738,7 +1734,7 @@ do { \ static void yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yyscanner) { - unsigned long int yylno = yyrline[yyrule]; + unsigned long yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", @@ -1749,7 +1745,7 @@ yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yysca YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, yystos[yyssp[yyi + 1 - yynrhs]], - &(yyvsp[(yyi + 1) - (yynrhs)]) + &yyvsp[(yyi + 1) - (yynrhs)] , yyscanner); YYFPRINTF (stderr, "\n"); } @@ -1853,7 +1849,10 @@ yytnamerr (char *yyres, const char *yystr) case '\\': if (*++yyp != '\\') goto do_not_strip_quotes; - /* Fall through. */ + else + goto append; + + append: default: if (yyres) yyres[yyn] = *yyp; @@ -1871,7 +1870,7 @@ yytnamerr (char *yyres, const char *yystr) if (! yyres) return yystrlen (yystr); - return yystpcpy (yyres, yystr) - yyres; + return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres); } # endif @@ -1949,10 +1948,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yyarg[yycount++] = yytname[yyx]; { YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); - if (! (yysize <= yysize1 - && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } } } @@ -1964,6 +1963,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, case N: \ yyformat = S; \ break + default: /* Avoid compiler warnings. */ YYCASE_(0, YY_("syntax error")); YYCASE_(1, YY_("syntax error, unexpected %s")); YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); @@ -1975,9 +1975,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, { YYSIZE_T yysize1 = yysize + yystrlen (yyformat); - if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } if (*yymsg_alloc < yysize) @@ -2108,23 +2109,31 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); yychar = YYEMPTY; /* Cause a token to be read. */ goto yysetstate; + /*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | +| yynewstate -- push a new state, which is found in yystate. | `------------------------------------------------------------*/ - yynewstate: +yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; - yysetstate: - *yyssp = yystate; + +/*--------------------------------------------------------------------. +| yynewstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + *yyssp = (yytype_int16) yystate; if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + goto yyexhaustedlab; +#else { /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; + YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1); -#ifdef yyoverflow +# if defined yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into @@ -2140,14 +2149,10 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yystacksize); - yyss = yyss1; yyvs = yyvs1; } -#else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -# else +# else /* defined YYSTACK_RELOCATE */ /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab; @@ -2163,22 +2168,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); goto yyexhaustedlab; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); -# undef YYSTACK_RELOCATE +# undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif -#endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); + (unsigned long) yystacksize)); if (yyss + yystacksize - 1 <= yyssp) YYABORT; } +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ YYDPRINTF ((stderr, "Entering state %d\n", yystate)); @@ -2187,11 +2192,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); goto yybackup; + /*-----------. | yybackup. | `-----------*/ yybackup: - /* Do appropriate processing given the current state. Read a lookahead token if we need one and don't already have one. */ @@ -2264,7 +2269,7 @@ yydefault: /*-----------------------------. -| yyreduce -- Do a reduction. | +| yyreduce -- do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ @@ -2285,214 +2290,214 @@ yyreduce: switch (yyn) { case 2: -#line 183 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 183 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2296 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2301 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 3: -#line 192 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 192 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2307 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2312 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 4: -#line 200 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 200 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2318 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2323 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 5: -#line 208 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 208 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2329 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2334 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 6: -#line 216 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 216 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2340 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2345 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 7: -#line 224 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 224 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2351 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2356 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 8: -#line 232 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 232 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2362 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2367 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 9: -#line 241 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 241 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2373 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2378 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 10: -#line 249 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 249 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2384 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2389 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 11: -#line 258 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 258 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2395 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2400 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 12: -#line 266 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 266 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2406 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2411 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 13: -#line 275 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 275 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); } -#line 2414 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2419 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 14: -#line 280 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 280 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); } -#line 2422 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2427 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 15: -#line 285 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 285 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); } -#line 2430 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2435 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 16: -#line 290 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 290 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); } -#line 2438 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2443 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 17: -#line 295 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 295 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); } -#line 2446 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2451 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 18: -#line 300 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 300 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); } -#line 2454 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2459 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 19: -#line 305 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 305 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); } -#line 2462 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2467 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 20: -#line 310 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 310 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); } -#line 2470 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2475 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 21: -#line 316 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 316 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2481 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2486 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 22: -#line 324 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 324 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2492 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2497 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 23: -#line 333 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 333 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpStoreClass((yyvsp[0].str)); @@ -2500,44 +2505,44 @@ yyreduce: (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2504 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2509 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 24: -#line 343 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 343 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2515 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2520 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 25: -#line 352 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 352 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2526 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2531 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 26: -#line 361 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 361 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2537 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2542 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 27: -#line 369 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 369 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpStoreClass((yyvsp[-1].str)); @@ -2545,56 +2550,56 @@ yyreduce: (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2549 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2554 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 28: -#line 379 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 379 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); (yyval.str) = (yyvsp[0].str); } -#line 2558 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2563 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 29: -#line 385 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 385 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); (yyval.str) = (yyvsp[0].str); } -#line 2567 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2572 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 30: -#line 392 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 392 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); (yyval.str) = (yyvsp[0].str); } -#line 2576 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2581 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 31: -#line 399 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 399 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); (yyval.str) = (yyvsp[0].str); } -#line 2585 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2590 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 32: -#line 405 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 405 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); (yyval.str) = (yyvsp[0].str); } -#line 2594 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2599 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 33: -#line 412 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 412 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); yyGetParser->AddClassFound((yyvsp[-2].str)); @@ -2602,11 +2607,11 @@ yyreduce: yyGetParser->DeallocateParserType(&((yyvsp[-2].str))); (yyval.str) = const_cast<char*>(yyGetParser->GetCurrentCombine()); } -#line 2606 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2611 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 34: -#line 421 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 421 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpStoreClass((yyvsp[-2].str)); @@ -2615,11 +2620,11 @@ yyreduce: (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2619 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2624 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 35: -#line 431 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 431 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpStoreClass((yyvsp[-2].str)); @@ -2628,118 +2633,118 @@ yyreduce: (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2632 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2637 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 36: -#line 441 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 441 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2643 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2648 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 37: -#line 450 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 450 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2654 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2659 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 38: -#line 458 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 458 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2665 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2670 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 39: -#line 467 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 467 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2676 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2681 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 40: -#line 475 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 475 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2686 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2691 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 41: -#line 482 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 482 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2697 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2702 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 42: -#line 490 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 490 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2707 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2712 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 43: -#line 497 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 497 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2718 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2723 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 44: -#line 505 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 505 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2728 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2733 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 45: -#line 512 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 512 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2739 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2744 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 46: -#line 521 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 521 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); yyGetParser->SetCurrentPackage((yyvsp[-1].str)); @@ -2749,33 +2754,33 @@ yyreduce: (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2753 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2758 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 47: -#line 533 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 533 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2764 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2769 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 48: -#line 541 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 541 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2775 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2780 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 49: -#line 550 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 550 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); yyGetParser->AddPackagesImport((yyvsp[-1].str)); @@ -2785,11 +2790,11 @@ yyreduce: (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2789 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2794 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 50: -#line 562 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 562 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); std::string str = (yyvsp[-3].str); @@ -2800,77 +2805,77 @@ yyreduce: (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2804 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2809 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 51: -#line 575 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 575 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2815 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2820 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 52: -#line 583 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 583 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2826 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2831 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 53: -#line 591 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 591 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2837 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2842 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 54: -#line 600 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 600 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2848 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2853 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 55: -#line 608 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 608 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2859 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2864 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 67: -#line 623 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 623 "cmDependsJavaParser.y" /* yacc.c:1652 */ { yyGetParser->StartClass((yyvsp[0].str)); jpElementStart(3); yyGetParser->DeallocateParserType(&((yyvsp[0].str))); jpCheckEmpty(3); } -#line 2870 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2875 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 68: -#line 633 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 633 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -2878,11 +2883,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); yyGetParser->EndClass(); } -#line 2882 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2887 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 69: -#line 642 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 642 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(2); @@ -2890,11 +2895,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); yyGetParser->EndClass(); } -#line 2894 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2899 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 70: -#line 651 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 651 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -2902,11 +2907,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); yyGetParser->EndClass(); } -#line 2906 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2911 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 71: -#line 660 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 660 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -2914,226 +2919,226 @@ yyreduce: yyGetParser->SetCurrentCombine(""); yyGetParser->EndClass(); } -#line 2918 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2923 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 72: -#line 669 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 669 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2928 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2933 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 73: -#line 676 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 676 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2939 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2944 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 74: -#line 685 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 685 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2950 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2955 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 75: -#line 694 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 694 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2961 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2966 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 76: -#line 703 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 703 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2972 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2977 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 77: -#line 711 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 711 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2983 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2988 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 78: -#line 720 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 720 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 2994 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 2999 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 79: -#line 728 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 728 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3004 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3009 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 80: -#line 735 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 735 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3015 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3020 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 81: -#line 744 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 744 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3026 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3031 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 82: -#line 752 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 752 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3037 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3042 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 83: -#line 760 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 760 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3048 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3053 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 84: -#line 768 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 768 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3059 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3064 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 85: -#line 777 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 777 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3070 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3075 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 86: -#line 785 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 785 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3081 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3086 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 87: -#line 794 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 794 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); } -#line 3089 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3094 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 88: -#line 800 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 800 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3100 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3105 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 89: -#line 808 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 808 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3111 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3116 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 90: -#line 817 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 817 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3122 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3127 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 91: -#line 825 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 825 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3133 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3138 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 92: -#line 834 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 834 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); yyGetParser->DeallocateParserType(&((yyvsp[0].str))); @@ -3141,77 +3146,77 @@ yyreduce: (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3145 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3150 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 93: -#line 843 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 843 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3156 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3161 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 94: -#line 852 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 852 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3167 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3172 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 95: -#line 860 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 860 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3178 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3183 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 96: -#line 869 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 869 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3189 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3194 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 97: -#line 877 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 877 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3200 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3205 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 98: -#line 885 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 885 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3211 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3216 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 99: -#line 894 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 894 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -3219,11 +3224,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3223 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3228 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 100: -#line 903 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 903 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -3231,22 +3236,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3235 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3240 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 101: -#line 912 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 912 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3246 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3251 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 102: -#line 920 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 920 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3254,11 +3259,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3258 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3263 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 103: -#line 930 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 930 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); yyGetParser->DeallocateParserType(&((yyvsp[-3].str))); @@ -3267,40 +3272,40 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3271 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3276 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 104: -#line 940 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 940 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); } -#line 3280 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3285 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 105: -#line 946 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 946 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3291 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3296 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 107: -#line 957 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 957 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); } -#line 3300 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3305 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 108: -#line 963 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 963 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -3308,11 +3313,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3312 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3317 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 109: -#line 973 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 973 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -3320,11 +3325,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3324 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3329 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 110: -#line 983 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 983 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -3332,20 +3337,20 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3336 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3341 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 111: -#line 993 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 993 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); } -#line 3345 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3350 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 112: -#line 999 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 999 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -3353,11 +3358,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3357 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3362 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 113: -#line 1009 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1009 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3365,11 +3370,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3369 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3374 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 114: -#line 1019 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1019 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -3377,11 +3382,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3381 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3386 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 115: -#line 1029 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1029 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -3389,11 +3394,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3393 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3398 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 116: -#line 1038 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1038 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); jpCheckEmpty(5); @@ -3401,11 +3406,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3405 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3410 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 117: -#line 1048 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1048 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); yyGetParser->DeallocateParserType(&((yyvsp[-3].str))); @@ -3414,11 +3419,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3418 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3423 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 118: -#line 1059 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1059 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -3426,22 +3431,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3430 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3435 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 119: -#line 1068 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1068 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3441 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3446 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 120: -#line 1076 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1076 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -3449,11 +3454,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3453 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3458 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 121: -#line 1086 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1086 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); jpCheckEmpty(5); @@ -3461,11 +3466,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3465 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3470 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 122: -#line 1095 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1095 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); jpCheckEmpty(5); @@ -3473,22 +3478,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3477 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3482 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 123: -#line 1105 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1105 "cmDependsJavaParser.y" /* yacc.c:1652 */ { yyGetParser->StartClass((yyvsp[0].str)); jpElementStart(3); yyGetParser->DeallocateParserType(&((yyvsp[0].str))); jpCheckEmpty(3); } -#line 3488 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3493 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 124: -#line 1114 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1114 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -3496,21 +3501,21 @@ yyreduce: yyGetParser->SetCurrentCombine(""); yyGetParser->EndClass(); } -#line 3500 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3505 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 125: -#line 1123 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1123 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3510 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3515 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 126: -#line 1130 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1130 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3518,11 +3523,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3522 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3527 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 127: -#line 1140 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1140 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -3530,11 +3535,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3534 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3539 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 128: -#line 1149 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1149 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -3542,11 +3547,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3546 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3551 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 129: -#line 1159 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1159 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -3554,33 +3559,33 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3558 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3563 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 130: -#line 1168 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1168 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3569 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3574 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 131: -#line 1176 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1176 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3580 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3585 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 132: -#line 1185 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1185 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3588,11 +3593,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3592 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3597 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 133: -#line 1194 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1194 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3600,11 +3605,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3604 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3609 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 134: -#line 1203 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1203 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3612,22 +3617,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3616 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3621 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 135: -#line 1212 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1212 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3627 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3632 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 136: -#line 1220 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1220 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3635,22 +3640,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3639 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3644 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 137: -#line 1229 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1229 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3650 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3655 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 138: -#line 1238 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1238 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3658,11 +3663,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3662 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3667 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 139: -#line 1248 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1248 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -3670,11 +3675,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3674 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3679 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 140: -#line 1258 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1258 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3682,11 +3687,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3686 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3691 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 141: -#line 1267 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1267 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -3694,11 +3699,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3698 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3703 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 142: -#line 1277 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1277 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -3706,22 +3711,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3710 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3715 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 143: -#line 1286 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1286 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3721 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3726 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 144: -#line 1294 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1294 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3729,11 +3734,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3733 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3738 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 145: -#line 1303 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1303 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -3741,11 +3746,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3745 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3750 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 146: -#line 1313 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1313 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3753,11 +3758,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3757 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3762 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 147: -#line 1322 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1322 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -3765,33 +3770,33 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3769 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3774 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 148: -#line 1332 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1332 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3780 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3785 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 149: -#line 1340 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1340 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 3791 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3796 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 150: -#line 1348 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1348 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3799,11 +3804,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3803 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3808 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 151: -#line 1358 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1358 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3811,11 +3816,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3815 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3820 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 152: -#line 1367 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1367 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(2); @@ -3823,11 +3828,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3827 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3832 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 153: -#line 1377 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1377 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3835,11 +3840,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3839 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3844 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 154: -#line 1386 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1386 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3847,11 +3852,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3851 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3856 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 155: -#line 1395 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1395 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3859,11 +3864,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3863 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3868 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 156: -#line 1405 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1405 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(2); @@ -3871,11 +3876,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3875 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3880 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 157: -#line 1415 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1415 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(3); @@ -3883,11 +3888,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3887 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3892 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 158: -#line 1424 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1424 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(2); @@ -3895,11 +3900,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3899 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3904 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 159: -#line 1434 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1434 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3907,11 +3912,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3911 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3916 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 160: -#line 1443 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1443 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3919,11 +3924,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3923 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3928 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 161: -#line 1452 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1452 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3931,11 +3936,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3935 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3940 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 162: -#line 1461 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1461 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3943,11 +3948,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3947 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3952 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 163: -#line 1470 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1470 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3955,11 +3960,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3959 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3964 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 164: -#line 1479 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1479 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3967,11 +3972,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3971 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3976 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 165: -#line 1489 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1489 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3979,11 +3984,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3983 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 3988 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 166: -#line 1498 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1498 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -3991,11 +3996,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 3995 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4000 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 167: -#line 1507 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1507 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4003,11 +4008,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4007 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4012 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 168: -#line 1516 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1516 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4015,11 +4020,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4019 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4024 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 169: -#line 1525 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1525 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4027,11 +4032,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4031 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4036 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 170: -#line 1535 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1535 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4039,11 +4044,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4043 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4048 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 171: -#line 1544 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1544 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4051,11 +4056,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4055 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4060 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 172: -#line 1553 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1553 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4063,11 +4068,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4067 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4072 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 173: -#line 1562 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1562 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4075,11 +4080,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4079 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4084 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 174: -#line 1571 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1571 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4087,11 +4092,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4091 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4096 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 175: -#line 1580 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1580 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4099,11 +4104,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4103 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4108 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 176: -#line 1589 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1589 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4111,11 +4116,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4115 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4120 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 177: -#line 1598 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1598 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4123,11 +4128,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4127 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4132 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 178: -#line 1607 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1607 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4135,11 +4140,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4139 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4144 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 179: -#line 1616 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1616 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4147,11 +4152,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4151 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4156 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 180: -#line 1625 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1625 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4159,11 +4164,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4163 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4168 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 181: -#line 1634 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1634 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4171,11 +4176,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4175 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4180 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 182: -#line 1644 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1644 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4183,11 +4188,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4187 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4192 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 183: -#line 1654 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1654 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); yyGetParser->DeallocateParserType(&((yyvsp[-2].str))); @@ -4196,11 +4201,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4200 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4205 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 184: -#line 1665 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1665 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -4208,11 +4213,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4212 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4217 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 185: -#line 1675 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1675 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -4220,11 +4225,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4224 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4229 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 186: -#line 1685 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1685 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4232,11 +4237,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4236 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4241 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 187: -#line 1694 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1694 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4244,11 +4249,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4248 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4253 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 188: -#line 1703 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1703 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4256,11 +4261,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4260 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4265 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 189: -#line 1712 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1712 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4268,11 +4273,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4272 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4277 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 190: -#line 1721 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1721 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4280,11 +4285,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4284 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4289 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 191: -#line 1730 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1730 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4292,11 +4297,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4296 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4301 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 192: -#line 1739 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1739 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4304,11 +4309,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4308 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4313 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 193: -#line 1749 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1749 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); jpCheckEmpty(5); @@ -4316,11 +4321,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4320 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4325 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 194: -#line 1759 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1759 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(7); jpCheckEmpty(7); @@ -4328,11 +4333,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4332 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4337 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 195: -#line 1769 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1769 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(7); jpCheckEmpty(7); @@ -4340,40 +4345,40 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4344 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4349 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 196: -#line 1779 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1779 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); } -#line 4353 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4358 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 197: -#line 1786 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1786 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); } -#line 4362 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4367 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 198: -#line 1792 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1792 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 4373 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4378 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 199: -#line 1800 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1800 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4381,22 +4386,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4385 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4390 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 200: -#line 1809 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1809 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 4396 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4401 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 201: -#line 1817 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1817 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -4404,11 +4409,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4408 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4413 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 202: -#line 1827 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1827 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -4416,11 +4421,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4420 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4425 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 203: -#line 1837 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1837 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4428,11 +4433,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4432 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4437 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 204: -#line 1846 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1846 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -4440,11 +4445,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4444 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4449 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 205: -#line 1856 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1856 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -4452,11 +4457,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4456 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4461 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 206: -#line 1865 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1865 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -4464,58 +4469,58 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4468 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4473 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 207: -#line 1875 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1875 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); } -#line 4477 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4482 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 208: -#line 1882 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1882 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); } -#line 4486 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4491 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 209: -#line 1889 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1889 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(7); } -#line 4495 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4500 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 210: -#line 1897 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1897 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(9); } -#line 4504 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4509 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 211: -#line 1903 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1903 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 4515 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4520 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 212: -#line 1911 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1911 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4523,22 +4528,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4527 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4532 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 213: -#line 1920 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1920 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 4538 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4543 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 214: -#line 1928 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1928 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4546,33 +4551,33 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4550 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4555 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 215: -#line 1939 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1939 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(9); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 4561 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4566 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 216: -#line 1947 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1947 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 4572 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4577 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 217: -#line 1955 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1955 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4580,11 +4585,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4584 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4589 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 218: -#line 1965 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1965 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4592,11 +4597,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4596 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4601 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 219: -#line 1974 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1974 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4604,11 +4609,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4608 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4613 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 220: -#line 1984 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1984 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4616,11 +4621,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4620 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4625 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 221: -#line 1994 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 1994 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4628,11 +4633,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4632 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4637 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 222: -#line 2003 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2003 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -4640,11 +4645,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4644 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4649 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 223: -#line 2013 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2013 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -4652,11 +4657,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4656 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4661 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 224: -#line 2022 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2022 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); jpCheckEmpty(5); @@ -4664,11 +4669,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4668 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4673 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 225: -#line 2032 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2032 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); yyGetParser->DeallocateParserType(&((yyvsp[-1].str))); @@ -4677,31 +4682,31 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4681 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4686 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 226: -#line 2042 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2042 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 4692 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4697 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 227: -#line 2050 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2050 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); } -#line 4701 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4706 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 228: -#line 2057 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2057 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); yyGetParser->DeallocateParserType(&((yyvsp[-1].str))); @@ -4710,11 +4715,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4714 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4719 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 229: -#line 2068 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2068 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -4722,11 +4727,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4726 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4731 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 230: -#line 2078 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2078 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -4734,11 +4739,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4738 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4743 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 231: -#line 2088 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2088 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); jpCheckEmpty(5); @@ -4746,11 +4751,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4750 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4755 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 232: -#line 2098 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2098 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -4758,11 +4763,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4762 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4767 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 233: -#line 2107 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2107 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -4770,22 +4775,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4774 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4779 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 234: -#line 2116 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2116 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 4785 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4790 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 235: -#line 2124 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2124 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4793,11 +4798,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4797 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4802 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 236: -#line 2134 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2134 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4805,11 +4810,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4809 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4814 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 237: -#line 2143 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2143 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -4817,20 +4822,20 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4821 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4826 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 238: -#line 2153 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2153 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); } -#line 4830 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4835 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 239: -#line 2160 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2160 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -4838,11 +4843,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4842 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4847 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 240: -#line 2170 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2170 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4850,11 +4855,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4854 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4859 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 241: -#line 2179 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2179 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4862,11 +4867,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4866 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4871 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 242: -#line 2189 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2189 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4874,20 +4879,20 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4878 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4883 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 243: -#line 2198 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2198 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); } -#line 4887 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4892 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 244: -#line 2204 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2204 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -4895,11 +4900,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4899 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4904 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 245: -#line 2213 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2213 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4907,11 +4912,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4911 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4916 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 246: -#line 2222 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2222 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4919,11 +4924,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4923 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4928 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 247: -#line 2231 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2231 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4931,11 +4936,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4935 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4940 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 248: -#line 2240 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2240 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4943,11 +4948,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4947 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4952 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 249: -#line 2250 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2250 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(6); jpCheckEmpty(6); @@ -4955,22 +4960,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4959 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4964 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 250: -#line 2259 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2259 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 4970 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4975 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 251: -#line 2267 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2267 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -4978,22 +4983,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 4982 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4987 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 252: -#line 2276 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2276 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 4993 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 4998 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 253: -#line 2284 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2284 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5001,11 +5006,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5005 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5010 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 254: -#line 2294 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2294 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5013,11 +5018,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5017 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5022 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 255: -#line 2303 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2303 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5025,11 +5030,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5029 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5034 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 256: -#line 2313 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2313 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -5037,11 +5042,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5041 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5046 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 257: -#line 2322 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2322 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -5049,11 +5054,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5053 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5058 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 258: -#line 2331 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2331 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -5061,11 +5066,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5065 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5070 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 259: -#line 2340 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2340 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -5073,22 +5078,22 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5077 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5082 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 260: -#line 2349 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2349 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(0); (yyval.str) = 0; yyGetParser->SetCurrentCombine(""); } -#line 5088 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5093 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 261: -#line 2357 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2357 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5096,11 +5101,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5100 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5105 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 262: -#line 2367 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2367 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5108,11 +5113,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5112 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5117 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 263: -#line 2376 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2376 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -5120,11 +5125,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5124 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5129 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 264: -#line 2386 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2386 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5132,29 +5137,29 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5136 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5141 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 265: -#line 2396 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2396 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); } -#line 5145 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5150 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 266: -#line 2402 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2402 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); } -#line 5154 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5159 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 267: -#line 2409 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2409 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); yyGetParser->DeallocateParserType(&((yyvsp[0].str))); @@ -5163,11 +5168,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5167 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5172 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 268: -#line 2419 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2419 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); yyGetParser->DeallocateParserType(&((yyvsp[0].str))); @@ -5176,11 +5181,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5180 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5185 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 269: -#line 2429 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2429 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); yyGetParser->DeallocateParserType(&((yyvsp[0].str))); @@ -5189,11 +5194,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5193 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5198 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 270: -#line 2439 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2439 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); yyGetParser->DeallocateParserType(&((yyvsp[0].str))); @@ -5202,11 +5207,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5206 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5211 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 271: -#line 2450 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2450 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); yyGetParser->DeallocateParserType(&((yyvsp[-3].str))); @@ -5215,11 +5220,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5219 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5224 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 272: -#line 2460 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2460 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(6); yyGetParser->DeallocateParserType(&((yyvsp[-5].str))); @@ -5229,11 +5234,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5233 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5238 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 273: -#line 2471 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2471 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(6); yyGetParser->DeallocateParserType(&((yyvsp[-3].str))); @@ -5242,11 +5247,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5246 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5251 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 274: -#line 2481 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2481 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(6); yyGetParser->DeallocateParserType(&((yyvsp[-3].str))); @@ -5255,11 +5260,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5259 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5264 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 275: -#line 2492 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2492 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); yyGetParser->DeallocateParserType(&((yyvsp[-3].str))); @@ -5268,11 +5273,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5272 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5277 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 276: -#line 2502 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2502 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -5280,11 +5285,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5284 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5289 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 277: -#line 2512 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2512 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5292,11 +5297,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5296 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5301 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 278: -#line 2521 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2521 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); yyGetParser->DeallocateParserType(&((yyvsp[0].str))); @@ -5304,11 +5309,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5308 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5313 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 279: -#line 2530 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2530 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5316,11 +5321,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5320 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5325 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 280: -#line 2539 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2539 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5328,11 +5333,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5332 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5337 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 281: -#line 2548 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2548 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5340,11 +5345,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5344 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5349 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 282: -#line 2558 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2558 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -5352,11 +5357,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5356 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5361 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 283: -#line 2568 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2568 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -5364,11 +5369,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5368 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5373 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 284: -#line 2578 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2578 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5376,11 +5381,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5380 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5385 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 285: -#line 2587 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2587 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5388,11 +5393,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5392 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5397 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 286: -#line 2596 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2596 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -5400,11 +5405,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5404 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5409 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 287: -#line 2605 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2605 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -5412,11 +5417,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5416 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5421 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 288: -#line 2614 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2614 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5424,11 +5429,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5428 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5433 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 289: -#line 2624 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2624 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -5436,11 +5441,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5440 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5445 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 290: -#line 2634 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2634 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -5448,11 +5453,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5452 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5457 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 291: -#line 2644 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2644 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5460,11 +5465,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5464 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5469 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 292: -#line 2653 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2653 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -5472,11 +5477,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5476 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5481 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 293: -#line 2662 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2662 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(2); jpCheckEmpty(2); @@ -5484,11 +5489,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5488 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5493 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 294: -#line 2671 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2671 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5496,11 +5501,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5500 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5505 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 295: -#line 2681 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2681 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); jpCheckEmpty(5); @@ -5508,11 +5513,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5512 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5517 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 296: -#line 2690 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2690 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(4); jpCheckEmpty(4); @@ -5520,20 +5525,20 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5524 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5529 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 297: -#line 2699 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2699 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); } -#line 5533 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5538 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 298: -#line 2706 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2706 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5541,11 +5546,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5545 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5550 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 299: -#line 2715 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2715 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5553,11 +5558,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5557 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5562 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 300: -#line 2724 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2724 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5565,11 +5570,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5569 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5574 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 301: -#line 2733 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2733 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5577,11 +5582,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5581 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5586 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 302: -#line 2743 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2743 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5589,11 +5594,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5593 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5598 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 303: -#line 2752 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2752 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5601,11 +5606,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5605 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5610 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 304: -#line 2761 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2761 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5613,11 +5618,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5617 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5622 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 305: -#line 2771 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2771 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5625,11 +5630,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5629 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5634 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 306: -#line 2780 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2780 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5637,11 +5642,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5641 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5646 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 307: -#line 2789 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2789 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5649,11 +5654,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5653 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5658 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 308: -#line 2798 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2798 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5661,11 +5666,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5665 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5670 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 309: -#line 2808 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2808 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5673,11 +5678,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5677 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5682 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 310: -#line 2817 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2817 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5685,11 +5690,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5689 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5694 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 311: -#line 2826 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2826 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5697,11 +5702,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5701 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5706 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 312: -#line 2835 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2835 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5709,11 +5714,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5713 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5718 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 313: -#line 2844 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2844 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5721,11 +5726,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5725 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5730 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 314: -#line 2853 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2853 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5733,11 +5738,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5737 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5742 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 315: -#line 2863 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2863 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5745,11 +5750,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5749 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5754 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 316: -#line 2872 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2872 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5757,11 +5762,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5761 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5766 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 317: -#line 2881 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2881 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5769,11 +5774,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5773 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5778 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 318: -#line 2891 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2891 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5781,11 +5786,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5785 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5790 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 319: -#line 2900 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2900 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5793,11 +5798,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5797 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5802 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 320: -#line 2910 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2910 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5805,11 +5810,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5809 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5814 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 321: -#line 2919 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2919 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5817,11 +5822,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5821 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5826 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 322: -#line 2929 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2929 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5829,11 +5834,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5833 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5838 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 323: -#line 2938 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2938 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5841,11 +5846,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5845 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5850 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 324: -#line 2948 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2948 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5853,11 +5858,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5857 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5862 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 325: -#line 2957 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2957 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5865,11 +5870,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5869 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5874 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 326: -#line 2967 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2967 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5877,11 +5882,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5881 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5886 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 327: -#line 2976 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2976 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5889,11 +5894,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5893 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5898 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 328: -#line 2986 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2986 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5901,11 +5906,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5905 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5910 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 329: -#line 2995 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 2995 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(5); jpCheckEmpty(5); @@ -5913,11 +5918,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5917 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5922 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 330: -#line 3005 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3005 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5925,11 +5930,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5929 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5934 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 331: -#line 3014 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3014 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5937,11 +5942,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5941 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5946 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 332: -#line 3024 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3024 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpCheckEmpty(3); @@ -5949,11 +5954,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5953 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5958 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 333: -#line 3034 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3034 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); yyGetParser->DeallocateParserType(&((yyvsp[0].str))); @@ -5962,11 +5967,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5966 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5971 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 334: -#line 3044 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3044 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5974,11 +5979,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5978 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5983 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 335: -#line 3053 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3053 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5986,11 +5991,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 5990 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 5995 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 336: -#line 3063 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3063 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -5998,11 +6003,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6002 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6007 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 337: -#line 3072 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3072 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6010,11 +6015,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6014 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6019 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 338: -#line 3081 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3081 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6022,11 +6027,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6026 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6031 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 339: -#line 3090 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3090 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6034,11 +6039,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6038 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6043 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 340: -#line 3099 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3099 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6046,11 +6051,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6050 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6055 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 341: -#line 3108 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3108 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6058,11 +6063,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6062 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6067 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 342: -#line 3117 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3117 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6070,11 +6075,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6074 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6079 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 343: -#line 3126 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3126 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6082,11 +6087,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6086 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6091 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 344: -#line 3135 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3135 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6094,11 +6099,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6098 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6103 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 345: -#line 3144 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3144 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6106,11 +6111,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6110 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6115 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 346: -#line 3153 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3153 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6118,11 +6123,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6122 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6127 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 347: -#line 3162 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3162 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6130,11 +6135,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6134 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6139 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 348: -#line 3172 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3172 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6142,11 +6147,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6146 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6151 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 349: -#line 3182 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3182 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6154,11 +6159,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6158 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6163 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 350: -#line 3192 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3192 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(1); jpCheckEmpty(1); @@ -6166,11 +6171,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6170 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6175 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; case 351: -#line 3201 "cmDependsJavaParser.y" /* yacc.c:1646 */ +#line 3201 "cmDependsJavaParser.y" /* yacc.c:1652 */ { jpElementStart(3); jpStoreClass((yyvsp[-2].str)); @@ -6179,11 +6184,11 @@ yyreduce: yyGetParser->SetCurrentCombine(""); } -#line 6183 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6188 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ break; -#line 6187 "cmDependsJavaParser.cxx" /* yacc.c:1646 */ +#line 6192 "cmDependsJavaParser.cxx" /* yacc.c:1652 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -6208,14 +6213,13 @@ yyreduce: /* Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTOKENS]; + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } goto yynewstate; @@ -6299,12 +6303,10 @@ yyerrlab: | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: - - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (/*CONSTCOND*/ 0) - goto yyerrorlab; + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ @@ -6367,6 +6369,7 @@ yyacceptlab: yyresult = 0; goto yyreturn; + /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ @@ -6374,6 +6377,7 @@ yyabortlab: yyresult = 1; goto yyreturn; + #if !defined yyoverflow || YYERROR_VERBOSE /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | @@ -6384,6 +6388,10 @@ yyexhaustedlab: /* Fall through. */ #endif + +/*-----------------------------------------------------. +| yyreturn -- parsing is finished, return the result. | +`-----------------------------------------------------*/ yyreturn: if (yychar != YYEMPTY) { @@ -6413,7 +6421,7 @@ yyreturn: #endif return yyresult; } -#line 3210 "cmDependsJavaParser.y" /* yacc.c:1906 */ +#line 3210 "cmDependsJavaParser.y" /* yacc.c:1918 */ /* End of grammar */ diff --git a/Source/LexerParser/cmDependsJavaParserTokens.h b/Source/LexerParser/cmDependsJavaParserTokens.h index 7f18f1d..6bbc084 100644 --- a/Source/LexerParser/cmDependsJavaParserTokens.h +++ b/Source/LexerParser/cmDependsJavaParserTokens.h @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.3.2. */ /* Bison interface for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -30,6 +31,9 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + #ifndef YY_CMDEPENDSJAVA_YY_CMDEPENDSJAVAPARSERTOKENS_H_INCLUDED # define YY_CMDEPENDSJAVA_YY_CMDEPENDSJAVAPARSERTOKENS_H_INCLUDED /* Debug traces. */ diff --git a/Source/LexerParser/cmExprParser.cxx b/Source/LexerParser/cmExprParser.cxx index 73ece2b..8416e72 100644 --- a/Source/LexerParser/cmExprParser.cxx +++ b/Source/LexerParser/cmExprParser.cxx @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.3.2. */ /* Bison implementation for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -40,11 +41,14 @@ define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "3.0.4" +#define YYBISON_VERSION "3.3.2" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -67,8 +71,8 @@ #define yynerrs cmExpr_yynerrs -/* Copy the first part of user declarations. */ -#line 1 "cmExprParser.y" /* yacc.c:339 */ +/* First part of user prologue. */ +#line 1 "cmExprParser.y" /* yacc.c:337 */ /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ @@ -112,13 +116,16 @@ static void cmExpr_yyerror(yyscan_t yyscanner, const char* message); # pragma GCC diagnostic ignored "-Wconversion" #endif -#line 116 "cmExprParser.cxx" /* yacc.c:339 */ - +#line 120 "cmExprParser.cxx" /* yacc.c:337 */ # ifndef YY_NULLPTR -# if defined __cplusplus && 201103L <= __cplusplus -# define YY_NULLPTR nullptr +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif # else -# define YY_NULLPTR 0 +# define YY_NULLPTR ((void*)0) # endif # endif @@ -187,9 +194,7 @@ int cmExpr_yyparse (yyscan_t yyscanner); #endif /* !YY_CMEXPR_YY_CMEXPRPARSERTOKENS_H_INCLUDED */ -/* Copy the second part of user declarations. */ -#line 193 "cmExprParser.cxx" /* yacc.c:358 */ #ifdef short # undef short @@ -210,13 +215,13 @@ typedef signed char yytype_int8; #ifdef YYTYPE_UINT16 typedef YYTYPE_UINT16 yytype_uint16; #else -typedef unsigned short int yytype_uint16; +typedef unsigned short yytype_uint16; #endif #ifdef YYTYPE_INT16 typedef YYTYPE_INT16 yytype_int16; #else -typedef short int yytype_int16; +typedef short yytype_int16; #endif #ifndef YYSIZE_T @@ -228,7 +233,7 @@ typedef short int yytype_int16; # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else -# define YYSIZE_T unsigned int +# define YYSIZE_T unsigned # endif #endif @@ -264,15 +269,6 @@ typedef short int yytype_int16; # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) #endif -#if !defined _Noreturn \ - && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) -# if defined _MSC_VER && 1200 <= _MSC_VER -# define _Noreturn __declspec (noreturn) -# else -# define _Noreturn YY_ATTRIBUTE ((__noreturn__)) -# endif -#endif - /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ # define YYUSE(E) ((void) (E)) @@ -280,7 +276,7 @@ typedef short int yytype_int16; # define YYUSE(E) /* empty */ #endif -#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ _Pragma ("GCC diagnostic push") \ @@ -429,29 +425,29 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 17 +#define YYFINAL 19 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 30 +#define YYLAST 34 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 17 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 10 /* YYNRULES -- Number of rules. */ -#define YYNRULES 23 +#define YYNRULES 24 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 39 +#define YYNSTATES 41 -/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned - by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 #define YYMAXUTOK 271 +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ #define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM - as returned by yylex, without out-of-bounds checking. */ + as returned by yylex. */ static const yytype_uint8 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -490,7 +486,7 @@ static const yytype_uint8 yyrline[] = { 0, 77, 77, 82, 85, 90, 93, 98, 101, 106, 109, 112, 117, 120, 123, 128, 131, 134, 140, 145, - 148, 151, 156, 159 + 148, 151, 154, 159, 162 }; #endif @@ -517,10 +513,10 @@ static const yytype_uint16 yytoknum[] = }; # endif -#define YYPACT_NINF -8 +#define YYPACT_NINF -11 #define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-8))) + (!!((Yystate) == (-11))) #define YYTABLE_NINF -1 @@ -531,10 +527,11 @@ static const yytype_uint16 yytoknum[] = STATE-NUM. */ static const yytype_int8 yypact[] = { - 0, 0, 0, 0, -8, 2, -7, -5, 8, 3, - 10, 1, -8, -8, -8, -8, 6, -8, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -8, -5, - 8, 3, 10, 10, 1, 1, -8, -8, -8 + 1, 1, 1, 1, 1, -11, 6, -10, -4, 9, + 4, 11, 2, -11, -11, -11, -11, 7, -11, -11, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + -11, -4, 9, 4, 11, 11, 2, 2, -11, -11, + -11 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -542,22 +539,23 @@ static const yytype_int8 yypact[] = means the default is an error. */ static const yytype_uint8 yydefact[] = { - 0, 0, 0, 0, 22, 0, 2, 3, 5, 7, - 9, 12, 15, 19, 20, 21, 0, 1, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 23, 4, - 6, 8, 10, 11, 13, 14, 16, 17, 18 + 0, 0, 0, 0, 0, 23, 0, 2, 3, 5, + 7, 9, 12, 15, 19, 20, 21, 0, 22, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 24, 4, 6, 8, 10, 11, 13, 14, 16, 17, + 18 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int8 yypgoto[] = { - -8, -8, 12, 5, 11, 9, -2, 4, -1, -8 + -11, -11, 22, 10, 8, 12, -3, -2, -1, -11 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int8 yydefgoto[] = { - -1, 5, 6, 7, 8, 9, 10, 11, 12, 13 + -1, 6, 7, 8, 9, 10, 11, 12, 13, 14 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -565,28 +563,29 @@ static const yytype_int8 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_uint8 yytable[] = { - 14, 15, 17, 1, 2, 18, 25, 26, 27, 19, - 3, 21, 22, 23, 24, 16, 4, 28, 18, 32, - 33, 20, 0, 29, 36, 37, 38, 34, 35, 31, - 30 + 15, 16, 20, 18, 1, 2, 19, 27, 28, 29, + 21, 3, 23, 24, 25, 26, 4, 5, 30, 20, + 34, 35, 22, 36, 37, 17, 38, 39, 40, 32, + 31, 0, 0, 0, 33 }; static const yytype_int8 yycheck[] = { - 1, 2, 0, 3, 4, 12, 5, 6, 7, 14, - 10, 8, 9, 3, 4, 3, 16, 11, 12, 21, - 22, 13, -1, 18, 25, 26, 27, 23, 24, 20, - 19 + 1, 2, 12, 4, 3, 4, 0, 5, 6, 7, + 14, 10, 8, 9, 3, 4, 15, 16, 11, 12, + 23, 24, 13, 25, 26, 3, 27, 28, 29, 21, + 20, -1, -1, -1, 22 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint8 yystos[] = { - 0, 3, 4, 10, 16, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 25, 25, 19, 0, 12, 14, - 13, 8, 9, 3, 4, 5, 6, 7, 11, 20, - 21, 22, 23, 23, 24, 24, 25, 25, 25 + 0, 3, 4, 10, 15, 16, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 25, 25, 19, 25, 0, + 12, 14, 13, 8, 9, 3, 4, 5, 6, 7, + 11, 20, 21, 22, 23, 23, 24, 24, 25, 25, + 25 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ @@ -594,7 +593,7 @@ static const yytype_uint8 yyr1[] = { 0, 17, 18, 19, 19, 20, 20, 21, 21, 22, 22, 22, 23, 23, 23, 24, 24, 24, 24, 25, - 25, 25, 26, 26 + 25, 25, 25, 26, 26 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ @@ -602,7 +601,7 @@ static const yytype_uint8 yyr2[] = { 0, 2, 1, 1, 3, 1, 3, 1, 3, 1, 3, 3, 1, 3, 3, 1, 3, 3, 3, 1, - 2, 2, 1, 3 + 2, 2, 2, 1, 3 }; @@ -618,22 +617,22 @@ static const yytype_uint8 yyr2[] = #define YYRECOVERING() (!!yyerrstatus) -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - YYPOPSTACK (yylen); \ - yystate = *yyssp; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (yyscanner, YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (0) +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (yyscanner, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) /* Error token number */ #define YYTERROR 1 @@ -673,38 +672,38 @@ do { \ } while (0) -/*----------------------------------------. -| Print this symbol's value on YYOUTPUT. | -`----------------------------------------*/ +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ static void -yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) +yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) { - FILE *yyo = yyoutput; - YYUSE (yyo); + FILE *yyoutput = yyo; + YYUSE (yyoutput); YYUSE (yyscanner); if (!yyvaluep) return; # ifdef YYPRINT if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); + YYPRINT (yyo, yytoknum[yytype], *yyvaluep); # endif YYUSE (yytype); } -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ static void -yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) +yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) { - YYFPRINTF (yyoutput, "%s %s (", + YYFPRINTF (yyo, "%s %s (", yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); - yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner); - YYFPRINTF (yyoutput, ")"); + yy_symbol_value_print (yyo, yytype, yyvaluep, yyscanner); + YYFPRINTF (yyo, ")"); } /*------------------------------------------------------------------. @@ -738,7 +737,7 @@ do { \ static void yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yyscanner) { - unsigned long int yylno = yyrline[yyrule]; + unsigned long yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", @@ -749,7 +748,7 @@ yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yysca YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, yystos[yyssp[yyi + 1 - yynrhs]], - &(yyvsp[(yyi + 1) - (yynrhs)]) + &yyvsp[(yyi + 1) - (yynrhs)] , yyscanner); YYFPRINTF (stderr, "\n"); } @@ -853,7 +852,10 @@ yytnamerr (char *yyres, const char *yystr) case '\\': if (*++yyp != '\\') goto do_not_strip_quotes; - /* Fall through. */ + else + goto append; + + append: default: if (yyres) yyres[yyn] = *yyp; @@ -871,7 +873,7 @@ yytnamerr (char *yyres, const char *yystr) if (! yyres) return yystrlen (yystr); - return yystpcpy (yyres, yystr) - yyres; + return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres); } # endif @@ -949,10 +951,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yyarg[yycount++] = yytname[yyx]; { YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); - if (! (yysize <= yysize1 - && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } } } @@ -964,6 +966,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, case N: \ yyformat = S; \ break + default: /* Avoid compiler warnings. */ YYCASE_(0, YY_("syntax error")); YYCASE_(1, YY_("syntax error, unexpected %s")); YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); @@ -975,9 +978,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, { YYSIZE_T yysize1 = yysize + yystrlen (yyformat); - if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } if (*yymsg_alloc < yysize) @@ -1108,23 +1112,31 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); yychar = YYEMPTY; /* Cause a token to be read. */ goto yysetstate; + /*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | +| yynewstate -- push a new state, which is found in yystate. | `------------------------------------------------------------*/ - yynewstate: +yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; - yysetstate: - *yyssp = yystate; + +/*--------------------------------------------------------------------. +| yynewstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + *yyssp = (yytype_int16) yystate; if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + goto yyexhaustedlab; +#else { /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; + YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1); -#ifdef yyoverflow +# if defined yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into @@ -1140,14 +1152,10 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yystacksize); - yyss = yyss1; yyvs = yyvs1; } -#else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -# else +# else /* defined YYSTACK_RELOCATE */ /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab; @@ -1163,22 +1171,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); goto yyexhaustedlab; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); -# undef YYSTACK_RELOCATE +# undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif -#endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); + (unsigned long) yystacksize)); if (yyss + yystacksize - 1 <= yyssp) YYABORT; } +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ YYDPRINTF ((stderr, "Entering state %d\n", yystate)); @@ -1187,11 +1195,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); goto yybackup; + /*-----------. | yybackup. | `-----------*/ yybackup: - /* Do appropriate processing given the current state. Read a lookahead token if we need one and don't already have one. */ @@ -1264,7 +1272,7 @@ yydefault: /*-----------------------------. -| yyreduce -- Do a reduction. | +| yyreduce -- do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ @@ -1285,186 +1293,194 @@ yyreduce: switch (yyn) { case 2: -#line 77 "cmExprParser.y" /* yacc.c:1646 */ +#line 77 "cmExprParser.y" /* yacc.c:1652 */ { cmExpr_yyget_extra(yyscanner)->SetResult((yyvsp[0].Number)); } -#line 1293 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1301 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 3: -#line 82 "cmExprParser.y" /* yacc.c:1646 */ +#line 82 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[0].Number); } -#line 1301 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1309 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 4: -#line 85 "cmExprParser.y" /* yacc.c:1646 */ +#line 85 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[-2].Number) | (yyvsp[0].Number); } -#line 1309 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1317 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 5: -#line 90 "cmExprParser.y" /* yacc.c:1646 */ +#line 90 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[0].Number); } -#line 1317 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1325 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 6: -#line 93 "cmExprParser.y" /* yacc.c:1646 */ +#line 93 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[-2].Number) ^ (yyvsp[0].Number); } -#line 1325 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1333 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 7: -#line 98 "cmExprParser.y" /* yacc.c:1646 */ +#line 98 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[0].Number); } -#line 1333 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1341 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 8: -#line 101 "cmExprParser.y" /* yacc.c:1646 */ +#line 101 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[-2].Number) & (yyvsp[0].Number); } -#line 1341 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1349 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 9: -#line 106 "cmExprParser.y" /* yacc.c:1646 */ +#line 106 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[0].Number); } -#line 1349 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1357 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 10: -#line 109 "cmExprParser.y" /* yacc.c:1646 */ +#line 109 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[-2].Number) << (yyvsp[0].Number); } -#line 1357 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1365 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 11: -#line 112 "cmExprParser.y" /* yacc.c:1646 */ +#line 112 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[-2].Number) >> (yyvsp[0].Number); } -#line 1365 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1373 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 12: -#line 117 "cmExprParser.y" /* yacc.c:1646 */ +#line 117 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[0].Number); } -#line 1373 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1381 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 13: -#line 120 "cmExprParser.y" /* yacc.c:1646 */ +#line 120 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[-2].Number) + (yyvsp[0].Number); } -#line 1381 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1389 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 14: -#line 123 "cmExprParser.y" /* yacc.c:1646 */ +#line 123 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[-2].Number) - (yyvsp[0].Number); } -#line 1389 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1397 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 15: -#line 128 "cmExprParser.y" /* yacc.c:1646 */ +#line 128 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[0].Number); } -#line 1397 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1405 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 16: -#line 131 "cmExprParser.y" /* yacc.c:1646 */ +#line 131 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[-2].Number) * (yyvsp[0].Number); } -#line 1405 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1413 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 17: -#line 134 "cmExprParser.y" /* yacc.c:1646 */ +#line 134 "cmExprParser.y" /* yacc.c:1652 */ { if (yyvsp[0].Number == 0) { throw std::overflow_error("divide by zero"); } (yyval.Number) = (yyvsp[-2].Number) / (yyvsp[0].Number); } -#line 1416 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1424 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 18: -#line 140 "cmExprParser.y" /* yacc.c:1646 */ +#line 140 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[-2].Number) % (yyvsp[0].Number); } -#line 1424 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1432 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 19: -#line 145 "cmExprParser.y" /* yacc.c:1646 */ +#line 145 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[0].Number); } -#line 1432 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1440 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 20: -#line 148 "cmExprParser.y" /* yacc.c:1646 */ +#line 148 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = + (yyvsp[0].Number); } -#line 1440 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1448 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 21: -#line 151 "cmExprParser.y" /* yacc.c:1646 */ +#line 151 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = - (yyvsp[0].Number); } -#line 1448 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1456 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 22: -#line 156 "cmExprParser.y" /* yacc.c:1646 */ +#line 154 "cmExprParser.y" /* yacc.c:1652 */ { - (yyval.Number) = (yyvsp[0].Number); + (yyval.Number) = ~ (yyvsp[0].Number); } -#line 1456 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1464 "cmExprParser.cxx" /* yacc.c:1652 */ break; case 23: -#line 159 "cmExprParser.y" /* yacc.c:1646 */ +#line 159 "cmExprParser.y" /* yacc.c:1652 */ + { + (yyval.Number) = (yyvsp[0].Number); + } +#line 1472 "cmExprParser.cxx" /* yacc.c:1652 */ + break; + + case 24: +#line 162 "cmExprParser.y" /* yacc.c:1652 */ { (yyval.Number) = (yyvsp[-1].Number); } -#line 1464 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1480 "cmExprParser.cxx" /* yacc.c:1652 */ break; -#line 1468 "cmExprParser.cxx" /* yacc.c:1646 */ +#line 1484 "cmExprParser.cxx" /* yacc.c:1652 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -1489,14 +1505,13 @@ yyreduce: /* Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTOKENS]; + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } goto yynewstate; @@ -1580,12 +1595,10 @@ yyerrlab: | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: - - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (/*CONSTCOND*/ 0) - goto yyerrorlab; + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ @@ -1648,6 +1661,7 @@ yyacceptlab: yyresult = 0; goto yyreturn; + /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ @@ -1655,6 +1669,7 @@ yyabortlab: yyresult = 1; goto yyreturn; + #if !defined yyoverflow || YYERROR_VERBOSE /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | @@ -1665,6 +1680,10 @@ yyexhaustedlab: /* Fall through. */ #endif + +/*-----------------------------------------------------. +| yyreturn -- parsing is finished, return the result. | +`-----------------------------------------------------*/ yyreturn: if (yychar != YYEMPTY) { @@ -1694,7 +1713,7 @@ yyreturn: #endif return yyresult; } -#line 164 "cmExprParser.y" /* yacc.c:1906 */ +#line 167 "cmExprParser.y" /* yacc.c:1918 */ /* End of grammar */ diff --git a/Source/LexerParser/cmExprParser.y b/Source/LexerParser/cmExprParser.y index 2137473..7ae2118 100644 --- a/Source/LexerParser/cmExprParser.y +++ b/Source/LexerParser/cmExprParser.y @@ -151,6 +151,9 @@ unary: | exp_MINUS unary { $<Number>$ = - $<Number>2; } +| exp_NOT unary { + $<Number>$ = ~ $<Number>2; + } factor: exp_NUMBER { diff --git a/Source/LexerParser/cmExprParserTokens.h b/Source/LexerParser/cmExprParserTokens.h index 84b2bbd..5ffd7c5 100644 --- a/Source/LexerParser/cmExprParserTokens.h +++ b/Source/LexerParser/cmExprParserTokens.h @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.3.2. */ /* Bison interface for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -30,6 +31,9 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + #ifndef YY_CMEXPR_YY_CMEXPRPARSERTOKENS_H_INCLUDED # define YY_CMEXPR_YY_CMEXPRPARSERTOKENS_H_INCLUDED /* Debug traces. */ diff --git a/Source/LexerParser/cmFortranParser.cxx b/Source/LexerParser/cmFortranParser.cxx index 015cab9..2ca7927 100644 --- a/Source/LexerParser/cmFortranParser.cxx +++ b/Source/LexerParser/cmFortranParser.cxx @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.3.2. */ /* Bison implementation for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -40,11 +41,14 @@ define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "3.0.4" +#define YYBISON_VERSION "3.3.2" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -67,8 +71,8 @@ #define yynerrs cmFortran_yynerrs -/* Copy the first part of user declarations. */ -#line 1 "cmFortranParser.y" /* yacc.c:339 */ +/* First part of user prologue. */ +#line 1 "cmFortranParser.y" /* yacc.c:337 */ /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ @@ -131,13 +135,16 @@ static void cmFortran_yyerror(yyscan_t yyscanner, const char* message) # pragma GCC diagnostic ignored "-Wconversion" #endif -#line 135 "cmFortranParser.cxx" /* yacc.c:339 */ - +#line 139 "cmFortranParser.cxx" /* yacc.c:337 */ # ifndef YY_NULLPTR -# if defined __cplusplus && 201103L <= __cplusplus -# define YY_NULLPTR nullptr +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif # else -# define YY_NULLPTR 0 +# define YY_NULLPTR ((void*)0) # endif # endif @@ -251,11 +258,11 @@ extern int cmFortran_yydebug; union YYSTYPE { -#line 73 "cmFortranParser.y" /* yacc.c:355 */ +#line 73 "cmFortranParser.y" /* yacc.c:352 */ char* string; -#line 259 "cmFortranParser.cxx" /* yacc.c:355 */ +#line 266 "cmFortranParser.cxx" /* yacc.c:352 */ }; typedef union YYSTYPE YYSTYPE; @@ -269,9 +276,7 @@ int cmFortran_yyparse (yyscan_t yyscanner); #endif /* !YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED */ -/* Copy the second part of user declarations. */ -#line 275 "cmFortranParser.cxx" /* yacc.c:358 */ #ifdef short # undef short @@ -292,13 +297,13 @@ typedef signed char yytype_int8; #ifdef YYTYPE_UINT16 typedef YYTYPE_UINT16 yytype_uint16; #else -typedef unsigned short int yytype_uint16; +typedef unsigned short yytype_uint16; #endif #ifdef YYTYPE_INT16 typedef YYTYPE_INT16 yytype_int16; #else -typedef short int yytype_int16; +typedef short yytype_int16; #endif #ifndef YYSIZE_T @@ -310,7 +315,7 @@ typedef short int yytype_int16; # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else -# define YYSIZE_T unsigned int +# define YYSIZE_T unsigned # endif #endif @@ -346,15 +351,6 @@ typedef short int yytype_int16; # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) #endif -#if !defined _Noreturn \ - && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) -# if defined _MSC_VER && 1200 <= _MSC_VER -# define _Noreturn __declspec (noreturn) -# else -# define _Noreturn YY_ATTRIBUTE ((__noreturn__)) -# endif -#endif - /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ # define YYUSE(E) ((void) (E)) @@ -362,7 +358,7 @@ typedef short int yytype_int16; # define YYUSE(E) /* empty */ #endif -#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ _Pragma ("GCC diagnostic push") \ @@ -524,16 +520,16 @@ union yyalloc /* YYNSTATES -- Number of states. */ #define YYNSTATES 126 -/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned - by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 #define YYMAXUTOK 295 +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ #define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM - as returned by yylex, without out-of-bounds checking. */ + as returned by yylex. */ static const yytype_uint8 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -863,22 +859,22 @@ static const yytype_uint8 yyr2[] = #define YYRECOVERING() (!!yyerrstatus) -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - YYPOPSTACK (yylen); \ - yystate = *yyssp; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (yyscanner, YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (0) +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (yyscanner, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) /* Error token number */ #define YYTERROR 1 @@ -918,38 +914,38 @@ do { \ } while (0) -/*----------------------------------------. -| Print this symbol's value on YYOUTPUT. | -`----------------------------------------*/ +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ static void -yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) +yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) { - FILE *yyo = yyoutput; - YYUSE (yyo); + FILE *yyoutput = yyo; + YYUSE (yyoutput); YYUSE (yyscanner); if (!yyvaluep) return; # ifdef YYPRINT if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); + YYPRINT (yyo, yytoknum[yytype], *yyvaluep); # endif YYUSE (yytype); } -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ static void -yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) +yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner) { - YYFPRINTF (yyoutput, "%s %s (", + YYFPRINTF (yyo, "%s %s (", yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); - yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner); - YYFPRINTF (yyoutput, ")"); + yy_symbol_value_print (yyo, yytype, yyvaluep, yyscanner); + YYFPRINTF (yyo, ")"); } /*------------------------------------------------------------------. @@ -983,7 +979,7 @@ do { \ static void yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yyscanner) { - unsigned long int yylno = yyrline[yyrule]; + unsigned long yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", @@ -994,7 +990,7 @@ yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yysca YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, yystos[yyssp[yyi + 1 - yynrhs]], - &(yyvsp[(yyi + 1) - (yynrhs)]) + &yyvsp[(yyi + 1) - (yynrhs)] , yyscanner); YYFPRINTF (stderr, "\n"); } @@ -1098,7 +1094,10 @@ yytnamerr (char *yyres, const char *yystr) case '\\': if (*++yyp != '\\') goto do_not_strip_quotes; - /* Fall through. */ + else + goto append; + + append: default: if (yyres) yyres[yyn] = *yyp; @@ -1116,7 +1115,7 @@ yytnamerr (char *yyres, const char *yystr) if (! yyres) return yystrlen (yystr); - return yystpcpy (yyres, yystr) - yyres; + return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres); } # endif @@ -1194,10 +1193,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yyarg[yycount++] = yytname[yyx]; { YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); - if (! (yysize <= yysize1 - && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } } } @@ -1209,6 +1208,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, case N: \ yyformat = S; \ break + default: /* Avoid compiler warnings. */ YYCASE_(0, YY_("syntax error")); YYCASE_(1, YY_("syntax error, unexpected %s")); YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); @@ -1220,9 +1220,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, { YYSIZE_T yysize1 = yysize + yystrlen (yyformat); - if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } if (*yymsg_alloc < yysize) @@ -1353,23 +1354,31 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); yychar = YYEMPTY; /* Cause a token to be read. */ goto yysetstate; + /*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | +| yynewstate -- push a new state, which is found in yystate. | `------------------------------------------------------------*/ - yynewstate: +yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; - yysetstate: - *yyssp = yystate; + +/*--------------------------------------------------------------------. +| yynewstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + *yyssp = (yytype_int16) yystate; if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + goto yyexhaustedlab; +#else { /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; + YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1); -#ifdef yyoverflow +# if defined yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into @@ -1385,14 +1394,10 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yystacksize); - yyss = yyss1; yyvs = yyvs1; } -#else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -# else +# else /* defined YYSTACK_RELOCATE */ /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab; @@ -1408,22 +1413,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); goto yyexhaustedlab; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); -# undef YYSTACK_RELOCATE +# undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif -#endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); + (unsigned long) yystacksize)); if (yyss + yystacksize - 1 <= yyssp) YYABORT; } +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ YYDPRINTF ((stderr, "Entering state %d\n", yystate)); @@ -1432,11 +1437,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); goto yybackup; + /*-----------. | yybackup. | `-----------*/ yybackup: - /* Do appropriate processing given the current state. Read a lookahead token if we need one and don't already have one. */ @@ -1509,7 +1514,7 @@ yydefault: /*-----------------------------. -| yyreduce -- Do a reduction. | +| yyreduce -- do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ @@ -1530,26 +1535,26 @@ yyreduce: switch (yyn) { case 4: -#line 104 "cmFortranParser.y" /* yacc.c:1646 */ +#line 104 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_SetInInterface(parser, true); } -#line 1539 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1544 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 5: -#line 108 "cmFortranParser.y" /* yacc.c:1646 */ +#line 108 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleUse(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1549 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1554 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 6: -#line 113 "cmFortranParser.y" /* yacc.c:1646 */ +#line 113 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); if (cmsysString_strcasecmp((yyvsp[-2].string), "function") != 0 && @@ -1559,22 +1564,22 @@ yyreduce: } free((yyvsp[-2].string)); } -#line 1563 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1568 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 7: -#line 122 "cmFortranParser.y" /* yacc.c:1646 */ +#line 122 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleSubmodule(parser, (yyvsp[-4].string), (yyvsp[-2].string)); free((yyvsp[-4].string)); free((yyvsp[-2].string)); } -#line 1574 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1579 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 8: -#line 128 "cmFortranParser.y" /* yacc.c:1646 */ +#line 128 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleSubmoduleNested(parser, (yyvsp[-6].string), (yyvsp[-4].string), (yyvsp[-2].string)); @@ -1582,40 +1587,40 @@ yyreduce: free((yyvsp[-4].string)); free((yyvsp[-2].string)); } -#line 1586 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1591 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 9: -#line 135 "cmFortranParser.y" /* yacc.c:1646 */ +#line 135 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_SetInInterface(parser, true); free((yyvsp[-2].string)); } -#line 1596 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1601 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 10: -#line 140 "cmFortranParser.y" /* yacc.c:1646 */ +#line 140 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_SetInInterface(parser, false); } -#line 1605 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1610 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 11: -#line 144 "cmFortranParser.y" /* yacc.c:1646 */ +#line 144 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleUse(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1615 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1620 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 12: -#line 149 "cmFortranParser.y" /* yacc.c:1646 */ +#line 149 "cmFortranParser.y" /* yacc.c:1652 */ { if (cmsysString_strcasecmp((yyvsp[-4].string), "non_intrinsic") == 0) { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); @@ -1624,139 +1629,139 @@ yyreduce: free((yyvsp[-4].string)); free((yyvsp[-2].string)); } -#line 1628 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1633 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 13: -#line 157 "cmFortranParser.y" /* yacc.c:1646 */ +#line 157 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleInclude(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1638 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1643 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 14: -#line 162 "cmFortranParser.y" /* yacc.c:1646 */ +#line 162 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleLineDirective(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1648 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1653 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 15: -#line 167 "cmFortranParser.y" /* yacc.c:1646 */ +#line 167 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleInclude(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1658 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1663 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 16: -#line 172 "cmFortranParser.y" /* yacc.c:1646 */ +#line 172 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleInclude(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1668 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1673 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 17: -#line 177 "cmFortranParser.y" /* yacc.c:1646 */ +#line 177 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleDefine(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1678 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1683 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 18: -#line 182 "cmFortranParser.y" /* yacc.c:1646 */ +#line 182 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleUndef(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1688 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1693 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 19: -#line 187 "cmFortranParser.y" /* yacc.c:1646 */ +#line 187 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleIfdef(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1698 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1703 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 20: -#line 192 "cmFortranParser.y" /* yacc.c:1646 */ +#line 192 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleIfndef(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1708 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1713 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 21: -#line 197 "cmFortranParser.y" /* yacc.c:1646 */ +#line 197 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleIf(parser); } -#line 1717 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1722 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 22: -#line 201 "cmFortranParser.y" /* yacc.c:1646 */ +#line 201 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleElif(parser); } -#line 1726 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1731 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 23: -#line 205 "cmFortranParser.y" /* yacc.c:1646 */ +#line 205 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleElse(parser); } -#line 1735 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1740 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 24: -#line 209 "cmFortranParser.y" /* yacc.c:1646 */ +#line 209 "cmFortranParser.y" /* yacc.c:1652 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleEndif(parser); } -#line 1744 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1749 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 48: -#line 231 "cmFortranParser.y" /* yacc.c:1646 */ +#line 231 "cmFortranParser.y" /* yacc.c:1652 */ { free ((yyvsp[0].string)); } -#line 1750 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1755 "cmFortranParser.cxx" /* yacc.c:1652 */ break; case 55: -#line 238 "cmFortranParser.y" /* yacc.c:1646 */ +#line 238 "cmFortranParser.y" /* yacc.c:1652 */ { free ((yyvsp[0].string)); } -#line 1756 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1761 "cmFortranParser.cxx" /* yacc.c:1652 */ break; -#line 1760 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1765 "cmFortranParser.cxx" /* yacc.c:1652 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -1781,14 +1786,13 @@ yyreduce: /* Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTOKENS]; + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } goto yynewstate; @@ -1872,12 +1876,10 @@ yyerrlab: | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: - - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (/*CONSTCOND*/ 0) - goto yyerrorlab; + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ @@ -1940,6 +1942,7 @@ yyacceptlab: yyresult = 0; goto yyreturn; + /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ @@ -1947,6 +1950,7 @@ yyabortlab: yyresult = 1; goto yyreturn; + #if !defined yyoverflow || YYERROR_VERBOSE /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | @@ -1957,6 +1961,10 @@ yyexhaustedlab: /* Fall through. */ #endif + +/*-----------------------------------------------------. +| yyreturn -- parsing is finished, return the result. | +`-----------------------------------------------------*/ yyreturn: if (yychar != YYEMPTY) { @@ -1986,6 +1994,6 @@ yyreturn: #endif return yyresult; } -#line 249 "cmFortranParser.y" /* yacc.c:1906 */ +#line 249 "cmFortranParser.y" /* yacc.c:1918 */ /* End of grammar */ diff --git a/Source/LexerParser/cmFortranParserTokens.h b/Source/LexerParser/cmFortranParserTokens.h index 29c6d60..0da4c1c 100644 --- a/Source/LexerParser/cmFortranParserTokens.h +++ b/Source/LexerParser/cmFortranParserTokens.h @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.3.2. */ /* Bison interface for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -30,6 +31,9 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + #ifndef YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED # define YY_CMFORTRAN_YY_CMFORTRANPARSERTOKENS_H_INCLUDED /* Debug traces. */ @@ -130,11 +134,11 @@ extern int cmFortran_yydebug; union YYSTYPE { -#line 73 "cmFortranParser.y" /* yacc.c:1909 */ +#line 73 "cmFortranParser.y" /* yacc.c:1921 */ char* string; -#line 138 "cmFortranParserTokens.h" /* yacc.c:1909 */ +#line 142 "cmFortranParserTokens.h" /* yacc.c:1921 */ }; typedef union YYSTYPE YYSTYPE; diff --git a/Source/QtDialog/CMakeSetup.cxx b/Source/QtDialog/CMakeSetup.cxx index c9ebba8..287a482 100644 --- a/Source/QtDialog/CMakeSetup.cxx +++ b/Source/QtDialog/CMakeSetup.cxx @@ -6,6 +6,7 @@ #include "cmAlgorithms.h" #include "cmDocumentation.h" #include "cmDocumentationEntry.h" +#include "cmStringAlgorithms.h" #include "cmVersion.h" #include "cmake.h" #include "cmsys/CommandLineArguments.hxx" diff --git a/Source/cmAlgorithms.h b/Source/cmAlgorithms.h index d153076..d7ea483 100644 --- a/Source/cmAlgorithms.h +++ b/Source/cmAlgorithms.h @@ -6,78 +6,14 @@ #include "cmConfigure.h" // IWYU pragma: keep #include "cmRange.h" - #include "cm_kwiml.h" #include <algorithm> #include <functional> #include <iterator> -#include <sstream> -#include <string.h> -#include <string> #include <unordered_set> #include <utility> #include <vector> -inline bool cmHasLiteralPrefixImpl(const std::string& str1, const char* str2, - size_t N) -{ - return strncmp(str1.c_str(), str2, N) == 0; -} - -inline bool cmHasLiteralPrefixImpl(const char* str1, const char* str2, - size_t N) -{ - return strncmp(str1, str2, N) == 0; -} - -inline bool cmHasLiteralSuffixImpl(const std::string& str1, const char* str2, - size_t N) -{ - size_t len = str1.size(); - return len >= N && strcmp(str1.c_str() + len - N, str2) == 0; -} - -inline bool cmHasLiteralSuffixImpl(const char* str1, const char* str2, - size_t N) -{ - size_t len = strlen(str1); - return len >= N && strcmp(str1 + len - N, str2) == 0; -} - -template <typename T, size_t N> -bool cmHasLiteralPrefix(const T& str1, const char (&str2)[N]) -{ - return cmHasLiteralPrefixImpl(str1, str2, N - 1); -} - -template <typename T, size_t N> -bool cmHasLiteralSuffix(const T& str1, const char (&str2)[N]) -{ - return cmHasLiteralSuffixImpl(str1, str2, N - 1); -} - -struct cmStrCmp -{ - cmStrCmp(const char* test) - : m_test(test) - { - } - cmStrCmp(std::string test) - : m_test(std::move(test)) - { - } - - bool operator()(const std::string& input) const { return m_test == input; } - - bool operator()(const char* input) const - { - return strcmp(input, m_test.c_str()) == 0; - } - -private: - const std::string m_test; -}; - template <typename FwdIt> FwdIt cmRotate(FwdIt first, FwdIt middle, FwdIt last) { @@ -157,8 +93,6 @@ private: }; } -typedef cmRange<std::vector<std::string>::const_iterator> cmStringRange; - class cmListFileBacktrace; typedef cmRange<std::vector<cmListFileBacktrace>::const_iterator> cmBacktraceRange; @@ -183,31 +117,6 @@ void cmAppend(std::vector<T>& v, InputIt first, InputIt last) } template <typename Range> -std::string cmJoin(Range const& r, const char* delimiter) -{ - if (r.empty()) { - return std::string(); - } - std::ostringstream os; - typedef typename Range::value_type ValueType; - typedef typename Range::const_iterator InputIt; - const InputIt first = r.begin(); - InputIt last = r.end(); - --last; - std::copy(first, last, std::ostream_iterator<ValueType>(os, delimiter)); - - os << *last; - - return os.str(); -} - -template <typename Range> -std::string cmJoin(Range const& r, std::string const& delimiter) -{ - return cmJoin(r, delimiter.c_str()); -} - -template <typename Range> typename Range::const_iterator cmRemoveN(Range& r, size_t n) { return ContainerAlgorithms::RemoveN(r.begin(), r.end(), n); @@ -285,23 +194,6 @@ typename Range::const_iterator cmRemoveDuplicates(Range& r) return cmRemoveDuplicates(r.begin(), r.end()); } -template <typename Range> -std::string cmWrap(std::string const& prefix, Range const& r, - std::string const& suffix, std::string const& sep) -{ - if (r.empty()) { - return std::string(); - } - return prefix + cmJoin(r, suffix + sep + prefix) + suffix; -} - -template <typename Range> -std::string cmWrap(char prefix, Range const& r, char suffix, - std::string const& sep) -{ - return cmWrap(std::string(1, prefix), r, std::string(1, suffix), sep); -} - template <typename Range, typename T> typename Range::const_iterator cmFindNot(Range const& r, T const& t) { @@ -314,29 +206,6 @@ std::reverse_iterator<Iter> cmMakeReverseIterator(Iter it) return std::reverse_iterator<Iter>(it); } -inline bool cmHasPrefix(std::string const& str, std::string const& prefix) -{ - if (str.size() < prefix.size()) { - return false; - } - return str.compare(0, prefix.size(), prefix) == 0; -} - -inline bool cmHasSuffix(const std::string& str, const std::string& suffix) -{ - if (str.size() < suffix.size()) { - return false; - } - return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0; -} - -inline void cmStripSuffixIfExists(std::string& str, const std::string& suffix) -{ - if (cmHasSuffix(str, suffix)) { - str.resize(str.size() - suffix.size()); - } -} - namespace cm { #if __cplusplus >= 201703L || defined(_MSVC_LANG) && _MSVC_LANG >= 201703L diff --git a/Source/cmAuxSourceDirectoryCommand.cxx b/Source/cmAuxSourceDirectoryCommand.cxx index 106e7a7..45c6411 100644 --- a/Source/cmAuxSourceDirectoryCommand.cxx +++ b/Source/cmAuxSourceDirectoryCommand.cxx @@ -7,9 +7,9 @@ #include <stddef.h> #include <utility> -#include "cmAlgorithms.h" #include "cmMakefile.h" #include "cmSourceFile.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmake.h" @@ -74,6 +74,6 @@ bool cmAuxSourceDirectoryCommand::InitialPass( sourceListValue += ";"; } sourceListValue += cmJoin(files, ";"); - this->Makefile->AddDefinition(args[1], sourceListValue.c_str()); + this->Makefile->AddDefinition(args[1], sourceListValue); return true; } diff --git a/Source/cmBinUtilsMacOSMachOLinker.cxx b/Source/cmBinUtilsMacOSMachOLinker.cxx index ac93155..0c73ac8 100644 --- a/Source/cmBinUtilsMacOSMachOLinker.cxx +++ b/Source/cmBinUtilsMacOSMachOLinker.cxx @@ -3,9 +3,9 @@ #include "cmBinUtilsMacOSMachOLinker.h" -#include "cmAlgorithms.h" #include "cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool.h" #include "cmRuntimeDependencyArchive.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include <sstream> diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx index 428a0b2..e9e1d49 100644 --- a/Source/cmBuildCommand.cxx +++ b/Source/cmBuildCommand.cxx @@ -92,7 +92,7 @@ bool cmBuildCommand::MainSignature(std::vector<std::string> const& args) this->Makefile->GetGlobalGenerator()->GenerateCMakeBuildCommand( target, configuration, "", this->Makefile->IgnoreErrorsCMP0061()); - this->Makefile->AddDefinition(variable, makecommand.c_str()); + this->Makefile->AddDefinition(variable, makecommand); return true; } diff --git a/Source/cmCMakeHostSystemInformationCommand.cxx b/Source/cmCMakeHostSystemInformationCommand.cxx index 54f08bb..b4cd2a5 100644 --- a/Source/cmCMakeHostSystemInformationCommand.cxx +++ b/Source/cmCMakeHostSystemInformationCommand.cxx @@ -55,7 +55,7 @@ bool cmCMakeHostSystemInformationCommand::InitialPass( result_list += value; } - this->Makefile->AddDefinition(variable, result_list.c_str()); + this->Makefile->AddDefinition(variable, result_list); return true; } diff --git a/Source/cmCMakeMinimumRequired.cxx b/Source/cmCMakeMinimumRequired.cxx index 4b4bca2..f2eae38 100644 --- a/Source/cmCMakeMinimumRequired.cxx +++ b/Source/cmCMakeMinimumRequired.cxx @@ -61,8 +61,7 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args, } // Save the required version string. - this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION", - version_min.c_str()); + this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION", version_min); // Get the current version number. unsigned int current_major = cmVersion::GetMajorVersion(); diff --git a/Source/cmCMakePolicyCommand.cxx b/Source/cmCMakePolicyCommand.cxx index 8da5ef7..ce046fc 100644 --- a/Source/cmCMakePolicyCommand.cxx +++ b/Source/cmCMakePolicyCommand.cxx @@ -209,8 +209,7 @@ bool cmCMakePolicyCommand::HandleGetWarningMode( } // Lookup the policy warning. - this->Makefile->AddDefinition(var, - cmPolicies::GetPolicyWarning(pid).c_str()); + this->Makefile->AddDefinition(var, cmPolicies::GetPolicyWarning(pid)); return true; } diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx index 255a8e6..80ca898 100644 --- a/Source/cmCPluginAPI.cxx +++ b/Source/cmCPluginAPI.cxx @@ -65,8 +65,10 @@ unsigned int CCONV cmGetMinorVersion(void*) void CCONV cmAddDefinition(void* arg, const char* name, const char* value) { - cmMakefile* mf = static_cast<cmMakefile*>(arg); - mf->AddDefinition(name, value); + if (value) { + cmMakefile* mf = static_cast<cmMakefile*>(arg); + mf->AddDefinition(name, value); + } } /* Add a definition to this makefile and the global cmake cache. */ @@ -421,7 +423,7 @@ int CCONV cmExecuteCommand(void* arg, const char* name, int numArgs, // Assume all arguments are quoted. lff.Arguments.emplace_back(args[i], cmListFileArgument::Quoted, 0); } - cmExecutionStatus status; + cmExecutionStatus status(*mf); return mf->ExecuteCommand(lff, status); } diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx index 83e3eff..610e9f9 100644 --- a/Source/cmCTest.cxx +++ b/Source/cmCTest.cxx @@ -52,6 +52,7 @@ #include "cmState.h" #include "cmStateSnapshot.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmVersion.h" #include "cmVersionConfig.h" diff --git a/Source/cmCommand.cxx b/Source/cmCommand.cxx index d349c91..0c2734e 100644 --- a/Source/cmCommand.cxx +++ b/Source/cmCommand.cxx @@ -2,11 +2,19 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmCommand.h" +#include <utility> + +#include "cmExecutionStatus.h" #include "cmMakefile.h" -class cmExecutionStatus; struct cmListFileArgument; +void cmCommand::SetExecutionStatus(cmExecutionStatus* status) +{ + this->Status = status; + this->Makefile = &status->GetMakefile(); +} + bool cmCommand::InvokeInitialPass(const std::vector<cmListFileArgument>& args, cmExecutionStatus& status) { @@ -19,15 +27,33 @@ bool cmCommand::InvokeInitialPass(const std::vector<cmListFileArgument>& args, return this->InitialPass(expandedArguments, status); } -const char* cmCommand::GetError() +void cmCommand::SetError(const std::string& e) { - if (this->Error.empty()) { - return "unknown error."; - } - return this->Error.c_str(); + this->Status->SetError(e); } -void cmCommand::SetError(const std::string& e) +cmLegacyCommandWrapper::cmLegacyCommandWrapper(std::unique_ptr<cmCommand> cmd) + : Command(std::move(cmd)) +{ +} + +cmLegacyCommandWrapper::cmLegacyCommandWrapper( + cmLegacyCommandWrapper const& other) + : Command(other.Command->Clone()) +{ +} + +cmLegacyCommandWrapper& cmLegacyCommandWrapper::operator=( + cmLegacyCommandWrapper const& other) +{ + this->Command = other.Command->Clone(); + return *this; +} + +bool cmLegacyCommandWrapper::operator()( + std::vector<cmListFileArgument> const& args, cmExecutionStatus& status) const { - this->Error = e; + auto cmd = this->Command->Clone(); + cmd->SetExecutionStatus(&status); + return cmd->InvokeInitialPass(args, status); } diff --git a/Source/cmCommand.h b/Source/cmCommand.h index b210f27..bcb178d 100644 --- a/Source/cmCommand.h +++ b/Source/cmCommand.h @@ -42,16 +42,18 @@ public: /** * Specify the makefile. */ - void SetMakefile(cmMakefile* m) { this->Makefile = m; } cmMakefile* GetMakefile() { return this->Makefile; } + void SetExecutionStatus(cmExecutionStatus* s); + cmExecutionStatus* GetExecutionStatus() { return this->Status; }; + /** * This is called by the cmMakefile when the command is first * encountered in the CMakeLists.txt file. It expands the command's * arguments and then invokes the InitialPass. */ - virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, - cmExecutionStatus& status); + bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, + cmExecutionStatus& status); /** * This is called when the command is first encountered in @@ -66,11 +68,6 @@ public: virtual std::unique_ptr<cmCommand> Clone() = 0; /** - * Return the last error string. - */ - const char* GetError(); - - /** * Set the error message */ void SetError(const std::string& e); @@ -79,7 +76,25 @@ protected: cmMakefile* Makefile = nullptr; private: - std::string Error; + cmExecutionStatus* Status = nullptr; +}; + +class cmLegacyCommandWrapper +{ +public: + explicit cmLegacyCommandWrapper(std::unique_ptr<cmCommand> cmd); + + cmLegacyCommandWrapper(cmLegacyCommandWrapper const& other); + cmLegacyCommandWrapper& operator=(cmLegacyCommandWrapper const& other); + + cmLegacyCommandWrapper(cmLegacyCommandWrapper&&) = default; + cmLegacyCommandWrapper& operator=(cmLegacyCommandWrapper&&) = default; + + bool operator()(std::vector<cmListFileArgument> const& args, + cmExecutionStatus& status) const; + +private: + std::unique_ptr<cmCommand> Command; }; #endif diff --git a/Source/cmCommands.cxx b/Source/cmCommands.cxx index 96c7105..f351ff8 100644 --- a/Source/cmCommands.cxx +++ b/Source/cmCommands.cxx @@ -147,7 +147,7 @@ void GetScriptingCommands(cmState* state) cm::make_unique<cmGetFilenameComponentCommand>()); state->AddBuiltinCommand("get_property", cm::make_unique<cmGetPropertyCommand>()); - state->AddBuiltinCommand("if", cm::make_unique<cmIfCommand>()); + state->AddBuiltinCommand("if", cmIfCommand); state->AddBuiltinCommand("include", cm::make_unique<cmIncludeCommand>()); state->AddBuiltinCommand("include_guard", cm::make_unique<cmIncludeGuardCommand>()); @@ -162,7 +162,7 @@ void GetScriptingCommands(cmState* state) state->AddBuiltinCommand("option", cm::make_unique<cmOptionCommand>()); state->AddBuiltinCommand("cmake_parse_arguments", cm::make_unique<cmParseArgumentsCommand>()); - state->AddBuiltinCommand("return", cm::make_unique<cmReturnCommand>()); + state->AddBuiltinCommand("return", cmReturnCommand); state->AddBuiltinCommand("separate_arguments", cm::make_unique<cmSeparateArgumentsCommand>()); state->AddBuiltinCommand("set", cm::make_unique<cmSetCommand>()); @@ -173,7 +173,7 @@ void GetScriptingCommands(cmState* state) state->AddBuiltinCommand("site_name", cm::make_unique<cmSiteNameCommand>()); state->AddBuiltinCommand("string", cm::make_unique<cmStringCommand>()); state->AddBuiltinCommand("unset", cm::make_unique<cmUnsetCommand>()); - state->AddBuiltinCommand("while", cm::make_unique<cmWhileCommand>()); + state->AddBuiltinCommand("while", cmWhileCommand); state->AddUnexpectedCommand( "else", @@ -255,8 +255,7 @@ void GetProjectCommands(cmState* state) cm::make_unique<cmDefinePropertyCommand>()); state->AddBuiltinCommand("enable_language", cm::make_unique<cmEnableLanguageCommand>()); - state->AddBuiltinCommand("enable_testing", - cm::make_unique<cmEnableTestingCommand>()); + state->AddBuiltinCommand("enable_testing", cmEnableTestingCommand); state->AddBuiltinCommand("get_source_file_property", cm::make_unique<cmGetSourceFilePropertyCommand>()); state->AddBuiltinCommand("get_target_property", diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx index 66250f3..61880c2 100644 --- a/Source/cmCommonTargetGenerator.cxx +++ b/Source/cmCommonTargetGenerator.cxx @@ -6,7 +6,6 @@ #include <sstream> #include <utility> -#include "cmAlgorithms.h" #include "cmComputeLinkInformation.h" #include "cmGeneratorTarget.h" #include "cmGlobalCommonGenerator.h" @@ -17,6 +16,7 @@ #include "cmOutputConverter.h" #include "cmSourceFile.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" cmCommonTargetGenerator::cmCommonTargetGenerator(cmGeneratorTarget* gt) : GeneratorTarget(gt) diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx index 54fc54c..f8b78b4 100644 --- a/Source/cmComputeLinkDepends.cxx +++ b/Source/cmComputeLinkDepends.cxx @@ -11,6 +11,7 @@ #include "cmMakefile.h" #include "cmRange.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmake.h" diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx index f696f28..78cddf0 100644 --- a/Source/cmComputeLinkInformation.cxx +++ b/Source/cmComputeLinkInformation.cxx @@ -2,7 +2,6 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmComputeLinkInformation.h" -#include "cmAlgorithms.h" #include "cmComputeLinkDepends.h" #include "cmGeneratorTarget.h" #include "cmGlobalGenerator.h" @@ -14,6 +13,7 @@ #include "cmPolicies.h" #include "cmState.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmake.h" diff --git a/Source/cmConditionEvaluator.cxx b/Source/cmConditionEvaluator.cxx index e7e91c1..5b88807 100644 --- a/Source/cmConditionEvaluator.cxx +++ b/Source/cmConditionEvaluator.cxx @@ -4,6 +4,7 @@ #include "cmsys/RegularExpression.hxx" #include <algorithm> +#include <functional> #include <sstream> #include <stdio.h> #include <stdlib.h> @@ -14,10 +15,10 @@ #include "cmMakefile.h" #include "cmMessageType.h" #include "cmState.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmake.h" -class cmCommand; class cmTest; static std::string const keyAND = "AND"; @@ -452,7 +453,7 @@ bool cmConditionEvaluator::HandleLevel1(cmArgumentList& newArgs, std::string&, } // does a command exist if (this->IsKeyword(keyCOMMAND, *arg) && argP1 != newArgs.end()) { - cmCommand* command = + cmState::Command command = this->Makefile.GetState()->GetCommand(argP1->c_str()); this->HandlePredicate(command != nullptr, reducible, arg, newArgs, argP1, argP2); diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx index f12ef0b..d2a4148 100644 --- a/Source/cmCoreTryCompile.cxx +++ b/Source/cmCoreTryCompile.cxx @@ -9,7 +9,6 @@ #include <string.h> #include <utility> -#include "cmAlgorithms.h" #include "cmExportTryCompileFileGenerator.h" #include "cmGlobalGenerator.h" #include "cmMakefile.h" @@ -17,6 +16,7 @@ #include "cmOutputConverter.h" #include "cmPolicies.h" #include "cmState.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmVersion.h" @@ -932,7 +932,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, cmStateEnums::INTERNAL); if (!outputVariable.empty()) { - this->Makefile->AddDefinition(outputVariable, output.c_str()); + this->Makefile->AddDefinition(outputVariable, output); } if (this->SrcFileSignature) { @@ -961,8 +961,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, } if (!copyFileError.empty()) { - this->Makefile->AddDefinition(copyFileError, - copyFileErrorMessage.c_str()); + this->Makefile->AddDefinition(copyFileError, copyFileErrorMessage); } } return res; diff --git a/Source/cmCreateTestSourceList.cxx b/Source/cmCreateTestSourceList.cxx index b78493f..427db72 100644 --- a/Source/cmCreateTestSourceList.cxx +++ b/Source/cmCreateTestSourceList.cxx @@ -125,16 +125,15 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args, } if (!extraInclude.empty()) { this->Makefile->AddDefinition("CMAKE_TESTDRIVER_EXTRA_INCLUDES", - extraInclude.c_str()); + extraInclude); } if (!function.empty()) { - this->Makefile->AddDefinition("CMAKE_TESTDRIVER_ARGVC_FUNCTION", - function.c_str()); + this->Makefile->AddDefinition("CMAKE_TESTDRIVER_ARGVC_FUNCTION", function); } this->Makefile->AddDefinition("CMAKE_FORWARD_DECLARE_TESTS", - forwardDeclareCode.c_str()); + forwardDeclareCode); this->Makefile->AddDefinition("CMAKE_FUNCTION_TABLE_ENTIRES", - functionMapCode.c_str()); + functionMapCode); bool res = true; if (!this->Makefile->ConfigureFile(configFile, driver, false, true, false)) { res = false; @@ -154,6 +153,6 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args, sourceListValue += *i; } - this->Makefile->AddDefinition(sourceList, sourceListValue.c_str()); + this->Makefile->AddDefinition(sourceList, sourceListValue); return res; } diff --git a/Source/cmCustomCommandGenerator.cxx b/Source/cmCustomCommandGenerator.cxx index 5e8731a..758a69a 100644 --- a/Source/cmCustomCommandGenerator.cxx +++ b/Source/cmCustomCommandGenerator.cxx @@ -25,6 +25,7 @@ cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc, , OldStyle(cc.GetEscapeOldStyle()) , MakeVars(cc.GetEscapeAllowMakeVars()) , GE(new cmGeneratorExpression(cc.GetBacktrace())) + , EmulatorsWithArguments(cc.GetCommandLines().size()) { const cmCustomCommandLines& cmdlines = this->CC.GetCommandLines(); for (cmCustomCommandLine const& cmdline : cmdlines) { @@ -107,7 +108,6 @@ void cmCustomCommandGenerator::FillEmulatorsWithArguments() continue; } - this->EmulatorsWithArguments.emplace_back(); cmSystemTools::ExpandListArgument(emulator_property, this->EmulatorsWithArguments[c]); } diff --git a/Source/cmDefinitions.cxx b/Source/cmDefinitions.cxx index 894447c..42e70d6 100644 --- a/Source/cmDefinitions.cxx +++ b/Source/cmDefinitions.cxx @@ -13,10 +13,12 @@ cmDefinitions::Def const& cmDefinitions::GetInternal(const std::string& key, StackIter end, bool raise) { assert(begin != end); - MapType::iterator i = begin->Map.find(key); - if (i != begin->Map.end()) { - i->second.Used = true; - return i->second; + { + MapType::iterator it = begin->Map.find(key); + if (it != begin->Map.end()) { + it->second.Used = true; + return it->second; + } } StackIter it = begin; ++it; @@ -27,14 +29,14 @@ cmDefinitions::Def const& cmDefinitions::GetInternal(const std::string& key, if (!raise) { return def; } - return begin->Map.insert(MapType::value_type(key, def)).first->second; + return begin->Map.emplace(key, def).first->second; } const std::string* cmDefinitions::Get(const std::string& key, StackIter begin, StackIter end) { Def const& def = cmDefinitions::GetInternal(key, begin, end, false); - return def.Exists ? &def : nullptr; + return def.Exists ? &def.Value : nullptr; } void cmDefinitions::Raise(const std::string& key, StackIter begin, @@ -47,19 +49,23 @@ bool cmDefinitions::HasKey(const std::string& key, StackIter begin, StackIter end) { for (StackIter it = begin; it != end; ++it) { - MapType::const_iterator i = it->Map.find(key); - if (i != it->Map.end()) { + if (it->Map.find(key) != it->Map.end()) { return true; } } return false; } -void cmDefinitions::Set(const std::string& key, const char* value) +void cmDefinitions::Set(const std::string& key, cm::string_view value) { this->Map[key] = Def(value); } +void cmDefinitions::Unset(const std::string& key) +{ + this->Map[key] = Def(); +} + std::vector<std::string> cmDefinitions::UnusedKeys() const { std::vector<std::string> keys; @@ -97,8 +103,8 @@ cmDefinitions cmDefinitions::MakeClosure(StackIter begin, StackIter end) std::vector<std::string> cmDefinitions::ClosureKeys(StackIter begin, StackIter end) { - std::set<std::string> bound; std::vector<std::string> defined; + std::set<std::string> bound; for (StackIter it = begin; it != end; ++it) { defined.reserve(defined.size() + it->Map.size()); diff --git a/Source/cmDefinitions.h b/Source/cmDefinitions.h index 6c252be..4d8810a 100644 --- a/Source/cmDefinitions.h +++ b/Source/cmDefinitions.h @@ -5,12 +5,14 @@ #include "cmConfigure.h" // IWYU pragma: keep +#include "cm_string_view.hxx" + +#include "cmLinkedTree.h" + #include <string> #include <unordered_map> #include <vector> -#include "cmLinkedTree.h" - /** \class cmDefinitions * \brief Store a scope of variable definitions for CMake language. * @@ -30,8 +32,11 @@ public: static bool HasKey(const std::string& key, StackIter begin, StackIter end); - /** Set (or unset if null) a value associated with a key. */ - void Set(const std::string& key, const char* value); + /** Set a value associated with a key. */ + void Set(const std::string& key, cm::string_view value); + + /** Unset a definition. */ + void Unset(const std::string& key); std::vector<std::string> UnusedKeys() const; @@ -40,24 +45,17 @@ public: static cmDefinitions MakeClosure(StackIter begin, StackIter end); private: - // String with existence boolean. - struct Def : public std::string + /** String with existence boolean. */ + struct Def { - private: - typedef std::string std_string; - public: Def() = default; - Def(const char* v) - : std_string(v ? v : "") - , Exists(v ? true : false) - { - } - Def(const std_string& v) - : std_string(v) + Def(cm::string_view value) + : Value(value) , Exists(true) { } + std::string Value; bool Exists = false; bool Used = false; }; diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx index 178e18b..764ba30 100644 --- a/Source/cmDependsFortran.cxx +++ b/Source/cmDependsFortran.cxx @@ -9,7 +9,6 @@ #include <stdlib.h> #include <utility> -#include "cmAlgorithms.h" #include "cmFortranParser.h" /* Interface to parser object. */ #include "cmGeneratedFileStream.h" #include "cmLocalGenerator.h" @@ -17,6 +16,7 @@ #include "cmOutputConverter.h" #include "cmStateDirectory.h" #include "cmStateSnapshot.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" // TODO: Test compiler for the case of the mod file. Some always diff --git a/Source/cmDisallowedCommand.cxx b/Source/cmDisallowedCommand.cxx index 418d98c..aa1f90b 100644 --- a/Source/cmDisallowedCommand.cxx +++ b/Source/cmDisallowedCommand.cxx @@ -24,8 +24,6 @@ bool cmDisallowedCommand::InitialPass(std::vector<std::string> const& args, return true; } - this->Command->SetMakefile(this->GetMakefile()); - bool const ret = this->Command->InitialPass(args, status); - this->SetError(this->Command->GetError()); - return ret; + this->Command->SetExecutionStatus(this->GetExecutionStatus()); + return this->Command->InitialPass(args, status); } diff --git a/Source/cmEnableTestingCommand.cxx b/Source/cmEnableTestingCommand.cxx index 6a64450..89212c8 100644 --- a/Source/cmEnableTestingCommand.cxx +++ b/Source/cmEnableTestingCommand.cxx @@ -2,15 +2,12 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmEnableTestingCommand.h" +#include "cmExecutionStatus.h" #include "cmMakefile.h" -class cmExecutionStatus; - -// we do this in the final pass so that we now the subdirs have all -// been defined -bool cmEnableTestingCommand::InitialPass(std::vector<std::string> const&, - cmExecutionStatus&) +bool cmEnableTestingCommand(std::vector<std::string> const&, + cmExecutionStatus& status) { - this->Makefile->AddDefinition("CMAKE_TESTING_ENABLED", "1"); + status.GetMakefile().AddDefinition("CMAKE_TESTING_ENABLED", "1"); return true; } diff --git a/Source/cmEnableTestingCommand.h b/Source/cmEnableTestingCommand.h index fd50ebc..e4593f2 100644 --- a/Source/cmEnableTestingCommand.h +++ b/Source/cmEnableTestingCommand.h @@ -8,13 +8,9 @@ #include <string> #include <vector> -#include "cm_memory.hxx" - -#include "cmCommand.h" - class cmExecutionStatus; -/** \class cmEnableTestingCommand +/** * \brief Enable testing for this directory and below. * * Produce the output testfile. This produces a file in the build directory @@ -27,23 +23,7 @@ class cmExecutionStatus; * Note that CTest expects to find this file in the build directory root; * therefore, this command should be in the source directory root too. */ -class cmEnableTestingCommand : public cmCommand -{ -public: - /** - * This is a virtual constructor for the command. - */ - std::unique_ptr<cmCommand> Clone() override - { - return cm::make_unique<cmEnableTestingCommand>(); - } - - /** - * This is called when the command is first encountered in - * the CMakeLists.txt file. - */ - bool InitialPass(std::vector<std::string> const&, - cmExecutionStatus&) override; -}; +bool cmEnableTestingCommand(std::vector<std::string> const&, + cmExecutionStatus&); #endif diff --git a/Source/cmExecProgramCommand.cxx b/Source/cmExecProgramCommand.cxx index 4b559e7..bc1d173 100644 --- a/Source/cmExecProgramCommand.cxx +++ b/Source/cmExecProgramCommand.cxx @@ -103,7 +103,7 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args, } std::string coutput = std::string(output, first, last - first + 1); - this->Makefile->AddDefinition(output_variable, coutput.c_str()); + this->Makefile->AddDefinition(output_variable, coutput); } if (!return_variable.empty()) { diff --git a/Source/cmExecuteProcessCommand.cxx b/Source/cmExecuteProcessCommand.cxx index 689fc20..465f4b3 100644 --- a/Source/cmExecuteProcessCommand.cxx +++ b/Source/cmExecuteProcessCommand.cxx @@ -16,6 +16,7 @@ #include "cmMakefile.h" #include "cmMessageType.h" #include "cmProcessOutput.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" class cmExecutionStatus; @@ -332,7 +333,7 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args, } } this->Makefile->AddDefinition(arguments.ResultsVariable, - cmJoin(res, ";").c_str()); + cmJoin(res, ";")); } break; case cmsysProcess_State_Exception: this->Makefile->AddDefinition(arguments.ResultsVariable, diff --git a/Source/cmExecutionStatus.h b/Source/cmExecutionStatus.h index 56199dd..bcacc2f 100644 --- a/Source/cmExecutionStatus.h +++ b/Source/cmExecutionStatus.h @@ -3,6 +3,11 @@ #ifndef cmExecutionStatus_h #define cmExecutionStatus_h +#include <cmConfigure.h> // IWYU pragma: keep +#include <string> + +class cmMakefile; + /** \class cmExecutionStatus * \brief Superclass for all command status classes * @@ -11,14 +16,26 @@ class cmExecutionStatus { public: + cmExecutionStatus(cmMakefile& makefile) + : Makefile(makefile) + , Error("unknown error.") + { + } + void Clear() { + this->Error = "unknown error."; this->ReturnInvoked = false; this->BreakInvoked = false; this->ContinueInvoked = false; this->NestedError = false; } + cmMakefile& GetMakefile() { return this->Makefile; } + + void SetError(std::string const& e) { this->Error = e; } + std::string const& GetError() const { return this->Error; } + void SetReturnInvoked() { this->ReturnInvoked = true; } bool GetReturnInvoked() const { return this->ReturnInvoked; } @@ -32,6 +49,8 @@ public: bool GetNestedError() const { return this->NestedError; } private: + cmMakefile& Makefile; + std::string Error; bool ReturnInvoked = false; bool BreakInvoked = false; bool ContinueInvoked = false; diff --git a/Source/cmExportBuildAndroidMKGenerator.cxx b/Source/cmExportBuildAndroidMKGenerator.cxx index e693155..5edf7ca 100644 --- a/Source/cmExportBuildAndroidMKGenerator.cxx +++ b/Source/cmExportBuildAndroidMKGenerator.cxx @@ -6,13 +6,13 @@ #include <sstream> #include <utility> -#include "cmAlgorithms.h" #include "cmGeneratorTarget.h" #include "cmLinkItem.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmPolicies.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" diff --git a/Source/cmExportBuildFileGenerator.cxx b/Source/cmExportBuildFileGenerator.cxx index de3e0e2..33806f2 100644 --- a/Source/cmExportBuildFileGenerator.cxx +++ b/Source/cmExportBuildFileGenerator.cxx @@ -2,7 +2,6 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmExportBuildFileGenerator.h" -#include "cmAlgorithms.h" #include "cmExportSet.h" #include "cmGeneratorExpression.h" #include "cmGeneratorTarget.h" @@ -12,6 +11,7 @@ #include "cmMessageType.h" #include "cmPolicies.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmTarget.h" #include "cmTargetExport.h" #include "cmake.h" diff --git a/Source/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx index 29afc9f..8fd2947 100644 --- a/Source/cmExportFileGenerator.cxx +++ b/Source/cmExportFileGenerator.cxx @@ -2,7 +2,6 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmExportFileGenerator.h" -#include "cmAlgorithms.h" #include "cmComputeLinkInformation.h" #include "cmGeneratedFileStream.h" #include "cmGeneratorTarget.h" @@ -14,6 +13,7 @@ #include "cmPolicies.h" #include "cmPropertyMap.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmTargetExport.h" diff --git a/Source/cmExportInstallFileGenerator.cxx b/Source/cmExportInstallFileGenerator.cxx index f8bc0ab..ab4a62b 100644 --- a/Source/cmExportInstallFileGenerator.cxx +++ b/Source/cmExportInstallFileGenerator.cxx @@ -2,7 +2,6 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmExportInstallFileGenerator.h" -#include "cmAlgorithms.h" #include "cmExportSet.h" #include "cmExportSetMap.h" #include "cmGeneratedFileStream.h" @@ -15,6 +14,7 @@ #include "cmMakefile.h" #include "cmPolicies.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmTargetExport.h" diff --git a/Source/cmFLTKWrapUICommand.cxx b/Source/cmFLTKWrapUICommand.cxx index 70800b4..b7a2b27 100644 --- a/Source/cmFLTKWrapUICommand.cxx +++ b/Source/cmFLTKWrapUICommand.cxx @@ -117,8 +117,9 @@ bool cmFLTKWrapUICommand::InitialPass(std::vector<std::string> const& args, } sourceListValue += generatedSourcesClasses[classNum]->GetFullPath(); } + std::string const varName = target + "_FLTK_UI_SRCS"; - this->Makefile->AddDefinition(varName, sourceListValue.c_str()); + this->Makefile->AddDefinition(varName, sourceListValue); this->Makefile->AddFinalAction( [target](cmMakefile& makefile) { FinalAction(makefile, target); }); diff --git a/Source/cmFileAPI.cxx b/Source/cmFileAPI.cxx index ba42669..aa84396 100644 --- a/Source/cmFileAPI.cxx +++ b/Source/cmFileAPI.cxx @@ -2,12 +2,12 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmFileAPI.h" -#include "cmAlgorithms.h" #include "cmCryptoHash.h" #include "cmFileAPICMakeFiles.h" #include "cmFileAPICache.h" #include "cmFileAPICodemodel.h" #include "cmGlobalGenerator.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTimestamp.h" #include "cmake.h" diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx index 9871f49..22f0d1f 100644 --- a/Source/cmFileCommand.cxx +++ b/Source/cmFileCommand.cxx @@ -39,6 +39,7 @@ #include "cmRange.h" #include "cmRuntimeDependencyArchive.h" #include "cmState.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTimestamp.h" #include "cm_sys_stat.h" @@ -365,7 +366,7 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args) } } } - this->Makefile->AddDefinition(variable, output.c_str()); + this->Makefile->AddDefinition(variable, output); return true; } @@ -383,7 +384,7 @@ bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args) if (hash) { std::string out = hash->HashFile(args[1]); if (!out.empty()) { - this->Makefile->AddDefinition(args[2], out.c_str()); + this->Makefile->AddDefinition(args[2], out); return true; } std::ostringstream e; @@ -751,7 +752,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args) } // Save the output in a makefile variable. - this->Makefile->AddDefinition(outVar, output.c_str()); + this->Makefile->AddDefinition(outVar, output); return true; } @@ -938,7 +939,7 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args, std::sort(files.begin(), files.end()); files.erase(std::unique(files.begin(), files.end()), files.end()); - this->Makefile->AddDefinition(variable, cmJoin(files, ";").c_str()); + this->Makefile->AddDefinition(variable, cmJoin(files, ";")); return true; } @@ -1071,6 +1072,7 @@ bool cmFileCommand::HandleRPathChangeCommand( std::string file; const char* oldRPath = nullptr; const char* newRPath = nullptr; + bool removeEnvironmentRPath = false; enum Doing { DoingNone, @@ -1086,6 +1088,8 @@ bool cmFileCommand::HandleRPathChangeCommand( doing = DoingNew; } else if (args[i] == "FILE") { doing = DoingFile; + } else if (args[i] == "INSTALL_REMOVE_ENVIRONMENT_RPATH") { + removeEnvironmentRPath = true; } else if (doing == DoingFile) { file = args[i]; doing = DoingNone; @@ -1124,7 +1128,9 @@ bool cmFileCommand::HandleRPathChangeCommand( cmFileTimes const ft(file); std::string emsg; bool changed; - if (!cmSystemTools::ChangeRPath(file, oldRPath, newRPath, &emsg, &changed)) { + + if (!cmSystemTools::ChangeRPath(file, oldRPath, newRPath, + removeEnvironmentRPath, &emsg, &changed)) { std::ostringstream e; /* clang-format off */ e << "RPATH_CHANGE could not write new RPATH:\n" @@ -1298,14 +1304,14 @@ bool cmFileCommand::HandleReadElfCommand(std::vector<std::string> const& args) if (cmELF::StringEntry const* se_rpath = elf.GetRPath()) { std::string rpath(se_rpath->Value); std::replace(rpath.begin(), rpath.end(), ':', ';'); - this->Makefile->AddDefinition(arguments.RPath, rpath.c_str()); + this->Makefile->AddDefinition(arguments.RPath, rpath); } } if (!arguments.RunPath.empty()) { if (cmELF::StringEntry const* se_runpath = elf.GetRunPath()) { std::string runpath(se_runpath->Value); std::replace(runpath.begin(), runpath.end(), ':', ';'); - this->Makefile->AddDefinition(arguments.RunPath, runpath.c_str()); + this->Makefile->AddDefinition(arguments.RunPath, runpath); } } @@ -1316,7 +1322,7 @@ bool cmFileCommand::HandleReadElfCommand(std::vector<std::string> const& args) this->SetError(error); return false; } - this->Makefile->AddDefinition(arguments.Error, error.c_str()); + this->Makefile->AddDefinition(arguments.Error, error); return true; #endif } @@ -1354,7 +1360,7 @@ bool cmFileCommand::HandleRelativePathCommand( } std::string res = cmSystemTools::RelativePath(directoryName, fileName); - this->Makefile->AddDefinition(outVar, res.c_str()); + this->Makefile->AddDefinition(outVar, res); return true; } @@ -1460,7 +1466,7 @@ bool cmFileCommand::HandleCMakePathCommand( std::string value = cmJoin( cmMakeRange(path).transform(nativePath ? ToNativePath : ToCMakePath), ";"); - this->Makefile->AddDefinition(args[2], value.c_str()); + this->Makefile->AddDefinition(args[2], value); return true; } @@ -1800,7 +1806,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args) if (!statusVar.empty()) { std::ostringstream result; result << 0 << ";\"" << msg; - this->Makefile->AddDefinition(statusVar, result.str().c_str()); + this->Makefile->AddDefinition(statusVar, result.str()); } return true; } @@ -1949,7 +1955,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args) std::ostringstream result; result << static_cast<int>(res) << ";\"" << ::curl_easy_strerror(res) << "\""; - this->Makefile->AddDefinition(statusVar, result.str().c_str()); + this->Makefile->AddDefinition(statusVar, result.str()); } ::curl_global_cleanup(); @@ -1981,7 +1987,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args) std::string status = "1;HASH mismatch: " "expected: " + expectedHash + " actual: " + actualHash; - this->Makefile->AddDefinition(statusVar, status.c_str()); + this->Makefile->AddDefinition(statusVar, status); } this->SetError(oss.str()); @@ -2236,7 +2242,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args) std::ostringstream result; result << static_cast<int>(res) << ";\"" << ::curl_easy_strerror(res) << "\""; - this->Makefile->AddDefinition(statusVar, result.str().c_str()); + this->Makefile->AddDefinition(statusVar, result.str()); } ::curl_global_cleanup(); @@ -2261,7 +2267,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args) log += "\n"; } - this->Makefile->AddDefinition(logVar, log.c_str()); + this->Makefile->AddDefinition(logVar, log); } return true; @@ -2479,7 +2485,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args) } if (!resultVariable.empty()) { - this->Makefile->AddDefinition(resultVariable, result.c_str()); + this->Makefile->AddDefinition(resultVariable, result); } return true; @@ -2528,7 +2534,7 @@ bool cmFileCommand::HandleTimestampCommand( cmTimestamp timestamp; std::string result = timestamp.FileModificationTime(filename.c_str(), formatString, utcFlag); - this->Makefile->AddDefinition(outputVariable, result.c_str()); + this->Makefile->AddDefinition(outputVariable, result); return true; } @@ -2556,8 +2562,7 @@ bool cmFileCommand::HandleSizeCommand(std::vector<std::string> const& args) } this->Makefile->AddDefinition( - outputVariable, - std::to_string(cmSystemTools::FileLength(filename)).c_str()); + outputVariable, std::to_string(cmSystemTools::FileLength(filename))); return true; } @@ -2584,7 +2589,7 @@ bool cmFileCommand::HandleReadSymlinkCommand( return false; } - this->Makefile->AddDefinition(outputVariable, result.c_str()); + this->Makefile->AddDefinition(outputVariable, result); return true; } @@ -2630,7 +2635,7 @@ bool cmFileCommand::HandleCreateLinkCommand( if (fileName == newFileName) { result = "CREATE_LINK cannot use same file and newfile"; if (!arguments.Result.empty()) { - this->Makefile->AddDefinition(arguments.Result, result.c_str()); + this->Makefile->AddDefinition(arguments.Result, result); return true; } this->SetError(result); @@ -2641,7 +2646,7 @@ bool cmFileCommand::HandleCreateLinkCommand( if (!arguments.Symbolic && !cmSystemTools::FileExists(fileName)) { result = "Cannot hard link \'" + fileName + "\' as it does not exist."; if (!arguments.Result.empty()) { - this->Makefile->AddDefinition(arguments.Result, result.c_str()); + this->Makefile->AddDefinition(arguments.Result, result); return true; } this->SetError(result); @@ -2658,7 +2663,7 @@ bool cmFileCommand::HandleCreateLinkCommand( << cmSystemTools::GetLastSystemError() << "\n"; if (!arguments.Result.empty()) { - this->Makefile->AddDefinition(arguments.Result, e.str().c_str()); + this->Makefile->AddDefinition(arguments.Result, e.str()); return true; } this->SetError(e.str()); @@ -2693,7 +2698,7 @@ bool cmFileCommand::HandleCreateLinkCommand( } if (!arguments.Result.empty()) { - this->Makefile->AddDefinition(arguments.Result, result.c_str()); + this->Makefile->AddDefinition(arguments.Result, result); } return true; @@ -2821,7 +2826,7 @@ bool cmFileCommand::HandleGetRuntimeDependenciesCommand( std::string varName = parsedArgs.ConflictingDependenciesPrefix + "_" + val.first; std::string pathsStr = cmJoin(paths, ";"); - this->Makefile->AddDefinition(varName, pathsStr.c_str()); + this->Makefile->AddDefinition(varName, pathsStr); } else { std::ostringstream e; e << "Multiple conflicting paths found for " << val.first << ":"; @@ -2851,18 +2856,16 @@ bool cmFileCommand::HandleGetRuntimeDependenciesCommand( if (!parsedArgs.ResolvedDependenciesVar.empty()) { std::string val = cmJoin(deps, ";"); - this->Makefile->AddDefinition(parsedArgs.ResolvedDependenciesVar, - val.c_str()); + this->Makefile->AddDefinition(parsedArgs.ResolvedDependenciesVar, val); } if (!parsedArgs.UnresolvedDependenciesVar.empty()) { std::string val = cmJoin(unresolvedDeps, ";"); - this->Makefile->AddDefinition(parsedArgs.UnresolvedDependenciesVar, - val.c_str()); + this->Makefile->AddDefinition(parsedArgs.UnresolvedDependenciesVar, val); } if (!parsedArgs.ConflictingDependenciesPrefix.empty()) { std::string val = cmJoin(conflictingDeps, ";"); this->Makefile->AddDefinition( - parsedArgs.ConflictingDependenciesPrefix + "_FILENAMES", val.c_str()); + parsedArgs.ConflictingDependenciesPrefix + "_FILENAMES", val); } return true; } diff --git a/Source/cmFileCopier.cxx b/Source/cmFileCopier.cxx index 49e8cd5..4f1a158 100644 --- a/Source/cmFileCopier.cxx +++ b/Source/cmFileCopier.cxx @@ -174,11 +174,8 @@ bool cmFileCopier::GetDefaultDirectoryPermissions(mode_t** mode) cmSystemTools::ExpandListArgument(default_dir_install_permissions, items); for (const auto& arg : items) { if (!this->CheckPermissions(arg, **mode)) { - std::ostringstream e; - e << this->FileCommand->GetError() - << " Set with CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS " - "variable."; - this->FileCommand->SetError(e.str()); + this->FileCommand->SetError( + " Set with CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS variable."); return false; } } diff --git a/Source/cmFileInstaller.cxx b/Source/cmFileInstaller.cxx index d4f76fd..9378439 100644 --- a/Source/cmFileInstaller.cxx +++ b/Source/cmFileInstaller.cxx @@ -38,7 +38,7 @@ cmFileInstaller::~cmFileInstaller() { // Save the updated install manifest. this->Makefile->AddDefinition("CMAKE_INSTALL_MANIFEST_FILES", - this->Manifest.c_str()); + this->Manifest); } void cmFileInstaller::ManifestAppend(std::string const& file) diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx index be7964a..b1ccc83 100644 --- a/Source/cmFindBase.cxx +++ b/Source/cmFindBase.cxx @@ -13,6 +13,7 @@ #include "cmSearchPath.h" #include "cmState.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" cmFindBase::cmFindBase() diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx index c6d599e..04fbbad 100644 --- a/Source/cmFindPackageCommand.cxx +++ b/Source/cmFindPackageCommand.cxx @@ -28,6 +28,7 @@ #include "cmSearchPath.h" #include "cmState.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmVersion.h" #if defined(__HAIKU__) @@ -225,6 +226,9 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args, this->SortDirection = strcmp(sd, "ASC") == 0 ? Asc : Dec; } + // Find what search path locations have been enabled/disable + this->SelectDefaultSearchModes(); + // Find the current root path mode. this->SelectDefaultRootPathMode(); @@ -675,7 +679,9 @@ void cmFindPackageCommand::AddFindDefinition(const std::string& var, } else { this->OriginalDefs[var].exists = false; } - this->Makefile->AddDefinition(var, val); + if (val) { + this->Makefile->AddDefinition(var, val); + } } void cmFindPackageCommand::RestoreFindDefinitions() @@ -683,7 +689,7 @@ void cmFindPackageCommand::RestoreFindDefinitions() for (auto const& i : this->OriginalDefs) { OriginalDef const& od = i.second; if (od.exists) { - this->Makefile->AddDefinition(i.first, od.value.c_str()); + this->Makefile->AddDefinition(i.first, od.value); } else { this->Makefile->RemoveDefinition(i.first); } @@ -957,7 +963,7 @@ bool cmFindPackageCommand::HandlePackageMode( std::string fileVar = this->Name; fileVar += "_CONFIG"; if (found) { - this->Makefile->AddDefinition(fileVar, this->FileFound.c_str()); + this->Makefile->AddDefinition(fileVar, this->FileFound); } else { this->Makefile->RemoveDefinition(fileVar); } @@ -979,11 +985,9 @@ bool cmFindPackageCommand::HandlePackageMode( sep = ";"; } - this->Makefile->AddDefinition(consideredConfigsVar, - consideredConfigFiles.c_str()); + this->Makefile->AddDefinition(consideredConfigsVar, consideredConfigFiles); - this->Makefile->AddDefinition(consideredVersionsVar, - consideredVersions.c_str()); + this->Makefile->AddDefinition(consideredVersionsVar, consideredVersions); return result; } @@ -1612,8 +1616,8 @@ bool cmFindPackageCommand::CheckVersionFile(std::string const& version_file, this->Makefile->RemoveDefinition("PACKAGE_VERSION_EXACT"); // Set the input variables. - this->Makefile->AddDefinition("PACKAGE_FIND_NAME", this->Name.c_str()); - this->Makefile->AddDefinition("PACKAGE_FIND_VERSION", this->Version.c_str()); + this->Makefile->AddDefinition("PACKAGE_FIND_NAME", this->Name); + this->Makefile->AddDefinition("PACKAGE_FIND_VERSION", this->Version); char buf[64]; sprintf(buf, "%u", this->VersionMajor); this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_MAJOR", buf); @@ -1690,7 +1694,7 @@ void cmFindPackageCommand::StoreVersionFound() if (this->VersionFound.empty()) { this->Makefile->RemoveDefinition(ver); } else { - this->Makefile->AddDefinition(ver, this->VersionFound.c_str()); + this->Makefile->AddDefinition(ver, this->VersionFound); } // Store the version components. diff --git a/Source/cmForEachCommand.cxx b/Source/cmForEachCommand.cxx index a30ebe1..06dce2c 100644 --- a/Source/cmForEachCommand.cxx +++ b/Source/cmForEachCommand.cxx @@ -53,21 +53,21 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff, for (std::string const& arg : cmMakeRange(this->Args).advance(1)) { // set the variable to the loop value - mf.AddDefinition(this->Args[0], arg.c_str()); + mf.AddDefinition(this->Args[0], arg); // Invoke all the functions that were collected in the block. - cmExecutionStatus status; + cmExecutionStatus status(mf); for (cmListFileFunction const& func : this->Functions) { status.Clear(); mf.ExecuteCommand(func, status); if (status.GetReturnInvoked()) { inStatus.SetReturnInvoked(); // restore the variable to its prior value - mf.AddDefinition(this->Args[0], oldDef.c_str()); + mf.AddDefinition(this->Args[0], oldDef); return true; } if (status.GetBreakInvoked()) { // restore the variable to its prior value - mf.AddDefinition(this->Args[0], oldDef.c_str()); + mf.AddDefinition(this->Args[0], oldDef); return true; } if (status.GetContinueInvoked()) { @@ -80,7 +80,7 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff, } // restore the variable to its prior value - mf.AddDefinition(this->Args[0], oldDef.c_str()); + mf.AddDefinition(this->Args[0], oldDef); return true; } // close out a nested foreach diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx index 6d06531..2809cf7 100644 --- a/Source/cmFunctionCommand.cxx +++ b/Source/cmFunctionCommand.cxx @@ -5,45 +5,24 @@ #include <sstream> #include <utility> -#include "cm_memory.hxx" - #include "cmAlgorithms.h" #include "cmExecutionStatus.h" #include "cmMakefile.h" #include "cmPolicies.h" #include "cmRange.h" #include "cmState.h" +#include "cmStringAlgorithms.h" // define the class for function commands -class cmFunctionHelperCommand : public cmCommand +class cmFunctionHelperCommand { public: /** - * This is a virtual constructor for the command. - */ - std::unique_ptr<cmCommand> Clone() override - { - auto newC = cm::make_unique<cmFunctionHelperCommand>(); - // we must copy when we clone - newC->Args = this->Args; - newC->Functions = this->Functions; - newC->Policies = this->Policies; - newC->FilePath = this->FilePath; - return std::unique_ptr<cmCommand>(std::move(newC)); - } - - /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, - cmExecutionStatus&) override; - - bool InitialPass(std::vector<std::string> const&, - cmExecutionStatus&) override - { - return false; - } + bool operator()(std::vector<cmListFileArgument> const& args, + cmExecutionStatus& inStatus) const; std::vector<std::string> Args; std::vector<cmListFileFunction> Functions; @@ -51,12 +30,15 @@ public: std::string FilePath; }; -bool cmFunctionHelperCommand::InvokeInitialPass( - const std::vector<cmListFileArgument>& args, cmExecutionStatus& inStatus) +bool cmFunctionHelperCommand::operator()( + std::vector<cmListFileArgument> const& args, + cmExecutionStatus& inStatus) const { + cmMakefile& makefile = inStatus.GetMakefile(); + // Expand the argument list to the function. std::vector<std::string> expandedArgs; - this->Makefile->ExpandArguments(args, expandedArgs); + makefile.ExpandArguments(args, expandedArgs); // make sure the number of arguments passed is at least the number // required by the signature @@ -64,30 +46,30 @@ bool cmFunctionHelperCommand::InvokeInitialPass( std::string errorMsg = "Function invoked with incorrect arguments for function named: "; errorMsg += this->Args[0]; - this->SetError(errorMsg); + inStatus.SetError(errorMsg); return false; } - cmMakefile::FunctionPushPop functionScope(this->Makefile, this->FilePath, + cmMakefile::FunctionPushPop functionScope(&makefile, this->FilePath, this->Policies); // set the value of argc std::ostringstream strStream; strStream << expandedArgs.size(); - this->Makefile->AddDefinition("ARGC", strStream.str().c_str()); - this->Makefile->MarkVariableAsUsed("ARGC"); + makefile.AddDefinition("ARGC", strStream.str()); + makefile.MarkVariableAsUsed("ARGC"); // set the values for ARGV0 ARGV1 ... for (unsigned int t = 0; t < expandedArgs.size(); ++t) { std::ostringstream tmpStream; tmpStream << "ARGV" << t; - this->Makefile->AddDefinition(tmpStream.str(), expandedArgs[t].c_str()); - this->Makefile->MarkVariableAsUsed(tmpStream.str()); + makefile.AddDefinition(tmpStream.str(), expandedArgs[t]); + makefile.MarkVariableAsUsed(tmpStream.str()); } // define the formal arguments for (unsigned int j = 1; j < this->Args.size(); ++j) { - this->Makefile->AddDefinition(this->Args[j], expandedArgs[j - 1].c_str()); + makefile.AddDefinition(this->Args[j], expandedArgs[j - 1]); } // define ARGV and ARGN @@ -95,17 +77,16 @@ bool cmFunctionHelperCommand::InvokeInitialPass( std::vector<std::string>::const_iterator eit = expandedArgs.begin() + (this->Args.size() - 1); std::string argnDef = cmJoin(cmMakeRange(eit, expandedArgs.end()), ";"); - this->Makefile->AddDefinition("ARGV", argvDef.c_str()); - this->Makefile->MarkVariableAsUsed("ARGV"); - this->Makefile->AddDefinition("ARGN", argnDef.c_str()); - this->Makefile->MarkVariableAsUsed("ARGN"); + makefile.AddDefinition("ARGV", argvDef); + makefile.MarkVariableAsUsed("ARGV"); + makefile.AddDefinition("ARGN", argnDef); + makefile.MarkVariableAsUsed("ARGN"); // Invoke all the functions that were collected in the block. // for each function for (cmListFileFunction const& func : this->Functions) { - cmExecutionStatus status; - if (!this->Makefile->ExecuteCommand(func, status) || - status.GetNestedError()) { + cmExecutionStatus status(makefile); + if (!makefile.ExecuteCommand(func, status) || status.GetNestedError()) { // The error message should have already included the call stack // so we do not need to report an error here. functionScope.Quiet(); @@ -132,11 +113,11 @@ bool cmFunctionFunctionBlocker::IsFunctionBlocked( // if this is the endfunction for this function then execute if (!this->Depth) { // create a new command and add it to cmake - auto f = cm::make_unique<cmFunctionHelperCommand>(); - f->Args = this->Args; - f->Functions = this->Functions; - f->FilePath = this->GetStartingContext().FilePath; - mf.RecordPolicies(f->Policies); + cmFunctionHelperCommand f; + f.Args = this->Args; + f.Functions = this->Functions; + f.FilePath = this->GetStartingContext().FilePath; + mf.RecordPolicies(f.Policies); mf.GetState()->AddScriptedCommand(this->Args[0], std::move(f)); // remove the function blocker now that the function is defined mf.RemoveFunctionBlocker(this, lff); diff --git a/Source/cmGeneratorExpressionDAGChecker.cxx b/Source/cmGeneratorExpressionDAGChecker.cxx index 728f2a4..df2227f 100644 --- a/Source/cmGeneratorExpressionDAGChecker.cxx +++ b/Source/cmGeneratorExpressionDAGChecker.cxx @@ -2,12 +2,12 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmGeneratorExpressionDAGChecker.h" -#include "cmAlgorithms.h" #include "cmGeneratorExpressionContext.h" #include "cmGeneratorExpressionEvaluator.h" #include "cmGeneratorTarget.h" #include "cmLocalGenerator.h" #include "cmMessageType.h" +#include "cmStringAlgorithms.h" #include "cmake.h" #include <sstream> @@ -68,9 +68,7 @@ void cmGeneratorExpressionDAGChecker::Initialize() return; } } - const_cast<cmGeneratorExpressionDAGChecker*>(top) - ->Seen[this->Target] - .insert(this->Property); + top->Seen[this->Target].insert(this->Property); } } diff --git a/Source/cmGeneratorExpressionDAGChecker.h b/Source/cmGeneratorExpressionDAGChecker.h index e1fba5e..6d7d6ef 100644 --- a/Source/cmGeneratorExpressionDAGChecker.h +++ b/Source/cmGeneratorExpressionDAGChecker.h @@ -88,7 +88,7 @@ private: const cmGeneratorExpressionDAGChecker* const Parent; cmGeneratorTarget const* Target; const std::string Property; - std::map<cmGeneratorTarget const*, std::set<std::string>> Seen; + mutable std::map<cmGeneratorTarget const*, std::set<std::string>> Seen; const GeneratorExpressionContent* const Content; const cmListFileBacktrace Backtrace; Result CheckResult; diff --git a/Source/cmGeneratorExpressionNode.cxx b/Source/cmGeneratorExpressionNode.cxx index d828dac..14dc7b8 100644 --- a/Source/cmGeneratorExpressionNode.cxx +++ b/Source/cmGeneratorExpressionNode.cxx @@ -19,6 +19,7 @@ #include "cmState.h" #include "cmStateSnapshot.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cm_static_string_view.hxx" @@ -1038,45 +1039,38 @@ static const struct CompileLanguageAndIdNode : public cmGeneratorExpressionNode } } languageAndIdNode; -#define TRANSITIVE_PROPERTY_NAME(PROPERTY) , "INTERFACE_" #PROPERTY - -static const char* targetPropertyTransitiveWhitelist[] = { - nullptr CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(TRANSITIVE_PROPERTY_NAME) -}; - -#undef TRANSITIVE_PROPERTY_NAME - -template <typename T> std::string getLinkedTargetsContent( - std::vector<T> const& libraries, cmGeneratorTarget const* target, - cmGeneratorTarget const* headTarget, cmGeneratorExpressionContext* context, - cmGeneratorExpressionDAGChecker* dagChecker, - const std::string& interfacePropertyName) -{ - std::string linkedTargetsContent; - std::string sep; - std::string depString; - for (T const& l : libraries) { - // Broken code can have a target in its own link interface. - // Don't follow such link interface entries so as not to create a - // self-referencing loop. - if (l.Target && l.Target != target) { - std::string uniqueName = - target->GetGlobalGenerator()->IndexGeneratorTargetUniquely(l.Target); - depString += sep + "$<TARGET_PROPERTY:" + std::move(uniqueName) + "," + - interfacePropertyName + ">"; - sep = ";"; - } - } - if (!depString.empty()) { - linkedTargetsContent = - cmGeneratorExpressionNode::EvaluateDependentExpression( - depString, target->GetLocalGenerator(), context, headTarget, target, - dagChecker); - } - linkedTargetsContent = - cmGeneratorExpression::StripEmptyListElements(linkedTargetsContent); - return linkedTargetsContent; + cmGeneratorTarget const* target, std::string const& prop, + cmGeneratorExpressionContext* context, + cmGeneratorExpressionDAGChecker* dagChecker) +{ + std::string result; + if (cmLinkImplementationLibraries const* impl = + target->GetLinkImplementationLibraries(context->Config)) { + for (cmLinkImplItem const& lib : impl->Libraries) { + if (lib.Target) { + // Pretend $<TARGET_PROPERTY:lib.Target,prop> appeared in our + // caller's property and hand-evaluate it as if it were compiled. + // Create a context as cmCompiledGeneratorExpression::Evaluate does. + cmGeneratorExpressionContext libContext( + target->GetLocalGenerator(), context->Config, context->Quiet, target, + target, context->EvaluateForBuildsystem, lib.Backtrace, + context->Language); + std::string libResult = + lib.Target->EvaluateInterfaceProperty(prop, &libContext, dagChecker); + if (!libResult.empty()) { + if (result.empty()) { + result = std::move(libResult); + } else { + result.reserve(result.size() + 1 + libResult.size()); + result += ";"; + result += libResult; + } + } + } + } + } + return result; } static const struct TargetPropertyNode : public cmGeneratorExpressionNode @@ -1205,44 +1199,37 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode return target->GetLinkerLanguage(context->Config); } - cmGeneratorExpressionDAGChecker dagChecker( - context->Backtrace, target, propertyName, content, dagCheckerParent); + std::string interfacePropertyName; + bool isInterfaceProperty = false; - switch (dagChecker.Check()) { - case cmGeneratorExpressionDAGChecker::SELF_REFERENCE: - dagChecker.ReportError(context, content->GetOriginalExpression()); - return std::string(); - case cmGeneratorExpressionDAGChecker::CYCLIC_REFERENCE: - // No error. We just skip cyclic references. - return std::string(); - case cmGeneratorExpressionDAGChecker::ALREADY_SEEN: - for (size_t i = 1; i < cm::size(targetPropertyTransitiveWhitelist); - ++i) { - if (targetPropertyTransitiveWhitelist[i] == propertyName) { - // No error. We're not going to find anything new here. - return std::string(); - } - } - case cmGeneratorExpressionDAGChecker::DAG: - break; - } +#define POPULATE_INTERFACE_PROPERTY_NAME(prop) \ + if (propertyName == #prop) { \ + interfacePropertyName = "INTERFACE_" #prop; \ + } else if (propertyName == "INTERFACE_" #prop) { \ + interfacePropertyName = "INTERFACE_" #prop; \ + isInterfaceProperty = true; \ + } else - std::string prop; - bool haveProp = false; - if (const char* p = target->GetProperty(propertyName)) { - prop = p; - haveProp = true; + CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(POPULATE_INTERFACE_PROPERTY_NAME) + // Note that the above macro terminates with an else + /* else */ if (cmHasLiteralPrefix(propertyName, "COMPILE_DEFINITIONS_")) { + cmPolicies::PolicyStatus polSt = + context->LG->GetPolicyStatus(cmPolicies::CMP0043); + if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD) { + interfacePropertyName = "INTERFACE_COMPILE_DEFINITIONS"; + } } +#undef POPULATE_INTERFACE_PROPERTY_NAME + + bool evaluatingLinkLibraries = false; if (dagCheckerParent) { if (dagCheckerParent->EvaluatingGenexExpression() || dagCheckerParent->EvaluatingPICExpression()) { // No check required. } else if (dagCheckerParent->EvaluatingLinkLibraries()) { -#define TRANSITIVE_PROPERTY_COMPARE(PROPERTY) \ - (#PROPERTY == propertyName || "INTERFACE_" #PROPERTY == propertyName) || - if (CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME( - TRANSITIVE_PROPERTY_COMPARE) false) { // NOLINT(*) + evaluatingLinkLibraries = true; + if (!interfacePropertyName.empty()) { reportError( context, content->GetOriginalExpression(), "$<TARGET_PROPERTY:...> expression in link libraries " @@ -1250,69 +1237,47 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode "over the link libraries, creating a recursion."); return std::string(); } -#undef TRANSITIVE_PROPERTY_COMPARE - - if (!haveProp) { - return std::string(); - } } else { #define ASSERT_TRANSITIVE_PROPERTY_METHOD(METHOD) dagCheckerParent->METHOD() || - assert(CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD( ASSERT_TRANSITIVE_PROPERTY_METHOD) false); // NOLINT(clang-tidy) #undef ASSERT_TRANSITIVE_PROPERTY_METHOD } } - std::string linkedTargetsContent; - - std::string interfacePropertyName; - bool isInterfaceProperty = false; + if (isInterfaceProperty) { + return target->EvaluateInterfaceProperty(propertyName, context, + dagCheckerParent); + } -#define POPULATE_INTERFACE_PROPERTY_NAME(prop) \ - if (propertyName == #prop) { \ - interfacePropertyName = "INTERFACE_" #prop; \ - } else if (propertyName == "INTERFACE_" #prop) { \ - interfacePropertyName = "INTERFACE_" #prop; \ - isInterfaceProperty = true; \ - } else + cmGeneratorExpressionDAGChecker dagChecker( + context->Backtrace, target, propertyName, content, dagCheckerParent); - CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(POPULATE_INTERFACE_PROPERTY_NAME) - // Note that the above macro terminates with an else - /* else */ if (cmHasLiteralPrefix(propertyName, "COMPILE_DEFINITIONS_")) { - cmPolicies::PolicyStatus polSt = - context->LG->GetPolicyStatus(cmPolicies::CMP0043); - if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD) { - interfacePropertyName = "INTERFACE_COMPILE_DEFINITIONS"; - } + switch (dagChecker.Check()) { + case cmGeneratorExpressionDAGChecker::SELF_REFERENCE: + dagChecker.ReportError(context, content->GetOriginalExpression()); + return std::string(); + case cmGeneratorExpressionDAGChecker::CYCLIC_REFERENCE: + // No error. We just skip cyclic references. + return std::string(); + case cmGeneratorExpressionDAGChecker::ALREADY_SEEN: + // We handle transitive properties above. For non-transitive + // properties we accept repeats anyway. + case cmGeneratorExpressionDAGChecker::DAG: + break; } -#undef POPULATE_INTERFACE_PROPERTY_NAME - cmGeneratorTarget const* headTarget = - context->HeadTarget && isInterfaceProperty ? context->HeadTarget - : target; - if (isInterfaceProperty) { - if (cmLinkInterfaceLibraries const* iface = - target->GetLinkInterfaceLibraries(context->Config, headTarget, - true)) { - linkedTargetsContent = - getLinkedTargetsContent(iface->Libraries, target, headTarget, - context, &dagChecker, interfacePropertyName); - } - } else if (!interfacePropertyName.empty()) { - if (cmLinkImplementationLibraries const* impl = - target->GetLinkImplementationLibraries(context->Config)) { - linkedTargetsContent = - getLinkedTargetsContent(impl->Libraries, target, target, context, - &dagChecker, interfacePropertyName); - } + std::string result; + bool haveProp = false; + if (const char* p = target->GetProperty(propertyName)) { + result = p; + haveProp = true; + } else if (evaluatingLinkLibraries) { + return std::string(); } - if (!haveProp) { - if (target->IsImported() || - target->GetType() == cmStateEnums::INTERFACE_LIBRARY) { - return linkedTargetsContent; - } + if (!haveProp && !target->IsImported() && + target->GetType() != cmStateEnums::INTERFACE_LIBRARY) { if (target->IsLinkInterfaceDependentBoolProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; @@ -1345,8 +1310,6 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode context->Config); return propContent ? propContent : ""; } - - return linkedTargetsContent; } if (!target->IsImported() && dagCheckerParent && @@ -1368,15 +1331,17 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode return propContent ? propContent : ""; } } + if (!interfacePropertyName.empty()) { - std::string result = this->EvaluateDependentExpression( - prop, context->LG, context, headTarget, target, &dagChecker); + result = this->EvaluateDependentExpression(result, context->LG, context, + target, target, &dagChecker); + std::string linkedTargetsContent = getLinkedTargetsContent( + target, interfacePropertyName, context, &dagChecker); if (!linkedTargetsContent.empty()) { result += (result.empty() ? "" : ";") + linkedTargetsContent; } - return result; } - return prop; + return result; } } targetPropertyNode; diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx index d3e8248..38f34ac 100644 --- a/Source/cmGeneratorTarget.cxx +++ b/Source/cmGeneratorTarget.cxx @@ -22,7 +22,9 @@ #include "cmCustomCommandGenerator.h" #include "cmCustomCommandLines.h" #include "cmGeneratorExpression.h" +#include "cmGeneratorExpressionContext.h" #include "cmGeneratorExpressionDAGChecker.h" +#include "cmGeneratorExpressionNode.h" #include "cmGlobalGenerator.h" #include "cmLocalGenerator.h" #include "cmMakefile.h" @@ -32,6 +34,7 @@ #include "cmSourceFile.h" #include "cmSourceFileLocation.h" #include "cmState.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmTargetLinkLibraryType.h" @@ -92,9 +95,6 @@ public: virtual bool GetHadContextSensitiveCondition() const { return false; } cmLinkImplItem const& LinkImplItem; - -private: - cmListFileBacktrace Backtrace; }; cmLinkImplItem cmGeneratorTarget::TargetPropertyEntry::NoLinkImplItem; @@ -209,6 +209,63 @@ void CreatePropertyGeneratorExpressions( } } +namespace { +// Represent a target property entry after evaluating generator expressions +// and splitting up lists. +struct EvaluatedTargetPropertyEntry +{ + EvaluatedTargetPropertyEntry(cmLinkImplItem const& item, + cmListFileBacktrace bt) + : LinkImplItem(item) + , Backtrace(std::move(bt)) + { + } + + // Move-only. + EvaluatedTargetPropertyEntry(EvaluatedTargetPropertyEntry&&) = default; + EvaluatedTargetPropertyEntry(EvaluatedTargetPropertyEntry const&) = delete; + EvaluatedTargetPropertyEntry& operator=(EvaluatedTargetPropertyEntry&&) = + delete; + EvaluatedTargetPropertyEntry& operator=( + EvaluatedTargetPropertyEntry const&) = delete; + + cmLinkImplItem const& LinkImplItem; + cmListFileBacktrace Backtrace; + std::vector<std::string> Values; + bool ContextDependent = false; +}; + +EvaluatedTargetPropertyEntry EvaluateTargetPropertyEntry( + cmGeneratorTarget const* thisTarget, std::string const& config, + std::string const& lang, cmGeneratorExpressionDAGChecker* dagChecker, + cmGeneratorTarget::TargetPropertyEntry* entry) +{ + EvaluatedTargetPropertyEntry ee(entry->LinkImplItem, entry->GetBacktrace()); + cmSystemTools::ExpandListArgument( + entry->Evaluate(thisTarget->GetLocalGenerator(), config, false, thisTarget, + dagChecker, lang), + ee.Values); + if (entry->GetHadContextSensitiveCondition()) { + ee.ContextDependent = true; + } + return ee; +} + +std::vector<EvaluatedTargetPropertyEntry> EvaluateTargetPropertyEntries( + cmGeneratorTarget const* thisTarget, std::string const& config, + std::string const& lang, cmGeneratorExpressionDAGChecker* dagChecker, + std::vector<cmGeneratorTarget::TargetPropertyEntry*> const& in) +{ + std::vector<EvaluatedTargetPropertyEntry> out; + out.reserve(in.size()); + for (cmGeneratorTarget::TargetPropertyEntry* entry : in) { + out.emplace_back(EvaluateTargetPropertyEntry(thisTarget, config, lang, + dagChecker, entry)); + } + return out; +} +} + cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg) : Target(t) , FortranModuleDirectoryCreated(false) @@ -654,12 +711,14 @@ std::vector<cmSourceFile*> const* cmGeneratorTarget::GetSourceDepends( return nullptr; } -static void handleSystemIncludesDep( - cmLocalGenerator* lg, cmGeneratorTarget const* depTgt, - const std::string& config, cmGeneratorTarget const* headTarget, - cmGeneratorExpressionDAGChecker* dagChecker, - std::vector<std::string>& result, bool excludeImported, - std::string const& language) +namespace { +void handleSystemIncludesDep(cmLocalGenerator* lg, + cmGeneratorTarget const* depTgt, + const std::string& config, + cmGeneratorTarget const* headTarget, + cmGeneratorExpressionDAGChecker* dagChecker, + std::vector<std::string>& result, + bool excludeImported, std::string const& language) { if (const char* dirs = depTgt->GetProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES")) { @@ -682,6 +741,7 @@ static void handleSystemIncludesDep( result); } } +} /* clang-format off */ #define IMPLEMENT_VISIT(KIND) \ @@ -1084,77 +1144,205 @@ bool cmGeneratorTarget::GetPropertyAsBool(const std::string& prop) const return this->Target->GetPropertyAsBool(prop); } -static void AddInterfaceEntries( - cmGeneratorTarget const* thisTarget, std::string const& config, - std::string const& prop, - std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries) +bool cmGeneratorTarget::MaybeHaveInterfaceProperty( + std::string const& prop, cmGeneratorExpressionContext* context) const +{ + std::string const key = prop + '@' + context->Config; + auto i = this->MaybeInterfacePropertyExists.find(key); + if (i == this->MaybeInterfacePropertyExists.end()) { + // Insert an entry now in case there is a cycle. + i = this->MaybeInterfacePropertyExists.emplace(key, false).first; + bool& maybeInterfaceProp = i->second; + + // If this target itself has a non-empty property value, we are done. + const char* p = this->GetProperty(prop); + maybeInterfaceProp = p && *p; + + // Otherwise, recurse to interface dependencies. + if (!maybeInterfaceProp) { + cmGeneratorTarget const* headTarget = + context->HeadTarget ? context->HeadTarget : this; + if (cmLinkInterfaceLibraries const* iface = + this->GetLinkInterfaceLibraries(context->Config, headTarget, + true)) { + if (iface->HadHeadSensitiveCondition) { + // With a different head target we may get to a library with + // this interface property. + maybeInterfaceProp = true; + } else { + // The transitive interface libraries do not depend on the + // head target, so we can follow them. + for (cmLinkItem const& lib : iface->Libraries) { + if (lib.Target && + lib.Target->MaybeHaveInterfaceProperty(prop, context)) { + maybeInterfaceProp = true; + break; + } + } + } + } + } + } + return i->second; +} + +std::string cmGeneratorTarget::EvaluateInterfaceProperty( + std::string const& prop, cmGeneratorExpressionContext* context, + cmGeneratorExpressionDAGChecker* dagCheckerParent) const +{ + std::string result; + + // If the property does not appear transitively at all, we are done. + if (!this->MaybeHaveInterfaceProperty(prop, context)) { + return result; + } + + // Evaluate $<TARGET_PROPERTY:this,prop> as if it were compiled. This is + // a subset of TargetPropertyNode::Evaluate without stringify/parse steps + // but sufficient for transitive interface properties. + cmGeneratorExpressionDAGChecker dagChecker(context->Backtrace, this, prop, + nullptr, dagCheckerParent); + switch (dagChecker.Check()) { + case cmGeneratorExpressionDAGChecker::SELF_REFERENCE: + dagChecker.ReportError( + context, "$<TARGET_PROPERTY:" + this->GetName() + "," + prop + ">"); + return result; + case cmGeneratorExpressionDAGChecker::CYCLIC_REFERENCE: + // No error. We just skip cyclic references. + return result; + case cmGeneratorExpressionDAGChecker::ALREADY_SEEN: + // No error. We have already seen this transitive property. + return result; + case cmGeneratorExpressionDAGChecker::DAG: + break; + } + + cmGeneratorTarget const* headTarget = + context->HeadTarget ? context->HeadTarget : this; + + if (const char* p = this->GetProperty(prop)) { + result = cmGeneratorExpressionNode::EvaluateDependentExpression( + p, context->LG, context, headTarget, this, &dagChecker); + } + + if (cmLinkInterfaceLibraries const* iface = + this->GetLinkInterfaceLibraries(context->Config, headTarget, true)) { + for (cmLinkItem const& lib : iface->Libraries) { + // Broken code can have a target in its own link interface. + // Don't follow such link interface entries so as not to create a + // self-referencing loop. + if (lib.Target && lib.Target != this) { + // Pretend $<TARGET_PROPERTY:lib.Target,prop> appeared in the + // above property and hand-evaluate it as if it were compiled. + // Create a context as cmCompiledGeneratorExpression::Evaluate does. + cmGeneratorExpressionContext libContext( + context->LG, context->Config, context->Quiet, headTarget, this, + context->EvaluateForBuildsystem, context->Backtrace, + context->Language); + std::string libResult = cmGeneratorExpression::StripEmptyListElements( + lib.Target->EvaluateInterfaceProperty(prop, &libContext, + &dagChecker)); + if (!libResult.empty()) { + if (result.empty()) { + result = std::move(libResult); + } else { + result.reserve(result.size() + 1 + libResult.size()); + result += ";"; + result += libResult; + } + } + context->HadContextSensitiveCondition = + context->HadContextSensitiveCondition || + libContext.HadContextSensitiveCondition; + context->HadHeadSensitiveCondition = + context->HadHeadSensitiveCondition || + libContext.HadHeadSensitiveCondition; + } + } + } + + return result; +} + +namespace { +void AddInterfaceEntries(cmGeneratorTarget const* headTarget, + std::string const& config, std::string const& prop, + std::string const& lang, + cmGeneratorExpressionDAGChecker* dagChecker, + std::vector<EvaluatedTargetPropertyEntry>& entries) { if (cmLinkImplementationLibraries const* impl = - thisTarget->GetLinkImplementationLibraries(config)) { + headTarget->GetLinkImplementationLibraries(config)) { for (cmLinkImplItem const& lib : impl->Libraries) { if (lib.Target) { - std::string uniqueName = - thisTarget->GetGlobalGenerator()->IndexGeneratorTargetUniquely( - lib.Target); - std::string genex = - "$<TARGET_PROPERTY:" + std::move(uniqueName) + "," + prop + ">"; - cmGeneratorExpression ge(lib.Backtrace); - std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex); - cge->SetEvaluateForBuildsystem(true); - entries.push_back(new TargetPropertyEntryGenex(std::move(cge), lib)); + EvaluatedTargetPropertyEntry ee(lib, lib.Backtrace); + // Pretend $<TARGET_PROPERTY:lib.Target,prop> appeared in our + // caller's property and hand-evaluate it as if it were compiled. + // Create a context as cmCompiledGeneratorExpression::Evaluate does. + cmGeneratorExpressionContext context( + headTarget->GetLocalGenerator(), config, false, headTarget, + headTarget, true, lib.Backtrace, lang); + cmSystemTools::ExpandListArgument( + lib.Target->EvaluateInterfaceProperty(prop, &context, dagChecker), + ee.Values); + ee.ContextDependent = context.HadContextSensitiveCondition; + entries.emplace_back(std::move(ee)); } } } } -static void AddObjectEntries( - cmGeneratorTarget const* thisTarget, std::string const& config, - std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries) +void AddObjectEntries(cmGeneratorTarget const* headTarget, + std::string const& config, + cmGeneratorExpressionDAGChecker* dagChecker, + std::vector<EvaluatedTargetPropertyEntry>& entries) { if (cmLinkImplementationLibraries const* impl = - thisTarget->GetLinkImplementationLibraries(config)) { + headTarget->GetLinkImplementationLibraries(config)) { for (cmLinkImplItem const& lib : impl->Libraries) { if (lib.Target && lib.Target->GetType() == cmStateEnums::OBJECT_LIBRARY) { std::string uniqueName = - thisTarget->GetGlobalGenerator()->IndexGeneratorTargetUniquely( + headTarget->GetGlobalGenerator()->IndexGeneratorTargetUniquely( lib.Target); std::string genex = "$<TARGET_OBJECTS:" + std::move(uniqueName) + ">"; cmGeneratorExpression ge(lib.Backtrace); std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex); cge->SetEvaluateForBuildsystem(true); - entries.push_back(new TargetPropertyEntryGenex(std::move(cge), lib)); + + EvaluatedTargetPropertyEntry ee(lib, lib.Backtrace); + cmSystemTools::ExpandListArgument( + cge->Evaluate(headTarget->GetLocalGenerator(), config, false, + headTarget, dagChecker), + ee.Values); + if (cge->GetHadContextSensitiveCondition()) { + ee.ContextDependent = true; + } + entries.emplace_back(std::move(ee)); } } } } -static bool processSources( - cmGeneratorTarget const* tgt, - const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries, - std::vector<BT<std::string>>& srcs, - std::unordered_set<std::string>& uniqueSrcs, - cmGeneratorExpressionDAGChecker* dagChecker, std::string const& config, - bool debugSources) +bool processSources(cmGeneratorTarget const* tgt, + std::vector<EvaluatedTargetPropertyEntry>& entries, + std::vector<BT<std::string>>& srcs, + std::unordered_set<std::string>& uniqueSrcs, + bool debugSources) { cmMakefile* mf = tgt->Target->GetMakefile(); bool contextDependent = false; - for (cmGeneratorTarget::TargetPropertyEntry* entry : entries) { - cmLinkImplItem const& item = entry->LinkImplItem; - std::string const& targetName = item.AsStr(); - std::vector<std::string> entrySources; - cmSystemTools::ExpandListArgument(entry->Evaluate(tgt->GetLocalGenerator(), - config, false, tgt, tgt, - dagChecker), - entrySources); - - if (entry->GetHadContextSensitiveCondition()) { + for (EvaluatedTargetPropertyEntry& entry : entries) { + if (entry.ContextDependent) { contextDependent = true; } - for (std::string& src : entrySources) { + cmLinkImplItem const& item = entry.LinkImplItem; + std::string const& targetName = item.AsStr(); + + for (std::string& src : entry.Values) { cmSourceFile* sf = mf->GetOrCreateSource(src); std::string e; std::string fullPath = sf->GetFullPath(&e); @@ -1183,9 +1371,9 @@ static bool processSources( src = fullPath; } std::string usedSources; - for (std::string const& src : entrySources) { + for (std::string const& src : entry.Values) { if (uniqueSrcs.insert(src).second) { - srcs.emplace_back(src, entry->GetBacktrace()); + srcs.emplace_back(src, entry.Backtrace); if (debugSources) { usedSources += " * " + src + "\n"; } @@ -1196,11 +1384,12 @@ static bool processSources( MessageType::LOG, std::string("Used sources for target ") + tgt->GetName() + ":\n" + usedSources, - entry->GetBacktrace()); + entry.Backtrace); } } return contextDependent; } +} std::vector<BT<std::string>> cmGeneratorTarget::GetSourceFilePaths( std::string const& config) const @@ -1248,28 +1437,28 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetSourceFilePaths( cmGeneratorExpressionDAGChecker dagChecker(this, "SOURCES", nullptr, nullptr); + std::vector<EvaluatedTargetPropertyEntry> entries = + EvaluateTargetPropertyEntries(this, config, std::string(), &dagChecker, + this->SourceEntries); + std::unordered_set<std::string> uniqueSrcs; bool contextDependentDirectSources = - processSources(this, this->SourceEntries, files, uniqueSrcs, &dagChecker, - config, debugSources); + processSources(this, entries, files, uniqueSrcs, debugSources); // Collect INTERFACE_SOURCES of all direct link-dependencies. - std::vector<cmGeneratorTarget::TargetPropertyEntry*> - linkInterfaceSourcesEntries; - AddInterfaceEntries(this, config, "INTERFACE_SOURCES", - linkInterfaceSourcesEntries); + std::vector<EvaluatedTargetPropertyEntry> linkInterfaceSourcesEntries; + AddInterfaceEntries(this, config, "INTERFACE_SOURCES", std::string(), + &dagChecker, linkInterfaceSourcesEntries); std::vector<std::string>::size_type numFilesBefore = files.size(); - bool contextDependentInterfaceSources = - processSources(this, linkInterfaceSourcesEntries, files, uniqueSrcs, - &dagChecker, config, debugSources); + bool contextDependentInterfaceSources = processSources( + this, linkInterfaceSourcesEntries, files, uniqueSrcs, debugSources); // Collect TARGET_OBJECTS of direct object link-dependencies. - std::vector<cmGeneratorTarget::TargetPropertyEntry*> linkObjectsEntries; - AddObjectEntries(this, config, linkObjectsEntries); + std::vector<EvaluatedTargetPropertyEntry> linkObjectsEntries; + AddObjectEntries(this, config, &dagChecker, linkObjectsEntries); std::vector<std::string>::size_type numFilesBefore2 = files.size(); bool contextDependentObjects = - processSources(this, linkObjectsEntries, files, uniqueSrcs, &dagChecker, - config, debugSources); + processSources(this, linkObjectsEntries, files, uniqueSrcs, debugSources); if (!contextDependentDirectSources && !(contextDependentInterfaceSources && numFilesBefore < files.size()) && @@ -1277,8 +1466,6 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetSourceFilePaths( this->LinkImplementationLanguageIsContextDependent = false; } - cmDeleteAll(linkInterfaceSourcesEntries); - cmDeleteAll(linkObjectsEntries); return files; } @@ -1855,16 +2042,17 @@ std::string cmGeneratorTarget::GetSOName(const std::string& config) const return this->GetLibraryNames(config).SharedObject; } -static bool shouldAddFullLevel(cmGeneratorTarget::BundleDirectoryLevel level) +namespace { +bool shouldAddFullLevel(cmGeneratorTarget::BundleDirectoryLevel level) { return level == cmGeneratorTarget::FullLevel; } -static bool shouldAddContentLevel( - cmGeneratorTarget::BundleDirectoryLevel level) +bool shouldAddContentLevel(cmGeneratorTarget::BundleDirectoryLevel level) { return level == cmGeneratorTarget::ContentLevel || shouldAddFullLevel(level); } +} std::string cmGeneratorTarget::GetAppBundleDirectory( const std::string& config, BundleDirectoryLevel level) const @@ -2767,27 +2955,22 @@ std::string cmGeneratorTarget::GetCreateRuleVariable( } return ""; } -static void processIncludeDirectories( + +namespace { +void processIncludeDirectories( cmGeneratorTarget const* tgt, - const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries, + std::vector<EvaluatedTargetPropertyEntry>& entries, std::vector<BT<std::string>>& includes, - std::unordered_set<std::string>& uniqueIncludes, - cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config, - bool debugIncludes, const std::string& language) + std::unordered_set<std::string>& uniqueIncludes, bool debugIncludes) { - for (cmGeneratorTarget::TargetPropertyEntry* entry : entries) { - cmLinkImplItem const& item = entry->LinkImplItem; + for (EvaluatedTargetPropertyEntry& entry : entries) { + cmLinkImplItem const& item = entry.LinkImplItem; std::string const& targetName = item.AsStr(); bool const fromImported = item.Target && item.Target->IsImported(); bool const checkCMP0027 = item.FromGenex; - std::vector<std::string> entryIncludes; - cmSystemTools::ExpandListArgument(entry->Evaluate(tgt->GetLocalGenerator(), - config, false, tgt, - dagChecker, language), - entryIncludes); std::string usedIncludes; - for (std::string& entryInclude : entryIncludes) { + for (std::string& entryInclude : entry.Values) { if (fromImported && !cmSystemTools::FileExists(entryInclude)) { std::ostringstream e; MessageType messageType = MessageType::FATAL_ERROR; @@ -2859,12 +3042,11 @@ static void processIncludeDirectories( if (!cmSystemTools::IsOff(entryInclude)) { cmSystemTools::ConvertToUnixSlashes(entryInclude); } - std::string inc = entryInclude; - if (uniqueIncludes.insert(inc).second) { - includes.emplace_back(inc, entry->GetBacktrace()); + if (uniqueIncludes.insert(entryInclude).second) { + includes.emplace_back(entryInclude, entry.Backtrace); if (debugIncludes) { - usedIncludes += " * " + inc + "\n"; + usedIncludes += " * " + entryInclude + "\n"; } } } @@ -2873,10 +3055,11 @@ static void processIncludeDirectories( MessageType::LOG, std::string("Used includes for target ") + tgt->GetName() + ":\n" + usedIncludes, - entry->GetBacktrace()); + entry.Backtrace); } } } +} std::vector<BT<std::string>> cmGeneratorTarget::GetIncludeDirectories( const std::string& config, const std::string& lang) const @@ -2902,14 +3085,12 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetIncludeDirectories( this->DebugIncludesDone = true; } - processIncludeDirectories(this, this->IncludeDirectoriesEntries, includes, - uniqueIncludes, &dagChecker, config, debugIncludes, - lang); + std::vector<EvaluatedTargetPropertyEntry> entries = + EvaluateTargetPropertyEntries(this, config, lang, &dagChecker, + this->IncludeDirectoriesEntries); - std::vector<cmGeneratorTarget::TargetPropertyEntry*> - linkInterfaceIncludeDirectoriesEntries; - AddInterfaceEntries(this, config, "INTERFACE_INCLUDE_DIRECTORIES", - linkInterfaceIncludeDirectoriesEntries); + AddInterfaceEntries(this, config, "INTERFACE_INCLUDE_DIRECTORIES", lang, + &dagChecker, entries); if (this->Makefile->IsOn("APPLE")) { cmLinkImplementationLibraries const* impl = @@ -2925,16 +3106,14 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetIncludeDirectories( libDir = frameworkCheck.match(1); - linkInterfaceIncludeDirectoriesEntries.push_back( - CreateTargetPropertyEntry(libDir)); + EvaluatedTargetPropertyEntry ee(lib, cmListFileBacktrace()); + ee.Values.emplace_back(std::move(libDir)); + entries.emplace_back(std::move(ee)); } } - processIncludeDirectories(this, linkInterfaceIncludeDirectoriesEntries, - includes, uniqueIncludes, &dagChecker, config, - debugIncludes, lang); - - cmDeleteAll(linkInterfaceIncludeDirectoriesEntries); + processIncludeDirectories(this, entries, includes, uniqueIncludes, + debugIncludes); return includes; } @@ -2945,33 +3124,26 @@ enum class OptionsParse Shell }; -static void processOptionsInternal( - cmGeneratorTarget const* tgt, - const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries, - std::vector<BT<std::string>>& options, - std::unordered_set<std::string>& uniqueOptions, - cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config, - bool debugOptions, const char* logName, std::string const& language, - OptionsParse parse) -{ - for (cmGeneratorTarget::TargetPropertyEntry* entry : entries) { - std::vector<std::string> entryOptions; - cmSystemTools::ExpandListArgument(entry->Evaluate(tgt->GetLocalGenerator(), - config, false, tgt, - dagChecker, language), - entryOptions); +namespace { +void processOptions(cmGeneratorTarget const* tgt, + std::vector<EvaluatedTargetPropertyEntry> const& entries, + std::vector<BT<std::string>>& options, + std::unordered_set<std::string>& uniqueOptions, + bool debugOptions, const char* logName, OptionsParse parse) +{ + for (EvaluatedTargetPropertyEntry const& entry : entries) { std::string usedOptions; - for (std::string const& opt : entryOptions) { + for (std::string const& opt : entry.Values) { if (uniqueOptions.insert(opt).second) { if (parse == OptionsParse::Shell && cmHasLiteralPrefix(opt, "SHELL:")) { std::vector<std::string> tmp; cmSystemTools::ParseUnixCommandLine(opt.c_str() + 6, tmp); for (std::string& o : tmp) { - options.emplace_back(std::move(o), entry->GetBacktrace()); + options.emplace_back(std::move(o), entry.Backtrace); } } else { - options.emplace_back(opt, entry->GetBacktrace()); + options.emplace_back(opt, entry.Backtrace); } if (debugOptions) { usedOptions += " * " + opt + "\n"; @@ -2983,22 +3155,10 @@ static void processOptionsInternal( MessageType::LOG, std::string("Used ") + logName + std::string(" for target ") + tgt->GetName() + ":\n" + usedOptions, - entry->GetBacktrace()); + entry.Backtrace); } } } - -static void processCompileOptions( - cmGeneratorTarget const* tgt, - const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries, - std::vector<BT<std::string>>& options, - std::unordered_set<std::string>& uniqueOptions, - cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config, - bool debugOptions, std::string const& language) -{ - processOptionsInternal(tgt, entries, options, uniqueOptions, dagChecker, - config, debugOptions, "compile options", language, - OptionsParse::Shell); } void cmGeneratorTarget::GetCompileOptions(std::vector<std::string>& result, @@ -3036,37 +3196,19 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetCompileOptions( this->DebugCompileOptionsDone = true; } - processCompileOptions(this, this->CompileOptionsEntries, result, - uniqueOptions, &dagChecker, config, debugOptions, - language); + std::vector<EvaluatedTargetPropertyEntry> entries = + EvaluateTargetPropertyEntries(this, config, language, &dagChecker, + this->CompileOptionsEntries); - std::vector<cmGeneratorTarget::TargetPropertyEntry*> - linkInterfaceCompileOptionsEntries; + AddInterfaceEntries(this, config, "INTERFACE_COMPILE_OPTIONS", language, + &dagChecker, entries); - AddInterfaceEntries(this, config, "INTERFACE_COMPILE_OPTIONS", - linkInterfaceCompileOptionsEntries); + processOptions(this, entries, result, uniqueOptions, debugOptions, + "compile options", OptionsParse::Shell); - processCompileOptions(this, linkInterfaceCompileOptionsEntries, result, - uniqueOptions, &dagChecker, config, debugOptions, - language); - - cmDeleteAll(linkInterfaceCompileOptionsEntries); return result; } -static void processCompileFeatures( - cmGeneratorTarget const* tgt, - const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries, - std::vector<BT<std::string>>& options, - std::unordered_set<std::string>& uniqueOptions, - cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config, - bool debugOptions) -{ - processOptionsInternal(tgt, entries, options, uniqueOptions, dagChecker, - config, debugOptions, "compile features", - std::string(), OptionsParse::None); -} - void cmGeneratorTarget::GetCompileFeatures(std::vector<std::string>& result, const std::string& config) const { @@ -3101,34 +3243,19 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetCompileFeatures( this->DebugCompileFeaturesDone = true; } - processCompileFeatures(this, this->CompileFeaturesEntries, result, - uniqueFeatures, &dagChecker, config, debugFeatures); + std::vector<EvaluatedTargetPropertyEntry> entries = + EvaluateTargetPropertyEntries(this, config, std::string(), &dagChecker, + this->CompileFeaturesEntries); - std::vector<cmGeneratorTarget::TargetPropertyEntry*> - linkInterfaceCompileFeaturesEntries; AddInterfaceEntries(this, config, "INTERFACE_COMPILE_FEATURES", - linkInterfaceCompileFeaturesEntries); + std::string(), &dagChecker, entries); - processCompileFeatures(this, linkInterfaceCompileFeaturesEntries, result, - uniqueFeatures, &dagChecker, config, debugFeatures); + processOptions(this, entries, result, uniqueFeatures, debugFeatures, + "compile features", OptionsParse::None); - cmDeleteAll(linkInterfaceCompileFeaturesEntries); return result; } -static void processCompileDefinitions( - cmGeneratorTarget const* tgt, - const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries, - std::vector<BT<std::string>>& options, - std::unordered_set<std::string>& uniqueOptions, - cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config, - bool debugOptions, std::string const& language) -{ - processOptionsInternal(tgt, entries, options, uniqueOptions, dagChecker, - config, debugOptions, "compile definitions", language, - OptionsParse::None); -} - void cmGeneratorTarget::GetCompileDefinitions( std::vector<std::string>& result, const std::string& config, const std::string& language) const @@ -3165,14 +3292,13 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetCompileDefinitions( this->DebugCompileDefinitionsDone = true; } - processCompileDefinitions(this, this->CompileDefinitionsEntries, list, - uniqueOptions, &dagChecker, config, debugDefines, - language); + std::vector<EvaluatedTargetPropertyEntry> entries = + EvaluateTargetPropertyEntries(this, config, language, &dagChecker, + this->CompileDefinitionsEntries); + + AddInterfaceEntries(this, config, "INTERFACE_COMPILE_DEFINITIONS", language, + &dagChecker, entries); - std::vector<cmGeneratorTarget::TargetPropertyEntry*> - linkInterfaceCompileDefinitionsEntries; - AddInterfaceEntries(this, config, "INTERFACE_COMPILE_DEFINITIONS", - linkInterfaceCompileDefinitionsEntries); if (!config.empty()) { std::string configPropName = "COMPILE_DEFINITIONS_" + cmSystemTools::UpperCase(config); @@ -3187,8 +3313,10 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetCompileDefinitions( CM_FALLTHROUGH; } case cmPolicies::OLD: { - linkInterfaceCompileDefinitionsEntries.push_back( + std::unique_ptr<TargetPropertyEntry> entry( CreateTargetPropertyEntry(configProp)); + entries.emplace_back(EvaluateTargetPropertyEntry( + this, config, language, &dagChecker, entry.get())); } break; case cmPolicies::NEW: case cmPolicies::REQUIRED_ALWAYS: @@ -3198,29 +3326,12 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetCompileDefinitions( } } - processCompileDefinitions(this, linkInterfaceCompileDefinitionsEntries, list, - uniqueOptions, &dagChecker, config, debugDefines, - language); + processOptions(this, entries, list, uniqueOptions, debugDefines, + "compile definitions", OptionsParse::None); - cmDeleteAll(linkInterfaceCompileDefinitionsEntries); return list; } -namespace { -void processLinkOptions( - cmGeneratorTarget const* tgt, - const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries, - std::vector<BT<std::string>>& options, - std::unordered_set<std::string>& uniqueOptions, - cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config, - bool debugOptions, std::string const& language) -{ - processOptionsInternal(tgt, entries, options, uniqueOptions, dagChecker, - config, debugOptions, "link options", language, - OptionsParse::Shell); -} -} - void cmGeneratorTarget::GetLinkOptions(std::vector<std::string>& result, const std::string& config, const std::string& language) const @@ -3256,20 +3367,15 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetLinkOptions( this->DebugLinkOptionsDone = true; } - processLinkOptions(this, this->LinkOptionsEntries, result, uniqueOptions, - &dagChecker, config, debugOptions, language); + std::vector<EvaluatedTargetPropertyEntry> entries = + EvaluateTargetPropertyEntries(this, config, language, &dagChecker, + this->LinkOptionsEntries); - std::vector<cmGeneratorTarget::TargetPropertyEntry*> - linkInterfaceLinkOptionsEntries; + AddInterfaceEntries(this, config, "INTERFACE_LINK_OPTIONS", language, + &dagChecker, entries); - AddInterfaceEntries(this, config, "INTERFACE_LINK_OPTIONS", - linkInterfaceLinkOptionsEntries); - - processLinkOptions(this, linkInterfaceLinkOptionsEntries, result, - uniqueOptions, &dagChecker, config, debugOptions, - language); - - cmDeleteAll(linkInterfaceLinkOptionsEntries); + processOptions(this, entries, result, uniqueOptions, debugOptions, + "link options", OptionsParse::Shell); // Last step: replace "LINKER:" prefixed elements by // actual linker wrapper @@ -3375,21 +3481,6 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetLinkOptions( return result; } -namespace { -void processStaticLibraryLinkOptions( - cmGeneratorTarget const* tgt, - const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries, - std::vector<BT<std::string>>& options, - std::unordered_set<std::string>& uniqueOptions, - cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config, - std::string const& language) -{ - processOptionsInternal(tgt, entries, options, uniqueOptions, dagChecker, - config, false, "static library link options", - language, OptionsParse::Shell); -} -} - void cmGeneratorTarget::GetStaticLibraryLinkOptions( std::vector<std::string>& result, const std::string& config, const std::string& language) const @@ -3406,47 +3497,41 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetStaticLibraryLinkOptions( std::string const& config, std::string const& language) const { std::vector<BT<std::string>> result; - std::vector<cmGeneratorTarget::TargetPropertyEntry*> entries; std::unordered_set<std::string> uniqueOptions; cmGeneratorExpressionDAGChecker dagChecker(this, "STATIC_LIBRARY_OPTIONS", nullptr, nullptr); + std::vector<EvaluatedTargetPropertyEntry> entries; if (const char* linkOptions = this->GetProperty("STATIC_LIBRARY_OPTIONS")) { std::vector<std::string> options; cmSystemTools::ExpandListArgument(linkOptions, options); for (const auto& option : options) { - entries.push_back(CreateTargetPropertyEntry(option)); + std::unique_ptr<TargetPropertyEntry> entry( + CreateTargetPropertyEntry(option)); + entries.emplace_back(EvaluateTargetPropertyEntry( + this, config, language, &dagChecker, entry.get())); } } - processStaticLibraryLinkOptions(this, entries, result, uniqueOptions, - &dagChecker, config, language); + processOptions(this, entries, result, uniqueOptions, false, + "static library link options", OptionsParse::Shell); - cmDeleteAll(entries); return result; } namespace { -void processLinkDirectories( - cmGeneratorTarget const* tgt, - const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries, - std::vector<BT<std::string>>& directories, - std::unordered_set<std::string>& uniqueDirectories, - cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config, - bool debugDirectories, std::string const& language) -{ - for (cmGeneratorTarget::TargetPropertyEntry* entry : entries) { - cmLinkImplItem const& item = entry->LinkImplItem; +void processLinkDirectories(cmGeneratorTarget const* tgt, + std::vector<EvaluatedTargetPropertyEntry>& entries, + std::vector<BT<std::string>>& directories, + std::unordered_set<std::string>& uniqueDirectories, + bool debugDirectories) +{ + for (EvaluatedTargetPropertyEntry& entry : entries) { + cmLinkImplItem const& item = entry.LinkImplItem; std::string const& targetName = item.AsStr(); - std::vector<std::string> entryDirectories; - cmSystemTools::ExpandListArgument(entry->Evaluate(tgt->GetLocalGenerator(), - config, false, tgt, - dagChecker, language), - entryDirectories); - std::string usedDirectories; - for (std::string& entryDirectory : entryDirectories) { + for (std::string& entryDirectory : entry.Values) { if (!cmSystemTools::FileIsFullPath(entryDirectory)) { std::ostringstream e; bool noMessage = false; @@ -3499,7 +3584,7 @@ void processLinkDirectories( MessageType::LOG, std::string("Used link directories for target ") + tgt->GetName() + ":\n" + usedDirectories, - entry->GetBacktrace()); + entry.Backtrace); } } } @@ -3541,39 +3626,19 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetLinkDirectories( this->DebugLinkDirectoriesDone = true; } - processLinkDirectories(this, this->LinkDirectoriesEntries, result, - uniqueDirectories, &dagChecker, config, - debugDirectories, language); + std::vector<EvaluatedTargetPropertyEntry> entries = + EvaluateTargetPropertyEntries(this, config, language, &dagChecker, + this->LinkDirectoriesEntries); - std::vector<cmGeneratorTarget::TargetPropertyEntry*> - linkInterfaceLinkDirectoriesEntries; + AddInterfaceEntries(this, config, "INTERFACE_LINK_DIRECTORIES", language, + &dagChecker, entries); - AddInterfaceEntries(this, config, "INTERFACE_LINK_DIRECTORIES", - linkInterfaceLinkDirectoriesEntries); + processLinkDirectories(this, entries, result, uniqueDirectories, + debugDirectories); - processLinkDirectories(this, linkInterfaceLinkDirectoriesEntries, result, - uniqueDirectories, &dagChecker, config, - debugDirectories, language); - - cmDeleteAll(linkInterfaceLinkDirectoriesEntries); return result; } -namespace { -void processLinkDepends( - cmGeneratorTarget const* tgt, - const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries, - std::vector<BT<std::string>>& options, - std::unordered_set<std::string>& uniqueOptions, - cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config, - std::string const& language) -{ - processOptionsInternal(tgt, entries, options, uniqueOptions, dagChecker, - config, false, "link depends", language, - OptionsParse::None); -} -} - void cmGeneratorTarget::GetLinkDepends(std::vector<std::string>& result, const std::string& config, const std::string& language) const @@ -3589,24 +3654,27 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetLinkDepends( std::string const& config, std::string const& language) const { std::vector<BT<std::string>> result; - std::vector<cmGeneratorTarget::TargetPropertyEntry*> linkDependsEntries; std::unordered_set<std::string> uniqueOptions; cmGeneratorExpressionDAGChecker dagChecker(this, "LINK_DEPENDS", nullptr, nullptr); + std::vector<EvaluatedTargetPropertyEntry> entries; if (const char* linkDepends = this->GetProperty("LINK_DEPENDS")) { std::vector<std::string> depends; cmSystemTools::ExpandListArgument(linkDepends, depends); for (const auto& depend : depends) { - linkDependsEntries.push_back(CreateTargetPropertyEntry(depend)); + std::unique_ptr<TargetPropertyEntry> entry( + CreateTargetPropertyEntry(depend)); + entries.emplace_back(EvaluateTargetPropertyEntry( + this, config, language, &dagChecker, entry.get())); } } - AddInterfaceEntries(this, config, "INTERFACE_LINK_DEPENDS", - linkDependsEntries); - processLinkDepends(this, linkDependsEntries, result, uniqueOptions, - &dagChecker, config, language); + AddInterfaceEntries(this, config, "INTERFACE_LINK_DEPENDS", language, + &dagChecker, entries); + + processOptions(this, entries, result, uniqueOptions, false, "link depends", + OptionsParse::None); - cmDeleteAll(linkDependsEntries); return result; } @@ -4346,8 +4414,9 @@ void checkPropertyConsistency(cmGeneratorTarget const* depender, } } -static std::string intersect(const std::set<std::string>& s1, - const std::set<std::string>& s2) +namespace { +std::string intersect(const std::set<std::string>& s1, + const std::set<std::string>& s2) { std::set<std::string> intersect; std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), @@ -4358,9 +4427,9 @@ static std::string intersect(const std::set<std::string>& s1, return ""; } -static std::string intersect(const std::set<std::string>& s1, - const std::set<std::string>& s2, - const std::set<std::string>& s3) +std::string intersect(const std::set<std::string>& s1, + const std::set<std::string>& s2, + const std::set<std::string>& s3) { std::string result; result = intersect(s1, s2); @@ -4374,10 +4443,10 @@ static std::string intersect(const std::set<std::string>& s1, return intersect(s2, s3); } -static std::string intersect(const std::set<std::string>& s1, - const std::set<std::string>& s2, - const std::set<std::string>& s3, - const std::set<std::string>& s4) +std::string intersect(const std::set<std::string>& s1, + const std::set<std::string>& s2, + const std::set<std::string>& s3, + const std::set<std::string>& s4) { std::string result; result = intersect(s1, s2); @@ -4394,6 +4463,7 @@ static std::string intersect(const std::set<std::string>& s1, } return intersect(s2, s3, s4); } +} void cmGeneratorTarget::CheckPropertyCompatibility( cmComputeLinkInformation* info, const std::string& config) const diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h index e86535d..3874738 100644 --- a/Source/cmGeneratorTarget.h +++ b/Source/cmGeneratorTarget.h @@ -14,6 +14,7 @@ #include <set> #include <stddef.h> #include <string> +#include <unordered_map> #include <utility> #include <vector> @@ -25,6 +26,9 @@ class cmMakefile; class cmSourceFile; class cmTarget; +struct cmGeneratorExpressionContext; +struct cmGeneratorExpressionDAGChecker; + class cmGeneratorTarget { public: @@ -674,6 +678,10 @@ public: class TargetPropertyEntry; + std::string EvaluateInterfaceProperty( + std::string const& prop, cmGeneratorExpressionContext* context, + cmGeneratorExpressionDAGChecker* dagCheckerParent) const; + bool HaveInstallTreeRPATH(const std::string& config) const; bool GetBuildRPATH(const std::string& config, std::string& rpath) const; @@ -849,6 +857,10 @@ private: mutable std::vector<AllConfigSource> AllConfigSources; void ComputeAllConfigSources() const; + mutable std::unordered_map<std::string, bool> MaybeInterfacePropertyExists; + bool MaybeHaveInterfaceProperty(std::string const& prop, + cmGeneratorExpressionContext* context) const; + std::vector<TargetPropertyEntry*> IncludeDirectoriesEntries; std::vector<TargetPropertyEntry*> CompileOptionsEntries; std::vector<TargetPropertyEntry*> CompileFeaturesEntries; diff --git a/Source/cmGetCMakePropertyCommand.cxx b/Source/cmGetCMakePropertyCommand.cxx index fc82fee..38fee28 100644 --- a/Source/cmGetCMakePropertyCommand.cxx +++ b/Source/cmGetCMakePropertyCommand.cxx @@ -4,10 +4,10 @@ #include <set> -#include "cmAlgorithms.h" #include "cmGlobalGenerator.h" #include "cmMakefile.h" #include "cmState.h" +#include "cmStringAlgorithms.h" class cmExecutionStatus; @@ -46,7 +46,7 @@ bool cmGetCMakePropertyCommand::InitialPass( } } - this->Makefile->AddDefinition(variable, output.c_str()); + this->Makefile->AddDefinition(variable, output); return true; } diff --git a/Source/cmGetDirectoryPropertyCommand.cxx b/Source/cmGetDirectoryPropertyCommand.cxx index a92eb71..98ccb0a 100644 --- a/Source/cmGetDirectoryPropertyCommand.cxx +++ b/Source/cmGetDirectoryPropertyCommand.cxx @@ -66,7 +66,7 @@ bool cmGetDirectoryPropertyCommand::InitialPass( return false; } std::string const& output = dir->GetSafeDefinition(*i); - this->Makefile->AddDefinition(variable, output.c_str()); + this->Makefile->AddDefinition(variable, output); return true; } @@ -97,9 +97,5 @@ bool cmGetDirectoryPropertyCommand::InitialPass( void cmGetDirectoryPropertyCommand::StoreResult(std::string const& variable, const char* prop) { - if (prop) { - this->Makefile->AddDefinition(variable, prop); - return; - } - this->Makefile->AddDefinition(variable, ""); + this->Makefile->AddDefinition(variable, prop ? prop : ""); } diff --git a/Source/cmGetFilenameComponentCommand.cxx b/Source/cmGetFilenameComponentCommand.cxx index 163b4c8..fc82535 100644 --- a/Source/cmGetFilenameComponentCommand.cxx +++ b/Source/cmGetFilenameComponentCommand.cxx @@ -128,9 +128,9 @@ bool cmGetFilenameComponentCommand::InitialPass( args[2] == "PATH" ? cmStateEnums::FILEPATH : cmStateEnums::STRING); } else { if (!programArgs.empty() && !storeArgs.empty()) { - this->Makefile->AddDefinition(storeArgs, programArgs.c_str()); + this->Makefile->AddDefinition(storeArgs, programArgs); } - this->Makefile->AddDefinition(args.front(), result.c_str()); + this->Makefile->AddDefinition(args.front(), result); } return true; diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx index 039f439..de462ed 100644 --- a/Source/cmGetPropertyCommand.cxx +++ b/Source/cmGetPropertyCommand.cxx @@ -121,7 +121,7 @@ bool cmGetPropertyCommand::InitialPass(std::vector<std::string> const& args, } else { output = "NOTFOUND"; } - this->Makefile->AddDefinition(this->Variable, output.c_str()); + this->Makefile->AddDefinition(this->Variable, output); } else if (this->InfoType == OutFullDoc) { // Lookup full documentation. std::string output; @@ -132,7 +132,7 @@ bool cmGetPropertyCommand::InitialPass(std::vector<std::string> const& args, } else { output = "NOTFOUND"; } - this->Makefile->AddDefinition(this->Variable, output.c_str()); + this->Makefile->AddDefinition(this->Variable, output); } else if (this->InfoType == OutDefined) { // Lookup if the property is defined if (this->Makefile->GetState()->GetPropertyDefinition(this->PropertyName, diff --git a/Source/cmGetSourceFilePropertyCommand.cxx b/Source/cmGetSourceFilePropertyCommand.cxx index 75879a5..a16076d 100644 --- a/Source/cmGetSourceFilePropertyCommand.cxx +++ b/Source/cmGetSourceFilePropertyCommand.cxx @@ -25,7 +25,7 @@ bool cmGetSourceFilePropertyCommand::InitialPass( } if (sf) { if (args[2] == "LANGUAGE") { - this->Makefile->AddDefinition(var, sf->GetLanguage().c_str()); + this->Makefile->AddDefinition(var, sf->GetLanguage()); return true; } const char* prop = nullptr; diff --git a/Source/cmGetTargetPropertyCommand.cxx b/Source/cmGetTargetPropertyCommand.cxx index fc0e9c6..07aaf02 100644 --- a/Source/cmGetTargetPropertyCommand.cxx +++ b/Source/cmGetTargetPropertyCommand.cxx @@ -75,9 +75,9 @@ bool cmGetTargetPropertyCommand::InitialPass( } } if (prop_exists) { - this->Makefile->AddDefinition(var, prop.c_str()); + this->Makefile->AddDefinition(var, prop); return true; } - this->Makefile->AddDefinition(var, (var + "-NOTFOUND").c_str()); + this->Makefile->AddDefinition(var, var + "-NOTFOUND"); return true; } diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index ec4107b..88da5eb 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -337,15 +337,16 @@ bool cmGlobalGenerator::CheckTargetsForType() const bool failed = false; for (cmLocalGenerator* generator : this->LocalGenerators) { for (cmGeneratorTarget* target : generator->GetGeneratorTargets()) { - std::vector<std::string> configs; - target->Makefile->GetConfigurations(configs); - if (configs.empty()) { - configs.emplace_back(); - } + if (target->GetType() == cmStateEnums::EXECUTABLE && + target->GetPropertyAsBool("WIN32_EXECUTABLE")) { + std::vector<std::string> configs; + target->Makefile->GetConfigurations(configs); + if (configs.empty()) { + configs.emplace_back(); + } - for (std::string const& config : configs) { - if (target->GetLinkerLanguage(config) == "Swift") { - if (target->GetPropertyAsBool("WIN32_EXECUTABLE")) { + for (std::string const& config : configs) { + if (target->GetLinkerLanguage(config) == "Swift") { this->GetCMakeInstance()->IssueMessage( MessageType::FATAL_ERROR, "WIN32_EXECUTABLE property is not supported on Swift " @@ -511,7 +512,7 @@ void cmGlobalGenerator::EnableLanguage( bool fatalError = false; - mf->AddDefinition("RUN_CONFIGURE", true); + mf->AddDefinitionBool("RUN_CONFIGURE", true); std::string rootBin = this->CMakeInstance->GetHomeOutputDirectory(); rootBin += "/CMakeFiles"; @@ -525,7 +526,7 @@ void cmGlobalGenerator::EnableLanguage( rootBin += cmVersion::GetCMakeVersion(); // set the dir for parent files so they can be used by modules - mf->AddDefinition("CMAKE_PLATFORM_INFO_DIR", rootBin.c_str()); + mf->AddDefinition("CMAKE_PLATFORM_INFO_DIR", rootBin); if (!this->CMakeInstance->GetIsInTryCompile()) { // Keep a mark in the cache to indicate that we've initialized the @@ -585,8 +586,7 @@ void cmGlobalGenerator::EnableLanguage( windowsVersionString << osviex.dwMajorVersion << "." << osviex.dwMinorVersion << "." << osviex.dwBuildNumber; - mf->AddDefinition("CMAKE_HOST_SYSTEM_VERSION", - windowsVersionString.str().c_str()); + mf->AddDefinition("CMAKE_HOST_SYSTEM_VERSION", windowsVersionString.str()); #endif // Read the DetermineSystem file std::string systemFile = mf->GetModulesFile("CMakeDetermineSystem.cmake"); diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h index e36825c..ea40ebc 100644 --- a/Source/cmGlobalGenerator.h +++ b/Source/cmGlobalGenerator.h @@ -19,6 +19,7 @@ #include "cmDuration.h" #include "cmExportSetMap.h" #include "cmStateSnapshot.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmTargetDepend.h" diff --git a/Source/cmGlobalGhsMultiGenerator.cxx b/Source/cmGlobalGhsMultiGenerator.cxx index b69dea0..7cfbea6 100644 --- a/Source/cmGlobalGhsMultiGenerator.cxx +++ b/Source/cmGlobalGhsMultiGenerator.cxx @@ -111,7 +111,7 @@ bool cmGlobalGhsMultiGenerator::SetGeneratorToolset(std::string const& ts, mf->AddCacheDefinition("CMAKE_MAKE_PROGRAM", gbuild.c_str(), "build program to use", cmStateEnums::INTERNAL, true); - mf->AddDefinition("CMAKE_SYSTEM_VERSION", tsp.c_str()); + mf->AddDefinition("CMAKE_SYSTEM_VERSION", tsp); return true; } diff --git a/Source/cmGlobalMSYSMakefileGenerator.cxx b/Source/cmGlobalMSYSMakefileGenerator.cxx index 7b58389..483d4ab 100644 --- a/Source/cmGlobalMSYSMakefileGenerator.cxx +++ b/Source/cmGlobalMSYSMakefileGenerator.cxx @@ -69,9 +69,9 @@ void cmGlobalMSYSMakefileGenerator::EnableLanguage( rc = trc; } mf->AddDefinition("MSYS", "1"); - mf->AddDefinition("CMAKE_GENERATOR_CC", gcc.c_str()); - mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx.c_str()); - mf->AddDefinition("CMAKE_GENERATOR_RC", rc.c_str()); + mf->AddDefinition("CMAKE_GENERATOR_CC", gcc); + mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx); + mf->AddDefinition("CMAKE_GENERATOR_RC", rc); this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional); if (!mf->IsSet("CMAKE_AR") && !this->CMakeInstance->GetIsInTryCompile() && diff --git a/Source/cmGlobalMinGWMakefileGenerator.cxx b/Source/cmGlobalMinGWMakefileGenerator.cxx index e218b4b..d9fc505 100644 --- a/Source/cmGlobalMinGWMakefileGenerator.cxx +++ b/Source/cmGlobalMinGWMakefileGenerator.cxx @@ -44,9 +44,9 @@ void cmGlobalMinGWMakefileGenerator::EnableLanguage( if (!trc.empty()) { rc = trc; } - mf->AddDefinition("CMAKE_GENERATOR_CC", gcc.c_str()); - mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx.c_str()); - mf->AddDefinition("CMAKE_GENERATOR_RC", rc.c_str()); + mf->AddDefinition("CMAKE_GENERATOR_CC", gcc); + mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx); + mf->AddDefinition("CMAKE_GENERATOR_RC", rc); this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional); } diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx index 7e81a54..bad715d 100644 --- a/Source/cmGlobalNinjaGenerator.cxx +++ b/Source/cmGlobalNinjaGenerator.cxx @@ -32,6 +32,7 @@ #include "cmStateDirectory.h" #include "cmStateSnapshot.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmTargetDepend.h" diff --git a/Source/cmGlobalVisualStudio10Generator.cxx b/Source/cmGlobalVisualStudio10Generator.cxx index 55374a4..4a3cadd 100644 --- a/Source/cmGlobalVisualStudio10Generator.cxx +++ b/Source/cmGlobalVisualStudio10Generator.cxx @@ -445,7 +445,7 @@ bool cmGlobalVisualStudio10Generator::InitializeSystem(cmMakefile* mf) this->DefaultPlatformName = "Tegra-Android"; this->DefaultPlatformToolset = "Default"; this->NsightTegraVersion = v; - mf->AddDefinition("CMAKE_VS_NsightTegra_VERSION", v.c_str()); + mf->AddDefinition("CMAKE_VS_NsightTegra_VERSION", v); } return true; @@ -659,8 +659,7 @@ bool cmGlobalVisualStudio10Generator::FindMakeProgram(cmMakefile* mf) if (!this->cmGlobalVisualStudio8Generator::FindMakeProgram(mf)) { return false; } - mf->AddDefinition("CMAKE_VS_MSBUILD_COMMAND", - this->GetMSBuildCommand().c_str()); + mf->AddDefinition("CMAKE_VS_MSBUILD_COMMAND", this->GetMSBuildCommand()); return true; } diff --git a/Source/cmGlobalVisualStudio14Generator.cxx b/Source/cmGlobalVisualStudio14Generator.cxx index 6509b56..cd48474 100644 --- a/Source/cmGlobalVisualStudio14Generator.cxx +++ b/Source/cmGlobalVisualStudio14Generator.cxx @@ -182,7 +182,7 @@ void cmGlobalVisualStudio14Generator::SetWindowsTargetPlatformVersion( mf->DisplayStatus(e.str(), -1); } mf->AddDefinition("CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION", - this->WindowsTargetPlatformVersion.c_str()); + this->WindowsTargetPlatformVersion); } bool cmGlobalVisualStudio14Generator::SelectWindowsStoreToolset( diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx index 8764ee4..8401efb 100644 --- a/Source/cmGlobalVisualStudio7Generator.cxx +++ b/Source/cmGlobalVisualStudio7Generator.cxx @@ -121,8 +121,7 @@ bool cmGlobalVisualStudio7Generator::FindMakeProgram(cmMakefile* mf) if (!this->cmGlobalVisualStudioGenerator::FindMakeProgram(mf)) { return false; } - mf->AddDefinition("CMAKE_VS_DEVENV_COMMAND", - this->GetDevEnvCommand().c_str()); + mf->AddDefinition("CMAKE_VS_DEVENV_COMMAND", this->GetDevEnvCommand()); return true; } @@ -268,7 +267,7 @@ bool cmGlobalVisualStudio7Generator::SetSystemName(std::string const& s, cmMakefile* mf) { mf->AddDefinition("CMAKE_VS_INTEL_Fortran_PROJECT_VERSION", - this->GetIntelProjectVersion().c_str()); + this->GetIntelProjectVersion()); return this->cmGlobalVisualStudioGenerator::SetSystemName(s, mf); } diff --git a/Source/cmGlobalVisualStudio8Generator.cxx b/Source/cmGlobalVisualStudio8Generator.cxx index 85ddc85..cc6e421 100644 --- a/Source/cmGlobalVisualStudio8Generator.cxx +++ b/Source/cmGlobalVisualStudio8Generator.cxx @@ -54,8 +54,7 @@ void cmGlobalVisualStudio8Generator::EnableLanguage( void cmGlobalVisualStudio8Generator::AddPlatformDefinitions(cmMakefile* mf) { if (this->TargetsWindowsCE()) { - mf->AddDefinition("CMAKE_VS_WINCE_VERSION", - this->WindowsCEVersion.c_str()); + mf->AddDefinition("CMAKE_VS_WINCE_VERSION", this->WindowsCEVersion); } } diff --git a/Source/cmGlobalVisualStudioGenerator.cxx b/Source/cmGlobalVisualStudioGenerator.cxx index cd0355f..ba541a9 100644 --- a/Source/cmGlobalVisualStudioGenerator.cxx +++ b/Source/cmGlobalVisualStudioGenerator.cxx @@ -57,7 +57,7 @@ void cmGlobalVisualStudioGenerator::EnableLanguage( std::vector<std::string> const& lang, cmMakefile* mf, bool optional) { mf->AddDefinition("CMAKE_VS_PLATFORM_NAME_DEFAULT", - this->DefaultPlatformName.c_str()); + this->DefaultPlatformName); this->cmGlobalGenerator::EnableLanguage(lang, mf, optional); } @@ -69,7 +69,7 @@ bool cmGlobalVisualStudioGenerator::SetGeneratorPlatform(std::string const& p, } else if (this->GetPlatformName() == "Itanium") { mf->AddDefinition("CMAKE_FORCE_IA64", "TRUE"); } - mf->AddDefinition("CMAKE_VS_PLATFORM_NAME", this->GetPlatformName().c_str()); + mf->AddDefinition("CMAKE_VS_PLATFORM_NAME", this->GetPlatformName()); return this->cmGlobalGenerator::SetGeneratorPlatform(p, mf); } @@ -488,7 +488,7 @@ bool cmGlobalVisualStudioGenerator::FindMakeProgram(cmMakefile* mf) // directly instead of needing a helper module to do it, so we // do not actually need to put CMAKE_MAKE_PROGRAM into the cache. if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) { - mf->AddDefinition("CMAKE_MAKE_PROGRAM", this->GetVSMakeProgram().c_str()); + mf->AddDefinition("CMAKE_MAKE_PROGRAM", this->GetVSMakeProgram()); } return true; } diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx index d99a906..8f4ae62 100644 --- a/Source/cmGlobalXCodeGenerator.cxx +++ b/Source/cmGlobalXCodeGenerator.cxx @@ -241,8 +241,7 @@ bool cmGlobalXCodeGenerator::FindMakeProgram(cmMakefile* mf) // directly instead of needing a helper module to do it, so we // do not actually need to put CMAKE_MAKE_PROGRAM into the cache. if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) { - mf->AddDefinition("CMAKE_MAKE_PROGRAM", - this->GetXcodeBuildCommand().c_str()); + mf->AddDefinition("CMAKE_MAKE_PROGRAM", this->GetXcodeBuildCommand()); } return true; } @@ -283,8 +282,7 @@ bool cmGlobalXCodeGenerator::SetGeneratorToolset(std::string const& ts, } this->GeneratorToolset = ts; if (!this->GeneratorToolset.empty()) { - mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET", - this->GeneratorToolset.c_str()); + mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET", this->GeneratorToolset); } return true; } @@ -293,7 +291,7 @@ void cmGlobalXCodeGenerator::EnableLanguage( std::vector<std::string> const& lang, cmMakefile* mf, bool optional) { mf->AddDefinition("XCODE", "1"); - mf->AddDefinition("XCODE_VERSION", this->VersionString.c_str()); + mf->AddDefinition("XCODE_VERSION", this->VersionString); if (!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES")) { mf->AddCacheDefinition( "CMAKE_CONFIGURATION_TYPES", "Debug;Release;MinSizeRel;RelWithDebInfo", diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx index 625dd45..385022c 100644 --- a/Source/cmIfCommand.cxx +++ b/Source/cmIfCommand.cxx @@ -13,6 +13,7 @@ #include "cmSystemTools.h" #include "cmake.h" +#include <string> #include <utility> static std::string cmIfCommandError( @@ -47,7 +48,7 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff, } // execute the functions for the true parts of the if statement - cmExecutionStatus status; + cmExecutionStatus status(mf); int scopeDepth = 0; for (cmListFileFunction const& func : this->Functions) { // keep track of scope depth @@ -176,19 +177,19 @@ bool cmIfFunctionBlocker::ShouldRemove(const cmListFileFunction& lff, } //========================================================================= -bool cmIfCommand::InvokeInitialPass( - const std::vector<cmListFileArgument>& args, cmExecutionStatus&) +bool cmIfCommand(std::vector<cmListFileArgument> const& args, + cmExecutionStatus& inStatus) { + cmMakefile& makefile = inStatus.GetMakefile(); std::string errorString; std::vector<cmExpandedCommandArgument> expandedArguments; - this->Makefile->ExpandArguments(args, expandedArguments); + makefile.ExpandArguments(args, expandedArguments); MessageType status; cmConditionEvaluator conditionEvaluator( - *(this->Makefile), this->Makefile->GetExecutionContext(), - this->Makefile->GetBacktrace()); + makefile, makefile.GetExecutionContext(), makefile.GetBacktrace()); bool isTrue = conditionEvaluator.IsTrue(expandedArguments, errorString, status); @@ -197,11 +198,11 @@ bool cmIfCommand::InvokeInitialPass( std::string err = "if " + cmIfCommandError(expandedArguments); err += errorString; if (status == MessageType::FATAL_ERROR) { - this->Makefile->IssueMessage(MessageType::FATAL_ERROR, err); + makefile.IssueMessage(MessageType::FATAL_ERROR, err); cmSystemTools::SetFatalErrorOccured(); return true; } - this->Makefile->IssueMessage(status, err); + makefile.IssueMessage(status, err); } { @@ -213,7 +214,7 @@ bool cmIfCommand::InvokeInitialPass( fb->HasRun = true; } fb->Args = args; - this->Makefile->AddFunctionBlocker(std::move(fb)); + makefile.AddFunctionBlocker(std::move(fb)); } return true; diff --git a/Source/cmIfCommand.h b/Source/cmIfCommand.h index 4a67760..775e609 100644 --- a/Source/cmIfCommand.h +++ b/Source/cmIfCommand.h @@ -5,17 +5,12 @@ #include "cmConfigure.h" // IWYU pragma: keep -#include <string> #include <vector> -#include "cm_memory.hxx" - -#include "cmCommand.h" #include "cmFunctionBlocker.h" #include "cmListFileCache.h" class cmExecutionStatus; -class cmExpandedCommandArgument; class cmMakefile; class cmIfFunctionBlocker : public cmFunctionBlocker @@ -34,37 +29,7 @@ public: }; /// Starts an if block -class cmIfCommand : public cmCommand -{ -public: - /** - * This is a virtual constructor for the command. - */ - std::unique_ptr<cmCommand> Clone() override - { - return cm::make_unique<cmIfCommand>(); - } - - /** - * This overrides the default InvokeInitialPass implementation. - * It records the arguments before expansion. - */ - bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, - cmExecutionStatus&) override; - - /** - * This is called when the command is first encountered in - * the CMakeLists.txt file. - */ - bool InitialPass(std::vector<std::string> const&, - cmExecutionStatus&) override - { - return false; - } - - // Filter the given variable definition based on policy CMP0054. - static const char* GetDefinitionIfUnquoted( - const cmMakefile* mf, cmExpandedCommandArgument const& argument); -}; +bool cmIfCommand(std::vector<cmListFileArgument> const& args, + cmExecutionStatus& status); #endif diff --git a/Source/cmIncludeGuardCommand.cxx b/Source/cmIncludeGuardCommand.cxx index 505b07c..3b126b0 100644 --- a/Source/cmIncludeGuardCommand.cxx +++ b/Source/cmIncludeGuardCommand.cxx @@ -85,7 +85,7 @@ bool cmIncludeGuardCommand::InitialPass(std::vector<std::string> const& args, status.SetReturnInvoked(); return true; } - mf->AddDefinition(includeGuardVar, true); + mf->AddDefinitionBool(includeGuardVar, true); break; case DIRECTORY: if (CheckIncludeGuardIsSet(mf, includeGuardVar)) { diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx index 3b0659c..aca7268 100644 --- a/Source/cmInstallCommand.cxx +++ b/Source/cmInstallCommand.cxx @@ -9,7 +9,6 @@ #include <stddef.h> #include <utility> -#include "cmAlgorithms.h" #include "cmArgumentParser.h" #include "cmExportSet.h" #include "cmExportSetMap.h" @@ -27,6 +26,7 @@ #include "cmMessageType.h" #include "cmPolicies.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmTargetExport.h" diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx index d891ad8..a61239e 100644 --- a/Source/cmInstallTargetGenerator.cxx +++ b/Source/cmInstallTargetGenerator.cxx @@ -767,12 +767,18 @@ void cmInstallTargetGenerator::AddChrpathPatchRule( this->IssueCMP0095Warning(newRpath); CM_FALLTHROUGH; case cmPolicies::OLD: - os << indent << " NEW_RPATH \"" << newRpath << "\")\n"; + os << indent << " NEW_RPATH \"" << newRpath << "\""; break; default: - os << indent << " NEW_RPATH " << escapedNewRpath << ")\n"; + os << indent << " NEW_RPATH " << escapedNewRpath; break; } + + if (this->Target->GetPropertyAsBool("INSTALL_REMOVE_ENVIRONMENT_RPATH")) { + os << "\n" << indent << " INSTALL_REMOVE_ENVIRONMENT_RPATH)\n"; + } else { + os << indent << ")\n"; + } } } diff --git a/Source/cmLinkDirectoriesCommand.cxx b/Source/cmLinkDirectoriesCommand.cxx index 7850977..a278925 100644 --- a/Source/cmLinkDirectoriesCommand.cxx +++ b/Source/cmLinkDirectoriesCommand.cxx @@ -4,11 +4,11 @@ #include <sstream> -#include "cmAlgorithms.h" #include "cmGeneratorExpression.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmPolicies.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" class cmExecutionStatus; diff --git a/Source/cmLinkItem.h b/Source/cmLinkItem.h index 5b635b5..6450c62 100644 --- a/Source/cmLinkItem.h +++ b/Source/cmLinkItem.h @@ -58,6 +58,9 @@ struct cmLinkInterfaceLibraries { // Libraries listed in the interface. std::vector<cmLinkItem> Libraries; + + // Whether the list depends on a genex referencing the head target. + bool HadHeadSensitiveCondition = false; }; struct cmLinkInterface : public cmLinkInterfaceLibraries @@ -84,7 +87,6 @@ struct cmOptionalLinkInterface : public cmLinkInterface bool LibrariesDone = false; bool AllDone = false; bool Exists = false; - bool HadHeadSensitiveCondition = false; const char* ExplicitLibraries = nullptr; }; diff --git a/Source/cmLinkLineDeviceComputer.cxx b/Source/cmLinkLineDeviceComputer.cxx index 8d2add6..656907a 100644 --- a/Source/cmLinkLineDeviceComputer.cxx +++ b/Source/cmLinkLineDeviceComputer.cxx @@ -9,7 +9,6 @@ #include <utility> #include <vector> -#include "cmAlgorithms.h" #include "cmComputeLinkInformation.h" #include "cmGeneratorTarget.h" #include "cmGlobalGenerator.h" @@ -17,6 +16,7 @@ #include "cmStateDirectory.h" #include "cmStateSnapshot.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" class cmOutputConverter; diff --git a/Source/cmListCommand.cxx b/Source/cmListCommand.cxx index a2e665f..8c14596 100644 --- a/Source/cmListCommand.cxx +++ b/Source/cmListCommand.cxx @@ -23,6 +23,7 @@ #include "cmMessageType.h" #include "cmPolicies.h" #include "cmRange.h" +#include "cmStringAlgorithms.h" #include "cmStringReplaceHelper.h" #include "cmSystemTools.h" @@ -222,7 +223,7 @@ bool cmListCommand::HandleGetCommand(std::vector<std::string> const& args) value += varArgsExpanded[item]; } - this->Makefile->AddDefinition(variableName, value.c_str()); + this->Makefile->AddDefinition(variableName, value); return true; } @@ -246,7 +247,7 @@ bool cmListCommand::HandleAppendCommand(std::vector<std::string> const& args) std::string::size_type(listString.empty() || args.empty()); listString += &";"[offset] + cmJoin(cmMakeRange(args).advance(2), ";"); - this->Makefile->AddDefinition(listName, listString.c_str()); + this->Makefile->AddDefinition(listName, listString); return true; } @@ -271,7 +272,7 @@ bool cmListCommand::HandlePrependCommand(std::vector<std::string> const& args) listString.insert(0, cmJoin(cmMakeRange(args).advance(2), ";") + &";"[offset]); - this->Makefile->AddDefinition(listName, listString.c_str()); + this->Makefile->AddDefinition(listName, listString); return true; } @@ -299,7 +300,7 @@ bool cmListCommand::HandlePopBackCommand(std::vector<std::string> const& args) // Ok, assign elements to be removed to the given variables for (; !varArgsExpanded.empty() && ai != args.cend(); ++ai) { assert(!ai->empty()); - this->Makefile->AddDefinition(*ai, varArgsExpanded.back().c_str()); + this->Makefile->AddDefinition(*ai, varArgsExpanded.back()); varArgsExpanded.pop_back(); } // Undefine the rest variables if the list gets empty earlier... @@ -308,8 +309,7 @@ bool cmListCommand::HandlePopBackCommand(std::vector<std::string> const& args) } } - this->Makefile->AddDefinition(listName, - cmJoin(varArgsExpanded, ";").c_str()); + this->Makefile->AddDefinition(listName, cmJoin(varArgsExpanded, ";")); } else if (ai != args.cend()) { // The list is empty, but some args were given @@ -347,7 +347,7 @@ bool cmListCommand::HandlePopFrontCommand(std::vector<std::string> const& args) auto vi = varArgsExpanded.begin(); for (; vi != varArgsExpanded.end() && ai != args.cend(); ++ai, ++vi) { assert(!ai->empty()); - this->Makefile->AddDefinition(*ai, vi->c_str()); + this->Makefile->AddDefinition(*ai, *vi); } varArgsExpanded.erase(varArgsExpanded.begin(), vi); // Undefine the rest variables if the list gets empty earlier... @@ -356,8 +356,7 @@ bool cmListCommand::HandlePopFrontCommand(std::vector<std::string> const& args) } } - this->Makefile->AddDefinition(listName, - cmJoin(varArgsExpanded, ";").c_str()); + this->Makefile->AddDefinition(listName, cmJoin(varArgsExpanded, ";")); } else if (ai != args.cend()) { // The list is empty, but some args were given @@ -391,7 +390,7 @@ bool cmListCommand::HandleFindCommand(std::vector<std::string> const& args) if (it != varArgsExpanded.end()) { std::ostringstream indexStream; indexStream << std::distance(varArgsExpanded.begin(), it); - this->Makefile->AddDefinition(variableName, indexStream.str().c_str()); + this->Makefile->AddDefinition(variableName, indexStream.str()); return true; } @@ -437,7 +436,7 @@ bool cmListCommand::HandleInsertCommand(std::vector<std::string> const& args) args.end()); std::string value = cmJoin(varArgsExpanded, ";"); - this->Makefile->AddDefinition(listName, value.c_str()); + this->Makefile->AddDefinition(listName, value); return true; } @@ -465,7 +464,7 @@ bool cmListCommand::HandleJoinCommand(std::vector<std::string> const& args) std::string value = cmJoin(cmMakeRange(varArgsExpanded.begin(), varArgsExpanded.end()), glue); - this->Makefile->AddDefinition(variableName, value.c_str()); + this->Makefile->AddDefinition(variableName, value); return true; } @@ -494,7 +493,7 @@ bool cmListCommand::HandleRemoveItemCommand( cmRemoveMatching(varArgsExpanded, cmMakeRange(remBegin, remEnd)); std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin(); std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";"); - this->Makefile->AddDefinition(listName, value.c_str()); + this->Makefile->AddDefinition(listName, value); return true; } @@ -515,7 +514,7 @@ bool cmListCommand::HandleReverseCommand(std::vector<std::string> const& args) std::string value = cmJoin(cmReverseRange(varArgsExpanded), ";"); - this->Makefile->AddDefinition(listName, value.c_str()); + this->Makefile->AddDefinition(listName, value); return true; } @@ -540,7 +539,7 @@ bool cmListCommand::HandleRemoveDuplicatesCommand( std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin(); std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";"); - this->Makefile->AddDefinition(listName, value.c_str()); + this->Makefile->AddDefinition(listName, value); return true; } @@ -1091,7 +1090,7 @@ bool cmListCommand::HandleTransformCommand( } this->Makefile->AddDefinition(command.OutputName, - cmJoin(varArgsExpanded, ";").c_str()); + cmJoin(varArgsExpanded, ";")); return true; } @@ -1300,7 +1299,7 @@ bool cmListCommand::HandleSortCommand(std::vector<std::string> const& args) } std::string value = cmJoin(varArgsExpanded, ";"); - this->Makefile->AddDefinition(listName, value.c_str()); + this->Makefile->AddDefinition(listName, value); return true; } @@ -1349,7 +1348,7 @@ bool cmListCommand::HandleSublistCommand(std::vector<std::string> const& args) : size_type(start + length); std::vector<std::string> sublist(varArgsExpanded.begin() + start, varArgsExpanded.begin() + end); - this->Makefile->AddDefinition(variableName, cmJoin(sublist, ";").c_str()); + this->Makefile->AddDefinition(variableName, cmJoin(sublist, ";")); return true; } @@ -1406,7 +1405,7 @@ bool cmListCommand::HandleRemoveAtCommand(std::vector<std::string> const& args) std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin(); std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";"); - this->Makefile->AddDefinition(listName, value.c_str()); + this->Makefile->AddDefinition(listName, value); return true; } @@ -1500,6 +1499,6 @@ bool cmListCommand::FilterRegex(std::vector<std::string> const& args, std::remove_if(argsBegin, argsEnd, MatchesRegex(regex, includeMatches)); std::string value = cmJoin(cmMakeRange(argsBegin, newArgsEnd), ";"); - this->Makefile->AddDefinition(listName, value.c_str()); + this->Makefile->AddDefinition(listName, value); return true; } diff --git a/Source/cmLoadCacheCommand.cxx b/Source/cmLoadCacheCommand.cxx index b1fee8d..3fd7343 100644 --- a/Source/cmLoadCacheCommand.cxx +++ b/Source/cmLoadCacheCommand.cxx @@ -153,7 +153,7 @@ void cmLoadCacheCommand::CheckLine(const char* line) // prefix. var = this->Prefix + var; if (!value.empty()) { - this->Makefile->AddDefinition(var, value.c_str()); + this->Makefile->AddDefinition(var, value); } else { this->Makefile->RemoveDefinition(var); } diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx index f5da2ee..5ae660a 100644 --- a/Source/cmLoadCommandCommand.cxx +++ b/Source/cmLoadCommandCommand.cxx @@ -230,7 +230,7 @@ bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& args, } // Report what file was loaded for this command. - this->Makefile->AddDefinition(reportVar, fullPath.c_str()); + this->Makefile->AddDefinition(reportVar, fullPath); // find the init function std::string initFuncName = args[0] + "Init"; @@ -247,7 +247,8 @@ bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& args, // function blocker if (initFunction) { this->Makefile->GetState()->AddScriptedCommand( - args[0], cm::make_unique<cmLoadedCommand>(initFunction)); + args[0], + cmLegacyCommandWrapper(cm::make_unique<cmLoadedCommand>(initFunction))); return true; } this->SetError("Attempt to load command failed. " diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 4ffd6e0..28ae82e 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -21,6 +21,7 @@ #include "cmState.h" #include "cmStateDirectory.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmTestGenerator.h" @@ -1134,11 +1135,13 @@ void cmLocalGenerator::GetStaticLibraryFlags(std::string& flags, std::string const& linkLanguage, cmGeneratorTarget* target) { - this->AppendFlags( - flags, this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS")); - if (!config.empty()) { - std::string name = "CMAKE_STATIC_LINKER_FLAGS_" + config; - this->AppendFlags(flags, this->Makefile->GetSafeDefinition(name)); + if (linkLanguage != "Swift") { + this->AppendFlags( + flags, this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS")); + if (!config.empty()) { + std::string name = "CMAKE_STATIC_LINKER_FLAGS_" + config; + this->AppendFlags(flags, this->Makefile->GetSafeDefinition(name)); + } } this->AppendFlags(flags, target->GetProperty("STATIC_LIBRARY_FLAGS")); if (!config.empty()) { @@ -2971,7 +2974,7 @@ void cmLocalGenerator::GenerateAppleInfoPList(cmGeneratorTarget* target, // back to the directory-level values set by the user. cmMakefile* mf = this->Makefile; cmMakefile::ScopePushPop varScope(mf); - mf->AddDefinition("MACOSX_BUNDLE_EXECUTABLE_NAME", targetName.c_str()); + mf->AddDefinition("MACOSX_BUNDLE_EXECUTABLE_NAME", targetName); cmLGInfoProp(mf, target, "MACOSX_BUNDLE_INFO_STRING"); cmLGInfoProp(mf, target, "MACOSX_BUNDLE_ICON_FILE"); cmLGInfoProp(mf, target, "MACOSX_BUNDLE_GUI_IDENTIFIER"); @@ -3010,7 +3013,7 @@ void cmLocalGenerator::GenerateFrameworkInfoPList( // back to the directory-level values set by the user. cmMakefile* mf = this->Makefile; cmMakefile::ScopePushPop varScope(mf); - mf->AddDefinition("MACOSX_FRAMEWORK_NAME", targetName.c_str()); + mf->AddDefinition("MACOSX_FRAMEWORK_NAME", targetName); cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_ICON_FILE"); cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_IDENTIFIER"); cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_SHORT_VERSION_STRING"); diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx index 1ec1fd9..713c985 100644 --- a/Source/cmLocalUnixMakefileGenerator3.cxx +++ b/Source/cmLocalUnixMakefileGenerator3.cxx @@ -32,6 +32,7 @@ #include "cmStateDirectory.h" #include "cmStateSnapshot.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmVersion.h" #include "cmake.h" diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx index 6e65c6b..1f2b5b2 100644 --- a/Source/cmMacroCommand.cxx +++ b/Source/cmMacroCommand.cxx @@ -14,38 +14,19 @@ #include "cmPolicies.h" #include "cmRange.h" #include "cmState.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" // define the class for macro commands -class cmMacroHelperCommand : public cmCommand +class cmMacroHelperCommand { public: /** - * This is a virtual constructor for the command. - */ - std::unique_ptr<cmCommand> Clone() override - { - auto newC = cm::make_unique<cmMacroHelperCommand>(); - // we must copy when we clone - newC->Args = this->Args; - newC->Functions = this->Functions; - newC->FilePath = this->FilePath; - newC->Policies = this->Policies; - return std::unique_ptr<cmCommand>(std::move(newC)); - } - - /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, - cmExecutionStatus&) override; - - bool InitialPass(std::vector<std::string> const&, - cmExecutionStatus&) override - { - return false; - } + bool operator()(std::vector<cmListFileArgument> const& args, + cmExecutionStatus& inStatus) const; std::vector<std::string> Args; std::vector<cmListFileFunction> Functions; @@ -53,12 +34,15 @@ public: std::string FilePath; }; -bool cmMacroHelperCommand::InvokeInitialPass( - const std::vector<cmListFileArgument>& args, cmExecutionStatus& inStatus) +bool cmMacroHelperCommand::operator()( + std::vector<cmListFileArgument> const& args, + cmExecutionStatus& inStatus) const { + cmMakefile& makefile = inStatus.GetMakefile(); + // Expand the argument list to the macro. std::vector<std::string> expandedArgs; - this->Makefile->ExpandArguments(args, expandedArgs); + makefile.ExpandArguments(args, expandedArgs); // make sure the number of arguments passed is at least the number // required by the signature @@ -66,11 +50,11 @@ bool cmMacroHelperCommand::InvokeInitialPass( std::string errorMsg = "Macro invoked with incorrect arguments for macro named: "; errorMsg += this->Args[0]; - this->SetError(errorMsg); + inStatus.SetError(errorMsg); return false; } - cmMakefile::MacroPushPop macroScope(this->Makefile, this->FilePath, + cmMakefile::MacroPushPop macroScope(&makefile, this->FilePath, this->Policies); // set the value of argc @@ -132,9 +116,8 @@ bool cmMacroHelperCommand::InvokeInitialPass( arg.Line = k.Line; newLFF.Arguments.push_back(std::move(arg)); } - cmExecutionStatus status; - if (!this->Makefile->ExecuteCommand(newLFF, status) || - status.GetNestedError()) { + cmExecutionStatus status(makefile); + if (!makefile.ExecuteCommand(newLFF, status) || status.GetNestedError()) { // The error message should have already included the call stack // so we do not need to report an error here. macroScope.Quiet(); @@ -166,11 +149,11 @@ bool cmMacroFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff, if (!this->Depth) { mf.AppendProperty("MACROS", this->Args[0].c_str()); // create a new command and add it to cmake - auto f = cm::make_unique<cmMacroHelperCommand>(); - f->Args = this->Args; - f->Functions = this->Functions; - f->FilePath = this->GetStartingContext().FilePath; - mf.RecordPolicies(f->Policies); + cmMacroHelperCommand f; + f.Args = this->Args; + f.Functions = this->Functions; + f.FilePath = this->GetStartingContext().FilePath; + mf.RecordPolicies(f.Policies); mf.GetState()->AddScriptedCommand(this->Args[0], std::move(f)); // remove the function blocker now that the macro is defined mf.RemoveFunctionBlocker(this, lff); diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index 1723c5a..8188ffa 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -16,7 +16,6 @@ #include <utility> #include "cmAlgorithms.h" -#include "cmCommand.h" #include "cmCommandArgumentParserHelper.h" #include "cmCustomCommand.h" #include "cmCustomCommandLines.h" @@ -388,12 +387,8 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff, } // Lookup the command prototype. - if (cmCommand* proto = + if (cmState::Command command = this->GetState()->GetCommandByExactName(lff.Name.Lower)) { - // Clone the prototype. - std::unique_ptr<cmCommand> pcmd(proto->Clone()); - pcmd->SetMakefile(this); - // Decide whether to invoke the command. if (!cmSystemTools::GetFatalErrorOccured()) { // if trace is enabled, print out invoke information @@ -401,13 +396,13 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff, this->PrintCommandTrace(lff); } // Try invoking the command. - bool invokeSucceeded = pcmd->InvokeInitialPass(lff.Arguments, status); + bool invokeSucceeded = command(lff.Arguments, status); bool hadNestedError = status.GetNestedError(); if (!invokeSucceeded || hadNestedError) { if (!hadNestedError) { // The command invocation requested that we report an error. std::string const error = - std::string(lff.Name.Original) + " " + pcmd->GetError(); + std::string(lff.Name.Original) + " " + status.GetError(); this->IssueMessage(MessageType::FATAL_ERROR, error); } result = false; @@ -562,8 +557,9 @@ void cmMakefile::IncludeScope::EnforceCMP0011() bool cmMakefile::ReadDependentFile(const std::string& filename, bool noPolicyScope) { - this->AddDefinition("CMAKE_PARENT_LIST_FILE", - this->GetDefinition("CMAKE_CURRENT_LIST_FILE")); + if (const char* def = this->GetDefinition("CMAKE_CURRENT_LIST_FILE")) { + this->AddDefinition("CMAKE_PARENT_LIST_FILE", def); + } std::string filenametoread = cmSystemTools::CollapseFullPath( filename, this->GetCurrentSourceDirectory()); @@ -646,9 +642,9 @@ void cmMakefile::ReadListFile(cmListFile const& listFile, this->GetSafeDefinition("CMAKE_PARENT_LIST_FILE"); std::string currentFile = this->GetSafeDefinition("CMAKE_CURRENT_LIST_FILE"); - this->AddDefinition("CMAKE_CURRENT_LIST_FILE", filenametoread.c_str()); + this->AddDefinition("CMAKE_CURRENT_LIST_FILE", filenametoread); this->AddDefinition("CMAKE_CURRENT_LIST_DIR", - cmSystemTools::GetFilenamePath(filenametoread).c_str()); + cmSystemTools::GetFilenamePath(filenametoread)); this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE"); this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE"); @@ -657,7 +653,7 @@ void cmMakefile::ReadListFile(cmListFile const& listFile, // Run the parsed commands. const size_t numberFunctions = listFile.Functions.size(); for (size_t i = 0; i < numberFunctions; ++i) { - cmExecutionStatus status; + cmExecutionStatus status(*this); this->ExecuteCommand(listFile.Functions[i], status); if (cmSystemTools::GetFatalErrorOccured()) { break; @@ -669,10 +665,10 @@ void cmMakefile::ReadListFile(cmListFile const& listFile, } this->CheckForUnusedVariables(); - this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile.c_str()); - this->AddDefinition("CMAKE_CURRENT_LIST_FILE", currentFile.c_str()); + this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile); + this->AddDefinition("CMAKE_CURRENT_LIST_FILE", currentFile); this->AddDefinition("CMAKE_CURRENT_LIST_DIR", - cmSystemTools::GetFilenamePath(currentFile).c_str()); + cmSystemTools::GetFilenamePath(currentFile)); this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE"); this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE"); this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_DIR"); @@ -1540,7 +1536,7 @@ void cmMakefile::Configure() cmSystemTools::MakeDirectory(filesDir); assert(cmSystemTools::FileExists(currentStart, true)); - this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentStart.c_str()); + this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentStart); cmListFile listFile; if (!listFile.ParseFile(currentStart.c_str(), this->GetMessenger(), @@ -1788,12 +1784,8 @@ void cmMakefile::AddSystemIncludeDirectories(const std::set<std::string>& incs) } } -void cmMakefile::AddDefinition(const std::string& name, const char* value) +void cmMakefile::AddDefinition(const std::string& name, cm::string_view value) { - if (!value) { - return; - } - if (this->VariableInitialized(name)) { this->LogUnused("changing definition", name); } @@ -1803,11 +1795,16 @@ void cmMakefile::AddDefinition(const std::string& name, const char* value) cmVariableWatch* vv = this->GetVariableWatch(); if (vv) { vv->VariableAccessed(name, cmVariableWatch::VARIABLE_MODIFIED_ACCESS, - value, this); + value.data(), this); } #endif } +void cmMakefile::AddDefinitionBool(const std::string& name, bool value) +{ + this->AddDefinition(name, value ? "ON" : "OFF"); +} + void cmMakefile::AddCacheDefinition(const std::string& name, const char* value, const char* doc, cmStateEnums::CacheEntryType type, @@ -1853,23 +1850,6 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value, this->StateSnapshot.RemoveDefinition(name); } -void cmMakefile::AddDefinition(const std::string& name, bool value) -{ - if (this->VariableInitialized(name)) { - this->LogUnused("changing definition", name); - } - - this->StateSnapshot.SetDefinition(name, value ? "ON" : "OFF"); - -#ifdef CMAKE_BUILD_WITH_CMAKE - cmVariableWatch* vv = this->GetVariableWatch(); - if (vv) { - vv->VariableAccessed(name, cmVariableWatch::VARIABLE_MODIFIED_ACCESS, - value ? "ON" : "OFF", this); - } -#endif -} - void cmMakefile::CheckForUnusedVariables() const { if (!this->WarnUnused) { @@ -3081,15 +3061,7 @@ bool cmMakefile::IsFunctionBlocked(const cmListFileFunction& lff, return false; } - // loop over all function blockers to see if any block this command - // evaluate in reverse, this is critical for balanced IF statements etc - for (auto const& pos : cmReverseRange(this->FunctionBlockers)) { - if (pos->IsFunctionBlocked(lff, *this, status)) { - return true; - } - } - - return false; + return this->FunctionBlockers.top()->IsFunctionBlocked(lff, *this, status); } void cmMakefile::PushFunctionBlockerBarrier() @@ -3104,8 +3076,8 @@ void cmMakefile::PopFunctionBlockerBarrier(bool reportError) this->FunctionBlockerBarriers.back(); while (this->FunctionBlockers.size() > barrier) { std::unique_ptr<cmFunctionBlocker> fb( - std::move(this->FunctionBlockers.back())); - this->FunctionBlockers.pop_back(); + std::move(this->FunctionBlockers.top())); + this->FunctionBlockers.pop(); if (reportError) { // Report the context in which the unclosed block was opened. cmListFileContext const& lfc = fb->GetStartingContext(); @@ -3236,46 +3208,36 @@ void cmMakefile::AddFunctionBlocker(std::unique_ptr<cmFunctionBlocker> fb) fb->SetStartingContext(this->GetExecutionContext()); } - this->FunctionBlockers.push_back(std::move(fb)); + this->FunctionBlockers.push(std::move(fb)); } std::unique_ptr<cmFunctionBlocker> cmMakefile::RemoveFunctionBlocker( cmFunctionBlocker* fb, const cmListFileFunction& lff) { - // Find the function blocker stack barrier for the current scope. - // We only remove a blocker whose index is not less than the barrier. - FunctionBlockersType::size_type barrier = 0; - if (!this->FunctionBlockerBarriers.empty()) { - barrier = this->FunctionBlockerBarriers.back(); - } - - // Search for the function blocker whose scope this command ends. - for (FunctionBlockersType::size_type i = this->FunctionBlockers.size(); - i > barrier; --i) { - auto pos = this->FunctionBlockers.begin() + (i - 1); - if (pos->get() == fb) { - // Warn if the arguments do not match, but always remove. - if (!(*pos)->ShouldRemove(lff, *this)) { - cmListFileContext const& lfc = fb->GetStartingContext(); - cmListFileContext closingContext = - cmListFileContext::FromCommandContext(lff, lfc.FilePath); - std::ostringstream e; - /* clang-format off */ - e << "A logical block opening on the line\n" - << " " << lfc << "\n" - << "closes on the line\n" - << " " << closingContext << "\n" - << "with mis-matching arguments."; - /* clang-format on */ - this->IssueMessage(MessageType::AUTHOR_WARNING, e.str()); - } - std::unique_ptr<cmFunctionBlocker> b = std::move(*pos); - this->FunctionBlockers.erase(pos); - return b; - } + assert(!this->FunctionBlockers.empty()); + assert(this->FunctionBlockers.top().get() == fb); + assert(this->FunctionBlockerBarriers.empty() || + this->FunctionBlockers.size() > this->FunctionBlockerBarriers.back()); + + // Warn if the arguments do not match, but always remove. + if (!fb->ShouldRemove(lff, *this)) { + cmListFileContext const& lfc = fb->GetStartingContext(); + cmListFileContext closingContext = + cmListFileContext::FromCommandContext(lff, lfc.FilePath); + std::ostringstream e; + /* clang-format off */ + e << "A logical block opening on the line\n" + << " " << lfc << "\n" + << "closes on the line\n" + << " " << closingContext << "\n" + << "with mis-matching arguments."; + /* clang-format on */ + this->IssueMessage(MessageType::AUTHOR_WARNING, e.str()); } - return std::unique_ptr<cmFunctionBlocker>(); + auto b = std::move(this->FunctionBlockers.top()); + this->FunctionBlockers.pop(); + return b; } std::string const& cmMakefile::GetHomeDirectory() const @@ -3290,20 +3252,20 @@ std::string const& cmMakefile::GetHomeOutputDirectory() const void cmMakefile::SetScriptModeFile(std::string const& scriptfile) { - this->AddDefinition("CMAKE_SCRIPT_MODE_FILE", scriptfile.c_str()); + this->AddDefinition("CMAKE_SCRIPT_MODE_FILE", scriptfile); } void cmMakefile::SetArgcArgv(const std::vector<std::string>& args) { std::ostringstream strStream; strStream << args.size(); - this->AddDefinition("CMAKE_ARGC", strStream.str().c_str()); + this->AddDefinition("CMAKE_ARGC", strStream.str()); // this->MarkVariableAsUsed("CMAKE_ARGC"); for (unsigned int t = 0; t < args.size(); ++t) { std::ostringstream tmpStream; tmpStream << "CMAKE_ARGV" << t; - this->AddDefinition(tmpStream.str(), args[t].c_str()); + this->AddDefinition(tmpStream.str(), args[t]); // this->MarkVariableAsUsed(tmpStream.str().c_str()); } } @@ -3384,8 +3346,9 @@ void cmMakefile::AddTargetObject(std::string const& tgtName, void cmMakefile::EnableLanguage(std::vector<std::string> const& lang, bool optional) { - this->AddDefinition("CMAKE_CFG_INTDIR", - this->GetGlobalGenerator()->GetCMakeCFGIntDir()); + if (const char* def = this->GetGlobalGenerator()->GetCMakeCFGIntDir()) { + this->AddDefinition("CMAKE_CFG_INTDIR", def); + } // If RC is explicitly listed we need to do it after other languages. // On some platforms we enable RC implicitly while enabling others. // Do not let that look like recursive enable_language(RC). @@ -4237,7 +4200,7 @@ void cmMakefile::StoreMatches(cmsys::RegularExpression& re) std::string const& m = re.match(i); if (!m.empty()) { std::string const& var = matchVariables[i]; - this->AddDefinition(var, m.c_str()); + this->AddDefinition(var, m); this->MarkVariableAsUsed(var); highest = static_cast<char>('0' + i); } diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h index 1eca18c..dc196ac 100644 --- a/Source/cmMakefile.h +++ b/Source/cmMakefile.h @@ -17,8 +17,9 @@ #include <unordered_map> #include <vector> +#include "cm_string_view.hxx" + #include "cmAlgorithms.h" -#include "cmFunctionBlocker.h" #include "cmListFileCache.h" #include "cmMessageType.h" #include "cmNewLineStyle.h" @@ -26,6 +27,7 @@ #include "cmSourceFileLocationKind.h" #include "cmStateSnapshot.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmTarget.h" #if defined(CMAKE_BUILD_WITH_CMAKE) @@ -37,6 +39,7 @@ class cmCustomCommandLines; class cmExecutionStatus; class cmExpandedCommandArgument; class cmExportBuildFileGenerator; +class cmFunctionBlocker; class cmGeneratorExpressionEvaluationFile; class cmGlobalGenerator; class cmInstallGenerator; @@ -263,18 +266,17 @@ public: * Add a variable definition to the build. This variable * can be used in CMake to refer to lists, directories, etc. */ - void AddDefinition(const std::string& name, const char* value); + void AddDefinition(const std::string& name, cm::string_view value); + /** + * Add bool variable definition to the build. + */ + void AddDefinitionBool(const std::string& name, bool); //! Add a definition to this makefile and the global cmake cache. void AddCacheDefinition(const std::string& name, const char* value, const char* doc, cmStateEnums::CacheEntryType type, bool force = false); /** - * Add bool variable definition to the build. - */ - void AddDefinition(const std::string& name, bool); - - /** * Remove a variable definition from the build. This is not valid * for cache entries, and will only affect the current makefile. */ @@ -962,7 +964,9 @@ private: bool EnforceUniqueDir(const std::string& srcPath, const std::string& binPath) const; - typedef std::vector<std::unique_ptr<cmFunctionBlocker>> FunctionBlockersType; + using FunctionBlockerPtr = std::unique_ptr<cmFunctionBlocker>; + using FunctionBlockersType = + std::stack<FunctionBlockerPtr, std::vector<FunctionBlockerPtr>>; FunctionBlockersType FunctionBlockers; std::vector<FunctionBlockersType::size_type> FunctionBlockerBarriers; void PushFunctionBlockerBarrier(); diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index b5a6246..008248c 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -28,6 +28,7 @@ #include "cmStateDirectory.h" #include "cmStateSnapshot.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmake.h" diff --git a/Source/cmMessageCommand.cxx b/Source/cmMessageCommand.cxx index 5320ec5..66d3c88 100644 --- a/Source/cmMessageCommand.cxx +++ b/Source/cmMessageCommand.cxx @@ -2,11 +2,11 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmMessageCommand.h" -#include "cmAlgorithms.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmMessenger.h" #include "cmRange.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmake.h" @@ -25,7 +25,6 @@ bool cmMessageCommand::InitialPass(std::vector<std::string> const& args, auto i = args.cbegin(); auto type = MessageType::MESSAGE; - auto status = false; auto fatal = false; auto level = cmake::LogLevel::LOG_UNDEFINED; if (*i == "SEND_ERROR") { @@ -55,19 +54,15 @@ bool cmMessageCommand::InitialPass(std::vector<std::string> const& args, } ++i; } else if (*i == "STATUS") { - status = true; level = cmake::LogLevel::LOG_STATUS; ++i; } else if (*i == "VERBOSE") { - status = true; level = cmake::LogLevel::LOG_VERBOSE; ++i; } else if (*i == "DEBUG") { - status = true; level = cmake::LogLevel::LOG_DEBUG; ++i; } else if (*i == "TRACE") { - status = true; level = cmake::LogLevel::LOG_TRACE; ++i; } else if (*i == "DEPRECATION") { @@ -105,17 +100,46 @@ bool cmMessageCommand::InitialPass(std::vector<std::string> const& args, auto message = cmJoin(cmMakeRange(i, args.cend()), ""); - if (type != MessageType::MESSAGE) { - // we've overridden the message type, above, so display it directly - cmMessenger* m = this->Makefile->GetMessenger(); - m->DisplayMessage(type, message, this->Makefile->GetBacktrace()); - } else { - if (status) { - this->Makefile->DisplayStatus(message, -1); - } else { + if (cmake::LogLevel::LOG_NOTICE <= level) { + // Check if any indentation has requested: + // `CMAKE_MESSAGE_INDENT` is a list of "padding" pieces + // to be joined and prepended to the message lines. + auto indent = + cmJoin(cmSystemTools::ExpandedListArgument( + this->Makefile->GetSafeDefinition("CMAKE_MESSAGE_INDENT")), + ""); + // Make every line of the `message` indented + // NOTE Can't reuse `cmDocumentationFormatter::PrintPreformatted` + // here cuz it appends `\n` to the EOM ;-( + cmSystemTools::ReplaceString(message, "\n", "\n" + indent); + message = indent + message; + } + + switch (level) { + case cmake::LogLevel::LOG_ERROR: + case cmake::LogLevel::LOG_WARNING: + // we've overridden the message type, above, so display it directly + this->Makefile->GetMessenger()->DisplayMessage( + type, message, this->Makefile->GetBacktrace()); + break; + + case cmake::LogLevel::LOG_NOTICE: cmSystemTools::Message(message); - } + break; + + case cmake::LogLevel::LOG_STATUS: + case cmake::LogLevel::LOG_VERBOSE: + case cmake::LogLevel::LOG_DEBUG: + case cmake::LogLevel::LOG_TRACE: + this->Makefile->DisplayStatus(message, -1); + break; + + default: + assert("Unexpected log level! Review the `cmMessageCommand.cxx`." && + false); + break; } + if (fatal) { cmSystemTools::SetFatalErrorOccured(); } diff --git a/Source/cmMessenger.cxx b/Source/cmMessenger.cxx index 0d2b21f..07d011e 100644 --- a/Source/cmMessenger.cxx +++ b/Source/cmMessenger.cxx @@ -2,8 +2,8 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmMessenger.h" -#include "cmAlgorithms.h" #include "cmDocumentationFormatter.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #if defined(CMAKE_BUILD_WITH_CMAKE) diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx index 88040f8..cd84c03 100644 --- a/Source/cmNinjaNormalTargetGenerator.cxx +++ b/Source/cmNinjaNormalTargetGenerator.cxx @@ -33,6 +33,7 @@ #include "cmStateDirectory.h" #include "cmStateSnapshot.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" cmNinjaNormalTargetGenerator::cmNinjaNormalTargetGenerator( diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx index de79817..8b0a6ba 100644 --- a/Source/cmNinjaTargetGenerator.cxx +++ b/Source/cmNinjaTargetGenerator.cxx @@ -31,6 +31,7 @@ #include "cmSourceFile.h" #include "cmState.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmake.h" @@ -910,8 +911,8 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements() this->GetBuildFileStream() << "\n"; if (!this->SwiftOutputMap.empty()) { - std::string const mapFilePath = this->ConvertToNinjaPath( - this->GeneratorTarget->GetSupportDirectory() + "/output-file-map.json"); + std::string const mapFilePath = + this->GeneratorTarget->GetSupportDirectory() + "/output-file-map.json"; std::string const targetSwiftDepsPath = [this]() -> std::string { cmGeneratorTarget const* target = this->GeneratorTarget; if (const char* name = target->GetProperty("Swift_DEPENDENCIES_FILE")) { diff --git a/Source/cmOptionCommand.cxx b/Source/cmOptionCommand.cxx index 52f63a3..3724ba7 100644 --- a/Source/cmOptionCommand.cxx +++ b/Source/cmOptionCommand.cxx @@ -4,13 +4,13 @@ #include <sstream> -#include "cmAlgorithms.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmPolicies.h" #include "cmState.h" #include "cmStateSnapshot.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" class cmExecutionStatus; diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx index d7bcf7e..da7f8bc 100644 --- a/Source/cmOutputConverter.cxx +++ b/Source/cmOutputConverter.cxx @@ -6,7 +6,6 @@ #include <assert.h> #include <ctype.h> #include <set> -#include <string.h> #include <vector> #include "cmState.h" @@ -38,10 +37,10 @@ std::string cmOutputConverter::ConvertToOutputForExisting( return this->ConvertToOutputFormat(remote, format); } -std::string cmOutputConverter::ConvertToOutputFormat(const std::string& source, +std::string cmOutputConverter::ConvertToOutputFormat(cm::string_view source, OutputFormat output) const { - std::string result = source; + std::string result(source); // Convert it to an output path. if (output == SHELL || output == WATCOMQUOTE) { result = this->ConvertDirectorySeparatorsForShell(source); @@ -53,9 +52,9 @@ std::string cmOutputConverter::ConvertToOutputFormat(const std::string& source, } std::string cmOutputConverter::ConvertDirectorySeparatorsForShell( - const std::string& source) const + cm::string_view source) const { - std::string result = source; + 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. @@ -71,21 +70,21 @@ std::string cmOutputConverter::ConvertDirectorySeparatorsForShell( return result; } -static bool cmOutputConverterIsShellOperator(const std::string& str) +static bool cmOutputConverterIsShellOperator(cm::string_view str) { - static std::set<std::string> const shellOperators{ + static std::set<cm::string_view> const shellOperators{ "<", ">", "<<", ">>", "|", "||", "&&", "&>", "1>", "2>", "2>&1", "1>&2" }; return (shellOperators.count(str) != 0); } -std::string cmOutputConverter::EscapeForShell(const std::string& str, +std::string cmOutputConverter::EscapeForShell(cm::string_view str, bool makeVars, bool forEcho, bool useWatcomQuote) const { // Do not escape shell operators. if (cmOutputConverterIsShellOperator(str)) { - return str; + return std::string(str); } // Compute the flags for the target shell environment. @@ -117,46 +116,44 @@ std::string cmOutputConverter::EscapeForShell(const std::string& str, flags |= Shell_Flag_IsUnix; } - return Shell__GetArgument(str.c_str(), flags); + return Shell__GetArgument(str, flags); } -std::string cmOutputConverter::EscapeForCMake(const std::string& str) +std::string cmOutputConverter::EscapeForCMake(cm::string_view str) { // Always double-quote the argument to take care of most escapes. std::string result = "\""; - for (const char* c = str.c_str(); *c; ++c) { - if (*c == '"') { + for (const char c : str) { + if (c == '"') { // Escape the double quote to avoid ending the argument. result += "\\\""; - } else if (*c == '$') { + } else if (c == '$') { // Escape the dollar to avoid expanding variables. result += "\\$"; - } else if (*c == '\\') { + } else if (c == '\\') { // Escape the backslash to avoid other escapes. result += "\\\\"; } else { // Other characters will be parsed correctly. - result += *c; + result += c; } } result += "\""; return result; } -std::string cmOutputConverter::EscapeWindowsShellArgument(const char* arg, +std::string cmOutputConverter::EscapeWindowsShellArgument(cm::string_view arg, int shell_flags) { return Shell__GetArgument(arg, shell_flags); } cmOutputConverter::FortranFormat cmOutputConverter::GetFortranFormat( - const char* value) + cm::string_view value) { FortranFormat format = FortranFormatNone; - if (value && *value) { - std::vector<std::string> fmt; - cmSystemTools::ExpandListArgument(value, fmt); - for (std::string const& fi : fmt) { + if (!value.empty()) { + for (std::string const& fi : cmSystemTools::ExpandedListArgument(value)) { if (fi == "FIXED") { format = FortranFormatFixed; } @@ -168,6 +165,15 @@ cmOutputConverter::FortranFormat cmOutputConverter::GetFortranFormat( return format; } +cmOutputConverter::FortranFormat cmOutputConverter::GetFortranFormat( + const char* value) +{ + if (!value) { + return FortranFormatNone; + } + return GetFortranFormat(cm::string_view(value)); +} + void cmOutputConverter::SetLinkScriptShell(bool linkScriptShell) { this->LinkScriptShell = linkScriptShell; @@ -213,12 +219,12 @@ use the caret character itself (^), use two in a row (^^). */ /* Some helpers to identify character classes */ -static int Shell__CharIsWhitespace(char c) +static bool Shell__CharIsWhitespace(char c) { return ((c == ' ') || (c == '\t')); } -static int Shell__CharNeedsQuotesOnUnix(char c) +static bool Shell__CharNeedsQuotesOnUnix(char c) { return ((c == '\'') || (c == '`') || (c == ';') || (c == '#') || (c == '&') || (c == '$') || (c == '(') || (c == ')') || (c == '~') || @@ -226,51 +232,52 @@ static int Shell__CharNeedsQuotesOnUnix(char c) (c == '\\')); } -static int Shell__CharNeedsQuotesOnWindows(char c) +static bool Shell__CharNeedsQuotesOnWindows(char c) { return ((c == '\'') || (c == '#') || (c == '&') || (c == '<') || (c == '>') || (c == '|') || (c == '^')); } -static int Shell__CharIsMakeVariableName(char c) +static bool Shell__CharIsMakeVariableName(char c) { return c && (c == '_' || isalpha((static_cast<int>(c)))); } -int cmOutputConverter::Shell__CharNeedsQuotes(char c, int flags) +bool cmOutputConverter::Shell__CharNeedsQuotes(char c, int flags) { /* On Windows the built-in command shell echo never needs quotes. */ if (!(flags & Shell_Flag_IsUnix) && (flags & Shell_Flag_EchoWindows)) { - return 0; + return false; } /* On all platforms quotes are needed to preserve whitespace. */ if (Shell__CharIsWhitespace(c)) { - return 1; + return true; } if (flags & Shell_Flag_IsUnix) { /* On UNIX several special characters need quotes to preserve them. */ if (Shell__CharNeedsQuotesOnUnix(c)) { - return 1; + return true; } } else { /* On Windows several special characters need quotes to preserve them. */ if (Shell__CharNeedsQuotesOnWindows(c)) { - return 1; + return true; } } - return 0; + return false; } -const char* cmOutputConverter::Shell__SkipMakeVariables(const char* c) +cm::string_view::iterator cmOutputConverter::Shell__SkipMakeVariables( + cm::string_view::iterator c, cm::string_view::iterator end) { - while (*c == '$' && *(c + 1) == '(') { - const char* skip = c + 2; - while (Shell__CharIsMakeVariableName(*skip)) { + while ((c != end && (c + 1) != end) && (*c == '$' && *(c + 1) == '(')) { + cm::string_view::iterator skip = c + 2; + while ((skip != end) && Shell__CharIsMakeVariableName(*skip)) { ++skip; } - if (*skip == ')') { + if ((skip != end) && *skip == ')') { c = skip + 1; } else { break; @@ -302,63 +309,60 @@ flag later when we understand applications of this better. */ #define KWSYS_SYSTEM_SHELL_QUOTE_MAKE_VARIABLES 0 -int cmOutputConverter::Shell__ArgumentNeedsQuotes(const char* in, int flags) +bool cmOutputConverter::Shell__ArgumentNeedsQuotes(cm::string_view in, + int flags) { /* The empty string needs quotes. */ - if (!*in) { - return 1; + if (in.empty()) { + return true; } /* Scan the string for characters that require quoting. */ - { - const char* c; - for (c = in; *c; ++c) { - /* Look for $(MAKEVAR) syntax if requested. */ - if (flags & Shell_Flag_AllowMakeVariables) { + for (cm::string_view::iterator cit = in.begin(), cend = in.end(); + cit != cend; ++cit) { + /* Look for $(MAKEVAR) syntax if requested. */ + if (flags & Shell_Flag_AllowMakeVariables) { #if KWSYS_SYSTEM_SHELL_QUOTE_MAKE_VARIABLES - const char* skip = Shell__SkipMakeVariables(c); - if (skip != c) { - /* We need to quote make variable references to preserve the - string with contents substituted in its place. */ - return 1; - } + cm::string_view::iterator skip = Shell__SkipMakeVariables(cit, cend); + if (skip != cit) { + /* We need to quote make variable references to preserve the + string with contents substituted in its place. */ + return true; + } #else - /* Skip over the make variable references if any are present. */ - c = Shell__SkipMakeVariables(c); + /* Skip over the make variable references if any are present. */ + cit = Shell__SkipMakeVariables(cit, cend); - /* Stop if we have reached the end of the string. */ - if (!*c) { - break; - } -#endif + /* Stop if we have reached the end of the string. */ + if (cit == cend) { + break; } +#endif + } - /* Check whether this character needs quotes. */ - if (Shell__CharNeedsQuotes(*c, flags)) { - return 1; - } + /* Check whether this character needs quotes. */ + if (Shell__CharNeedsQuotes(*cit, flags)) { + return true; } } /* On Windows some single character arguments need quotes. */ - if (flags & Shell_Flag_IsUnix && *in && !*(in + 1)) { - char c = *in; + if (flags & Shell_Flag_IsUnix && in.size() == 1) { + char c = in[0]; if ((c == '?') || (c == '&') || (c == '^') || (c == '|') || (c == '#')) { - return 1; + return true; } } - return 0; + return false; } -std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags) +std::string cmOutputConverter::Shell__GetArgument(cm::string_view in, + int flags) { /* Output will be at least as long as input string. */ std::string out; - out.reserve(strlen(in)); - - /* String iterator. */ - const char* c; + out.reserve(in.size()); /* Keep track of how many backslashes have been encountered in a row. */ int windows_backslashes = 0; @@ -378,14 +382,15 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags) } /* Scan the string for characters that require escaping or quoting. */ - for (c = in; *c; ++c) { + for (cm::string_view::iterator cit = in.begin(), cend = in.end(); + cit != cend; ++cit) { /* Look for $(MAKEVAR) syntax if requested. */ if (flags & Shell_Flag_AllowMakeVariables) { - const char* skip = Shell__SkipMakeVariables(c); - if (skip != c) { + cm::string_view::iterator skip = Shell__SkipMakeVariables(cit, cend); + if (skip != cit) { /* Copy to the end of the make variable references. */ - while (c != skip) { - out += *c++; + while (cit != skip) { + out += *cit++; } /* The make variable reference eliminates any escaping needed @@ -393,7 +398,7 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags) windows_backslashes = 0; /* Stop if we have reached the end of the string. */ - if (!*c) { + if (cit == cend) { break; } } @@ -403,7 +408,7 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags) if (flags & Shell_Flag_IsUnix) { /* On Unix a few special characters need escaping even inside a quoted argument. */ - if (*c == '\\' || *c == '"' || *c == '`' || *c == '$') { + if (*cit == '\\' || *cit == '"' || *cit == '`' || *cit == '$') { /* This character needs a backslash to escape it. */ out += '\\'; } @@ -411,10 +416,10 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags) /* On Windows the built-in command shell echo never needs escaping. */ } else { /* On Windows only backslashes and double-quotes need escaping. */ - if (*c == '\\') { + if (*cit == '\\') { /* Found a backslash. It may need to be escaped later. */ ++windows_backslashes; - } else if (*c == '"') { + } else if (*cit == '"') { /* Found a double-quote. Escape all immediately preceding backslashes. */ while (windows_backslashes > 0) { @@ -432,7 +437,7 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags) } /* Check whether this character needs escaping for a make tool. */ - if (*c == '$') { + if (*cit == '$') { if (flags & Shell_Flag_Make) { /* In Makefiles a dollar is written $$. The make tool will replace it with just $ before passing it to the shell. */ @@ -449,7 +454,7 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags) /* Otherwise a dollar is written just $. */ out += '$'; } - } else if (*c == '#') { + } else if (*cit == '#') { if ((flags & Shell_Flag_Make) && (flags & Shell_Flag_WatcomWMake)) { /* In Watcom WMake makefiles a pound is written $#. The make tool will replace it with just # before passing it to the @@ -459,7 +464,7 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags) /* Otherwise a pound is written just #. */ out += '#'; } - } else if (*c == '%') { + } else if (*cit == '%') { if ((flags & Shell_Flag_VSIDE) || ((flags & Shell_Flag_Make) && ((flags & Shell_Flag_MinGWMake) || (flags & Shell_Flag_NMake)))) { @@ -469,7 +474,7 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags) /* Otherwise a percent is written just %. */ out += '%'; } - } else if (*c == ';') { + } else if (*cit == ';') { if (flags & Shell_Flag_VSIDE) { /* In a VS IDE a semicolon is written ";". If this is written in an un-quoted argument it starts a quoted segment, @@ -483,7 +488,7 @@ std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags) } } else { /* Store this character. */ - out += *c; + out += *cit; } } diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h index deca767..671efe7 100644 --- a/Source/cmOutputConverter.h +++ b/Source/cmOutputConverter.h @@ -5,9 +5,10 @@ #include "cmConfigure.h" // IWYU pragma: keep -#include <string> - #include "cmStateSnapshot.h" +#include "cm_string_view.hxx" + +#include <string> class cmState; @@ -22,10 +23,9 @@ public: WATCOMQUOTE, RESPONSE }; - std::string ConvertToOutputFormat(const std::string& source, + std::string ConvertToOutputFormat(cm::string_view source, OutputFormat output) const; - std::string ConvertDirectorySeparatorsForShell( - const std::string& source) const; + std::string ConvertDirectorySeparatorsForShell(cm::string_view source) const; //! for existing files convert to output path and short path if spaces std::string ConvertToOutputForExisting(const std::string& remote, @@ -72,15 +72,15 @@ public: Shell_Flag_IsUnix = (1 << 8) }; - std::string EscapeForShell(const std::string& str, bool makeVars = false, + std::string EscapeForShell(cm::string_view str, bool makeVars = false, bool forEcho = false, bool useWatcomQuote = false) const; - static std::string EscapeForCMake(const std::string& str); + static std::string EscapeForCMake(cm::string_view str); /** Compute an escaped version of the given argument for use in a windows shell. */ - static std::string EscapeWindowsShellArgument(const char* arg, + static std::string EscapeWindowsShellArgument(cm::string_view arg, int shell_flags); enum FortranFormat @@ -89,15 +89,17 @@ public: FortranFormatFixed, FortranFormatFree }; + static FortranFormat GetFortranFormat(cm::string_view value); static FortranFormat GetFortranFormat(const char* value); private: cmState* GetState() const; - static int Shell__CharNeedsQuotes(char c, int flags); - static const char* Shell__SkipMakeVariables(const char* c); - static int Shell__ArgumentNeedsQuotes(const char* in, int flags); - static std::string Shell__GetArgument(const char* in, int flags); + static bool Shell__CharNeedsQuotes(char c, int flags); + static cm::string_view::iterator Shell__SkipMakeVariables( + cm::string_view::iterator begin, cm::string_view::iterator end); + static bool Shell__ArgumentNeedsQuotes(cm::string_view in, int flags); + static std::string Shell__GetArgument(cm::string_view in, int flags); private: cmStateSnapshot StateSnapshot; diff --git a/Source/cmOutputRequiredFilesCommand.cxx b/Source/cmOutputRequiredFilesCommand.cxx index f3276ec..a66af5a 100644 --- a/Source/cmOutputRequiredFilesCommand.cxx +++ b/Source/cmOutputRequiredFilesCommand.cxx @@ -11,6 +11,7 @@ #include "cmGeneratorExpression.h" #include "cmMakefile.h" #include "cmSourceFile.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" diff --git a/Source/cmParseArgumentsCommand.cxx b/Source/cmParseArgumentsCommand.cxx index 5213432..04fa0fb 100644 --- a/Source/cmParseArgumentsCommand.cxx +++ b/Source/cmParseArgumentsCommand.cxx @@ -7,11 +7,11 @@ #include <sstream> #include <utility> -#include "cmAlgorithms.h" #include "cmArgumentParser.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmRange.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cm_string_view.hxx" @@ -75,7 +75,7 @@ static void PassParsedArguments( for (auto const& iter : singleValArgs) { if (!iter.second.empty()) { - makefile.AddDefinition(prefix + iter.first, iter.second.c_str()); + makefile.AddDefinition(prefix + iter.first, iter.second); } else { makefile.RemoveDefinition(prefix + iter.first); } @@ -84,7 +84,7 @@ static void PassParsedArguments( for (auto const& iter : multiValArgs) { if (!iter.second.empty()) { makefile.AddDefinition(prefix + iter.first, - JoinList(iter.second, parseFromArgV).c_str()); + JoinList(iter.second, parseFromArgV)); } else { makefile.RemoveDefinition(prefix + iter.first); } @@ -92,15 +92,14 @@ static void PassParsedArguments( if (!unparsed.empty()) { makefile.AddDefinition(prefix + "UNPARSED_ARGUMENTS", - JoinList(unparsed, parseFromArgV).c_str()); + JoinList(unparsed, parseFromArgV)); } else { makefile.RemoveDefinition(prefix + "UNPARSED_ARGUMENTS"); } if (!keywordsMissingValues.empty()) { - makefile.AddDefinition( - prefix + "KEYWORDS_MISSING_VALUES", - cmJoin(cmMakeRange(keywordsMissingValues), ";").c_str()); + makefile.AddDefinition(prefix + "KEYWORDS_MISSING_VALUES", + cmJoin(cmMakeRange(keywordsMissingValues), ";")); } else { makefile.RemoveDefinition(prefix + "KEYWORDS_MISSING_VALUES"); } diff --git a/Source/cmPolicies.cxx b/Source/cmPolicies.cxx index ec40136..51a61dc 100644 --- a/Source/cmPolicies.cxx +++ b/Source/cmPolicies.cxx @@ -1,10 +1,10 @@ #include "cmPolicies.h" -#include "cmAlgorithms.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmState.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmVersion.h" diff --git a/Source/cmPolicies.h b/Source/cmPolicies.h index e0f48de..92c80bb 100644 --- a/Source/cmPolicies.h +++ b/Source/cmPolicies.h @@ -286,7 +286,11 @@ class cmMakefile; 3, 16, 0, cmPolicies::WARN) \ SELECT(POLICY, CMP0096, \ "project() preserves leading zeros in version components.", 3, 16, \ - 0, cmPolicies::WARN) + 0, cmPolicies::WARN) \ + SELECT(POLICY, CMP0097, \ + "ExternalProject_Add with GIT_SUBMODULES \"\" initializes no " \ + "submodules.", \ + 3, 16, 0, cmPolicies::WARN) #define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1) #define CM_FOR_EACH_POLICY_ID(POLICY) \ diff --git a/Source/cmProjectCommand.cxx b/Source/cmProjectCommand.cxx index e3d3bd8..96d9843 100644 --- a/Source/cmProjectCommand.cxx +++ b/Source/cmProjectCommand.cxx @@ -10,11 +10,11 @@ #include <sstream> #include <utility> -#include "cmAlgorithms.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmPolicies.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" class cmExecutionStatus; @@ -45,12 +45,12 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args, this->Makefile->GetCurrentSourceDirectory().c_str(), "Value Computed by CMake", cmStateEnums::STATIC); - this->Makefile->AddDefinition( - "PROJECT_BINARY_DIR", this->Makefile->GetCurrentBinaryDirectory().c_str()); - this->Makefile->AddDefinition( - "PROJECT_SOURCE_DIR", this->Makefile->GetCurrentSourceDirectory().c_str()); + this->Makefile->AddDefinition("PROJECT_BINARY_DIR", + this->Makefile->GetCurrentBinaryDirectory()); + this->Makefile->AddDefinition("PROJECT_SOURCE_DIR", + this->Makefile->GetCurrentSourceDirectory()); - this->Makefile->AddDefinition("PROJECT_NAME", projectName.c_str()); + this->Makefile->AddDefinition("PROJECT_NAME", projectName); // Set the CMAKE_PROJECT_NAME variable to be the highest-level // project name in the tree. If there are two project commands @@ -60,7 +60,7 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args, // will work. if (!this->Makefile->GetDefinition("CMAKE_PROJECT_NAME") || (this->Makefile->IsRootMakefile())) { - this->Makefile->AddDefinition("CMAKE_PROJECT_NAME", projectName.c_str()); + this->Makefile->AddDefinition("CMAKE_PROJECT_NAME", projectName); this->Makefile->AddCacheDefinition( "CMAKE_PROJECT_NAME", projectName.c_str(), "Value Computed by CMake", cmStateEnums::STATIC); @@ -258,24 +258,24 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args, std::string vv; vv = projectName + "_VERSION"; - this->Makefile->AddDefinition("PROJECT_VERSION", version_string.c_str()); - this->Makefile->AddDefinition(vv, version_string.c_str()); + this->Makefile->AddDefinition("PROJECT_VERSION", version_string); + this->Makefile->AddDefinition(vv, version_string); vv = projectName + "_VERSION_MAJOR"; this->Makefile->AddDefinition("PROJECT_VERSION_MAJOR", - version_components[0].c_str()); - this->Makefile->AddDefinition(vv, version_components[0].c_str()); + version_components[0]); + this->Makefile->AddDefinition(vv, version_components[0]); vv = projectName + "_VERSION_MINOR"; this->Makefile->AddDefinition("PROJECT_VERSION_MINOR", - version_components[1].c_str()); - this->Makefile->AddDefinition(vv, version_components[1].c_str()); + version_components[1]); + this->Makefile->AddDefinition(vv, version_components[1]); vv = projectName + "_VERSION_PATCH"; this->Makefile->AddDefinition("PROJECT_VERSION_PATCH", - version_components[2].c_str()); - this->Makefile->AddDefinition(vv, version_components[2].c_str()); + version_components[2]); + this->Makefile->AddDefinition(vv, version_components[2]); vv = projectName + "_VERSION_TWEAK"; this->Makefile->AddDefinition("PROJECT_VERSION_TWEAK", - version_components[3].c_str()); - this->Makefile->AddDefinition(vv, version_components[3].c_str()); + version_components[3]); + this->Makefile->AddDefinition(vv, version_components[3]); // Also, try set top level variables TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION", version_string.c_str()); TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION_MAJOR", @@ -327,14 +327,12 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args, } } - this->Makefile->AddDefinition("PROJECT_DESCRIPTION", description.c_str()); - this->Makefile->AddDefinition(projectName + "_DESCRIPTION", - description.c_str()); + this->Makefile->AddDefinition("PROJECT_DESCRIPTION", description); + this->Makefile->AddDefinition(projectName + "_DESCRIPTION", description); TopLevelCMakeVarCondSet("CMAKE_PROJECT_DESCRIPTION", description.c_str()); - this->Makefile->AddDefinition("PROJECT_HOMEPAGE_URL", homepage.c_str()); - this->Makefile->AddDefinition(projectName + "_HOMEPAGE_URL", - homepage.c_str()); + this->Makefile->AddDefinition("PROJECT_HOMEPAGE_URL", homepage); + this->Makefile->AddDefinition(projectName + "_HOMEPAGE_URL", homepage); TopLevelCMakeVarCondSet("CMAKE_PROJECT_HOMEPAGE_URL", homepage.c_str()); if (languages.empty()) { diff --git a/Source/cmQTWrapCPPCommand.cxx b/Source/cmQTWrapCPPCommand.cxx index 9a764c6..f5852a9 100644 --- a/Source/cmQTWrapCPPCommand.cxx +++ b/Source/cmQTWrapCPPCommand.cxx @@ -89,6 +89,6 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& args, } // Store the final list of source files. - this->Makefile->AddDefinition(sourceList, sourceListValue.c_str()); + this->Makefile->AddDefinition(sourceList, sourceListValue); return true; } diff --git a/Source/cmQTWrapUICommand.cxx b/Source/cmQTWrapUICommand.cxx index 2223e2d..361d7b3 100644 --- a/Source/cmQTWrapUICommand.cxx +++ b/Source/cmQTWrapUICommand.cxx @@ -132,7 +132,7 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args, } // Store the final list of source files and headers. - this->Makefile->AddDefinition(sourceList, sourceListValue.c_str()); - this->Makefile->AddDefinition(headerList, headerListValue.c_str()); + this->Makefile->AddDefinition(sourceList, sourceListValue); + this->Makefile->AddDefinition(headerList, headerListValue); return true; } diff --git a/Source/cmQtAutoGen.cxx b/Source/cmQtAutoGen.cxx index 3683edd..712e22c 100644 --- a/Source/cmQtAutoGen.cxx +++ b/Source/cmQtAutoGen.cxx @@ -5,6 +5,7 @@ #include "cmAlgorithms.h" #include "cmDuration.h" #include "cmProcessOutput.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmsys/FStream.hxx" #include "cmsys/RegularExpression.hxx" diff --git a/Source/cmQtAutoGenInitializer.cxx b/Source/cmQtAutoGenInitializer.cxx index 4b12419..da6094d 100644 --- a/Source/cmQtAutoGenInitializer.cxx +++ b/Source/cmQtAutoGenInitializer.cxx @@ -4,7 +4,6 @@ #include "cmQtAutoGen.h" #include "cmQtAutoGenGlobalInitializer.h" -#include "cmAlgorithms.h" #include "cmCustomCommand.h" #include "cmCustomCommandLines.h" #include "cmFilePathChecksum.h" @@ -23,6 +22,7 @@ #include "cmSourceGroup.h" #include "cmState.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmake.h" diff --git a/Source/cmQtAutoMocUic.cxx b/Source/cmQtAutoMocUic.cxx index 44d2db0..2aefe8f 100644 --- a/Source/cmQtAutoMocUic.cxx +++ b/Source/cmQtAutoMocUic.cxx @@ -16,6 +16,7 @@ #include "cmGeneratedFileStream.h" #include "cmMakefile.h" #include "cmQtAutoGen.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmake.h" #include "cmsys/FStream.hxx" diff --git a/Source/cmQtAutoRcc.cxx b/Source/cmQtAutoRcc.cxx index 20885df..59f632d 100644 --- a/Source/cmQtAutoRcc.cxx +++ b/Source/cmQtAutoRcc.cxx @@ -11,6 +11,7 @@ #include "cmFileLockResult.h" #include "cmMakefile.h" #include "cmProcessOutput.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" // -- Class methods diff --git a/Source/cmRST.cxx b/Source/cmRST.cxx index 2064275..a329f7d 100644 --- a/Source/cmRST.cxx +++ b/Source/cmRST.cxx @@ -4,6 +4,7 @@ #include "cmAlgorithms.h" #include "cmRange.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmVersion.h" diff --git a/Source/cmRemoveCommand.cxx b/Source/cmRemoveCommand.cxx index a64ad8c..d0ee4d4 100644 --- a/Source/cmRemoveCommand.cxx +++ b/Source/cmRemoveCommand.cxx @@ -52,7 +52,7 @@ bool cmRemoveCommand::InitialPass(std::vector<std::string> const& args, } // add the definition - this->Makefile->AddDefinition(variable, value.c_str()); + this->Makefile->AddDefinition(variable, value); return true; } diff --git a/Source/cmReturnCommand.cxx b/Source/cmReturnCommand.cxx index ceea8b4..5905669 100644 --- a/Source/cmReturnCommand.cxx +++ b/Source/cmReturnCommand.cxx @@ -5,8 +5,8 @@ #include "cmExecutionStatus.h" // cmReturnCommand -bool cmReturnCommand::InitialPass(std::vector<std::string> const&, - cmExecutionStatus& status) +bool cmReturnCommand(std::vector<std::string> const&, + cmExecutionStatus& status) { status.SetReturnInvoked(); return true; diff --git a/Source/cmReturnCommand.h b/Source/cmReturnCommand.h index e9264d2..2404a36 100644 --- a/Source/cmReturnCommand.h +++ b/Source/cmReturnCommand.h @@ -8,34 +8,10 @@ #include <string> #include <vector> -#include "cm_memory.hxx" - -#include "cmCommand.h" - class cmExecutionStatus; -/** \class cmReturnCommand - * \brief Return from a directory or function - * - * cmReturnCommand returns from a directory or function - */ -class cmReturnCommand : public cmCommand -{ -public: - /** - * This is a virtual constructor for the command. - */ - std::unique_ptr<cmCommand> Clone() override - { - return cm::make_unique<cmReturnCommand>(); - } - - /** - * This is called when the command is first encountered in - * the CMakeLists.txt file. - */ - bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status) override; -}; +/// Return from a directory or function +bool cmReturnCommand(std::vector<std::string> const& args, + cmExecutionStatus& status); #endif diff --git a/Source/cmSearchPath.cxx b/Source/cmSearchPath.cxx index f98984e..879cc95 100644 --- a/Source/cmSearchPath.cxx +++ b/Source/cmSearchPath.cxx @@ -6,9 +6,9 @@ #include <cassert> #include <utility> -#include "cmAlgorithms.h" #include "cmFindCommon.h" #include "cmMakefile.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" cmSearchPath::cmSearchPath(cmFindCommon* findCmd) diff --git a/Source/cmSeparateArgumentsCommand.cxx b/Source/cmSeparateArgumentsCommand.cxx index 28cbdc0..ab4a0c7 100644 --- a/Source/cmSeparateArgumentsCommand.cxx +++ b/Source/cmSeparateArgumentsCommand.cxx @@ -69,7 +69,7 @@ bool cmSeparateArgumentsCommand::InitialPass( if (const char* def = this->Makefile->GetDefinition(var)) { std::string value = def; std::replace(value.begin(), value.end(), ' ', ';'); - this->Makefile->AddDefinition(var, value.c_str()); + this->Makefile->AddDefinition(var, value); } } else { // Parse the command line. @@ -97,7 +97,7 @@ bool cmSeparateArgumentsCommand::InitialPass( value += si; } } - this->Makefile->AddDefinition(var, value.c_str()); + this->Makefile->AddDefinition(var, value); } return true; diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx index 41555e8..1a12785 100644 --- a/Source/cmSetCommand.cxx +++ b/Source/cmSetCommand.cxx @@ -2,12 +2,12 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmSetCommand.h" -#include "cmAlgorithms.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmRange.h" #include "cmState.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" class cmExecutionStatus; @@ -154,7 +154,7 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args, type, force); } else { // add the definition - this->Makefile->AddDefinition(variable, value.c_str()); + this->Makefile->AddDefinition(variable, value); } return true; } diff --git a/Source/cmSourceFileLocation.cxx b/Source/cmSourceFileLocation.cxx index acacba2..6e2e820 100644 --- a/Source/cmSourceFileLocation.cxx +++ b/Source/cmSourceFileLocation.cxx @@ -2,10 +2,10 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmSourceFileLocation.h" -#include "cmAlgorithms.h" #include "cmGlobalGenerator.h" #include "cmMakefile.h" #include "cmMessageType.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmake.h" @@ -146,8 +146,7 @@ bool cmSourceFileLocation::MatchesAmbiguousExtension( // adding an extension. if (!(this->Name.size() > loc.Name.size() && this->Name[loc.Name.size()] == '.' && - cmHasLiteralPrefixImpl(this->Name.c_str(), loc.Name.c_str(), - loc.Name.size()))) { + cmHasPrefix(this->Name, loc.Name))) { return false; } diff --git a/Source/cmState.cxx b/Source/cmState.cxx index 9748cf5..1ea72e1 100644 --- a/Source/cmState.cxx +++ b/Source/cmState.cxx @@ -5,23 +5,24 @@ #include "cmsys/RegularExpression.hxx" #include <algorithm> #include <assert.h> +#include <stdlib.h> #include <string.h> -#include <type_traits> #include <utility> #include "cm_memory.hxx" -#include "cmAlgorithms.h" #include "cmCacheManager.h" #include "cmCommand.h" #include "cmDefinitions.h" #include "cmDisallowedCommand.h" +#include "cmExecutionStatus.h" #include "cmGlobVerificationManager.h" #include "cmListFileCache.h" +#include "cmMakefile.h" #include "cmStatePrivate.h" #include "cmStateSnapshot.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" -#include "cmUnexpectedCommand.h" #include "cmake.h" cmState::cmState() @@ -307,8 +308,8 @@ cmStateSnapshot cmState::Reset() 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()); + pos->Vars->Set("CMAKE_SOURCE_DIR", srcDir); + pos->Vars->Set("CMAKE_BINARY_DIR", binDir); } this->DefineProperty("RULE_LAUNCH_COMPILE", cmProperty::DIRECTORY, "", "", @@ -421,11 +422,31 @@ void cmState::SetIsGeneratorMultiConfig(bool b) void cmState::AddBuiltinCommand(std::string const& name, std::unique_ptr<cmCommand> command) { + this->AddBuiltinCommand(name, cmLegacyCommandWrapper(std::move(command))); +} + +void cmState::AddBuiltinCommand(std::string const& name, Command command) +{ assert(name == cmSystemTools::LowerCase(name)); assert(this->BuiltinCommands.find(name) == this->BuiltinCommands.end()); - this->BuiltinCommands.insert( - std::map<std::string, std::unique_ptr<cmCommand>>::value_type( - name, std::move(command))); + this->BuiltinCommands.emplace(name, std::move(command)); +} + +void cmState::AddBuiltinCommand(std::string const& name, + BuiltinCommand command) +{ + this->AddBuiltinCommand( + name, + [command](const std::vector<cmListFileArgument>& args, + cmExecutionStatus& status) -> bool { + std::vector<std::string> expandedArguments; + if (!status.GetMakefile().ExpandArguments(args, expandedArguments)) { + // There was an error expanding arguments. It was already + // reported, so we can skip this command without error. + return true; + } + return command(expandedArguments, status); + }); } void cmState::AddDisallowedCommand(std::string const& name, @@ -440,49 +461,46 @@ void cmState::AddDisallowedCommand(std::string const& name, void cmState::AddUnexpectedCommand(std::string const& name, const char* error) { - this->AddBuiltinCommand(name, - cm::make_unique<cmUnexpectedCommand>(name, error)); + this->AddBuiltinCommand( + name, + [name, error](std::vector<cmListFileArgument> const&, + cmExecutionStatus& status) -> bool { + const char* versionValue = + status.GetMakefile().GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION"); + if (name == "endif" && (!versionValue || atof(versionValue) <= 1.4)) { + return true; + } + status.SetError(error); + return false; + }); } -void cmState::AddScriptedCommand(std::string const& name, - std::unique_ptr<cmCommand> command) +void cmState::AddScriptedCommand(std::string const& name, Command command) { std::string sName = cmSystemTools::LowerCase(name); // if the command already exists, give a new name to the old command. - if (cmCommand* oldCmd = this->GetCommand(sName)) { - std::string const newName = "_" + sName; - auto pos = this->ScriptedCommands.find(newName); - if (pos != this->ScriptedCommands.end()) { - this->ScriptedCommands.erase(pos); - } - this->ScriptedCommands.insert(std::make_pair(newName, oldCmd->Clone())); + if (Command oldCmd = this->GetCommand(sName)) { + this->ScriptedCommands["_" + sName] = oldCmd; } - // if the command already exists, free the old one - auto pos = this->ScriptedCommands.find(sName); - if (pos != this->ScriptedCommands.end()) { - this->ScriptedCommands.erase(pos); - } - this->ScriptedCommands.insert( - std::map<std::string, std::unique_ptr<cmCommand>>::value_type( - sName, std::move(command))); + this->ScriptedCommands[sName] = std::move(command); } -cmCommand* cmState::GetCommand(std::string const& name) const +cmState::Command cmState::GetCommand(std::string const& name) const { return GetCommandByExactName(cmSystemTools::LowerCase(name)); } -cmCommand* cmState::GetCommandByExactName(std::string const& name) const +cmState::Command cmState::GetCommandByExactName(std::string const& name) const { auto pos = this->ScriptedCommands.find(name); if (pos != this->ScriptedCommands.end()) { - return pos->second.get(); + return pos->second; } pos = this->BuiltinCommands.find(name); if (pos != this->BuiltinCommands.end()) { - return pos->second.get(); + return pos->second; } return nullptr; } @@ -507,9 +525,7 @@ std::vector<std::string> cmState::GetCommandNames() const void cmState::RemoveBuiltinCommand(std::string const& name) { assert(name == cmSystemTools::LowerCase(name)); - auto i = this->BuiltinCommands.find(name); - assert(i != this->BuiltinCommands.end()); - this->BuiltinCommands.erase(i); + this->BuiltinCommands.erase(name); } void cmState::RemoveUserDefinedCommands() diff --git a/Source/cmState.h b/Source/cmState.h index 7e88030..8847f3b 100644 --- a/Source/cmState.h +++ b/Source/cmState.h @@ -5,6 +5,7 @@ #include "cmConfigure.h" // IWYU pragma: keep +#include <functional> #include <map> #include <memory> #include <set> @@ -27,6 +28,7 @@ class cmGlobVerificationManager; class cmPropertyDefinition; class cmStateSnapshot; class cmMessenger; +class cmExecutionStatus; class cmState { @@ -141,19 +143,25 @@ public: bool GetIsGeneratorMultiConfig() const; void SetIsGeneratorMultiConfig(bool b); + using Command = std::function<bool(std::vector<cmListFileArgument> const&, + cmExecutionStatus&)>; + using BuiltinCommand = bool (*)(std::vector<std::string> const&, + cmExecutionStatus&); + // Returns a command from its name, case insensitive, or nullptr - cmCommand* GetCommand(std::string const& name) const; + Command GetCommand(std::string const& name) const; // Returns a command from its name, or nullptr - cmCommand* GetCommandByExactName(std::string const& name) const; + Command GetCommandByExactName(std::string const& name) const; void AddBuiltinCommand(std::string const& name, std::unique_ptr<cmCommand> command); + void AddBuiltinCommand(std::string const& name, Command command); + void AddBuiltinCommand(std::string const& name, BuiltinCommand command); void AddDisallowedCommand(std::string const& name, std::unique_ptr<cmCommand> command, cmPolicies::PolicyID policy, const char* message); void AddUnexpectedCommand(std::string const& name, const char* error); - void AddScriptedCommand(std::string const& name, - std::unique_ptr<cmCommand> command); + void AddScriptedCommand(std::string const& name, Command command); void RemoveBuiltinCommand(std::string const& name); void RemoveUserDefinedCommands(); std::vector<std::string> GetCommandNames() const; @@ -212,8 +220,8 @@ private: std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> PropertyDefinitions; std::vector<std::string> EnabledLanguages; - std::map<std::string, std::unique_ptr<cmCommand>> BuiltinCommands; - std::map<std::string, std::unique_ptr<cmCommand>> ScriptedCommands; + std::map<std::string, Command> BuiltinCommands; + std::map<std::string, Command> ScriptedCommands; cmPropertyMap GlobalProperties; std::unique_ptr<cmCacheManager> CacheManager; std::unique_ptr<cmGlobVerificationManager> GlobVerificationManager; diff --git a/Source/cmStateDirectory.h b/Source/cmStateDirectory.h index 6956594..fe15563 100644 --- a/Source/cmStateDirectory.h +++ b/Source/cmStateDirectory.h @@ -14,6 +14,7 @@ #include "cmListFileCache.h" #include "cmStatePrivate.h" #include "cmStateSnapshot.h" +#include "cmStringAlgorithms.h" class cmStateDirectory { diff --git a/Source/cmStateSnapshot.cxx b/Source/cmStateSnapshot.cxx index 63bec71..110ec56 100644 --- a/Source/cmStateSnapshot.cxx +++ b/Source/cmStateSnapshot.cxx @@ -222,14 +222,14 @@ bool cmStateSnapshot::IsInitialized(std::string const& name) const } void cmStateSnapshot::SetDefinition(std::string const& name, - std::string const& value) + cm::string_view value) { - this->Position->Vars->Set(name, value.c_str()); + this->Position->Vars->Set(name, value); } void cmStateSnapshot::RemoveDefinition(std::string const& name) { - this->Position->Vars->Set(name, nullptr); + this->Position->Vars->Unset(name); } std::vector<std::string> cmStateSnapshot::UnusedKeys() const @@ -264,7 +264,11 @@ bool cmStateSnapshot::RaiseScope(std::string const& var, const char* varDef) cmDefinitions::Raise(var, this->Position->Vars, this->Position->Root); // Now update the definition in the parent scope. - this->Position->Parent->Set(var, varDef); + if (varDef) { + this->Position->Parent->Set(var, varDef); + } else { + this->Position->Parent->Unset(var); + } return true; } diff --git a/Source/cmStateSnapshot.h b/Source/cmStateSnapshot.h index c315f48..da39127 100644 --- a/Source/cmStateSnapshot.h +++ b/Source/cmStateSnapshot.h @@ -9,6 +9,8 @@ #include <string> #include <vector> +#include "cm_string_view.hxx" + #include "cmLinkedTree.h" #include "cmPolicies.h" #include "cmStateTypes.h" @@ -24,7 +26,7 @@ public: std::string const* GetDefinition(std::string const& name) const; bool IsInitialized(std::string const& name) const; - void SetDefinition(std::string const& name, std::string const& value); + void SetDefinition(std::string const& name, cm::string_view value); void RemoveDefinition(std::string const& name); std::vector<std::string> UnusedKeys() const; std::vector<std::string> ClosureKeys() const; diff --git a/Source/cmStringAlgorithms.h b/Source/cmStringAlgorithms.h new file mode 100644 index 0000000..149e0ad --- /dev/null +++ b/Source/cmStringAlgorithms.h @@ -0,0 +1,139 @@ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ +#ifndef cmStringAlgorithms_h +#define cmStringAlgorithms_h + +#include "cmConfigure.h" // IWYU pragma: keep + +#include "cmRange.h" +#include "cm_string_view.hxx" +#include <algorithm> +#include <iterator> +#include <sstream> +#include <string.h> +#include <string> +#include <utility> +#include <vector> + +typedef cmRange<std::vector<std::string>::const_iterator> cmStringRange; + +struct cmStrCmp +{ + cmStrCmp(const char* test) + : m_test(test) + { + } + cmStrCmp(std::string test) + : m_test(std::move(test)) + { + } + + bool operator()(const std::string& input) const { return m_test == input; } + + bool operator()(const char* input) const + { + return strcmp(input, m_test.c_str()) == 0; + } + +private: + const std::string m_test; +}; + +template <typename Range> +std::string cmJoin(Range const& r, const char* delimiter) +{ + if (r.empty()) { + return std::string(); + } + std::ostringstream os; + typedef typename Range::value_type ValueType; + typedef typename Range::const_iterator InputIt; + const InputIt first = r.begin(); + InputIt last = r.end(); + --last; + std::copy(first, last, std::ostream_iterator<ValueType>(os, delimiter)); + + os << *last; + + return os.str(); +} + +template <typename Range> +std::string cmJoin(Range const& r, std::string const& delimiter) +{ + return cmJoin(r, delimiter.c_str()); +} + +template <typename Range> +std::string cmWrap(std::string const& prefix, Range const& r, + std::string const& suffix, std::string const& sep) +{ + if (r.empty()) { + return std::string(); + } + return prefix + cmJoin(r, suffix + sep + prefix) + suffix; +} + +template <typename Range> +std::string cmWrap(char prefix, Range const& r, char suffix, + std::string const& sep) +{ + return cmWrap(std::string(1, prefix), r, std::string(1, suffix), sep); +} + +/** Returns true if string @a str starts with the character @a prefix. **/ +inline bool cmHasPrefix(cm::string_view str, char prefix) +{ + return !str.empty() && (str.front() == prefix); +} + +/** Returns true if string @a str starts with string @a prefix. **/ +inline bool cmHasPrefix(cm::string_view str, cm::string_view prefix) +{ + return str.compare(0, prefix.size(), prefix) == 0; +} + +/** Returns true if string @a str starts with string @a prefix. **/ +template <size_t N> +inline bool cmHasLiteralPrefix(cm::string_view str, const char (&prefix)[N]) +{ + return cmHasPrefix(str, cm::string_view(prefix, N - 1)); +} + +/** Returns true if string @a str ends with the character @a suffix. **/ +inline bool cmHasSuffix(cm::string_view str, char suffix) +{ + return !str.empty() && (str.back() == suffix); +} + +/** Returns true if string @a str ends with string @a suffix. **/ +inline bool cmHasSuffix(cm::string_view str, cm::string_view suffix) +{ + return str.size() >= suffix.size() && + str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0; +} + +/** Returns true if string @a str ends with string @a suffix. **/ +template <size_t N> +inline bool cmHasLiteralSuffix(cm::string_view str, const char (&suffix)[N]) +{ + return cmHasSuffix(str, cm::string_view(suffix, N - 1)); +} + +/** Removes an existing suffix character of from the string @a str. **/ +inline void cmStripSuffixIfExists(std::string& str, char suffix) +{ + if (cmHasSuffix(str, suffix)) { + str.pop_back(); + } +} + +/** Removes an existing suffix string of from the string @a str. **/ +inline void cmStripSuffixIfExists(std::string& str, cm::string_view suffix) +{ + if (cmHasSuffix(str, suffix)) { + str.resize(str.size() - suffix.size()); + } +} + +#endif diff --git a/Source/cmStringCommand.cxx b/Source/cmStringCommand.cxx index 4ad0870..8b3b1e3 100644 --- a/Source/cmStringCommand.cxx +++ b/Source/cmStringCommand.cxx @@ -18,6 +18,7 @@ #include "cmMakefile.h" #include "cmMessageType.h" #include "cmRange.h" +#include "cmStringAlgorithms.h" #include "cmStringReplaceHelper.h" #include "cmSystemTools.h" #include "cmTimestamp.h" @@ -123,7 +124,7 @@ bool cmStringCommand::HandleHashCommand(std::vector<std::string> const& args) std::unique_ptr<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str())); if (hash) { std::string out = hash->HashString(args[2]); - this->Makefile->AddDefinition(args[1], out.c_str()); + this->Makefile->AddDefinition(args[1], out); return true; } return false; @@ -153,7 +154,7 @@ bool cmStringCommand::HandleToUpperLowerCommand( } // Store the output in the provided variable. - this->Makefile->AddDefinition(outvar, output.c_str()); + this->Makefile->AddDefinition(outvar, output); return true; } @@ -179,7 +180,7 @@ bool cmStringCommand::HandleAsciiCommand(std::vector<std::string> const& args) } } // Store the output in the provided variable. - this->Makefile->AddDefinition(outvar, output.c_str()); + this->Makefile->AddDefinition(outvar, output); return true; } @@ -216,7 +217,7 @@ bool cmStringCommand::HandleConfigureCommand( this->Makefile->ConfigureString(args[1], output, atOnly, escapeQuotes); // Store the output in the provided variable. - this->Makefile->AddDefinition(args[2], output.c_str()); + this->Makefile->AddDefinition(args[2], output); return true; } @@ -295,7 +296,7 @@ bool cmStringCommand::RegexMatch(std::vector<std::string> const& args) } // Store the output in the provided variable. - this->Makefile->AddDefinition(outvar, output.c_str()); + this->Makefile->AddDefinition(outvar, output); return true; } @@ -342,7 +343,7 @@ bool cmStringCommand::RegexMatchAll(std::vector<std::string> const& args) } // Store the output in the provided variable. - this->Makefile->AddDefinition(outvar, output.c_str()); + this->Makefile->AddDefinition(outvar, output); return true; } @@ -383,7 +384,7 @@ bool cmStringCommand::RegexReplace(std::vector<std::string> const& args) } // Store the output in the provided variable. - this->Makefile->AddDefinition(outvar, output.c_str()); + this->Makefile->AddDefinition(outvar, output); return true; } @@ -430,7 +431,7 @@ bool cmStringCommand::HandleFindCommand(std::vector<std::string> const& args) if (std::string::npos != pos) { std::ostringstream s; s << pos; - this->Makefile->AddDefinition(outvar, s.str().c_str()); + this->Makefile->AddDefinition(outvar, s.str()); return true; } @@ -505,7 +506,7 @@ bool cmStringCommand::HandleReplaceCommand( cmsys::SystemTools::ReplaceString(input, matchExpression.c_str(), replaceExpression.c_str()); - this->Makefile->AddDefinition(variableName, input.c_str()); + this->Makefile->AddDefinition(variableName, input); return true; } @@ -538,8 +539,7 @@ bool cmStringCommand::HandleSubstringCommand( return false; } - this->Makefile->AddDefinition(variableName, - stringValue.substr(begin, end).c_str()); + this->Makefile->AddDefinition(variableName, stringValue.substr(begin, end)); return true; } @@ -581,7 +581,7 @@ bool cmStringCommand::HandleAppendCommand(std::vector<std::string> const& args) value = oldValue; } value += cmJoin(cmMakeRange(args).advance(2), std::string()); - this->Makefile->AddDefinition(variable, value.c_str()); + this->Makefile->AddDefinition(variable, value); return true; } @@ -605,7 +605,7 @@ bool cmStringCommand::HandlePrependCommand( if (oldValue) { value += oldValue; } - this->Makefile->AddDefinition(variable, value.c_str()); + this->Makefile->AddDefinition(variable, value); return true; } @@ -637,7 +637,7 @@ bool cmStringCommand::joinImpl(std::vector<std::string> const& args, // both `CONCAT` and `JOIN` sub-commands. std::string value = cmJoin(cmMakeRange(args).advance(varIdx + 1), glue); - this->Makefile->AddDefinition(variableName, value.c_str()); + this->Makefile->AddDefinition(variableName, value); return true; } @@ -653,7 +653,7 @@ bool cmStringCommand::HandleMakeCIdentifierCommand( const std::string& variableName = args[2]; this->Makefile->AddDefinition(variableName, - cmSystemTools::MakeCidentifier(input).c_str()); + cmSystemTools::MakeCidentifier(input)); return true; } @@ -672,7 +672,7 @@ bool cmStringCommand::HandleGenexStripCommand( const std::string& variableName = args[2]; - this->Makefile->AddDefinition(variableName, result.c_str()); + this->Makefile->AddDefinition(variableName, result); return true; } @@ -711,8 +711,8 @@ bool cmStringCommand::HandleStripCommand(std::vector<std::string> const& args) outLength = endPos - startPos + 1; } - this->Makefile->AddDefinition( - variableName, stringValue.substr(startPos, outLength).c_str()); + this->Makefile->AddDefinition(variableName, + stringValue.substr(startPos, outLength)); return true; } @@ -765,7 +765,7 @@ bool cmStringCommand::HandleRepeatCommand(std::vector<std::string> const& args) break; } - this->Makefile->AddDefinition(variableName, result.c_str()); + this->Makefile->AddDefinition(variableName, result); return true; } @@ -871,7 +871,7 @@ bool cmStringCommand::HandleTimestampCommand( cmTimestamp timestamp; std::string result = timestamp.CurrentTime(formatString, utcFlag); - this->Makefile->AddDefinition(outputVariable, result.c_str()); + this->Makefile->AddDefinition(outputVariable, result); return true; } @@ -954,7 +954,7 @@ bool cmStringCommand::HandleUuidCommand(std::vector<std::string> const& args) uuid = cmSystemTools::UpperCase(uuid); } - this->Makefile->AddDefinition(outputVariable, uuid.c_str()); + this->Makefile->AddDefinition(outputVariable, uuid); return true; #else std::ostringstream e; diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx index 723f280..5f4e1fc 100644 --- a/Source/cmSystemTools.cxx +++ b/Source/cmSystemTools.cxx @@ -6,6 +6,7 @@ #include "cmDuration.h" #include "cmProcessOutput.h" #include "cmRange.h" +#include "cmStringAlgorithms.h" #include "cm_uv.h" #if defined(CMAKE_BUILD_WITH_CMAKE) @@ -176,36 +177,37 @@ void cmSystemTools::ExpandRegistryValues(std::string& source, } #endif -std::string cmSystemTools::EscapeQuotes(const std::string& str) +std::string cmSystemTools::EscapeQuotes(cm::string_view str) { std::string result; result.reserve(str.size()); - for (const char* ch = str.c_str(); *ch != '\0'; ++ch) { - if (*ch == '"') { + for (const char ch : str) { + if (ch == '"') { result += '\\'; } - result += *ch; + result += ch; } return result; } -std::string cmSystemTools::HelpFileName(std::string name) +std::string cmSystemTools::HelpFileName(cm::string_view str) { + std::string name(str); cmSystemTools::ReplaceString(name, "<", ""); cmSystemTools::ReplaceString(name, ">", ""); return name; } -std::string cmSystemTools::TrimWhitespace(const std::string& s) +std::string cmSystemTools::TrimWhitespace(cm::string_view str) { - std::string::const_iterator start = s.begin(); - while (start != s.end() && cm_isspace(*start)) { + auto start = str.begin(); + while (start != str.end() && cm_isspace(*start)) { ++start; } - if (start == s.end()) { - return ""; + if (start == str.end()) { + return std::string(); } - std::string::const_iterator stop = s.end() - 1; + auto stop = str.end() - 1; while (cm_isspace(*stop)) { --stop; } @@ -282,115 +284,85 @@ void cmSystemTools::ReportLastSystemError(const char* msg) cmSystemTools::Error(m); } -bool cmSystemTools::IsInternallyOn(const char* val) -{ - if (!val) { - return false; - } - std::string v = val; - if (v.size() > 4) { - return false; - } - - for (char& c : v) { - c = static_cast<char>(toupper(c)); +bool cmSystemTools::IsInternallyOn(cm::string_view val) +{ + return (val.size() == 4) && // + (val[0] == 'I' || val[0] == 'i') && // + (val[1] == '_') && // + (val[2] == 'O' || val[2] == 'o') && // + (val[3] == 'N' || val[3] == 'n'); +} + +bool cmSystemTools::IsOn(cm::string_view val) +{ + switch (val.size()) { + case 1: + return val[0] == '1' || val[0] == 'Y' || val[0] == 'y'; + case 2: + return // + (val[0] == 'O' || val[0] == 'o') && // + (val[1] == 'N' || val[1] == 'n'); + case 3: + return // + (val[0] == 'Y' || val[0] == 'y') && // + (val[1] == 'E' || val[1] == 'e') && // + (val[2] == 'S' || val[2] == 's'); + case 4: + return // + (val[0] == 'T' || val[0] == 't') && // + (val[1] == 'R' || val[1] == 'r') && // + (val[2] == 'U' || val[2] == 'u') && // + (val[3] == 'E' || val[3] == 'e'); + default: + break; } - return v == "I_ON"; -} -bool cmSystemTools::IsOn(const char* val) -{ - if (!val) { - return false; - } - /* clang-format off */ - // "1" - if (val[0] == '1' && val[1] == '\0') { - return true; - } - // "ON" - if ((val[0] == 'O' || val[0] == 'o') && - (val[1] == 'N' || val[1] == 'n') && val[2] == '\0') { - return true; - } - // "Y", "YES" - if ((val[0] == 'Y' || val[0] == 'y') && (val[1] == '\0' || ( - (val[1] == 'E' || val[1] == 'e') && - (val[2] == 'S' || val[2] == 's') && val[3] == '\0'))) { - return true; - } - // "TRUE" - if ((val[0] == 'T' || val[0] == 't') && - (val[1] == 'R' || val[1] == 'r') && - (val[2] == 'U' || val[2] == 'u') && - (val[3] == 'E' || val[3] == 'e') && val[4] == '\0') { - return true; - } - /* clang-format on */ return false; } -bool cmSystemTools::IsOn(const std::string& val) +bool cmSystemTools::IsNOTFOUND(cm::string_view val) { - return cmSystemTools::IsOn(val.c_str()); + return (val == "NOTFOUND") || cmHasLiteralSuffix(val, "-NOTFOUND"); } -bool cmSystemTools::IsNOTFOUND(const char* val) +bool cmSystemTools::IsOff(cm::string_view val) { - if (strcmp(val, "NOTFOUND") == 0) { - return true; + switch (val.size()) { + case 0: + return true; + case 1: + return val[0] == '0' || val[0] == 'N' || val[0] == 'n'; + case 2: + return // + (val[0] == 'N' || val[0] == 'n') && // + (val[1] == 'O' || val[1] == 'o'); + case 3: + return // + (val[0] == 'O' || val[0] == 'o') && // + (val[1] == 'F' || val[1] == 'f') && // + (val[2] == 'F' || val[2] == 'f'); + case 5: + return // + (val[0] == 'F' || val[0] == 'f') && // + (val[1] == 'A' || val[1] == 'a') && // + (val[2] == 'L' || val[2] == 'l') && // + (val[3] == 'S' || val[3] == 's') && // + (val[4] == 'E' || val[4] == 'e'); + case 6: + return // + (val[0] == 'I' || val[0] == 'i') && // + (val[1] == 'G' || val[1] == 'g') && // + (val[2] == 'N' || val[2] == 'n') && // + (val[3] == 'O' || val[3] == 'o') && // + (val[4] == 'R' || val[4] == 'r') && // + (val[5] == 'E' || val[5] == 'e'); + default: + break; } - return cmHasLiteralSuffix(val, "-NOTFOUND"); -} -bool cmSystemTools::IsOff(const char* val) -{ - // "" - if (!val || val[0] == '\0') { - return true; - } - /* clang-format off */ - // "0" - if (val[0] == '0' && val[1] == '\0') { - return true; - } - // "OFF" - if ((val[0] == 'O' || val[0] == 'o') && - (val[1] == 'F' || val[1] == 'f') && - (val[2] == 'F' || val[2] == 'f') && val[3] == '\0') { - return true; - } - // "N", "NO" - if ((val[0] == 'N' || val[0] == 'n') && (val[1] == '\0' || ( - (val[1] == 'O' || val[1] == 'o') && val[2] == '\0'))) { - return true; - } - // "FALSE" - if ((val[0] == 'F' || val[0] == 'f') && - (val[1] == 'A' || val[1] == 'a') && - (val[2] == 'L' || val[2] == 'l') && - (val[3] == 'S' || val[3] == 's') && - (val[4] == 'E' || val[4] == 'e') && val[5] == '\0') { - return true; - } - // "IGNORE" - if ((val[0] == 'I' || val[0] == 'i') && - (val[1] == 'G' || val[1] == 'g') && - (val[2] == 'N' || val[2] == 'n') && - (val[3] == 'O' || val[3] == 'o') && - (val[4] == 'R' || val[4] == 'r') && - (val[5] == 'E' || val[5] == 'e') && val[6] == '\0') { - return true; - } - /* clang-format on */ return cmSystemTools::IsNOTFOUND(val); } -bool cmSystemTools::IsOff(const std::string& val) -{ - return cmSystemTools::IsOff(val.c_str()); -} - void cmSystemTools::ParseWindowsCommandLine(const char* command, std::vector<std::string>& args) { @@ -1151,7 +1123,7 @@ void cmSystemTools::GlobDirs(const std::string& path, } } -void cmSystemTools::ExpandListArgument(const std::string& arg, +void cmSystemTools::ExpandListArgument(cm::string_view arg, std::vector<std::string>& argsOut, bool emptyArgs) { @@ -1159,25 +1131,29 @@ void cmSystemTools::ExpandListArgument(const std::string& arg, if (!emptyArgs && arg.empty()) { return; } + // if there are no ; in the name then just copy the current string - if (arg.find(';') == std::string::npos) { - argsOut.push_back(arg); + if (arg.find(';') == cm::string_view::npos) { + argsOut.emplace_back(arg); return; } + std::string newArg; - const char* last = arg.c_str(); // Break the string at non-escaped semicolons not nested in []. int squareNesting = 0; - for (const char* c = last; *c; ++c) { + cm::string_view::iterator last = arg.begin(); + cm::string_view::iterator const cend = arg.end(); + for (cm::string_view::iterator c = last; c != cend; ++c) { switch (*c) { case '\\': { // We only want to allow escaping of semicolons. Other // escapes should not be processed here. - const char* next = c + 1; - if (*next == ';') { - newArg.append(last, c - last); + cm::string_view::iterator cnext = c + 1; + if ((cnext != cend) && *cnext == ';') { + newArg.append(last, c); // Skip over the escape character - last = c = next; + last = cnext; + c = cnext; } } break; case '[': { @@ -1190,7 +1166,7 @@ void cmSystemTools::ExpandListArgument(const std::string& arg, // Break the string here if we are not nested inside square // brackets. if (squareNesting == 0) { - newArg.append(last, c - last); + newArg.append(last, c); // Skip over the semicolon last = c + 1; if (!newArg.empty() || emptyArgs) { @@ -1205,15 +1181,15 @@ void cmSystemTools::ExpandListArgument(const std::string& arg, } break; } } - newArg.append(last); + newArg.append(last, cend); if (!newArg.empty() || emptyArgs) { // Add the last argument if the string is not empty. - argsOut.push_back(newArg); + argsOut.push_back(std::move(newArg)); } } std::vector<std::string> cmSystemTools::ExpandedListArgument( - const std::string& arg, bool emptyArgs) + cm::string_view arg, bool emptyArgs) { std::vector<std::string> argsOut; ExpandListArgument(arg, argsOut, emptyArgs); @@ -2397,7 +2373,8 @@ struct cmSystemToolsRPathInfo #if defined(CMAKE_USE_ELF_PARSER) bool cmSystemTools::ChangeRPath(std::string const& file, std::string const& oldRPath, - std::string const& newRPath, std::string* emsg, + std::string const& newRPath, + bool removeEnvironmentRPath, std::string* emsg, bool* changed) { if (changed) { @@ -2484,7 +2461,9 @@ bool cmSystemTools::ChangeRPath(std::string const& file, // Construct the new value which preserves the part of the path // not being changed. - rp[rp_count].Value = se[i]->Value.substr(0, prefix_len); + if (!removeEnvironmentRPath) { + rp[rp_count].Value = se[i]->Value.substr(0, prefix_len); + } rp[rp_count].Value += newRPath; rp[rp_count].Value += se[i]->Value.substr(pos + oldRPath.length()); @@ -2570,6 +2549,7 @@ bool cmSystemTools::ChangeRPath(std::string const& file, bool cmSystemTools::ChangeRPath(std::string const& /*file*/, std::string const& /*oldRPath*/, std::string const& /*newRPath*/, + bool /*removeEnvironmentRPath*/, std::string* /*emsg*/, bool* /*changed*/) { return false; diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h index a9c03bd..ac1aa80 100644 --- a/Source/cmSystemTools.h +++ b/Source/cmSystemTools.h @@ -8,6 +8,7 @@ #include "cmCryptoHash.h" #include "cmDuration.h" #include "cmProcessOutput.h" +#include "cm_string_view.hxx" #include "cmsys/Process.h" #include "cmsys/SystemTools.hxx" // IWYU pragma: export #include <functional> @@ -31,7 +32,7 @@ public: * Expand the ; separated string @a arg into multiple arguments. * All found arguments are appended to @a argsOut. */ - static void ExpandListArgument(const std::string& arg, + static void ExpandListArgument(cm::string_view arg, std::vector<std::string>& argsOut, bool emptyArgs = false); @@ -53,7 +54,7 @@ public: * Same as ExpandListArgument but a new vector is created containing * the expanded arguments from the string @a arg. */ - static std::vector<std::string> ExpandedListArgument(const std::string& arg, + static std::vector<std::string> ExpandedListArgument(cm::string_view arg, bool emptyArgs = false); /** @@ -77,15 +78,15 @@ public: KeyWOW64 view = KeyWOW64_Default); //! Escape quotes in a string. - static std::string EscapeQuotes(const std::string& str); + static std::string EscapeQuotes(cm::string_view str); /** Map help document name to file name. */ - static std::string HelpFileName(std::string); + static std::string HelpFileName(cm::string_view); /** * Returns a string that has whitespace removed from the start and the end. */ - static std::string TrimWhitespace(const std::string& s); + static std::string TrimWhitespace(cm::string_view str); using MessageCallback = std::function<void(const std::string&, const char*)>; /** @@ -149,26 +150,45 @@ public: * forced this value. This is not the same as On, but this * may be considered as "internally switched on". */ - static bool IsInternallyOn(const char* val); + static bool IsInternallyOn(cm::string_view val); + static inline bool IsInternallyOn(const char* val) + { + if (!val) { + return false; + } + return IsInternallyOn(cm::string_view(val)); + } + /** - * does a string indicate a true or on value ? This is not the same - * as ifdef. + * Does a string indicate a true or on value? This is not the same as ifdef. */ - static bool IsOn(const char* val); - static bool IsOn(const std::string& val); + static bool IsOn(cm::string_view val); + inline static bool IsOn(const char* val) + { + if (!val) { + return false; + } + return IsOn(cm::string_view(val)); + } /** - * does a string indicate a false or off value ? Note that this is + * Does a string indicate a false or off value ? Note that this is * not the same as !IsOn(...) because there are a number of * ambiguous values such as "/usr/local/bin" a path will result in * IsON and IsOff both returning false. Note that the special path * NOTFOUND, *-NOTFOUND or IGNORE will cause IsOff to return true. */ - static bool IsOff(const char* val); - static bool IsOff(const std::string& val); + static bool IsOff(cm::string_view val); + inline static bool IsOff(const char* val) + { + if (!val) { + return true; + } + return IsOff(cm::string_view(val)); + } //! Return true if value is NOTFOUND or ends in -NOTFOUND. - static bool IsNOTFOUND(const char* value); + static bool IsNOTFOUND(cm::string_view val); //! Return true if the path is a framework static bool IsPathToFramework(const std::string& value); @@ -473,6 +493,7 @@ public: /** Try to set the RPATH in an ELF binary. */ static bool ChangeRPath(std::string const& file, std::string const& oldRPath, std::string const& newRPath, + bool removeEnvironmentRPath, std::string* emsg = nullptr, bool* changed = nullptr); diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx index b1a0127..beccfce 100644 --- a/Source/cmTarget.cxx +++ b/Source/cmTarget.cxx @@ -282,6 +282,7 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type, initProp("BUILD_RPATH"); initProp("BUILD_RPATH_USE_ORIGIN"); initProp("INSTALL_NAME_DIR"); + initProp("INSTALL_REMOVE_ENVIRONMENT_RPATH"); initPropValue("INSTALL_RPATH", ""); initPropValue("INSTALL_RPATH_USE_LINK_PATH", "OFF"); initProp("INTERPROCEDURAL_OPTIMIZATION"); diff --git a/Source/cmTarget.h b/Source/cmTarget.h index a808bb4..4e5141b 100644 --- a/Source/cmTarget.h +++ b/Source/cmTarget.h @@ -16,6 +16,7 @@ #include "cmListFileCache.h" #include "cmPolicies.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmTargetLinkLibraryType.h" class cmCustomCommand; diff --git a/Source/cmTargetCompileDefinitionsCommand.cxx b/Source/cmTargetCompileDefinitionsCommand.cxx index c4dc838..b64646a 100644 --- a/Source/cmTargetCompileDefinitionsCommand.cxx +++ b/Source/cmTargetCompileDefinitionsCommand.cxx @@ -4,9 +4,9 @@ #include <sstream> -#include "cmAlgorithms.h" #include "cmMakefile.h" #include "cmMessageType.h" +#include "cmStringAlgorithms.h" #include "cmTarget.h" class cmExecutionStatus; diff --git a/Source/cmTargetCompileFeaturesCommand.cxx b/Source/cmTargetCompileFeaturesCommand.cxx index c9e394b..976c8cb 100644 --- a/Source/cmTargetCompileFeaturesCommand.cxx +++ b/Source/cmTargetCompileFeaturesCommand.cxx @@ -4,9 +4,9 @@ #include <sstream> -#include "cmAlgorithms.h" #include "cmMakefile.h" #include "cmMessageType.h" +#include "cmStringAlgorithms.h" class cmExecutionStatus; class cmTarget; diff --git a/Source/cmTargetCompileOptionsCommand.cxx b/Source/cmTargetCompileOptionsCommand.cxx index 8b4763a..7dadb82 100644 --- a/Source/cmTargetCompileOptionsCommand.cxx +++ b/Source/cmTargetCompileOptionsCommand.cxx @@ -4,10 +4,10 @@ #include <sstream> -#include "cmAlgorithms.h" #include "cmListFileCache.h" #include "cmMakefile.h" #include "cmMessageType.h" +#include "cmStringAlgorithms.h" #include "cmTarget.h" class cmExecutionStatus; diff --git a/Source/cmTargetLinkDirectoriesCommand.cxx b/Source/cmTargetLinkDirectoriesCommand.cxx index 269f751..435c392 100644 --- a/Source/cmTargetLinkDirectoriesCommand.cxx +++ b/Source/cmTargetLinkDirectoriesCommand.cxx @@ -4,11 +4,11 @@ #include <sstream> -#include "cmAlgorithms.h" #include "cmGeneratorExpression.h" #include "cmListFileCache.h" #include "cmMakefile.h" #include "cmMessageType.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" diff --git a/Source/cmTargetLinkOptionsCommand.cxx b/Source/cmTargetLinkOptionsCommand.cxx index 5366486..2866cf1 100644 --- a/Source/cmTargetLinkOptionsCommand.cxx +++ b/Source/cmTargetLinkOptionsCommand.cxx @@ -4,10 +4,10 @@ #include <sstream> -#include "cmAlgorithms.h" #include "cmListFileCache.h" #include "cmMakefile.h" #include "cmMessageType.h" +#include "cmStringAlgorithms.h" #include "cmTarget.h" class cmExecutionStatus; diff --git a/Source/cmTargetPropCommandBase.cxx b/Source/cmTargetPropCommandBase.cxx index 1b8ee81..3aa845c 100644 --- a/Source/cmTargetPropCommandBase.cxx +++ b/Source/cmTargetPropCommandBase.cxx @@ -32,12 +32,13 @@ bool cmTargetPropCommandBase::HandleArguments( this->HandleMissingTarget(args[0]); return false; } - if ((this->Target->GetType() != cmStateEnums::SHARED_LIBRARY) && + if ((this->Target->GetType() != cmStateEnums::EXECUTABLE) && (this->Target->GetType() != cmStateEnums::STATIC_LIBRARY) && - (this->Target->GetType() != cmStateEnums::OBJECT_LIBRARY) && + (this->Target->GetType() != cmStateEnums::SHARED_LIBRARY) && (this->Target->GetType() != cmStateEnums::MODULE_LIBRARY) && + (this->Target->GetType() != cmStateEnums::OBJECT_LIBRARY) && (this->Target->GetType() != cmStateEnums::INTERFACE_LIBRARY) && - (this->Target->GetType() != cmStateEnums::EXECUTABLE)) { + (this->Target->GetType() != cmStateEnums::UNKNOWN_LIBRARY)) { this->SetError("called with non-compilable target type"); return false; } diff --git a/Source/cmTargetPropertyComputer.cxx b/Source/cmTargetPropertyComputer.cxx index eac300f..baab8da 100644 --- a/Source/cmTargetPropertyComputer.cxx +++ b/Source/cmTargetPropertyComputer.cxx @@ -11,6 +11,7 @@ #include "cmMessenger.h" #include "cmPolicies.h" #include "cmStateSnapshot.h" +#include "cmStringAlgorithms.h" bool cmTargetPropertyComputer::HandleLocationPropertyPolicy( std::string const& tgtName, cmMessenger* messenger, diff --git a/Source/cmTargetPropertyComputer.h b/Source/cmTargetPropertyComputer.h index efbf95f..3b11acd 100644 --- a/Source/cmTargetPropertyComputer.h +++ b/Source/cmTargetPropertyComputer.h @@ -7,9 +7,9 @@ #include <string> -#include "cmAlgorithms.h" #include "cmListFileCache.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" class cmMessenger; diff --git a/Source/cmTargetSourcesCommand.cxx b/Source/cmTargetSourcesCommand.cxx index 11e288f..eb5f37c 100644 --- a/Source/cmTargetSourcesCommand.cxx +++ b/Source/cmTargetSourcesCommand.cxx @@ -4,11 +4,11 @@ #include <sstream> -#include "cmAlgorithms.h" #include "cmGeneratorExpression.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmPolicies.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx index a92c2a0..ed944ac 100644 --- a/Source/cmTryRunCommand.cxx +++ b/Source/cmTryRunCommand.cxx @@ -137,7 +137,7 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv, // now put the output into the variables if (!this->RunOutputVariable.empty()) { this->Makefile->AddDefinition(this->RunOutputVariable, - runOutputContents.c_str()); + runOutputContents); } if (!this->OutputVariable.empty()) { @@ -148,8 +148,7 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv, if (compileOutput) { runOutputContents = compileOutput + runOutputContents; } - this->Makefile->AddDefinition(this->OutputVariable, - runOutputContents.c_str()); + this->Makefile->AddDefinition(this->OutputVariable, runOutputContents); } } } diff --git a/Source/cmUnexpectedCommand.cxx b/Source/cmUnexpectedCommand.cxx deleted file mode 100644 index a8de9e6..0000000 --- a/Source/cmUnexpectedCommand.cxx +++ /dev/null @@ -1,22 +0,0 @@ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ -#include "cmUnexpectedCommand.h" - -#include <stdlib.h> - -#include "cmMakefile.h" - -class cmExecutionStatus; - -bool cmUnexpectedCommand::InitialPass(std::vector<std::string> const&, - cmExecutionStatus&) -{ - const char* versionValue = - this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION"); - if (this->Name == "endif" && (!versionValue || atof(versionValue) <= 1.4)) { - return true; - } - - this->SetError(this->Error); - return false; -} diff --git a/Source/cmUnexpectedCommand.h b/Source/cmUnexpectedCommand.h deleted file mode 100644 index 6e4cee5..0000000 --- a/Source/cmUnexpectedCommand.h +++ /dev/null @@ -1,40 +0,0 @@ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ -#ifndef cmUnexpectedCommand_h -#define cmUnexpectedCommand_h - -#include "cmConfigure.h" // IWYU pragma: keep - -#include <string> -#include <utility> -#include <vector> - -#include "cm_memory.hxx" - -#include "cmCommand.h" - -class cmExecutionStatus; - -class cmUnexpectedCommand : public cmCommand -{ -public: - cmUnexpectedCommand(std::string name, const char* error) - : Name(std::move(name)) - , Error(error) - { - } - - std::unique_ptr<cmCommand> Clone() override - { - return cm::make_unique<cmUnexpectedCommand>(this->Name, this->Error); - } - - bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status) override; - -private: - std::string Name; - const char* Error; -}; - -#endif diff --git a/Source/cmUnsetCommand.cxx b/Source/cmUnsetCommand.cxx index cfaa1fd2..0e903c7 100644 --- a/Source/cmUnsetCommand.cxx +++ b/Source/cmUnsetCommand.cxx @@ -2,8 +2,8 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmUnsetCommand.h" -#include "cmAlgorithms.h" #include "cmMakefile.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" class cmExecutionStatus; diff --git a/Source/cmVariableRequiresCommand.cxx b/Source/cmVariableRequiresCommand.cxx index c02157a..9878ff1 100644 --- a/Source/cmVariableRequiresCommand.cxx +++ b/Source/cmVariableRequiresCommand.cxx @@ -42,7 +42,7 @@ bool cmVariableRequiresCommand::InitialPass( // if reqVar is set to true, but requirementsMet is false , then // set reqVar to false. if (!reqVar || (!requirementsMet && this->Makefile->IsOn(reqVar))) { - this->Makefile->AddDefinition(resultVariable, requirementsMet); + this->Makefile->AddDefinitionBool(resultVariable, requirementsMet); } if (!requirementsMet) { diff --git a/Source/cmVariableWatchCommand.cxx b/Source/cmVariableWatchCommand.cxx index afc0b76..83a774d 100644 --- a/Source/cmVariableWatchCommand.cxx +++ b/Source/cmVariableWatchCommand.cxx @@ -55,7 +55,7 @@ static void cmVariableWatchCommandVariableAccessed(const std::string& variable, newLFF.Arguments.emplace_back(stack, cmListFileArgument::Quoted, 9999); newLFF.Name = data->Command; newLFF.Line = 9999; - cmExecutionStatus status; + cmExecutionStatus status(*makefile); if (!makefile->ExecuteCommand(newLFF, status)) { std::ostringstream error; error << "Error in cmake code at\nUnknown:0:\n" diff --git a/Source/cmWhileCommand.cxx b/Source/cmWhileCommand.cxx index a902964..37d1c74 100644 --- a/Source/cmWhileCommand.cxx +++ b/Source/cmWhileCommand.cxx @@ -11,6 +11,7 @@ #include "cmMessageType.h" #include "cmSystemTools.h" +#include <string> #include <utility> cmWhileFunctionBlocker::cmWhileFunctionBlocker(cmMakefile* mf) @@ -82,7 +83,7 @@ bool cmWhileFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff, // Invoke all the functions that were collected in the block. for (cmListFileFunction const& fn : this->Functions) { - cmExecutionStatus status; + cmExecutionStatus status(mf); mf.ExecuteCommand(fn, status); if (status.GetReturnInvoked()) { inStatus.SetReturnInvoked(); @@ -129,19 +130,20 @@ bool cmWhileFunctionBlocker::ShouldRemove(const cmListFileFunction& lff, return false; } -bool cmWhileCommand::InvokeInitialPass( - const std::vector<cmListFileArgument>& args, cmExecutionStatus&) +bool cmWhileCommand(std::vector<cmListFileArgument> const& args, + cmExecutionStatus& status) { if (args.empty()) { - this->SetError("called with incorrect number of arguments"); + status.SetError("called with incorrect number of arguments"); return false; } // create a function blocker { - auto fb = cm::make_unique<cmWhileFunctionBlocker>(this->Makefile); + cmMakefile& makefile = status.GetMakefile(); + auto fb = cm::make_unique<cmWhileFunctionBlocker>(&makefile); fb->Args = args; - this->Makefile->AddFunctionBlocker(std::move(fb)); + makefile.AddFunctionBlocker(std::move(fb)); } return true; } diff --git a/Source/cmWhileCommand.h b/Source/cmWhileCommand.h index 857d1c8..2257799 100644 --- a/Source/cmWhileCommand.h +++ b/Source/cmWhileCommand.h @@ -5,12 +5,8 @@ #include "cmConfigure.h" // IWYU pragma: keep -#include <string> #include <vector> -#include "cm_memory.hxx" - -#include "cmCommand.h" #include "cmFunctionBlocker.h" #include "cmListFileCache.h" @@ -35,33 +31,7 @@ private: }; /// \brief Starts a while loop -class cmWhileCommand : public cmCommand -{ -public: - /** - * This is a virtual constructor for the command. - */ - std::unique_ptr<cmCommand> Clone() override - { - return cm::make_unique<cmWhileCommand>(); - } - - /** - * This overrides the default InvokeInitialPass implementation. - * It records the arguments before expansion. - */ - bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, - cmExecutionStatus&) override; - - /** - * This is called when the command is first encountered in - * the CMakeLists.txt file. - */ - bool InitialPass(std::vector<std::string> const&, - cmExecutionStatus&) override - { - return false; - } -}; +bool cmWhileCommand(std::vector<cmListFileArgument> const& args, + cmExecutionStatus& status); #endif diff --git a/Source/cmake.cxx b/Source/cmake.cxx index 7250e51..3b4a6c0 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -21,6 +21,7 @@ #include "cmMessenger.h" #include "cmState.h" #include "cmStateDirectory.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmTargetLinkLibraryType.h" diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx index cfb3cee..10a6825 100644 --- a/Source/cmakemain.cxx +++ b/Source/cmakemain.cxx @@ -7,6 +7,7 @@ #include "cmMakefile.h" #include "cmState.h" #include "cmStateTypes.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmake.h" #include "cmcmd.h" diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx index 503dce1..aecc978 100644 --- a/Source/cmcmd.cxx +++ b/Source/cmcmd.cxx @@ -13,6 +13,7 @@ #include "cmState.h" #include "cmStateDirectory.h" #include "cmStateSnapshot.h" +#include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmUtils.hxx" #include "cmVersion.h" diff --git a/Source/kwsys/CommandLineArguments.cxx b/Source/kwsys/CommandLineArguments.cxx index a97f7a8..dc9f01d 100644 --- a/Source/kwsys/CommandLineArguments.cxx +++ b/Source/kwsys/CommandLineArguments.cxx @@ -67,10 +67,10 @@ class CommandLineArgumentsInternal { public: CommandLineArgumentsInternal() + : UnknownArgumentCallback{ KWSYS_NULLPTR } + , ClientData{ KWSYS_NULLPTR } + , LastArgument{ 0 } { - this->UnknownArgumentCallback = KWSYS_NULLPTR; - this->ClientData = KWSYS_NULLPTR; - this->LastArgument = 0; } typedef CommandLineArgumentsVectorOfStrings VectorOfStrings; diff --git a/Source/kwsys/RegularExpression.cxx b/Source/kwsys/RegularExpression.cxx index 5f84b19..3e10765 100644 --- a/Source/kwsys/RegularExpression.cxx +++ b/Source/kwsys/RegularExpression.cxx @@ -337,7 +337,6 @@ bool RegularExpression::compile(const char* exp) { const char* scan; const char* longest; - size_t len; int flags; if (exp == KWSYS_NULLPTR) { @@ -412,7 +411,7 @@ bool RegularExpression::compile(const char* exp) // if (flags & SPSTART) { longest = KWSYS_NULLPTR; - len = 0; + size_t len = 0; for (; scan != KWSYS_NULLPTR; scan = regnext(scan)) if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) { longest = OPERAND(scan); diff --git a/Source/kwsys/RegularExpression.hxx.in b/Source/kwsys/RegularExpression.hxx.in index b7b93f9..ed86418 100644 --- a/Source/kwsys/RegularExpression.hxx.in +++ b/Source/kwsys/RegularExpression.hxx.in @@ -407,8 +407,12 @@ private: * Create an empty regular expression. */ inline RegularExpression::RegularExpression() + : regstart{} + , reganch{} + , regmust{} + , program{ 0 } + , progsize{} { - this->program = 0; } /** @@ -416,8 +420,12 @@ inline RegularExpression::RegularExpression() * compiles s. */ inline RegularExpression::RegularExpression(const char* s) + : regstart{} + , reganch{} + , regmust{} + , program{ 0 } + , progsize{} { - this->program = 0; if (s) { this->compile(s); } @@ -428,8 +436,12 @@ inline RegularExpression::RegularExpression(const char* s) * compiles s. */ inline RegularExpression::RegularExpression(const std::string& s) + : regstart{} + , reganch{} + , regmust{} + , program{ 0 } + , progsize{} { - this->program = 0; this->compile(s); } diff --git a/Source/kwsys/SystemTools.cxx b/Source/kwsys/SystemTools.cxx index 2135913..36f24c7 100644 --- a/Source/kwsys/SystemTools.cxx +++ b/Source/kwsys/SystemTools.cxx @@ -3394,15 +3394,16 @@ static void SystemToolsAppendComponents( static const std::string cur = "."; for (std::vector<std::string>::const_iterator i = first; i != last; ++i) { if (*i == up) { - if (out_components.size() > 1) { + // Remove the previous component if possible. Ignore ../ components + // that try to go above the root. Keep ../ components if they are + // at the beginning of a relative path (base path is relative). + if (out_components.size() > 1 && out_components.back() != up) { out_components.resize(out_components.size() - 1); + } else if (!out_components.empty() && out_components[0].empty()) { + out_components.emplace_back(std::move(*i)); } } else if (!i->empty() && *i != cur) { -#if __cplusplus >= 201103L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201103L) - out_components.push_back(std::move(*i)); -#else - out_components.push_back(*i); -#endif + out_components.emplace_back(std::move(*i)); } } } @@ -4738,7 +4739,7 @@ void SystemTools::ClassInitialize() // Test progressively shorter logical-to-physical mappings. std::string cwd_str = cwd; std::string pwd_path; - Realpath(pwd_str.c_str(), pwd_path); + Realpath(pwd_str, pwd_path); while (cwd_str == pwd_path && cwd_str != pwd_str) { // The current pair of paths is a working logical mapping. cwd_changed = cwd_str; @@ -4748,7 +4749,7 @@ void SystemTools::ClassInitialize() // mapping still works. pwd_str = SystemTools::GetFilenamePath(pwd_str); cwd_str = SystemTools::GetFilenamePath(cwd_str); - Realpath(pwd_str.c_str(), pwd_path); + Realpath(pwd_str, pwd_path); } // Add the translation to keep the logical path name. diff --git a/Source/kwsys/testSystemTools.cxx b/Source/kwsys/testSystemTools.cxx index 9a40b53..ffa6a29 100644 --- a/Source/kwsys/testSystemTools.cxx +++ b/Source/kwsys/testSystemTools.cxx @@ -684,9 +684,10 @@ static bool CheckRelativePaths() } static bool CheckCollapsePath(const std::string& path, - const std::string& expected) + const std::string& expected, + const char* base = nullptr) { - std::string result = kwsys::SystemTools::CollapseFullPath(path); + std::string result = kwsys::SystemTools::CollapseFullPath(path, base); if (!kwsys::SystemTools::ComparePath(expected, result)) { std::cerr << "CollapseFullPath(" << path << ") yielded " << result << " instead of " << expected << std::endl; @@ -710,6 +711,9 @@ static bool CheckCollapsePath() res &= CheckCollapsePath("C:/", "C:/"); res &= CheckCollapsePath("C:/../", "C:/"); res &= CheckCollapsePath("C:/../../", "C:/"); + res &= CheckCollapsePath("../b", "../../b", "../"); + res &= CheckCollapsePath("../a/../b", "../b", "../rel"); + res &= CheckCollapsePath("a/../b", "../rel/b", "../rel"); return res; } diff --git a/Tests/AliasTarget/CMakeLists.txt b/Tests/AliasTarget/CMakeLists.txt index 6271988..fc70135 100644 --- a/Tests/AliasTarget/CMakeLists.txt +++ b/Tests/AliasTarget/CMakeLists.txt @@ -7,7 +7,7 @@ set(CMAKE_CXX_STANDARD 98) # Clang/C2 in C++98 mode cannot properly handle some of MSVC headers if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC") - set(CMAKE_CXX_STANDARD 14) + set(CMAKE_CXX_STANDARD 11) endif() add_library(foo SHARED empty.cpp) diff --git a/Tests/CMakeOnly/CheckCXXSymbolExists/CMakeLists.txt b/Tests/CMakeOnly/CheckCXXSymbolExists/CMakeLists.txt index f058c19..2028a13 100644 --- a/Tests/CMakeOnly/CheckCXXSymbolExists/CMakeLists.txt +++ b/Tests/CMakeOnly/CheckCXXSymbolExists/CMakeLists.txt @@ -49,6 +49,15 @@ else () message(STATUS "errno found in <cerrno>") endif () +check_cxx_symbol_exists("std::fopen" "cstdio" CSE_RESULT_FOPEN) +if (NOT CSE_RESULT_FOPEN) + if(NOT ("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.10)) + message(SEND_ERROR "CheckCXXSymbolExists did not find std::fopen in <cstdio>") + endif() +else() + message(STATUS "std::fopen found in <cstdio>") +endif() + if (CMAKE_COMPILER_IS_GNUCXX) string(APPEND CMAKE_CXX_FLAGS " -O3") unset(CSE_RESULT_O3 CACHE) @@ -60,3 +69,8 @@ if (CMAKE_COMPILER_IS_GNUCXX) message(SEND_ERROR "CheckCXXSymbolExists reported a nonexistent symbol as existing with optimization -O3") endif () endif () + +check_cxx_symbol_exists("std::non_existent_function_for_symbol_test<int*>" "algorithm" CSE_RESULT_NON_SYMBOL) +if (CSE_RESULT_NON_SYMBOL) + message(SEND_ERROR "CheckCXXSymbolExists reported a nonexistent symbol.") +endif() diff --git a/Tests/CMakeTests/ELFTest.cmake.in b/Tests/CMakeTests/ELFTest.cmake.in index 4635778..85c2360 100644 --- a/Tests/CMakeTests/ELFTest.cmake.in +++ b/Tests/CMakeTests/ELFTest.cmake.in @@ -25,13 +25,38 @@ foreach(f ${files}) # Change the RPATH. file(RPATH_CHANGE FILE "${f}" OLD_RPATH "/sample/rpath" - NEW_RPATH "/rpath/sample") + NEW_RPATH "/path1:/path2") set(rpath) - file(STRINGS "${f}" rpath REGEX "/rpath/sample" LIMIT_COUNT 1) + file(STRINGS "${f}" rpath REGEX "/path1:/path2" LIMIT_COUNT 1) if(NOT rpath) message(FATAL_ERROR "RPATH not changed in ${f}") endif() + # Change the RPATH without compiler defined rpath removed + file(RPATH_CHANGE FILE "${f}" + OLD_RPATH "/path2" + NEW_RPATH "/path3") + set(rpath) + file(STRINGS "${f}" rpath REGEX "/path1:/path3" LIMIT_COUNT 1) + if(NOT rpath) + message(FATAL_ERROR "RPATH not updated in ${f}") + endif() + + # Change the RPATH with compiler defined rpath removed + file(RPATH_CHANGE FILE "${f}" + OLD_RPATH "/path3" + NEW_RPATH "/rpath/sample" + INSTALL_REMOVE_ENVIRONMENT_RPATH) + set(rpath) + file(STRINGS "${f}" rpath REGEX "/rpath/sample" LIMIT_COUNT 1) + if(NOT rpath) + message(FATAL_ERROR "RPATH not updated in ${f}") + endif() + file(STRINGS "${f}" rpath REGEX "/path1" LIMIT_COUNT 1) + if(rpath) + message(FATAL_ERROR "RPATH not removed in ${f}") + endif() + # Remove the RPATH. file(RPATH_REMOVE FILE "${f}") set(rpath) diff --git a/Tests/Complex/CMakeLists.txt b/Tests/Complex/CMakeLists.txt index fef83f6..2e41754 100644 --- a/Tests/Complex/CMakeLists.txt +++ b/Tests/Complex/CMakeLists.txt @@ -446,11 +446,6 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND set(CMAKE_CXX_STANDARD 11) endif() -if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND - CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU") - set(CMAKE_CXX_STANDARD 14) -endif() - # # Create the libs and the main exe # diff --git a/Tests/ComplexOneConfig/CMakeLists.txt b/Tests/ComplexOneConfig/CMakeLists.txt index 77baa4c..628cd4e 100644 --- a/Tests/ComplexOneConfig/CMakeLists.txt +++ b/Tests/ComplexOneConfig/CMakeLists.txt @@ -403,11 +403,6 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND set(CMAKE_CXX_STANDARD 11) endif() -if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND - CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU") - set(CMAKE_CXX_STANDARD 14) -endif() - # # Create the libs and the main exe # diff --git a/Tests/ExternalProject/CMakeLists.txt b/Tests/ExternalProject/CMakeLists.txt index 5adcbd9..093391e 100644 --- a/Tests/ExternalProject/CMakeLists.txt +++ b/Tests/ExternalProject/CMakeLists.txt @@ -421,7 +421,7 @@ if(do_git_tests) set(local_git_repo "../../LocalRepositories/GIT-with-submodules") - set(proj TS1-GIT-no-GIT_SUBMODULES) + set(proj TS1-GIT-all-GIT_SUBMODULES) ExternalProject_Add(${proj} GIT_REPOSITORY "${local_git_repo}" CMAKE_GENERATOR "${CMAKE_GENERATOR}" @@ -435,7 +435,8 @@ if(do_git_tests) ) set_property(TARGET ${proj} PROPERTY FOLDER "GIT") - set(proj TS1-GIT-empty-GIT_SUBMODULES) + set(proj TS1-GIT-all-GIT_SUBMODULES-via-CMP0097-OLD) + cmake_policy(SET CMP0097 OLD) ExternalProject_Add(${proj} GIT_REPOSITORY "${local_git_repo}" GIT_SUBMODULES "" @@ -450,6 +451,22 @@ if(do_git_tests) ) set_property(TARGET ${proj} PROPERTY FOLDER "GIT") + set(proj TS1-GIT-no-GIT_SUBMODULES) + cmake_policy(SET CMP0097 NEW) + ExternalProject_Add(${proj} + GIT_REPOSITORY "${local_git_repo}" + GIT_SUBMODULES "" + CMAKE_GENERATOR "${CMAKE_GENERATOR}" + CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR> + -DWITH_m1:BOOL=OFF + -DWITH_m2:BOOL=OFF + BUILD_COMMAND "" + INSTALL_COMMAND "" + DEPENDS "SetupLocalGITRepository" + "SetupLocalGITRepositoryWithSubmodules" + ) + set_property(TARGET ${proj} PROPERTY FOLDER "GIT") + set(proj TS1-GIT-some-GIT_SUBMODULES) ExternalProject_Add(${proj} GIT_REPOSITORY "${local_git_repo}" diff --git a/Tests/MathTest/CMakeLists.txt b/Tests/MathTest/CMakeLists.txt index 5403d29..396f633 100644 --- a/Tests/MathTest/CMakeLists.txt +++ b/Tests/MathTest/CMakeLists.txt @@ -16,6 +16,8 @@ set(expressions "1000 -12*5" "1000 +12*-5" "1000 -12*-5" + "~~1" + "1000 & ~0" ) set(FILE_EXPRESSIONS "extern void test_expression(int x, int y, const char * text);\n") diff --git a/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt b/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt index b30928d..cffef5a 100644 --- a/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt +++ b/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt @@ -133,9 +133,7 @@ endif() # for msvc the compiler version determines which c++11 features are available. if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" - OR (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" - AND "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC" - AND "x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xMSVC" )) + OR (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")) if(";${CMAKE_CXX_COMPILE_FEATURES};" MATCHES ";cxx_delegating_constructors;") list(APPEND true_defs EXPECTED_COMPILER_CXX_DELEGATING_CONSTRUCTORS) list(APPEND true_defs EXPECTED_COMPILER_CXX_VARIADIC_TEMPLATES) diff --git a/Tests/Plugin/CMakeLists.txt b/Tests/Plugin/CMakeLists.txt index c4540db..8e8fa07 100644 --- a/Tests/Plugin/CMakeLists.txt +++ b/Tests/Plugin/CMakeLists.txt @@ -5,17 +5,6 @@ project(Plugin) # We need proper C++98 support from the compiler set(CMAKE_CXX_STANDARD 98) -# Clang/C2 in C++98 mode cannot properly handle some of MSVC headers -if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND - CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC") - set(CMAKE_CXX_STANDARD 11) -endif() - -if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND - CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU") - set(CMAKE_CXX_STANDARD 14) -endif() - # Test per-target output directory properties. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${Plugin_BINARY_DIR}/bin) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${Plugin_BINARY_DIR}/lib/plugin) @@ -40,6 +29,12 @@ include_directories( ${Plugin_SOURCE_DIR}/include ) +# Clang/C2 in C++98 mode cannot properly handle some of MSVC headers +if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND + CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC") + set(CMAKE_CXX_STANDARD 11) +endif() + # Create an executable that exports an API for use by plugins. add_executable(example_exe src/example_exe.cxx) set_target_properties(example_exe PROPERTIES diff --git a/Tests/RunCMake/Android/common.cmake b/Tests/RunCMake/Android/common.cmake index aaa7c89..d96ab86 100644 --- a/Tests/RunCMake/Android/common.cmake +++ b/Tests/RunCMake/Android/common.cmake @@ -6,8 +6,6 @@ if(NOT ANDROID) endif() foreach(f - "${CMAKE_C_ANDROID_TOOLCHAIN_PREFIX}gcc${CMAKE_C_ANDROID_TOOLCHAIN_SUFFIX}" - "${CMAKE_CXX_ANDROID_TOOLCHAIN_PREFIX}g++${CMAKE_CXX_ANDROID_TOOLCHAIN_SUFFIX}" "${CMAKE_CXX_ANDROID_TOOLCHAIN_PREFIX}ar${CMAKE_CXX_ANDROID_TOOLCHAIN_SUFFIX}" "${CMAKE_CXX_ANDROID_TOOLCHAIN_PREFIX}ld${CMAKE_CXX_ANDROID_TOOLCHAIN_SUFFIX}" ) @@ -51,23 +49,26 @@ elseif(CMAKE_ANDROID_STANDALONE_TOOLCHAIN) endif() endif() -execute_process( - COMMAND "${CMAKE_C_ANDROID_TOOLCHAIN_PREFIX}gcc${CMAKE_C_ANDROID_TOOLCHAIN_SUFFIX}" -dumpmachine - OUTPUT_VARIABLE _out OUTPUT_STRIP_TRAILING_WHITESPACE - ERROR_VARIABLE _err - RESULT_VARIABLE _res - ) -if(NOT _res EQUAL 0) - message(SEND_ERROR "Failed to run 'gcc -dumpmachine':\n ${_res}") -endif() -string(REPLACE "--" "-" _out_check "${_out}") -if(NOT _out_check STREQUAL "${CMAKE_C_ANDROID_TOOLCHAIN_MACHINE}" - AND NOT (_out STREQUAL "arm--linux-android" AND CMAKE_C_ANDROID_TOOLCHAIN_MACHINE STREQUAL "arm-linux-androideabi")) - message(SEND_ERROR "'gcc -dumpmachine' produced:\n" - " ${_out}\n" - "which does not match CMAKE_C_ANDROID_TOOLCHAIN_MACHINE:\n" - " ${CMAKE_C_ANDROID_TOOLCHAIN_MACHINE}" +set(gcc ${CMAKE_C_ANDROID_TOOLCHAIN_PREFIX}gcc${CMAKE_C_ANDROID_TOOLCHAIN_SUFFIX}) +if(EXISTS "${gcc}") + execute_process( + COMMAND "${CMAKE_C_ANDROID_TOOLCHAIN_PREFIX}gcc${CMAKE_C_ANDROID_TOOLCHAIN_SUFFIX}" -dumpmachine + OUTPUT_VARIABLE _out OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_VARIABLE _err + RESULT_VARIABLE _res ) + if(NOT _res EQUAL 0) + message(SEND_ERROR "Failed to run 'gcc -dumpmachine':\n ${_res}") + endif() + string(REPLACE "--" "-" _out_check "${_out}") + if(NOT _out_check STREQUAL "${CMAKE_C_ANDROID_TOOLCHAIN_MACHINE}" + AND NOT (_out STREQUAL "arm--linux-android" AND CMAKE_C_ANDROID_TOOLCHAIN_MACHINE STREQUAL "arm-linux-androideabi")) + message(SEND_ERROR "'gcc -dumpmachine' produced:\n" + " ${_out}\n" + "which does not match CMAKE_C_ANDROID_TOOLCHAIN_MACHINE:\n" + " ${CMAKE_C_ANDROID_TOOLCHAIN_MACHINE}" + ) + endif() endif() if(CMAKE_ANDROID_STL_TYPE STREQUAL "none") diff --git a/Tests/RunCMake/Android/ndk-arm64-v8a-stdout.txt b/Tests/RunCMake/Android/ndk-arm64-v8a-stdout.txt index 8d0bdc2..a228ccc 100644 --- a/Tests/RunCMake/Android/ndk-arm64-v8a-stdout.txt +++ b/Tests/RunCMake/Android/ndk-arm64-v8a-stdout.txt @@ -1,2 +1,2 @@ -- Android: Targeting API '[0-9]+' with architecture 'arm64', ABI 'arm64-v8a', and processor 'aarch64' --- Android: Selected (Clang toolchain '[^']+' with )?GCC toolchain '[^']+' +-- Android: Selected (unified Clang toolchain|(Clang toolchain '[^']+' with )?GCC toolchain '[^']+') diff --git a/Tests/RunCMake/Android/ndk-armeabi-arm-stdout.txt b/Tests/RunCMake/Android/ndk-armeabi-arm-stdout.txt index 3741da3..72ec00e 100644 --- a/Tests/RunCMake/Android/ndk-armeabi-arm-stdout.txt +++ b/Tests/RunCMake/Android/ndk-armeabi-arm-stdout.txt @@ -1,3 +1,3 @@ -- Android: Targeting API '[0-9]+' with architecture 'arm', ABI 'armeabi', and processor 'armv5te' --- Android: Selected (Clang toolchain '[^']+' with )?GCC toolchain '[^']+' +-- Android: Selected (unified Clang toolchain|(Clang toolchain '[^']+' with )?GCC toolchain '[^']+') .*-- CMAKE_ANDROID_ARM_MODE=1 diff --git a/Tests/RunCMake/Android/ndk-armeabi-v7a-neon-stdout.txt b/Tests/RunCMake/Android/ndk-armeabi-v7a-neon-stdout.txt index ac2bfd5..8bd87fa 100644 --- a/Tests/RunCMake/Android/ndk-armeabi-v7a-neon-stdout.txt +++ b/Tests/RunCMake/Android/ndk-armeabi-v7a-neon-stdout.txt @@ -1,3 +1,3 @@ -- Android: Targeting API '[0-9]+' with architecture 'arm', ABI 'armeabi-v7a', and processor 'armv7-a' --- Android: Selected (Clang toolchain '[^']+' with )?GCC toolchain '[^']+' +-- Android: Selected (unified Clang toolchain|(Clang toolchain '[^']+' with )?GCC toolchain '[^']+') .*-- CMAKE_ANDROID_ARM_NEON=1 diff --git a/Tests/RunCMake/Android/ndk-armeabi-v7a-stdout.txt b/Tests/RunCMake/Android/ndk-armeabi-v7a-stdout.txt index 0edb4f7..554548e 100644 --- a/Tests/RunCMake/Android/ndk-armeabi-v7a-stdout.txt +++ b/Tests/RunCMake/Android/ndk-armeabi-v7a-stdout.txt @@ -1,3 +1,3 @@ -- Android: Targeting API '[0-9]+' with architecture 'arm', ABI 'armeabi-v7a', and processor 'armv7-a' --- Android: Selected (Clang toolchain '[^']+' with )?GCC toolchain '[^']+' +-- Android: Selected (unified Clang toolchain|(Clang toolchain '[^']+' with )?GCC toolchain '[^']+') .*-- CMAKE_ANDROID_ARM_NEON=0 diff --git a/Tests/RunCMake/Android/ndk-badver-stderr.txt b/Tests/RunCMake/Android/ndk-badver-stderr.txt index df2c5e6..ce6bc4e 100644 --- a/Tests/RunCMake/Android/ndk-badver-stderr.txt +++ b/Tests/RunCMake/Android/ndk-badver-stderr.txt @@ -1,11 +1,12 @@ ^CMake Error at .*/Modules/Platform/Android/Determine-Compiler-NDK.cmake:[0-9]+ \(message\): - Android: The CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION value 'badver' is not one + Android: The CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION value 'badver' is not( + supported by this NDK. It must be 'clang' or not set at all\.| one of the allowed forms: <major>.<minor> = GCC of specified version clang<major>.<minor> = Clang of specified version clang = Clang of most recent available version - +) Call Stack \(most recent call first\): .* ndk-badver.cmake:1 \(enable_language\) diff --git a/Tests/RunCMake/Android/ndk-badvernum-stderr.txt b/Tests/RunCMake/Android/ndk-badvernum-stderr.txt index adacaf1..aec91d9 100644 --- a/Tests/RunCMake/Android/ndk-badvernum-stderr.txt +++ b/Tests/RunCMake/Android/ndk-badvernum-stderr.txt @@ -1,4 +1,6 @@ -^CMake Error at .*/Modules/Platform/Android/Determine-Compiler-NDK.cmake:[0-9]+ \(message\): +^CMake Error at .*/Modules/Platform/Android/Determine-Compiler-NDK.cmake:[0-9]+ \(message\):( + Android: The CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION value '1.0' is not + supported by this NDK. It must be 'clang' or not set at all.| Android: No toolchain for ABI 'armeabi(-v7a)?' found in the NDK: .* @@ -6,7 +8,7 @@ of the version specified by CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION: 1\.0 - +) Call Stack \(most recent call first\): .* ndk-badvernum.cmake:1 \(enable_language\) diff --git a/Tests/RunCMake/Android/ndk-mips-stdout.txt b/Tests/RunCMake/Android/ndk-mips-stdout.txt index c744683..8ce544d 100644 --- a/Tests/RunCMake/Android/ndk-mips-stdout.txt +++ b/Tests/RunCMake/Android/ndk-mips-stdout.txt @@ -1,2 +1,2 @@ -- Android: Targeting API '[0-9]+' with architecture 'mips', ABI 'mips', and processor 'mips' --- Android: Selected (Clang toolchain '[^']+' with )?GCC toolchain '[^']+' +-- Android: Selected (unified Clang toolchain|(Clang toolchain '[^']+' with )?GCC toolchain '[^']+') diff --git a/Tests/RunCMake/Android/ndk-mips64-stdout.txt b/Tests/RunCMake/Android/ndk-mips64-stdout.txt index 839ddfd..1d7edea 100644 --- a/Tests/RunCMake/Android/ndk-mips64-stdout.txt +++ b/Tests/RunCMake/Android/ndk-mips64-stdout.txt @@ -1,2 +1,2 @@ -- Android: Targeting API '[0-9]+' with architecture 'mips64', ABI 'mips64', and processor 'mips64' --- Android: Selected (Clang toolchain '[^']+' with )?GCC toolchain '[^']+' +-- Android: Selected (unified Clang toolchain|(Clang toolchain '[^']+' with )?GCC toolchain '[^']+') diff --git a/Tests/RunCMake/Android/ndk-x86-stdout.txt b/Tests/RunCMake/Android/ndk-x86-stdout.txt index 2dbb2f0..8d710fe 100644 --- a/Tests/RunCMake/Android/ndk-x86-stdout.txt +++ b/Tests/RunCMake/Android/ndk-x86-stdout.txt @@ -1,2 +1,2 @@ -- Android: Targeting API '[0-9]+' with architecture 'x86', ABI 'x86', and processor 'i686' --- Android: Selected (Clang toolchain '[^']+' with )?GCC toolchain '[^']+' +-- Android: Selected (unified Clang toolchain|(Clang toolchain '[^']+' with )?GCC toolchain '[^']+') diff --git a/Tests/RunCMake/Android/ndk-x86_64-stdout.txt b/Tests/RunCMake/Android/ndk-x86_64-stdout.txt index a7ae91d..695a088 100644 --- a/Tests/RunCMake/Android/ndk-x86_64-stdout.txt +++ b/Tests/RunCMake/Android/ndk-x86_64-stdout.txt @@ -1,2 +1,2 @@ -- Android: Targeting API '[0-9]+' with architecture 'x86_64', ABI 'x86_64', and processor 'x86_64' --- Android: Selected (Clang toolchain '[^']+' with )?GCC toolchain '[^']+' +-- Android: Selected (unified Clang toolchain|(Clang toolchain '[^']+' with )?GCC toolchain '[^']+') diff --git a/Tests/RunCMake/BuildDepends/BuildUnderSource.c b/Tests/RunCMake/BuildDepends/BuildUnderSource.c new file mode 100644 index 0000000..688a040 --- /dev/null +++ b/Tests/RunCMake/BuildDepends/BuildUnderSource.c @@ -0,0 +1,5 @@ +#include "BuildUnderSource.h" +int main(void) +{ + return BUILD_UNDER_SOURCE; +} diff --git a/Tests/RunCMake/BuildDepends/BuildUnderSource.cmake b/Tests/RunCMake/BuildDepends/BuildUnderSource.cmake new file mode 100644 index 0000000..aa2a44f --- /dev/null +++ b/Tests/RunCMake/BuildDepends/BuildUnderSource.cmake @@ -0,0 +1,9 @@ +enable_language(C) +include_directories(include) +add_executable(BuildUnderSource BuildUnderSource.c) + +file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/check-$<LOWER_CASE:$<CONFIG>>.cmake CONTENT " +set(check_pairs + \"$<TARGET_FILE:BuildUnderSource>|${CMAKE_CURRENT_SOURCE_DIR}/include/BuildUnderSource.h\" + ) +") diff --git a/Tests/RunCMake/BuildDepends/BuildUnderSource.step1.cmake b/Tests/RunCMake/BuildDepends/BuildUnderSource.step1.cmake new file mode 100644 index 0000000..2cdd32b --- /dev/null +++ b/Tests/RunCMake/BuildDepends/BuildUnderSource.step1.cmake @@ -0,0 +1,3 @@ +file(WRITE "${RunCMake_TEST_SOURCE_DIR}/include/BuildUnderSource.h" [[ +#define BUILD_UNDER_SOURCE 1 +]]) diff --git a/Tests/RunCMake/BuildDepends/BuildUnderSource.step2.cmake b/Tests/RunCMake/BuildDepends/BuildUnderSource.step2.cmake new file mode 100644 index 0000000..8e4b858 --- /dev/null +++ b/Tests/RunCMake/BuildDepends/BuildUnderSource.step2.cmake @@ -0,0 +1,3 @@ +file(WRITE "${RunCMake_TEST_SOURCE_DIR}/include/BuildUnderSource.h" [[ +#define BUILD_UNDER_SOURCE 2 +]]) diff --git a/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake b/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake index 3445beb..14ae243 100644 --- a/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake +++ b/Tests/RunCMake/BuildDepends/RunCMakeTest.cmake @@ -9,7 +9,9 @@ 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) + if(NOT RunCMake_TEST_BINARY_DIR) + set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/${CASE}-build) + endif() set(RunCMake_TEST_NO_CLEAN 1) if(NOT RunCMake_GENERATOR_IS_MULTI_CONFIG) set(RunCMake_TEST_OPTIONS -DCMAKE_BUILD_TYPE=Debug) @@ -44,6 +46,18 @@ endif() run_BuildDepends(Custom-Symbolic-and-Byproduct) run_BuildDepends(Custom-Always) +# Test header dependencies with a build tree underneath a source tree. +set(RunCMake_TEST_SOURCE_DIR "${RunCMake_BINARY_DIR}/BuildUnderSource") +set(RunCMake_TEST_BINARY_DIR "${RunCMake_BINARY_DIR}/BuildUnderSource/build") +file(REMOVE_RECURSE "${RunCMake_TEST_SOURCE_DIR}") +file(MAKE_DIRECTORY "${RunCMake_TEST_SOURCE_DIR}/include") +foreach(f CMakeLists.txt BuildUnderSource.cmake BuildUnderSource.c) + configure_file("${RunCMake_SOURCE_DIR}/${f}" "${RunCMake_TEST_SOURCE_DIR}/${f}" COPYONLY) +endforeach() +run_BuildDepends(BuildUnderSource) +unset(RunCMake_TEST_BINARY_DIR) +unset(RunCMake_TEST_SOURCE_DIR) + if(RunCMake_GENERATOR MATCHES "Make") run_BuildDepends(MakeCustomIncludes) if(NOT "${RunCMake_BINARY_DIR}" STREQUAL "${RunCMake_SOURCE_DIR}") diff --git a/Tests/RunCMake/CPack/RunCMakeTest.cmake b/Tests/RunCMake/CPack/RunCMakeTest.cmake index 37df57c..d93f280 100644 --- a/Tests/RunCMake/CPack/RunCMakeTest.cmake +++ b/Tests/RunCMake/CPack/RunCMakeTest.cmake @@ -33,6 +33,6 @@ run_cpack_test(TIMESTAMPS "DEB.TIMESTAMPS;TGZ" false "COMPONENT") unset(ENVIRONMENT) run_cpack_test(USER_FILELIST "RPM.USER_FILELIST" false "MONOLITHIC") run_cpack_test(MD5SUMS "DEB.MD5SUMS" false "MONOLITHIC;COMPONENT") -run_cpack_test(CPACK_INSTALL_SCRIPT "ZIP" false "MONOLITHIC") +run_cpack_test_subtests(CPACK_INSTALL_SCRIPTS "singular;plural;both" "ZIP" false "MONOLITHIC") run_cpack_test(DEB_PACKAGE_VERSION_BACK_COMPATIBILITY "DEB.DEB_PACKAGE_VERSION_BACK_COMPATIBILITY" false "MONOLITHIC;COMPONENT") run_cpack_test_subtests(EXTERNAL "none;good;good_multi;bad_major;bad_minor;invalid_good;invalid_bad;stage_and_package" "External" false "MONOLITHIC;COMPONENT") diff --git a/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPT/test.cmake b/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPT/test.cmake deleted file mode 100644 index e3fe0ca..0000000 --- a/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPT/test.cmake +++ /dev/null @@ -1,11 +0,0 @@ -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/abc.txt" "test content") -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/user-script.cmake" - "file(INSTALL DESTINATION \"\${CMAKE_INSTALL_PREFIX}/foo\" - TYPE FILE FILES \"${CMAKE_CURRENT_BINARY_DIR}/abc.txt\")") -set(CPACK_INSTALL_SCRIPT "${CMAKE_CURRENT_BINARY_DIR}/user-script.cmake") - -function(run_after_include_cpack) - file(READ "${CPACK_OUTPUT_CONFIG_FILE}" conf_file_) - string(REGEX REPLACE "SET\\(CPACK_INSTALL_CMAKE_PROJECTS [^)]*\\)" "" conf_file_ "${conf_file_}") - file(WRITE "${CPACK_OUTPUT_CONFIG_FILE}" "${conf_file_}") -endfunction() diff --git a/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPT/ExpectedFiles.cmake b/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPTS/ExpectedFiles.cmake index 02a7821..02a7821 100644 --- a/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPT/ExpectedFiles.cmake +++ b/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPTS/ExpectedFiles.cmake diff --git a/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPTS/both-stderr.txt b/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPTS/both-stderr.txt new file mode 100644 index 0000000..666030e --- /dev/null +++ b/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPTS/both-stderr.txt @@ -0,0 +1 @@ +CPack Warning: Both CPACK_INSTALL_SCRIPTS and CPACK_INSTALL_SCRIPT are set, the latter will be ignored. diff --git a/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPTS/test.cmake b/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPTS/test.cmake new file mode 100644 index 0000000..249d2e6 --- /dev/null +++ b/Tests/RunCMake/CPack/tests/CPACK_INSTALL_SCRIPTS/test.cmake @@ -0,0 +1,26 @@ +file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/abc.txt" "test content") +set(user_script_ "${CMAKE_CURRENT_BINARY_DIR}/user-script.cmake") +file(WRITE "${user_script_}" + "file(INSTALL DESTINATION \"\${CMAKE_INSTALL_PREFIX}/foo\" + TYPE FILE FILES \"${CMAKE_CURRENT_BINARY_DIR}/abc.txt\")") + +if(RunCMake_SUBTEST_SUFFIX STREQUAL "both") + set(CPACK_INSTALL_SCRIPT "${user_script_}") + set(CPACK_INSTALL_SCRIPTS "${CPACK_INSTALL_SCRIPT}") + +elseif(RunCMake_SUBTEST_SUFFIX STREQUAL "singular") + set(CPACK_INSTALL_SCRIPT "${user_script_}") + +elseif(RunCMake_SUBTEST_SUFFIX STREQUAL "plural") + set(CPACK_INSTALL_SCRIPTS "${user_script_}") + +else() + message(FATAL_ERROR "Unexpected subtest name: ${RunCMake_SUBTEST_SUFFIX}") + +endif() + +function(run_after_include_cpack) + file(READ "${CPACK_OUTPUT_CONFIG_FILE}" conf_file_) + string(REGEX REPLACE "SET\\(CPACK_INSTALL_CMAKE_PROJECTS [^)]*\\)" "" conf_file_ "${conf_file_}") + file(WRITE "${CPACK_OUTPUT_CONFIG_FILE}" "${conf_file_}") +endfunction() diff --git a/Tests/RunCMake/CrosscompilingEmulator/AddCustomCommand.cmake b/Tests/RunCMake/CrosscompilingEmulator/AddCustomCommand.cmake index c4db11b..9fcc5bc 100644 --- a/Tests/RunCMake/CrosscompilingEmulator/AddCustomCommand.cmake +++ b/Tests/RunCMake/CrosscompilingEmulator/AddCustomCommand.cmake @@ -26,12 +26,14 @@ add_custom_command(OUTPUT output2 # DoesNotUseEmulator: The command will fail if emulator is prepended add_custom_command(OUTPUT output3 + COMMAND ${CMAKE_COMMAND} -E echo generated_exe_emulator_unexpected COMMAND $<TARGET_FILE:generated_exe_emulator_unexpected> COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/output3 DEPENDS generated_exe_emulator_unexpected) # DoesNotUseEmulator: The command will fail if emulator is prepended add_custom_command(OUTPUT outputImp + COMMAND ${CMAKE_COMMAND} -E echo generated_exe_emulator_unexpected_imported COMMAND generated_exe_emulator_unexpected_imported COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/outputImp ) @@ -39,6 +41,7 @@ add_custom_command(OUTPUT outputImp # UsesEmulator: The command only succeeds if the emulator is prepended # to the command. add_custom_command(OUTPUT output4 + COMMAND ${CMAKE_COMMAND} -E echo generated_exe_emulator_expected COMMAND generated_exe_emulator_expected COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/output4 DEPENDS generated_exe_emulator_expected) diff --git a/Tests/RunCMake/GenerateExportHeader/GEH.cmake b/Tests/RunCMake/GenerateExportHeader/GEH.cmake index b3f1c7f..ae9a84c 100644 --- a/Tests/RunCMake/GenerateExportHeader/GEH.cmake +++ b/Tests/RunCMake/GenerateExportHeader/GEH.cmake @@ -51,11 +51,6 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND set(CMAKE_CXX_STANDARD 11) endif() -if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND - CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU") - set(CMAKE_CXX_STANDARD 14) -endif() - add_subdirectory(lib_shared_and_static) if(CMAKE_SYSTEM_NAME MATCHES "AIX" AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU" diff --git a/Tests/RunCMake/add_library/UNKNOWNwithOnlyObjectSources-stderr.txt b/Tests/RunCMake/add_library/UNKNOWNwithOnlyObjectSources-stderr.txt index e332281..838992b 100644 --- a/Tests/RunCMake/add_library/UNKNOWNwithOnlyObjectSources-stderr.txt +++ b/Tests/RunCMake/add_library/UNKNOWNwithOnlyObjectSources-stderr.txt @@ -1,4 +1,4 @@ ^CMake Error at UNKNOWNwithOnlyObjectSources.cmake:[0-9]+ \(target_sources\): - target_sources called with non-compilable target type + target_sources may only set INTERFACE properties on IMPORTED targets Call Stack \(most recent call first\): CMakeLists.txt:[0-9]+ \(include\)$ diff --git a/Tests/RunCMake/find_file/FromPrefixPath.cmake b/Tests/RunCMake/find_file/FromPrefixPath.cmake index 1bf8409..63c6a07 100644 --- a/Tests/RunCMake/find_file/FromPrefixPath.cmake +++ b/Tests/RunCMake/find_file/FromPrefixPath.cmake @@ -1,3 +1,4 @@ +set(ENV_PATH "$ENV{PATH}") set(ENV{PATH} "") foreach(path "/does_not_exist" "/include" "") unset(PrefixInPATH_File CACHE) @@ -15,3 +16,4 @@ foreach(path "/does_not_exist" "/include" "") message(STATUS "PrefixInPATH_File='${PrefixInPATH_File}'") endforeach() set(CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH ON) +set(ENV{PATH} "${ENV_PATH}") diff --git a/Tests/RunCMake/find_package/FromPATHEnv-stdout.txt b/Tests/RunCMake/find_package/FromPATHEnv-stdout.txt new file mode 100644 index 0000000..2ead349 --- /dev/null +++ b/Tests/RunCMake/find_package/FromPATHEnv-stdout.txt @@ -0,0 +1,9 @@ +-- Resolved_FOUND='0' +-- Resolved_FOUND='1' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' diff --git a/Tests/RunCMake/find_package/FromPATHEnv.cmake b/Tests/RunCMake/find_package/FromPATHEnv.cmake new file mode 100644 index 0000000..4822b13 --- /dev/null +++ b/Tests/RunCMake/find_package/FromPATHEnv.cmake @@ -0,0 +1,27 @@ +set(ENV_PATH "$ENV{PATH}") +foreach(path "/does_not_exist" "/PackageRoot" "") + unset(Resolved_FOUND CACHE) + set(Resolved_DIR "") + set(ENV{PATH} "${CMAKE_CURRENT_SOURCE_DIR}${path}") + find_package(Resolved QUIET) + message(STATUS "Resolved_FOUND='${Resolved_FOUND}'") +endforeach() + +set(CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH OFF) +foreach(path "/does_not_exist" "/PackageRoot" "") + unset(Resolved_FOUND CACHE) + set(Resolved_DIR "") + set(ENV{PATH} "${CMAKE_CURRENT_SOURCE_DIR}${path}") + find_package(Resolved QUIET) + message(STATUS "Resolved_FOUND='${Resolved_FOUND}'") +endforeach() + +set(CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH ON) +foreach(path "/does_not_exist" "/PackageRoot" "") + unset(Resolved_FOUND CACHE) + set(Resolved_DIR "") + set(ENV{PATH} "${CMAKE_CURRENT_SOURCE_DIR}${path}") + find_package(Resolved NO_SYSTEM_ENVIRONMENT_PATH QUIET) + message(STATUS "Resolved_FOUND='${Resolved_FOUND}'") +endforeach() +set(ENV{PATH} "${ENV_PATH}") diff --git a/Tests/RunCMake/find_package/FromPrefixPath-stdout.txt b/Tests/RunCMake/find_package/FromPrefixPath-stdout.txt new file mode 100644 index 0000000..2ead349 --- /dev/null +++ b/Tests/RunCMake/find_package/FromPrefixPath-stdout.txt @@ -0,0 +1,9 @@ +-- Resolved_FOUND='0' +-- Resolved_FOUND='1' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' +-- Resolved_FOUND='0' diff --git a/Tests/RunCMake/find_package/FromPrefixPath.cmake b/Tests/RunCMake/find_package/FromPrefixPath.cmake new file mode 100644 index 0000000..be853c1 --- /dev/null +++ b/Tests/RunCMake/find_package/FromPrefixPath.cmake @@ -0,0 +1,29 @@ +set(ENV_PATH "$ENV{PATH}") +set(ENV{PATH} "") +foreach(path "/does_not_exist" "/PackageRoot" "") + unset(Resolved_FOUND CACHE) + set(Resolved_DIR "") + set(CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}${path}") + find_package(Resolved QUIET) + message(STATUS "Resolved_FOUND='${Resolved_FOUND}'") +endforeach() + +set(CMAKE_FIND_USE_CMAKE_PATH OFF) +set(CMAKE_PREFIX_PATH ) +foreach(path "/does_not_exist" "/PackageRoot" "") + unset(Resolved_FOUND CACHE) + set(Resolved_DIR "") + set(CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}${path}") + find_package(Resolved QUIET) + message(STATUS "Resolved_FOUND='${Resolved_FOUND}'") +endforeach() + +set(CMAKE_FIND_USE_CMAKE_PATH ON) +foreach(path "/does_not_exist" "/PackageRoot" "") + unset(Resolved_FOUND CACHE) + set(Resolved_DIR "") + set(CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}${path}") + find_package(Resolved NO_CMAKE_PATH QUIET) + message(STATUS "Resolved_FOUND='${Resolved_FOUND}'") +endforeach() +set(ENV{PATH} "${ENV_PATH}") diff --git a/Tests/RunCMake/find_package/RunCMakeTest.cmake b/Tests/RunCMake/find_package/RunCMakeTest.cmake index 066523e..208f83c 100644 --- a/Tests/RunCMake/find_package/RunCMakeTest.cmake +++ b/Tests/RunCMake/find_package/RunCMakeTest.cmake @@ -3,6 +3,8 @@ include(RunCMake) run_cmake(CMP0074-WARN) run_cmake(CMP0074-OLD) run_cmake(ComponentRequiredAndOptional) +run_cmake(FromPATHEnv) +run_cmake(FromPrefixPath) run_cmake(MissingNormal) run_cmake(MissingNormalRequired) run_cmake(MissingNormalVersion) diff --git a/Tests/RunCMake/find_program/RelAndAbsPath.cmake b/Tests/RunCMake/find_program/RelAndAbsPath.cmake index 3c60a20..6b61980 100644 --- a/Tests/RunCMake/find_program/RelAndAbsPath.cmake +++ b/Tests/RunCMake/find_program/RelAndAbsPath.cmake @@ -10,7 +10,6 @@ endfunction() strip_windows_path_prefix("${CMAKE_CURRENT_SOURCE_DIR}" srcdir) -file(MAKE_DIRECTORY "tmp${srcdir}") configure_file(testCWD "tmp${srcdir}/testNoSuchFile" COPYONLY) find_program(PROG_ABS diff --git a/Tests/RunCMake/math/MATH-InvalidExpression-stderr.txt b/Tests/RunCMake/math/MATH-InvalidExpression-stderr.txt index 9e73ed5..22226f2 100644 --- a/Tests/RunCMake/math/MATH-InvalidExpression-stderr.txt +++ b/Tests/RunCMake/math/MATH-InvalidExpression-stderr.txt @@ -1,5 +1,5 @@ ^CMake Error at MATH-InvalidExpression.cmake:1 \(math\): - math cannot parse the expression: "INVALID": syntax error, unexpected \$end, - expecting exp_PLUS or exp_MINUS or exp_OPENPARENT or exp_NUMBER \(7\). + math cannot parse the expression: "INVALID": syntax error, unexpected \$end + \(7\). Call Stack \(most recent call first\): CMakeLists.txt:3 \(include\)$ diff --git a/Tests/RunCMake/message/RunCMakeTest.cmake b/Tests/RunCMake/message/RunCMakeTest.cmake index cecfc7f..3c7e51c 100644 --- a/Tests/RunCMake/message/RunCMakeTest.cmake +++ b/Tests/RunCMake/message/RunCMakeTest.cmake @@ -52,3 +52,12 @@ run_cmake_command( message-loglevel-trace ${CMAKE_COMMAND} --loglevel=trace -P ${RunCMake_SOURCE_DIR}/message-all-loglevels.cmake ) + +run_cmake_command( + message-indent + ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/message-indent.cmake + ) +run_cmake_command( + message-indent-multiline + ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/message-indent-multiline.cmake + ) diff --git a/Tests/RunCMake/message/message-indent-multiline-stderr.txt b/Tests/RunCMake/message/message-indent-multiline-stderr.txt new file mode 100644 index 0000000..5853a31 --- /dev/null +++ b/Tests/RunCMake/message/message-indent-multiline-stderr.txt @@ -0,0 +1,3 @@ + >This is + >the multiline + >message diff --git a/Tests/RunCMake/message/message-indent-multiline-stdout.txt b/Tests/RunCMake/message/message-indent-multiline-stdout.txt new file mode 100644 index 0000000..ae0c72e --- /dev/null +++ b/Tests/RunCMake/message/message-indent-multiline-stdout.txt @@ -0,0 +1,8 @@ +-- >This is + >the multiline + >message + > + > +-- >This is + >the multiline + >message diff --git a/Tests/RunCMake/message/message-indent-multiline.cmake b/Tests/RunCMake/message/message-indent-multiline.cmake new file mode 100644 index 0000000..0f789bf --- /dev/null +++ b/Tests/RunCMake/message/message-indent-multiline.cmake @@ -0,0 +1,13 @@ +# NOTE Use non-space indent string, to check indentation +# of line endings and "empty" lines. +# ALERT Do not put any space characters after the non-space! +list(APPEND CMAKE_MESSAGE_INDENT " >") +set(msg [[This is +the multiline +message]]) # No `\n` at the end! +# NOTE Two empty lines after the text +message(STATUS "${msg}\n\n") +message(STATUS "${msg}") +# This is just to make sure NOTICE messages are also get indented: +# https://gitlab.kitware.com/cmake/cmake/issues/19418#note_588011 +message(NOTICE "${msg}") diff --git a/Tests/RunCMake/message/message-indent-stdout.txt b/Tests/RunCMake/message/message-indent-stdout.txt new file mode 100644 index 0000000..b2c3c60 --- /dev/null +++ b/Tests/RunCMake/message/message-indent-stdout.txt @@ -0,0 +1,13 @@ +-- COUNTING: +-- COUNTING_ENGLISH: +-- one +-- two +-- three +-- four +-- five +-- COUNTING_BAHASA: +-- satu +-- dua +-- tiga +-- empat +-- lima diff --git a/Tests/RunCMake/message/message-indent.cmake b/Tests/RunCMake/message/message-indent.cmake new file mode 100644 index 0000000..c07ff45 --- /dev/null +++ b/Tests/RunCMake/message/message-indent.cmake @@ -0,0 +1,19 @@ +function(debug_list LIST_VAR) + message(STATUS "${LIST_VAR}:") + list(APPEND CMAKE_MESSAGE_INDENT " ") + foreach(_item IN LISTS ${LIST_VAR}) + list(LENGTH ${_item} _item_len) + if(_item_len GREATER 1) + debug_list(${_item}) + else() + message(STATUS "${_item}") + endif() + endforeach() +endfunction() + +list(APPEND COUNTING_ENGLISH one two three four five) +list(APPEND COUNTING_BAHASA satu dua tiga empat lima) + +list(APPEND COUNTING COUNTING_ENGLISH COUNTING_BAHASA) + +debug_list(COUNTING) diff --git a/Tests/RunCMake/target_compile_definitions/RunCMakeTest.cmake b/Tests/RunCMake/target_compile_definitions/RunCMakeTest.cmake index b67c598..a419cc9 100644 --- a/Tests/RunCMake/target_compile_definitions/RunCMakeTest.cmake +++ b/Tests/RunCMake/target_compile_definitions/RunCMakeTest.cmake @@ -1,3 +1,4 @@ include(RunCMake) run_cmake(empty_keyword_args) +run_cmake(unknown_imported_target) diff --git a/Tests/RunCMake/target_compile_definitions/unknown_imported_target.cmake b/Tests/RunCMake/target_compile_definitions/unknown_imported_target.cmake new file mode 100644 index 0000000..4ae1c0d --- /dev/null +++ b/Tests/RunCMake/target_compile_definitions/unknown_imported_target.cmake @@ -0,0 +1,11 @@ +# Test that target_compile_definitions works on UNKNOWN IMPORTED target +add_library(imported UNKNOWN IMPORTED) +target_compile_definitions(imported INTERFACE FOO) + +get_target_property(IMPORTED_INTERFACE_CDS imported INTERFACE_COMPILE_DEFINITIONS) + +if (NOT FOO IN_LIST IMPORTED_INTERFACE_CDS) + message( + FATAL_ERROR "FOO should be in INTERFACE_COMPILE_DEFINITIONS.\n" + "Actual INTERFACE_COMPILE_DEFINITIONS: " ${IMPORTED_INTERFACE_CDS}) +endif() diff --git a/Tests/SwiftOnly/CMakeLists.txt b/Tests/SwiftOnly/CMakeLists.txt index e5f8588..f4cbac2 100644 --- a/Tests/SwiftOnly/CMakeLists.txt +++ b/Tests/SwiftOnly/CMakeLists.txt @@ -8,3 +8,6 @@ elseif(NOT XCODE_VERSION VERSION_LESS 8.0) endif() add_executable(SwiftOnly main.swift) + +# Dummy to make sure generation works with such targets. +add_library(SwiftIface INTERFACE) diff --git a/Utilities/Doxygen/CMakeLists.txt b/Utilities/Doxygen/CMakeLists.txt index ce4cfaf..f52caed 100644 --- a/Utilities/Doxygen/CMakeLists.txt +++ b/Utilities/Doxygen/CMakeLists.txt @@ -7,7 +7,7 @@ if(NOT CMake_SOURCE_DIR) get_filename_component(tmp "${CMAKE_CURRENT_SOURCE_DIR}" PATH) get_filename_component(CMake_SOURCE_DIR "${tmp}" PATH) include(${CMake_SOURCE_DIR}/Modules/CTestUseLaunchers.cmake) - include(${CMake_SOURCE_DIR}/Source/CMakeVersionCompute.cmake) + include(${CMake_SOURCE_DIR}/Source/CMakeVersion.cmake) include(${CMake_SOURCE_DIR}/Source/CMakeInstallDestinations.cmake) unset(CMAKE_DATA_DIR) unset(CMAKE_DATA_DIR CACHE) diff --git a/Utilities/Sphinx/CMakeLists.txt b/Utilities/Sphinx/CMakeLists.txt index e4e6e05..736a7c0 100644 --- a/Utilities/Sphinx/CMakeLists.txt +++ b/Utilities/Sphinx/CMakeLists.txt @@ -7,7 +7,7 @@ if(NOT CMake_SOURCE_DIR) get_filename_component(tmp "${CMAKE_CURRENT_SOURCE_DIR}" PATH) get_filename_component(CMake_SOURCE_DIR "${tmp}" PATH) include(${CMake_SOURCE_DIR}/Modules/CTestUseLaunchers.cmake) - include(${CMake_SOURCE_DIR}/Source/CMakeVersionCompute.cmake) + include(${CMake_SOURCE_DIR}/Source/CMakeVersion.cmake) include(${CMake_SOURCE_DIR}/Source/CMakeInstallDestinations.cmake) unset(CMAKE_DATA_DIR) unset(CMAKE_DATA_DIR CACHE) diff --git a/Utilities/cmcurl/CMakeLists.txt b/Utilities/cmcurl/CMakeLists.txt index 37522fc..bc8a7dc 100644 --- a/Utilities/cmcurl/CMakeLists.txt +++ b/Utilities/cmcurl/CMakeLists.txt @@ -449,7 +449,12 @@ if(CMAKE_USE_SECTRANSP) endif() if(CMAKE_USE_OPENSSL) - find_package(OpenSSL REQUIRED) + find_package(OpenSSL) + if(NOT OpenSSL_FOUND) + message(FATAL_ERROR + "Could not find OpenSSL. Install an OpenSSL development package or " + "configure CMake with -DCMAKE_USE_OPENSSL=OFF to build without OpenSSL.") + endif() set(SSL_ENABLED ON) set(USE_OPENSSL ON) set(HAVE_LIBCRYPTO ON) @@ -440,7 +440,6 @@ CMAKE_CXX_SOURCES="\ cmTimestamp \ cmTryCompileCommand \ cmTryRunCommand \ - cmUnexpectedCommand \ cmUnsetCommand \ cmUVHandlePtr \ cmUVProcessChain \ @@ -1125,6 +1124,25 @@ echo ' #error "SunPro <= 5.13 mode not supported due to bug in move semantics." #endif +#if __cplusplus > 201103L +#include <iterator> +int check_cxx14() +{ + int a[] = { 0, 1, 2 }; + auto ai = std::cbegin(a); + + int b[] = { 2, 1, 0 }; + auto bi = std::cend(b); + + return *ai + *(bi - 1); +} +#else +int check_cxx14() +{ + return 0; +} +#endif + class Class { public: @@ -1135,7 +1153,7 @@ private: int main() { auto const c = std::unique_ptr<Class>(new Class); - std::cout << c->Get() << std::endl; + std::cout << c->Get() << check_cxx14() << std::endl; return 0; } ' > "${TMPFILE}.cxx" |