diff options
81 files changed, 2913 insertions, 1791 deletions
diff --git a/Help/command/add_custom_command.rst b/Help/command/add_custom_command.rst index 028ca5a..130f5c2 100644 --- a/Help/command/add_custom_command.rst +++ b/Help/command/add_custom_command.rst @@ -3,10 +3,12 @@ add_custom_command Add a custom build rule to the generated build system. -There are two main signatures for add_custom_command The first -signature is for adding a custom command to produce an output. +There are two main signatures for ``add_custom_command``. -:: +Generating Files +^^^^^^^^^^^^^^^^ + +The first signature is for adding a custom command to produce an output:: add_custom_command(OUTPUT output1 [output2 ...] COMMAND command1 [ARGS] [args1...] @@ -18,28 +20,117 @@ signature is for adding a custom command to produce an output. [WORKING_DIRECTORY dir] [COMMENT comment] [VERBATIM] [APPEND]) -This defines a command to generate specified OUTPUT file(s). A target -created in the same directory (CMakeLists.txt file) that specifies any -output of the custom command as a source file is given a rule to -generate the file using the command at build time. Do not list the -output in more than one independent target that may build in parallel -or the two instances of the rule may conflict (instead use -add_custom_target to drive the command and make the other targets -depend on that one). If an output name is a relative path it will be -interpreted relative to the build tree directory corresponding to the -current source directory. Note that MAIN_DEPENDENCY is completely -optional and is used as a suggestion to visual studio about where to -hang the custom command. In makefile terms this creates a new target -in the following form: - -:: +This defines a command to generate specified ``OUTPUT`` file(s). +A target created in the same directory (``CMakeLists.txt`` file) +that specifies any output of the custom command as a source file +is given a rule to generate the file using the command at build time. +Do not list the output in more than one independent target that +may build in parallel or the two instances of the rule may conflict +(instead use the :command:`add_custom_target` command to drive the +command and make the other targets depend on that one). +In makefile terms this creates a new target in the following form:: OUTPUT: MAIN_DEPENDENCY DEPENDS COMMAND -If more than one command is specified they will be executed in order. -The optional ARGS argument is for backward compatibility and will be -ignored. +The options are: + +``APPEND`` + Append the ``COMMAND`` and ``DEPENDS`` option values to the custom + command for the first output specified. There must have already + been a previous call to this command with the same output. + The ``COMMENT``, ``MAIN_DEPENDENCY``, and ``WORKING_DIRECTORY`` + options are currently ignored when APPEND is given, but may be + used in the future. + +``COMMAND`` + Specify the command-line(s) to execute at build time. + If more than one command is specified they will be executed in order. + The optional ``ARGS`` argument is for backward compatibility and + will be ignored. + + If ``COMMAND`` specifies an executable target (created by the + :command:`add_executable` command) it will automatically be replaced + by the location of the executable created at build time. + Additionally a target-level dependency will be added so that the + executable target will be built before any target using this custom + command. However this does NOT add a file-level dependency that + would cause the custom command to re-run whenever the executable is + recompiled. + + Arguments to ``COMMAND`` may use + :manual:`generator expressions <cmake-generator-expressions(7)>`. + References to target names in generator expressions imply target-level + dependencies, but NOT file-level dependencies. List target names with + the ``DEPENDS`` option to add file-level dependencies. + +``COMMENT`` + Display the given message before the commands are executed at + build time. + +``DEPENDS`` + Specify files on which the command depends. If any dependency is + an ``OUTPUT`` of another custom command in the same directory + (``CMakeLists.txt`` file) CMake automatically brings the other + custom command into the target in which this command is built. + If ``DEPENDS`` is not specified the command will run whenever + the ``OUTPUT`` is missing; if the command does not actually + create the ``OUTPUT`` then the rule will always run. + If ``DEPENDS`` specifies any target (created by the + :command:`add_custom_target`, :command:`add_executable`, or + :command:`add_library` command) a target-level dependency is + created to make sure the target is built before any target + using this custom command. Additionally, if the target is an + executable or library a file-level dependency is created to + cause the custom command to re-run whenever the target is + recompiled. + + Arguments to ``DEPENDS`` may use + :manual:`generator expressions <cmake-generator-expressions(7)>`. + +``IMPLICIT_DEPENDS`` + Request scanning of implicit dependencies of an input file. + The language given specifies the programming language whose + corresponding dependency scanner should be used. + Currently only ``C`` and ``CXX`` language scanners are supported. + The language has to be specified for every file in the + ``IMPLICIT_DEPENDS`` list. Dependencies discovered from the + scanning are added to those of the custom command at build time. + Note that the ``IMPLICIT_DEPENDS`` option is currently supported + only for Makefile generators and will be ignored by other generators. + +``MAIN_DEPENDENCY`` + Specify the primary input source file to the command. This is + treated just like any value given to the ``DEPENDS`` option + but also suggests to Visual Studio generators where to hang + the custom command. + +``OUTPUT`` + Specify the output files the command is expected to produce. + If an output name is a relative path it will be interpreted + relative to the build tree directory corresponding to the + current source directory. + If the output of the custom command is not actually created + as a file on disk it should be marked with the :prop_sf:`SYMBOLIC` + source file property. + +``VERBATIM`` + All arguments to the commands will be escaped properly for the + build tool so that the invoked command receives each argument + unchanged. Note that one level of escapes is still used by the + CMake language processor before add_custom_command even sees the + arguments. Use of ``VERBATIM`` is recommended as it enables + correct behavior. When ``VERBATIM`` is not given the behavior + is platform specific because there is no protection of + tool-specific special characters. + +``WORKING_DIRECTORY`` + Execute the command with the given current working directory. + If it is a relative path it will be interpreted relative to the + build tree directory corresponding to the current source directory. + +Build Events +^^^^^^^^^^^^ The second signature adds a custom command to a target such as a library or executable. This is useful for performing an operation @@ -60,103 +151,15 @@ This defines a new command that will be associated with building the specified target. When the command will happen is determined by which of the following is specified: -:: - - PRE_BUILD - run before all other dependencies - PRE_LINK - run after other dependencies - POST_BUILD - run after the target has been built - -Note that the PRE_BUILD option is only supported on Visual Studio 7 or -later. For all other generators PRE_BUILD will be treated as -PRE_LINK. - -If WORKING_DIRECTORY is specified the command will be executed in the -directory given. If it is a relative path it will be interpreted -relative to the build tree directory corresponding to the current -source directory. If COMMENT is set, the value will be displayed as a -message before the commands are executed at build time. If APPEND is -specified the COMMAND and DEPENDS option values are appended to the -custom command for the first output specified. There must have -already been a previous call to this command with the same output. -The COMMENT, WORKING_DIRECTORY, and MAIN_DEPENDENCY options are -currently ignored when APPEND is given, but may be used in the future. - -If VERBATIM is given then all arguments to the commands will be -escaped properly for the build tool so that the invoked command -receives each argument unchanged. Note that one level of escapes is -still used by the CMake language processor before add_custom_command -even sees the arguments. Use of VERBATIM is recommended as it enables -correct behavior. When VERBATIM is not given the behavior is platform -specific because there is no protection of tool-specific special -characters. - -If the output of the custom command is not actually created as a file -on disk it should be marked as SYMBOLIC with -SET_SOURCE_FILES_PROPERTIES. - -The IMPLICIT_DEPENDS option requests scanning of implicit dependencies -of an input file. The language given specifies the programming -language whose corresponding dependency scanner should be used. -Currently only C and CXX language scanners are supported. The -language has to be specified for every file in the IMPLICIT_DEPENDS -list. Dependencies discovered from the scanning are added to those of -the custom command at build time. Note that the IMPLICIT_DEPENDS -option is currently supported only for Makefile generators and will be -ignored by other generators. - -If COMMAND specifies an executable target (created by ADD_EXECUTABLE) -it will automatically be replaced by the location of the executable -created at build time. Additionally a target-level dependency will be -added so that the executable target will be built before any target -using this custom command. However this does NOT add a file-level -dependency that would cause the custom command to re-run whenever the -executable is recompiled. - -Arguments to COMMAND may use "generator expressions" with the syntax -``$<...>``. See the :manual:`cmake-generator-expressions(7)` manual for -available expressions. - -Note that tgt is not added as a dependency of the target this -expression is evaluated on. - -:: - - $<TARGET_POLICY:pol> = '1' if the policy was NEW when the 'head' target was created, else '0'. If the policy was not set, the warning message for the policy will be emitted. This generator expression only works for a subset of policies. - $<INSTALL_PREFIX> = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise. - -Boolean expressions: - -:: - - $<AND:?[,?]...> = '1' if all '?' are '1', else '0' - $<OR:?[,?]...> = '0' if all '?' are '0', else '1' - $<NOT:?> = '0' if '?' is '1', else '1' - -where '?' is always either '0' or '1'. - -Expressions with an implicit 'this' target: - -:: - - $<TARGET_PROPERTY:prop> = The value of the property prop on the target on which the generator expression is evaluated. - -References to target names in generator expressions imply target-level -dependencies, but NOT file-level dependencies. List target names with -the DEPENDS option to add file dependencies. - -The DEPENDS option specifies files on which the command depends. If -any dependency is an OUTPUT of another custom command in the same -directory (CMakeLists.txt file) CMake automatically brings the other -custom command into the target in which this command is built. If -DEPENDS is not specified the command will run whenever the OUTPUT is -missing; if the command does not actually create the OUTPUT then the -rule will always run. If DEPENDS specifies any target (created by an -ADD_* command) a target-level dependency is created to make sure the -target is built before any target using this custom command. -Additionally, if the target is an executable or library a file-level -dependency is created to cause the custom command to re-run whenever -the target is recompiled. - -Arguments to ``DEPENDS`` may use "generator expressions" with the syntax -``$<...>``. See the :manual:`cmake-generator-expressions(7)` manual for -available expressions. +``PRE_BUILD`` + Run before any other rules are executed within the target. + This is supported only on Visual Studio 7 or later. + For all other generators ``PRE_BUILD`` will be treated as + ``PRE_LINK``. +``PRE_LINK`` + Run after sources have been compiled but before linking the binary + or running the librarian or archiver tool of a static library. + This is not defined for targets created by the + :command:`add_custom_target` command. +``POST_BUILD`` + Run after all other rules within the target have been executed. diff --git a/Help/command/file.rst b/Help/command/file.rst index 58e3a26..dbc4149 100644 --- a/Help/command/file.rst +++ b/Help/command/file.rst @@ -64,6 +64,9 @@ Parse a list of ASCII strings from ``<filename>`` and store it in ``REGEX <regex>`` Consider only strings that match the given regular expression. +``ENCODING <encoding-type>`` + Consider strings of a given encoding. "UTF-8" is currently supported. + For example, the code .. code-block:: cmake diff --git a/Help/manual/cmake-properties.7.rst b/Help/manual/cmake-properties.7.rst index 17dadc2..9faf99a 100644 --- a/Help/manual/cmake-properties.7.rst +++ b/Help/manual/cmake-properties.7.rst @@ -312,6 +312,7 @@ Properties on Installed Files /prop_inst/CPACK_NEVER_OVERWRITE.rst /prop_inst/CPACK_PERMANENT.rst + /prop_inst/CPACK_WIX_ACL.rst Deprecated Properties on Directories diff --git a/Help/prop_inst/CPACK_WIX_ACL.rst b/Help/prop_inst/CPACK_WIX_ACL.rst new file mode 100644 index 0000000..e7d526a --- /dev/null +++ b/Help/prop_inst/CPACK_WIX_ACL.rst @@ -0,0 +1,17 @@ +CPACK_WIX_ACL +------------- + +Specifies access permissions for files installed by a WiX installer. + +The property can contain multiple list entries, +each of which has to match the following format. + +:: + + <user>[@<domain>]=<permission>[,<permission>] + +``<user>`` and ``<domain>`` specify the windows user and domain for which the +``<Permission>`` element should be generated. + +``<permission>`` is any of the YesNoType attributes listed here: +http://wixtoolset.org/documentation/manual/v3/xsd/wix/permission.html diff --git a/Help/release/dev/CMakePackageConfigHelpers-INSTALL_PREFIX.rst b/Help/release/dev/CMakePackageConfigHelpers-INSTALL_PREFIX.rst new file mode 100644 index 0000000..da8d7c3 --- /dev/null +++ b/Help/release/dev/CMakePackageConfigHelpers-INSTALL_PREFIX.rst @@ -0,0 +1,7 @@ +CMakePackageConfigHelpers-INSTALL_PREFIX +---------------------------------------- + +* The :module:`CMakePackageConfigHelpers` module + :command:`configure_package_config_file` command learned a new + ``INSTALL_PREFIX`` option to generate package configuration files + meant for a prefix other than :variable:`CMAKE_INSTALL_PREFIX`. diff --git a/Help/release/dev/file-strings-encoding.rst b/Help/release/dev/file-strings-encoding.rst new file mode 100644 index 0000000..9da3e47 --- /dev/null +++ b/Help/release/dev/file-strings-encoding.rst @@ -0,0 +1,5 @@ +file-strings-encoding +--------------------- + +* The :command:`file(STRINGS)` command gained a new ``ENCODING`` + option to enable extraction of ``UTF-8`` strings. diff --git a/Help/release/dev/link-line-dedup.rst b/Help/release/dev/link-line-dedup.rst new file mode 100644 index 0000000..6ce31e3 --- /dev/null +++ b/Help/release/dev/link-line-dedup.rst @@ -0,0 +1,5 @@ +link-line-dedup +--------------- + +* When generating linker command-lines, CMake now avoids repeating + items corresponding to SHARED library targets. diff --git a/Help/release/dev/wix-acl.rst b/Help/release/dev/wix-acl.rst new file mode 100644 index 0000000..bf146d0 --- /dev/null +++ b/Help/release/dev/wix-acl.rst @@ -0,0 +1,6 @@ +wix-acl +------- + +* The :manual:`cpack(1)` ``WiX`` generator learned to support + a :prop_inst:`CPACK_WIX_ACL` installed file property to + specify an Access Control List. diff --git a/Modules/BundleUtilities.cmake b/Modules/BundleUtilities.cmake index 0c733fa..0046c97 100644 --- a/Modules/BundleUtilities.cmake +++ b/Modules/BundleUtilities.cmake @@ -237,6 +237,7 @@ function(get_bundle_main_executable bundle result_var) file(READ "${bundle}/Contents/Info.plist" info_plist) string(REPLACE ";" "\\;" info_plist "${info_plist}") string(REPLACE "\n" "${eol_char};" info_plist "${info_plist}") + string(REPLACE "\r" "${eol_char};" info_plist "${info_plist}") # Scan the lines for "<key>CFBundleExecutable</key>" - the line after that # is the name of the main executable. diff --git a/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake b/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake index abbcda4..aa7d96a 100644 --- a/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake +++ b/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake @@ -37,5 +37,6 @@ macro (CHECK_COMPILER_FLAG_COMMON_PATTERNS _VAR) FAIL_REGEX "WARNING: unknown flag:" # Open64 FAIL_REGEX "Incorrect command line option:" # Borland FAIL_REGEX "Warning: illegal option" # SunStudio 12 + FAIL_REGEX "[Ww]arning: Invalid suboption" # Fujitsu ) endmacro () diff --git a/Modules/CMakeCompilerIdDetection.cmake b/Modules/CMakeCompilerIdDetection.cmake index e247885..19bcbcc 100644 --- a/Modules/CMakeCompilerIdDetection.cmake +++ b/Modules/CMakeCompilerIdDetection.cmake @@ -74,6 +74,7 @@ function(compiler_id_detection outvar lang) PGI Cray TI + Fujitsu ) if (lang STREQUAL C) list(APPEND ordered_compilers diff --git a/Modules/CMakePackageConfigHelpers.cmake b/Modules/CMakePackageConfigHelpers.cmake index 473bbe5..c6dc141 100644 --- a/Modules/CMakePackageConfigHelpers.cmake +++ b/Modules/CMakePackageConfigHelpers.cmake @@ -2,29 +2,36 @@ # CMakePackageConfigHelpers # ------------------------- # -# CONFIGURE_PACKAGE_CONFIG_FILE(), WRITE_BASIC_PACKAGE_VERSION_FILE() +# Helpers functions for creating config files that can be included by other +# projects to find and use a package. # +# Adds the :command:`configure_package_config_file()` and +# :command:`write_basic_package_version_file()` commands. # +# Generating a Package Configuration File +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # -# :: +# .. command:: configure_package_config_file # -# CONFIGURE_PACKAGE_CONFIG_FILE(<input> <output> INSTALL_DESTINATION <path> +# Create a config file for a project:: +# +# configure_package_config_file(<input> <output> INSTALL_DESTINATION <path> # [PATH_VARS <var1> <var2> ... <varN>] # [NO_SET_AND_CHECK_MACRO] -# [NO_CHECK_REQUIRED_COMPONENTS_MACRO]) -# +# [NO_CHECK_REQUIRED_COMPONENTS_MACRO] +# [INSTALL_PREFIX <path>]) # # -# CONFIGURE_PACKAGE_CONFIG_FILE() should be used instead of the plain -# configure_file() command when creating the <Name>Config.cmake or -# <Name>-config.cmake file for installing a project or library. It -# helps making the resulting package relocatable by avoiding hardcoded -# paths in the installed Config.cmake file. +# ``configure_package_config_file()`` should be used instead of the plain +# :command:`configure_file()` command when creating the ``<Name>Config.cmake`` +# or ``<Name>-config.cmake`` file for installing a project or library. It helps +# making the resulting package relocatable by avoiding hardcoded paths in the +# installed ``Config.cmake`` file. # -# In a FooConfig.cmake file there may be code like this to make the -# install destinations know to the using project: +# In a ``FooConfig.cmake`` file there may be code like this to make the install +# destinations know to the using project: # -# :: +# .. code-block:: cmake # # set(FOO_INCLUDE_DIR "@CMAKE_INSTALL_FULL_INCLUDEDIR@" ) # set(FOO_DATA_DIR "@CMAKE_INSTALL_PREFIX@/@RELATIVE_DATA_INSTALL_DIR@" ) @@ -32,121 +39,133 @@ # ...logic to determine installedPrefix from the own location... # set(FOO_CONFIG_DIR "${installedPrefix}/@CONFIG_INSTALL_DIR@" ) # -# All 4 options shown above are not sufficient, since the first 3 -# hardcode the absolute directory locations, and the 4th case works only -# if the logic to determine the installedPrefix is correct, and if -# CONFIG_INSTALL_DIR contains a relative path, which in general cannot -# be guaranteed. This has the effect that the resulting FooConfig.cmake -# file would work poorly under Windows and OSX, where users are used to -# choose the install location of a binary package at install time, -# independent from how CMAKE_INSTALL_PREFIX was set at build/cmake time. -# -# Using CONFIGURE_PACKAGE_CONFIG_FILE() helps. If used correctly, it -# makes the resulting FooConfig.cmake file relocatable. Usage: -# -# :: -# -# 1. write a FooConfig.cmake.in file as you are used to -# 2. insert a line containing only the string "@PACKAGE_INIT@" -# 3. instead of set(FOO_DIR "@SOME_INSTALL_DIR@"), use set(FOO_DIR "@PACKAGE_SOME_INSTALL_DIR@") -# (this must be after the @PACKAGE_INIT@ line) -# 4. instead of using the normal configure_file(), use CONFIGURE_PACKAGE_CONFIG_FILE() -# -# -# -# The <input> and <output> arguments are the input and output file, the -# same way as in configure_file(). -# -# The <path> given to INSTALL_DESTINATION must be the destination where -# the FooConfig.cmake file will be installed to. This can either be a -# relative or absolute path, both work. -# -# The variables <var1> to <varN> given as PATH_VARS are the variables -# which contain install destinations. For each of them the macro will -# create a helper variable PACKAGE_<var...>. These helper variables -# must be used in the FooConfig.cmake.in file for setting the installed -# location. They are calculated by CONFIGURE_PACKAGE_CONFIG_FILE() so -# that they are always relative to the installed location of the -# package. This works both for relative and also for absolute -# locations. For absolute locations it works only if the absolute -# location is a subdirectory of CMAKE_INSTALL_PREFIX. -# -# By default configure_package_config_file() also generates two helper -# macros, set_and_check() and check_required_components() into the -# FooConfig.cmake file. -# -# set_and_check() should be used instead of the normal set() command for -# setting directories and file locations. Additionally to setting the -# variable it also checks that the referenced file or directory actually -# exists and fails with a FATAL_ERROR otherwise. This makes sure that -# the created FooConfig.cmake file does not contain wrong references. -# When using the NO_SET_AND_CHECK_MACRO, this macro is not generated -# into the FooConfig.cmake file. -# -# check_required_components(<package_name>) should be called at the end -# of the FooConfig.cmake file if the package supports components. This -# macro checks whether all requested, non-optional components have been -# found, and if this is not the case, sets the Foo_FOUND variable to -# FALSE, so that the package is considered to be not found. It does -# that by testing the Foo_<Component>_FOUND variables for all requested -# required components. When using the NO_CHECK_REQUIRED_COMPONENTS -# option, this macro is not generated into the FooConfig.cmake file. +# All 4 options shown above are not sufficient, since the first 3 hardcode the +# absolute directory locations, and the 4th case works only if the logic to +# determine the ``installedPrefix`` is correct, and if ``CONFIG_INSTALL_DIR`` +# contains a relative path, which in general cannot be guaranteed. This has the +# effect that the resulting ``FooConfig.cmake`` file would work poorly under +# Windows and OSX, where users are used to choose the install location of a +# binary package at install time, independent from how +# :variable:`CMAKE_INSTALL_PREFIX` was set at build/cmake time. +# +# Using ``configure_package_config_file`` helps. If used correctly, it makes +# the resulting ``FooConfig.cmake`` file relocatable. Usage: +# +# 1. write a ``FooConfig.cmake.in`` file as you are used to +# 2. insert a line containing only the string ``@PACKAGE_INIT@`` +# 3. instead of ``set(FOO_DIR "@SOME_INSTALL_DIR@")``, use +# ``set(FOO_DIR "@PACKAGE_SOME_INSTALL_DIR@")`` (this must be after the +# ``@PACKAGE_INIT@`` line) +# 4. instead of using the normal :command:`configure_file()`, use +# ``configure_package_config_file()`` +# +# +# +# The ``<input>`` and ``<output>`` arguments are the input and output file, the +# same way as in :command:`configure_file()`. +# +# The ``<path>`` given to ``INSTALL_DESTINATION`` must be the destination where +# the ``FooConfig.cmake`` file will be installed to. This path can either be +# absolute, or relative to the ``INSTALL_PREFIX`` path. +# +# The variables ``<var1>`` to ``<varN>`` given as ``PATH_VARS`` are the +# variables which contain install destinations. For each of them the macro will +# create a helper variable ``PACKAGE_<var...>``. These helper variables must be +# used in the ``FooConfig.cmake.in`` file for setting the installed location. +# They are calculated by ``configure_package_config_file`` so that they are +# always relative to the installed location of the package. This works both for +# relative and also for absolute locations. For absolute locations it works +# only if the absolute location is a subdirectory of ``INSTALL_PREFIX``. +# +# If the ``INSTALL_PREFIX`` argument is passed, this is used as base path to +# calculate all the relative paths. The ``<path>`` argument must be an absolute +# path. If this argument is not passed, the :variable:`CMAKE_INSTALL_PREFIX` +# variable will be used instead. The default value is good when generating a +# FooConfig.cmake file to use your package from the install tree. When +# generating a FooConfig.cmake file to use your package from the build tree this +# option should be used. +# +# By default ``configure_package_config_file`` also generates two helper macros, +# ``set_and_check()`` and ``check_required_components()`` into the +# ``FooConfig.cmake`` file. +# +# ``set_and_check()`` should be used instead of the normal ``set()`` command for +# setting directories and file locations. Additionally to setting the variable +# it also checks that the referenced file or directory actually exists and fails +# with a ``FATAL_ERROR`` otherwise. This makes sure that the created +# ``FooConfig.cmake`` file does not contain wrong references. +# When using the ``NO_SET_AND_CHECK_MACRO``, this macro is not generated +# into the ``FooConfig.cmake`` file. +# +# ``check_required_components(<package_name>)`` should be called at the end of +# the ``FooConfig.cmake`` file if the package supports components. This macro +# checks whether all requested, non-optional components have been found, and if +# this is not the case, sets the ``Foo_FOUND`` variable to ``FALSE``, so that +# the package is considered to be not found. It does that by testing the +# ``Foo_<Component>_FOUND`` variables for all requested required components. +# When using the ``NO_CHECK_REQUIRED_COMPONENTS_MACRO`` option, this macro is +# not generated into the ``FooConfig.cmake`` file. # # For an example see below the documentation for -# WRITE_BASIC_PACKAGE_VERSION_FILE(). -# -# -# -# :: -# -# WRITE_BASIC_PACKAGE_VERSION_FILE( filename [VERSION major.minor.patch] COMPATIBILITY (AnyNewerVersion|SameMajorVersion|ExactVersion) ) -# -# -# -# Writes a file for use as <package>ConfigVersion.cmake file to -# <filename>. See the documentation of find_package() for details on -# this. -# -# :: -# -# filename is the output filename, it should be in the build tree. -# major.minor.patch is the version number of the project to be installed -# -# If no ``VERSION`` is given, the :variable:`PROJECT_VERSION` variable -# is used. If this hasn't been set, it errors out. -# -# The COMPATIBILITY mode AnyNewerVersion means that the installed -# package version will be considered compatible if it is newer or -# exactly the same as the requested version. This mode should be used -# for packages which are fully backward compatible, also across major -# versions. If SameMajorVersion is used instead, then the behaviour -# differs from AnyNewerVersion in that the major version number must be -# the same as requested, e.g. version 2.0 will not be considered -# compatible if 1.0 is requested. This mode should be used for packages -# which guarantee backward compatibility within the same major version. -# If ExactVersion is used, then the package is only considered -# compatible if the requested version matches exactly its own version -# number (not considering the tweak version). For example, version -# 1.2.3 of a package is only considered compatible to requested version -# 1.2.3. This mode is for packages without compatibility guarantees. -# If your project has more elaborated version matching rules, you will -# need to write your own custom ConfigVersion.cmake file instead of -# using this macro. -# -# Internally, this macro executes configure_file() to create the -# resulting version file. Depending on the COMPATIBLITY, either the -# file BasicConfigVersion-SameMajorVersion.cmake.in or -# BasicConfigVersion-AnyNewerVersion.cmake.in is used. Please note that +# :command:`write_basic_package_version_file()`. +# +# Generating a Package Version File +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +# +# .. command:: write_basic_package_version_file +# +# Create a version file for a project:: +# +# write_basic_package_version_file(<filename> +# [VERSION <major.minor.patch>] +# COMPATIBILITY <AnyNewerVersion|SameMajorVersion|ExactVersion> ) +# +# +# Writes a file for use as ``<package>ConfigVersion.cmake`` file to +# ``<filename>``. See the documentation of :command:`find_package()` for +# details on this. +# +# ``<filename>`` is the output filename, it should be in the build tree. +# ``<major.minor.patch>`` is the version number of the project to be installed. +# +# If no ``VERSION`` is given, the :variable:`PROJECT_VERSION` variable is used. +# If this hasn't been set, it errors out. +# +# The ``COMPATIBILITY`` mode ``AnyNewerVersion`` means that the installed +# package version will be considered compatible if it is newer or exactly the +# same as the requested version. This mode should be used for packages which +# are fully backward compatible, also across major versions. +# If ``SameMajorVersion`` is used instead, then the behaviour differs from +# ``AnyNewerVersion`` in that the major version number must be the same as +# requested, e.g. version 2.0 will not be considered compatible if 1.0 is +# requested. This mode should be used for packages which guarantee backward +# compatibility within the same major version. +# If ``ExactVersion`` is used, then the package is only considered compatible if +# the requested version matches exactly its own version number (not considering +# the tweak version). For example, version 1.2.3 of a package is only +# considered compatible to requested version 1.2.3. This mode is for packages +# without compatibility guarantees. +# If your project has more elaborated version matching rules, you will need to +# write your own custom ``ConfigVersion.cmake`` file instead of using this +# macro. +# +# Internally, this macro executes :command:`configure_file()` to create the +# resulting version file. Depending on the ``COMPATIBLITY``, either the file +# ``BasicConfigVersion-SameMajorVersion.cmake.in`` or +# ``BasicConfigVersion-AnyNewerVersion.cmake.in`` is used. Please note that # these two files are internal to CMake and you should not call -# configure_file() on them yourself, but they can be used as starting -# point to create more sophisticted custom ConfigVersion.cmake files. +# :command:`configure_file()` on them yourself, but they can be used as starting +# point to create more sophisticted custom ``ConfigVersion.cmake`` files. # +# Example Generating Package Files +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # +# Example using both :command:`configure_package_config_file` and +# ``write_basic_package_version_file()``: # -# Example using both configure_package_config_file() and -# write_basic_package_version_file(): CMakeLists.txt: +# ``CMakeLists.txt``: # -# :: +# .. code-block:: cmake # # set(INCLUDE_INSTALL_DIR include/ ... CACHE ) # set(LIB_INSTALL_DIR lib/ ... CACHE ) @@ -162,11 +181,9 @@ # install(FILES ${CMAKE_CURRENT_BINARY_DIR}/FooConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/FooConfigVersion.cmake # DESTINATION ${LIB_INSTALL_DIR}/Foo/cmake ) # +# ``FooConfig.cmake.in``: # -# -# With a FooConfig.cmake.in: -# -# :: +# .. code-block:: cmake # # set(FOO_VERSION x.y.z) # ... @@ -175,10 +192,6 @@ # set_and_check(FOO_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@") # set_and_check(FOO_SYSCONFIG_DIR "@PACKAGE_SYSCONFIG_INSTALL_DIR@") # -# -# -# :: -# # check_required_components(Foo) @@ -203,11 +216,9 @@ macro(WRITE_BASIC_PACKAGE_VERSION_FILE) write_basic_config_version_file(${ARGN}) endmacro() -set(cfpch_dir ${CMAKE_CURRENT_LIST_DIR}) - function(CONFIGURE_PACKAGE_CONFIG_FILE _inputFile _outputFile) set(options NO_SET_AND_CHECK_MACRO NO_CHECK_REQUIRED_COMPONENTS_MACRO) - set(oneValueArgs INSTALL_DESTINATION ) + set(oneValueArgs INSTALL_DESTINATION INSTALL_PREFIX) set(multiValueArgs PATH_VARS ) cmake_parse_arguments(CCF "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) @@ -220,20 +231,30 @@ function(CONFIGURE_PACKAGE_CONFIG_FILE _inputFile _outputFile) message(FATAL_ERROR "No INSTALL_DESTINATION given to CONFIGURE_PACKAGE_CONFIG_FILE()") endif() + if(DEFINED CCF_INSTALL_PREFIX) + if(IS_ABSOLUTE "${CCF_INSTALL_PREFIX}") + set(installPrefix "${CCF_INSTALL_PREFIX}") + else() + message(FATAL_ERROR "INSTALL_PREFIX must be an absolute path") + endif() + else() + set(installPrefix "${CMAKE_INSTALL_PREFIX}") + endif() + if(IS_ABSOLUTE "${CCF_INSTALL_DESTINATION}") set(absInstallDir "${CCF_INSTALL_DESTINATION}") else() - set(absInstallDir "${CMAKE_INSTALL_PREFIX}/${CCF_INSTALL_DESTINATION}") + set(absInstallDir "${installPrefix}/${CCF_INSTALL_DESTINATION}") endif() - file(RELATIVE_PATH PACKAGE_RELATIVE_PATH "${absInstallDir}" "${CMAKE_INSTALL_PREFIX}" ) + file(RELATIVE_PATH PACKAGE_RELATIVE_PATH "${absInstallDir}" "${installPrefix}" ) foreach(var ${CCF_PATH_VARS}) if(NOT DEFINED ${var}) message(FATAL_ERROR "Variable ${var} does not exist") else() if(IS_ABSOLUTE "${${var}}") - string(REPLACE "${CMAKE_INSTALL_PREFIX}" "\${PACKAGE_PREFIX_DIR}" + string(REPLACE "${installPrefix}" "\${PACKAGE_PREFIX_DIR}" PACKAGE_${var} "${${var}}") else() set(PACKAGE_${var} "\${PACKAGE_PREFIX_DIR}/${${var}}") @@ -259,7 +280,7 @@ get_filename_component(PACKAGE_PREFIX_DIR \"\${CMAKE_CURRENT_LIST_DIR}/${PACKAGE get_filename_component(_realCurr \"\${CMAKE_CURRENT_LIST_DIR}\" REALPATH) get_filename_component(_realOrig \"${absInstallDir}\" REALPATH) if(_realCurr STREQUAL _realOrig) - set(PACKAGE_PREFIX_DIR \"${CMAKE_INSTALL_PREFIX}\") + set(PACKAGE_PREFIX_DIR \"${installPrefix}\") endif() unset(_realOrig) unset(_realCurr) diff --git a/Modules/CPack.cmake b/Modules/CPack.cmake index d9e1694..35259c4 100644 --- a/Modules/CPack.cmake +++ b/Modules/CPack.cmake @@ -418,44 +418,44 @@ if(NOT CPACK_GENERATOR) if(APPLE) option(CPACK_BINARY_BUNDLE "Enable to build OSX bundles" OFF) option(CPACK_BINARY_DRAGNDROP "Enable to build OSX Drag And Drop package" OFF) - option(CPACK_BINARY_PACKAGEMAKER "Enable to build PackageMaker packages" OFF) option(CPACK_BINARY_OSXX11 "Enable to build OSX X11 packages" OFF) + option(CPACK_BINARY_PACKAGEMAKER "Enable to build PackageMaker packages" OFF) else() option(CPACK_BINARY_TZ "Enable to build TZ packages" ON) endif() + option(CPACK_BINARY_DEB "Enable to build Debian packages" OFF) + option(CPACK_BINARY_NSIS "Enable to build NSIS packages" OFF) + option(CPACK_BINARY_RPM "Enable to build RPM packages" OFF) option(CPACK_BINARY_STGZ "Enable to build STGZ packages" ON) - option(CPACK_BINARY_TGZ "Enable to build TGZ packages" ON) option(CPACK_BINARY_TBZ2 "Enable to build TBZ2 packages" OFF) + option(CPACK_BINARY_TGZ "Enable to build TGZ packages" ON) option(CPACK_BINARY_TXZ "Enable to build TXZ packages" OFF) - option(CPACK_BINARY_DEB "Enable to build Debian packages" OFF) - option(CPACK_BINARY_RPM "Enable to build RPM packages" OFF) - option(CPACK_BINARY_NSIS "Enable to build NSIS packages" OFF) endif() else() + option(CPACK_BINARY_7Z "Enable to build 7-Zip packages" OFF) option(CPACK_BINARY_NSIS "Enable to build NSIS packages" ON) option(CPACK_BINARY_WIX "Enable to build WiX packages" OFF) option(CPACK_BINARY_ZIP "Enable to build ZIP packages" OFF) - option(CPACK_BINARY_7Z "Enable to build 7-Zip packages" OFF) endif() option(CPACK_BINARY_IFW "Enable to build IFW packages" OFF) + cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_7Z 7Z) cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_BUNDLE Bundle) - cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_DRAGNDROP DragNDrop) - cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_PACKAGEMAKER PackageMaker) - cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_OSXX11 OSXX11) cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_CYGWIN CygwinBinary) cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_DEB DEB) - cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_RPM RPM) + cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_DRAGNDROP DragNDrop) + cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_IFW IFW) cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_NSIS NSIS) + cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_OSXX11 OSXX11) + cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_PACKAGEMAKER PackageMaker) + cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_RPM RPM) cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_STGZ STGZ) - cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_TGZ TGZ) cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_TBZ2 TBZ2) + cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_TGZ TGZ) cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_TXZ TXZ) cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_TZ TZ) cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_WIX WIX) cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_ZIP ZIP) - cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_IFW IFW) - cpack_optional_append(CPACK_GENERATOR CPACK_BINARY_7Z 7Z) endif() @@ -472,29 +472,46 @@ if(NOT CPACK_SOURCE_GENERATOR) option(CPACK_SOURCE_ZIP "Enable to build ZIP source packages" OFF) endif() else() - option(CPACK_SOURCE_ZIP "Enable to build ZIP source packages" ON) option(CPACK_SOURCE_7Z "Enable to build 7-Zip source packages" ON) + option(CPACK_SOURCE_ZIP "Enable to build ZIP source packages" ON) endif() + cpack_optional_append(CPACK_SOURCE_GENERATOR CPACK_SOURCE_7Z 7Z) cpack_optional_append(CPACK_SOURCE_GENERATOR CPACK_SOURCE_CYGWIN CygwinSource) - cpack_optional_append(CPACK_SOURCE_GENERATOR CPACK_SOURCE_TGZ TGZ) cpack_optional_append(CPACK_SOURCE_GENERATOR CPACK_SOURCE_TBZ2 TBZ2) + cpack_optional_append(CPACK_SOURCE_GENERATOR CPACK_SOURCE_TGZ TGZ) cpack_optional_append(CPACK_SOURCE_GENERATOR CPACK_SOURCE_TXZ TXZ) cpack_optional_append(CPACK_SOURCE_GENERATOR CPACK_SOURCE_TZ TZ) cpack_optional_append(CPACK_SOURCE_GENERATOR CPACK_SOURCE_ZIP ZIP) - cpack_optional_append(CPACK_SOURCE_GENERATOR CPACK_SOURCE_7Z 7Z) endif() # mark the above options as advanced -mark_as_advanced(CPACK_BINARY_CYGWIN CPACK_BINARY_PACKAGEMAKER CPACK_BINARY_OSXX11 - CPACK_BINARY_STGZ CPACK_BINARY_TGZ CPACK_BINARY_TBZ2 - CPACK_BINARY_DEB CPACK_BINARY_RPM CPACK_BINARY_TZ - CPACK_BINARY_TXZ CPACK_BINARY_7Z - CPACK_BINARY_NSIS CPACK_BINARY_WIX CPACK_BINARY_ZIP CPACK_BINARY_BUNDLE - CPACK_BINARY_IFW - CPACK_SOURCE_CYGWIN CPACK_SOURCE_TBZ2 CPACK_SOURCE_TGZ - CPACK_SOURCE_TXZ CPACK_SOURCE_7Z - CPACK_SOURCE_TZ CPACK_SOURCE_ZIP CPACK_BINARY_DRAGNDROP) +mark_as_advanced( + CPACK_BINARY_7Z + CPACK_BINARY_BUNDLE + CPACK_BINARY_CYGWIN + CPACK_BINARY_DEB + CPACK_BINARY_DRAGNDROP + CPACK_BINARY_IFW + CPACK_BINARY_NSIS + CPACK_BINARY_OSXX11 + CPACK_BINARY_PACKAGEMAKER + CPACK_BINARY_RPM + CPACK_BINARY_STGZ + CPACK_BINARY_TBZ2 + CPACK_BINARY_TGZ + CPACK_BINARY_TXZ + CPACK_BINARY_TZ + CPACK_BINARY_WIX + CPACK_BINARY_ZIP + CPACK_SOURCE_7Z + CPACK_SOURCE_CYGWIN + CPACK_SOURCE_TBZ2 + CPACK_SOURCE_TGZ + CPACK_SOURCE_TXZ + CPACK_SOURCE_TZ + CPACK_SOURCE_ZIP + ) # Set some other variables cpack_set_if_not_set(CPACK_INSTALL_CMAKE_PROJECTS diff --git a/Modules/CPackIFW.cmake b/Modules/CPackIFW.cmake index 1f6de8f..29a0047 100644 --- a/Modules/CPackIFW.cmake +++ b/Modules/CPackIFW.cmake @@ -123,6 +123,7 @@ # :: # # cpack_ifw_configure_component(<compname> +# [COMMON] # [VERSION <version>] # [SCRIPT <script>] # [NAME <name>] @@ -132,7 +133,11 @@ # # This command should be called after cpack_add_component command. # -# ``VERSION`` is version of component. By default used :variable:`CPACK_PACKAGE_VERSION`. +# ``COMMON`` if set, then the component will be packaged and installed as part +# of a group to which he belongs. +# +# ``VERSION`` is version of component. +# By default used :variable:`CPACK_PACKAGE_VERSION`. # # ``SCRIPT`` is relative or absolute path to operations script # for this component. @@ -163,7 +168,8 @@ # # This command should be called after cpack_add_component_group command. # -# ``VERSION`` is version of component group. By default used :variable:`CPACK_PACKAGE_VERSION`. +# ``VERSION`` is version of component group. +# By default used :variable:`CPACK_PACKAGE_VERSION`. # # ``NAME`` is used to create domain-like identification for this component group. # By default used origin component group name. @@ -346,7 +352,7 @@ macro(cpack_ifw_configure_component compname) string(TOUPPER ${compname} _CPACK_IFWCOMP_UNAME) - set(_IFW_OPT) + set(_IFW_OPT COMMON) set(_IFW_ARGS VERSION SCRIPT NAME PRIORITY) set(_IFW_MULTI_ARGS DEPENDS LICENSES) cmake_parse_arguments(CPACK_IFW_COMPONENT_${_CPACK_IFWCOMP_UNAME} "${_IFW_OPT}" "${_IFW_ARGS}" "${_IFW_MULTI_ARGS}" ${ARGN}) @@ -367,6 +373,12 @@ macro(cpack_ifw_configure_component compname) set(_CPACK_IFWCOMP_STR "\n# Configuration for IFW component \"${compname}\"\n") + foreach(_IFW_ARG_NAME ${_IFW_OPT}) + cpack_append_option_set_command( + CPACK_IFW_COMPONENT_${_CPACK_IFWCOMP_UNAME}_${_IFW_ARG_NAME} + _CPACK_IFWCOMP_STR) + endforeach() + foreach(_IFW_ARG_NAME ${_IFW_ARGS}) cpack_append_string_variable_set_command( CPACK_IFW_COMPONENT_${_CPACK_IFWCOMP_UNAME}_${_IFW_ARG_NAME} diff --git a/Modules/CheckCSourceCompiles.cmake b/Modules/CheckCSourceCompiles.cmake index 8721d55..7523446 100644 --- a/Modules/CheckCSourceCompiles.cmake +++ b/Modules/CheckCSourceCompiles.cmake @@ -39,7 +39,7 @@ macro(CHECK_C_SOURCE_COMPILES SOURCE VAR) - if("${VAR}" MATCHES "^${VAR}$") + if(NOT DEFINED "${VAR}") set(_FAIL_REGEX) set(_key) foreach(arg ${ARGN}) diff --git a/Modules/CheckCSourceRuns.cmake b/Modules/CheckCSourceRuns.cmake index a4fa57e..0fb0f23 100644 --- a/Modules/CheckCSourceRuns.cmake +++ b/Modules/CheckCSourceRuns.cmake @@ -39,7 +39,7 @@ macro(CHECK_C_SOURCE_RUNS SOURCE VAR) - if("${VAR}" MATCHES "^${VAR}$") + if(NOT DEFINED "${VAR}") set(MACRO_CHECK_FUNCTION_DEFINITIONS "-D${VAR} ${CMAKE_REQUIRED_FLAGS}") if(CMAKE_REQUIRED_LIBRARIES) diff --git a/Modules/CheckCXXSourceCompiles.cmake b/Modules/CheckCXXSourceCompiles.cmake index 6ce64a1..edd62a6 100644 --- a/Modules/CheckCXXSourceCompiles.cmake +++ b/Modules/CheckCXXSourceCompiles.cmake @@ -39,7 +39,7 @@ macro(CHECK_CXX_SOURCE_COMPILES SOURCE VAR) - if("${VAR}" MATCHES "^${VAR}$") + if(NOT DEFINED "${VAR}") set(_FAIL_REGEX) set(_key) foreach(arg ${ARGN}) diff --git a/Modules/CheckCXXSourceRuns.cmake b/Modules/CheckCXXSourceRuns.cmake index c655863..02731f8 100644 --- a/Modules/CheckCXXSourceRuns.cmake +++ b/Modules/CheckCXXSourceRuns.cmake @@ -39,7 +39,7 @@ macro(CHECK_CXX_SOURCE_RUNS SOURCE VAR) - if("${VAR}" MATCHES "^${VAR}$") + if(NOT DEFINED "${VAR}") set(MACRO_CHECK_FUNCTION_DEFINITIONS "-D${VAR} ${CMAKE_REQUIRED_FLAGS}") if(CMAKE_REQUIRED_LIBRARIES) diff --git a/Modules/CheckFunctionExists.cmake b/Modules/CheckFunctionExists.cmake index bfd1836..01a652b 100644 --- a/Modules/CheckFunctionExists.cmake +++ b/Modules/CheckFunctionExists.cmake @@ -38,7 +38,7 @@ macro(CHECK_FUNCTION_EXISTS FUNCTION VARIABLE) - if("${VARIABLE}" MATCHES "^${VARIABLE}$") + if(NOT DEFINED "${VARIABLE}") set(MACRO_CHECK_FUNCTION_DEFINITIONS "-DCHECK_FUNCTION_EXISTS=${FUNCTION} ${CMAKE_REQUIRED_FLAGS}") if(NOT CMAKE_REQUIRED_QUIET) diff --git a/Modules/CheckIncludeFile.cmake b/Modules/CheckIncludeFile.cmake index ea73267..c217bd4 100644 --- a/Modules/CheckIncludeFile.cmake +++ b/Modules/CheckIncludeFile.cmake @@ -40,7 +40,7 @@ # License text for the above reference.) macro(CHECK_INCLUDE_FILE INCLUDE VARIABLE) - if("${VARIABLE}" MATCHES "^${VARIABLE}$") + if(NOT DEFINED "${VARIABLE}") if(CMAKE_REQUIRED_INCLUDES) set(CHECK_INCLUDE_FILE_C_INCLUDE_DIRS "-DINCLUDE_DIRECTORIES=${CMAKE_REQUIRED_INCLUDES}") else() diff --git a/Modules/CheckIncludeFileCXX.cmake b/Modules/CheckIncludeFileCXX.cmake index 39abeff..718e667 100644 --- a/Modules/CheckIncludeFileCXX.cmake +++ b/Modules/CheckIncludeFileCXX.cmake @@ -44,7 +44,7 @@ # License text for the above reference.) macro(CHECK_INCLUDE_FILE_CXX INCLUDE VARIABLE) - if("${VARIABLE}" MATCHES "^${VARIABLE}$") + if(NOT DEFINED "${VARIABLE}") if(CMAKE_REQUIRED_INCLUDES) set(CHECK_INCLUDE_FILE_CXX_INCLUDE_DIRS "-DINCLUDE_DIRECTORIES=${CMAKE_REQUIRED_INCLUDES}") else() diff --git a/Modules/CheckIncludeFiles.cmake b/Modules/CheckIncludeFiles.cmake index 6aa0f2b..f8378c0 100644 --- a/Modules/CheckIncludeFiles.cmake +++ b/Modules/CheckIncludeFiles.cmake @@ -39,7 +39,7 @@ # License text for the above reference.) macro(CHECK_INCLUDE_FILES INCLUDE VARIABLE) - if("${VARIABLE}" MATCHES "^${VARIABLE}$") + if(NOT DEFINED "${VARIABLE}") set(CMAKE_CONFIGURABLE_FILE_CONTENT "/* */\n") if(CMAKE_REQUIRED_INCLUDES) set(CHECK_INCLUDE_FILES_INCLUDE_DIRS "-DINCLUDE_DIRECTORIES=${CMAKE_REQUIRED_INCLUDES}") @@ -53,7 +53,7 @@ macro(CHECK_INCLUDE_FILES INCLUDE VARIABLE) "${CMAKE_CONFIGURABLE_FILE_CONTENT}#include <${FILE}>\n") endforeach() set(CMAKE_CONFIGURABLE_FILE_CONTENT - "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n\nint main(){return 0;}\n") + "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n\nint main(void){return 0;}\n") configure_file("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckIncludeFiles.c" @ONLY) diff --git a/Modules/CheckLibraryExists.cmake b/Modules/CheckLibraryExists.cmake index 2b41379..fac5dd1 100644 --- a/Modules/CheckLibraryExists.cmake +++ b/Modules/CheckLibraryExists.cmake @@ -41,7 +41,7 @@ macro(CHECK_LIBRARY_EXISTS LIBRARY FUNCTION LOCATION VARIABLE) - if("${VARIABLE}" MATCHES "^${VARIABLE}$") + if(NOT DEFINED "${VARIABLE}") set(MACRO_CHECK_LIBRARY_EXISTS_DEFINITION "-DCHECK_FUNCTION_EXISTS=${FUNCTION} ${CMAKE_REQUIRED_FLAGS}") if(NOT CMAKE_REQUIRED_QUIET) diff --git a/Modules/CheckSymbolExists.cmake b/Modules/CheckSymbolExists.cmake index bf2e797..6f50c88 100644 --- a/Modules/CheckSymbolExists.cmake +++ b/Modules/CheckSymbolExists.cmake @@ -50,7 +50,7 @@ macro(CHECK_SYMBOL_EXISTS SYMBOL FILES VARIABLE) endmacro() macro(_CHECK_SYMBOL_EXISTS SOURCEFILE SYMBOL FILES VARIABLE) - if("${VARIABLE}" MATCHES "^${VARIABLE}$") + if(NOT DEFINED "${VARIABLE}") set(CMAKE_CONFIGURABLE_FILE_CONTENT "/* */\n") set(MACRO_CHECK_SYMBOL_EXISTS_FLAGS ${CMAKE_REQUIRED_FLAGS}) if(CMAKE_REQUIRED_LIBRARIES) diff --git a/Modules/CheckVariableExists.cmake b/Modules/CheckVariableExists.cmake index 3a7ef13..9e8e984 100644 --- a/Modules/CheckVariableExists.cmake +++ b/Modules/CheckVariableExists.cmake @@ -45,7 +45,7 @@ macro(CHECK_VARIABLE_EXISTS VAR VARIABLE) - if("${VARIABLE}" MATCHES "^${VARIABLE}$") + if(NOT DEFINED "${VARIABLE}") set(MACRO_CHECK_VARIABLE_DEFINITIONS "-DCHECK_VARIABLE_EXISTS=${VAR} ${CMAKE_REQUIRED_FLAGS}") if(NOT CMAKE_REQUIRED_QUIET) diff --git a/Modules/Compiler/Fujitsu-DetermineCompiler.cmake b/Modules/Compiler/Fujitsu-DetermineCompiler.cmake new file mode 100644 index 0000000..73ee38c --- /dev/null +++ b/Modules/Compiler/Fujitsu-DetermineCompiler.cmake @@ -0,0 +1,2 @@ + +set(_compiler_id_pp_test "defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)") diff --git a/Modules/ExternalData.cmake b/Modules/ExternalData.cmake index 73a4990..79bb064 100644 --- a/Modules/ExternalData.cmake +++ b/Modules/ExternalData.cmake @@ -76,7 +76,7 @@ # SHA512 .sha512 US Secure Hash Algorithms, RFC 4634 # # Note that the hashes are used only for unique data identification and -# download verification. This is not security software. +# download verification. # # Example usage: # @@ -75,6 +75,22 @@ For instructions how to do this, see documentation on `Running CMake`_. .. _`Running CMake`: http://www.cmake.org/cmake/help/runningcmake.html +Reporting Bugs +============== + +If you have found a bug: + +1. If you have a patch, please read the `CONTRIBUTING.rst`_ document. + +2. Otherwise, please join the the `CMake Users List`_ and ask about + the expected and observed behaviors to determine if it is really + a bug. + +3. Finally, if the issue is not resolved by the above steps, open + an entry in the `CMake Issue Tracker`_. + +.. _`CMake Issue Tracker`: http://www.cmake.org/Bug + Contributing ============ diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index 7f36bb2..ff7bc8d 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -577,7 +577,9 @@ set(CPACK_SRCS CPack/cmCPackGenerator.cxx CPack/cmCPackLog.cxx CPack/cmCPackNSISGenerator.cxx - CPack/cmCPackIFWGenerator.cxx + CPack/IFW/cmCPackIFWPackage.cxx + CPack/IFW/cmCPackIFWInstaller.cxx + CPack/IFW/cmCPackIFWGenerator.cxx CPack/cmCPackSTGZGenerator.cxx CPack/cmCPackTGZGenerator.cxx CPack/cmCPackTXZGenerator.cxx @@ -604,13 +606,14 @@ endif() if(WIN32) set(CPACK_SRCS ${CPACK_SRCS} CPack/WiX/cmCPackWIXGenerator.cxx - CPack/WiX/cmWIXSourceWriter.cxx + CPack/WiX/cmWIXAccessControlList.cxx CPack/WiX/cmWIXDirectoriesSourceWriter.cxx CPack/WiX/cmWIXFeaturesSourceWriter.cxx CPack/WiX/cmWIXFilesSourceWriter.cxx - CPack/WiX/cmWIXRichTextFormatWriter.cxx CPack/WiX/cmWIXPatch.cxx CPack/WiX/cmWIXPatchParser.cxx + CPack/WiX/cmWIXRichTextFormatWriter.cxx + CPack/WiX/cmWIXSourceWriter.cxx ) endif() diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake index ea892aa..dffdbd1 100644 --- a/Source/CMakeVersion.cmake +++ b/Source/CMakeVersion.cmake @@ -1,5 +1,5 @@ # CMake version number components. set(CMake_VERSION_MAJOR 3) set(CMake_VERSION_MINOR 0) -set(CMake_VERSION_PATCH 20140731) +set(CMake_VERSION_PATCH 20140812) #set(CMake_VERSION_RC 1) diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.cxx b/Source/CPack/IFW/cmCPackIFWGenerator.cxx new file mode 100644 index 0000000..e7c97c6 --- /dev/null +++ b/Source/CPack/IFW/cmCPackIFWGenerator.cxx @@ -0,0 +1,538 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ + +#include "cmCPackIFWGenerator.h" + +#include "cmCPackIFWPackage.h" +#include "cmCPackIFWInstaller.h" + +#include <CPack/cmCPackLog.h> +#include <CPack/cmCPackComponentGroup.h> + +#include <cmsys/SystemTools.hxx> +#include <cmsys/Glob.hxx> +#include <cmsys/Directory.hxx> +#include <cmsys/RegularExpression.hxx> + +#include <cmGlobalGenerator.h> +#include <cmLocalGenerator.h> +#include <cmSystemTools.h> +#include <cmMakefile.h> +#include <cmGeneratedFileStream.h> +#include <cmXMLSafe.h> + +//---------------------------------------------------------------------------- +cmCPackIFWGenerator::cmCPackIFWGenerator() +{ + // Change the default behavior + componentPackageMethod = ONE_PACKAGE_PER_COMPONENT; +} + +//---------------------------------------------------------------------------- +cmCPackIFWGenerator::~cmCPackIFWGenerator() +{ +} + +//---------------------------------------------------------------------------- +int cmCPackIFWGenerator::PackageFiles() +{ + cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Configuration" << std::endl); + + // Installer configuragion + Installer.GenerateInstallerFile(); + + // Packages configuration + Installer.GeneratePackageFiles(); + + std::string ifwTLD = this->GetOption("CPACK_TOPLEVEL_DIRECTORY"); + std::string ifwTmpFile = ifwTLD; + ifwTmpFile += "/IFWOutput.log"; + + // Run repogen + if (!DownloadSite.empty()) + { + std::string ifwCmd = RepoGen; + ifwCmd += " -c " + this->toplevel + "/config/config.xml"; + ifwCmd += " -p " + this->toplevel + "/packages"; + + if(!PkgsDirsVector.empty()) + { + for(std::vector<std::string>::iterator it = PkgsDirsVector.begin(); + it != PkgsDirsVector.end(); ++it) + { + ifwCmd += " -p " + *it; + } + } + + if (!OnlineOnly && !DownloadedPackages.empty()) + { + ifwCmd += " -i "; + std::set<cmCPackIFWPackage*>::iterator it + = DownloadedPackages.begin(); + ifwCmd += (*it)->Name; + ++it; + while(it != DownloadedPackages.end()) + { + ifwCmd += "," + (*it)->Name; + ++it; + } + } + ifwCmd += " " + this->toplevel + "/repository"; + cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd + << std::endl); + std::string output; + int retVal = 1; + cmCPackLogger(cmCPackLog::LOG_OUTPUT, + "- Generate repository" << std::endl); + bool res = cmSystemTools::RunSingleCommand( + ifwCmd.c_str(), &output, &retVal, 0, this->GeneratorVerbose, 0); + if ( !res || retVal ) + { + cmGeneratedFileStream ofs(ifwTmpFile.c_str()); + ofs << "# Run command: " << ifwCmd << std::endl + << "# Output:" << std::endl + << output << std::endl; + cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: " + << ifwCmd << std::endl + << "Please check " << ifwTmpFile << " for errors" + << std::endl); + return 0; + } + cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- repository: " << this->toplevel + << "/repository generated" << std::endl); + } + + // Run binary creator + { + std::string ifwCmd = BinCreator; + ifwCmd += " -c " + this->toplevel + "/config/config.xml"; + ifwCmd += " -p " + this->toplevel + "/packages"; + + if(!PkgsDirsVector.empty()) + { + for(std::vector<std::string>::iterator it = PkgsDirsVector.begin(); + it != PkgsDirsVector.end(); ++it) + { + ifwCmd += " -p " + *it; + } + } + + if (OnlineOnly) + { + ifwCmd += " --online-only"; + } + else if (!DownloadedPackages.empty() && !DownloadSite.empty()) + { + ifwCmd += " -e "; + std::set<cmCPackIFWPackage*>::iterator it + = DownloadedPackages.begin(); + ifwCmd += (*it)->Name; + ++it; + while(it != DownloadedPackages.end()) + { + ifwCmd += "," + (*it)->Name; + ++it; + } + } + else if (!DependentPackages.empty()) + { + ifwCmd += " -i "; + // Binary + std::set<cmCPackIFWPackage*>::iterator bit = BinaryPackages.begin(); + while(bit != BinaryPackages.end()) + { + ifwCmd += (*bit)->Name + ","; + ++bit; + } + // Depend + DependenceMap::iterator it = DependentPackages.begin(); + ifwCmd += it->second.Name; + ++it; + while(it != DependentPackages.end()) + { + ifwCmd += "," + it->second.Name; + ++it; + } + } + // TODO: set correct name for multipackages + if (this->packageFileNames.size() > 0) + { + ifwCmd += " " + packageFileNames[0]; + } + else + { + ifwCmd += " installer"; + } + cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd + << std::endl); + std::string output; + int retVal = 1; + cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate package" << std::endl); + bool res = cmSystemTools::RunSingleCommand( + ifwCmd.c_str(), &output, &retVal, 0, this->GeneratorVerbose, 0); + if ( !res || retVal ) + { + cmGeneratedFileStream ofs(ifwTmpFile.c_str()); + ofs << "# Run command: " << ifwCmd << std::endl + << "# Output:" << std::endl + << output << std::endl; + cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: " + << ifwCmd << std::endl + << "Please check " << ifwTmpFile << " for errors" + << std::endl); + return 0; + } + } + + return 1; +} + +//---------------------------------------------------------------------------- +const char *cmCPackIFWGenerator::GetPackagingInstallPrefix() +{ + const char *defPrefix = cmCPackGenerator::GetPackagingInstallPrefix(); + + std::string tmpPref = defPrefix ? defPrefix : ""; + + if(this->Components.empty()) + { + tmpPref += "packages/" + GetRootPackageName() + "/data"; + } + + this->SetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX", tmpPref.c_str()); + + return this->GetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX"); +} + +//---------------------------------------------------------------------------- +const char *cmCPackIFWGenerator::GetOutputExtension() +{ + const char *suffix = this->GetOption("CMAKE_EXECUTABLE_SUFFIX"); + return suffix ? suffix : cmCPackGenerator::GetOutputExtension(); +} + +//---------------------------------------------------------------------------- +int cmCPackIFWGenerator::InitializeInternal() +{ + // Search Qt Installer Framework tools + + if(!this->IsOn("CPACK_IFW_BINARYCREATOR_EXECUTABLE_FOUND") || + !this->IsOn("CPACK_IFW_REPOGEN_EXECUTABLE_FOUND")) + { + this->ReadListFile("CPackIFW.cmake"); + } + + // Look 'binarycreator' executable (needs) + + if(this->IsOn("CPACK_IFW_BINARYCREATOR_EXECUTABLE_FOUND")) + { + const char *ifwBinCreatorStr = + this->GetOption("CPACK_IFW_BINARYCREATOR_EXECUTABLE"); + BinCreator = ifwBinCreatorStr ? ifwBinCreatorStr : ""; + } + else + { + BinCreator = ""; + } + + if (BinCreator.empty()) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Cannot find QtIFW compiler \"binarycreator\": " + "likely it is not installed, or not in your PATH" + << std::endl); + return 0; + } + + // Look 'repogen' executable (optional) + + if(this->IsOn("CPACK_IFW_REPOGEN_EXECUTABLE_FOUND")) + { + const char *ifwRepoGenStr = + this->GetOption("CPACK_IFW_REPOGEN_EXECUTABLE"); + RepoGen = ifwRepoGenStr ? ifwRepoGenStr : ""; + } + else + { + RepoGen = ""; + } + + // Variables that Change Behavior + + // Resolve duplicate names + ResolveDuplicateNames = this->IsOn("CPACK_IFW_RESOLVE_DUPLICATE_NAMES"); + + // Additional packages dirs + PkgsDirsVector.clear(); + if(const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES")) + { + cmSystemTools::ExpandListArgument(dirs, + PkgsDirsVector); + } + + // Remote repository + + if (const char *site = this->GetOption("CPACK_DOWNLOAD_SITE")) + { + DownloadSite = site; + } + + OnlineOnly = this->IsOn("CPACK_DOWNLOAD_ALL") ? true : false; + + if (!DownloadSite.empty() && RepoGen.empty()) { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Cannot find QtIFW repository generator \"repogen\": " + "likely it is not installed, or not in your PATH" + << std::endl); + return 0; + } + + // Installer + Installer.Generator = this; + Installer.ConfigureFromOptions(); + + return this->Superclass::InitializeInternal(); +} + +//---------------------------------------------------------------------------- +std::string +cmCPackIFWGenerator::GetComponentInstallDirNameSuffix( + const std::string& componentName) +{ + const std::string prefix = "packages/"; + const std::string suffix = "/data"; + + if (componentPackageMethod == ONE_PACKAGE) { + return std::string(prefix + GetRootPackageName() + suffix); + } + + return prefix + + GetComponentPackageName(&Components[componentName]) + + suffix; +} + +//---------------------------------------------------------------------------- +cmCPackComponent* +cmCPackIFWGenerator::GetComponent(const std::string &projectName, + const std::string &componentName) +{ + ComponentsMap::iterator cit = Components.find(componentName); + if ( cit != Components.end() ) return &(cit->second); + + cmCPackComponent* component + = cmCPackGenerator::GetComponent(projectName, componentName); + if(!component) return component; + + std::string name = GetComponentPackageName(component); + PackagesMap::iterator pit = Packages.find(name); + if(pit != Packages.end()) return component; + + cmCPackIFWPackage *package = &Packages[name]; + package->Name = name; + package->Generator = this; + if(package->ConfigureFromComponent(component)) + { + package->Installer = &Installer; + Installer.Packages.insert( + std::pair<std::string, cmCPackIFWPackage*>( + name, package)); + ComponentPackages.insert( + std::pair<cmCPackComponent*, cmCPackIFWPackage*>( + component, package)); + if(component->IsDownloaded) + { + DownloadedPackages.insert(package); + } + else + { + BinaryPackages.insert(package); + } + } + else + { + Packages.erase(name); + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Cannot configure package \"" << name << + "\" for component \"" << component->Name << "\"" + << std::endl); + } + + return component; +} + +//---------------------------------------------------------------------------- +cmCPackComponentGroup* +cmCPackIFWGenerator::GetComponentGroup(const std::string &projectName, + const std::string &groupName) +{ + ComponentGoupsMap::iterator git = ComponentGroups.find(groupName); + if ( git != ComponentGroups.end() ) return &(git->second); + + cmCPackComponentGroup* group + = cmCPackGenerator::GetComponentGroup(projectName, groupName); + if(!group) return group; + + std::string name = GetGroupPackageName(group); + PackagesMap::iterator pit = Packages.find(name); + if(pit != Packages.end()) return group; + + cmCPackIFWPackage *package = &Packages[name]; + package->Name = name; + package->Generator = this; + if(package->ConfigureFromComponentGroup(group)) + { + package->Installer = &Installer; + Installer.Packages.insert( + std::pair<std::string, cmCPackIFWPackage*>( + name, package)); + GroupPackages.insert( + std::pair<cmCPackComponentGroup*, cmCPackIFWPackage*>( + group, package)); + BinaryPackages.insert(package); + } + else + { + Packages.erase(name); + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Cannot configure package \"" << name << + "\" for component group \"" << group->Name << "\"" + << std::endl); + } + return group; +} + +//---------------------------------------------------------------------------- +enum cmCPackGenerator::CPackSetDestdirSupport +cmCPackIFWGenerator::SupportsSetDestdir() const +{ + return cmCPackGenerator::SETDESTDIR_SHOULD_NOT_BE_USED; +} + +//---------------------------------------------------------------------------- +bool cmCPackIFWGenerator::SupportsAbsoluteDestination() const +{ + return false; +} + +//---------------------------------------------------------------------------- +bool cmCPackIFWGenerator::SupportsComponentInstallation() const +{ + return true; +} + +//---------------------------------------------------------------------------- +bool cmCPackIFWGenerator::IsOnePackage() const +{ + return componentPackageMethod == ONE_PACKAGE; +} + +//---------------------------------------------------------------------------- +std::string cmCPackIFWGenerator::GetRootPackageName() const +{ + std::string name = "root"; + if(const char* optIFW_ROOT_PACKAGE_NAME = + this->GetOption("CPACK_IFW_ROOT_PACKAGE_NAME")) + { + name = optIFW_ROOT_PACKAGE_NAME; + } + else if (const char* optPACKAGE_NAME = + this->GetOption("CPACK_PACKAGE_NAME")) + { + name = optPACKAGE_NAME; + } + return name; +} + +//---------------------------------------------------------------------------- +std::string +cmCPackIFWGenerator::GetGroupPackageName(cmCPackComponentGroup *group) const +{ + std::string name; + if (!group) return name; + if (cmCPackIFWPackage* package = GetGroupPackage(group)) + { + return package->Name; + } + const char* option = GetOption( + "CPACK_IFW_COMPONENT_GROUP_" + + cmsys::SystemTools::UpperCase(group->Name) + + "_NAME"); + name = option ? option : group->Name; + if(group->ParentGroup) + { + cmCPackIFWPackage* package = GetGroupPackage(group->ParentGroup); + bool dot = !ResolveDuplicateNames; + if(dot && name.substr(0, package->Name.size()) == package->Name) + { + dot = false; + } + if(dot) + { + name = package->Name + "." + name; + } + } + return name; +} + +//---------------------------------------------------------------------------- +std::string cmCPackIFWGenerator::GetComponentPackageName( + cmCPackComponent *component) const +{ + std::string name; + if (!component) return name; + if (cmCPackIFWPackage* package = GetComponentPackage(component)) + { + return package->Name; + } + std::string prefix = "CPACK_IFW_COMPONENT_" + + cmsys::SystemTools::UpperCase(component->Name) + + "_"; + const char* option = GetOption(prefix + "NAME"); + name = option ? option : component->Name; + if(component->Group) + { + cmCPackIFWPackage* package = GetGroupPackage(component->Group); + if((componentPackageMethod == ONE_PACKAGE_PER_GROUP) + || IsOn(prefix + "COMMON")) + { + return package->Name; + } + bool dot = !ResolveDuplicateNames; + if(dot && name.substr(0, package->Name.size()) == package->Name) + { + dot = false; + } + if(dot) + { + name = package->Name + "." + name; + } + } + return name; +} + +//---------------------------------------------------------------------------- +cmCPackIFWPackage* cmCPackIFWGenerator::GetGroupPackage( + cmCPackComponentGroup *group) const +{ + std::map<cmCPackComponentGroup*, cmCPackIFWPackage*>::const_iterator pit + = GroupPackages.find(group); + return pit != GroupPackages.end() ? pit->second : 0; +} + +//---------------------------------------------------------------------------- +cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage( + cmCPackComponent *component) const +{ + std::map<cmCPackComponent*, cmCPackIFWPackage*>::const_iterator pit + = ComponentPackages.find(component); + return pit != ComponentPackages.end() ? pit->second : 0; +} diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.h b/Source/CPack/IFW/cmCPackIFWGenerator.h new file mode 100644 index 0000000..e871f7c --- /dev/null +++ b/Source/CPack/IFW/cmCPackIFWGenerator.h @@ -0,0 +1,137 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ + +#ifndef cmCPackIFWGenerator_h +#define cmCPackIFWGenerator_h + +#include <CPack/cmCPackGenerator.h> + +#include "cmCPackIFWPackage.h" +#include "cmCPackIFWInstaller.h" + +/** \class cmCPackIFWGenerator + * \brief A generator for Qt Installer Framework tools + * + * http://qt-project.org/doc/qtinstallerframework/index.html + */ +class cmCPackIFWGenerator : public cmCPackGenerator +{ +public: + cmCPackTypeMacro(cmCPackIFWGenerator, cmCPackGenerator); + + typedef std::map<std::string, cmCPackIFWPackage> PackagesMap; + typedef std::map<std::string, cmCPackComponent> ComponentsMap; + typedef std::map<std::string, cmCPackComponentGroup> ComponentGoupsMap; + typedef std::map<std::string, cmCPackIFWPackage::DependenceStruct> + DependenceMap; + + /** + * Construct IFW generator + */ + cmCPackIFWGenerator(); + + /** + * Destruct IFW generator + */ + virtual ~cmCPackIFWGenerator(); + +protected: // cmCPackGenerator reimplementation + + /** + * @brief Initialize generator + * @return 0 on failure + */ + virtual int InitializeInternal(); + virtual int PackageFiles(); + virtual const char* GetPackagingInstallPrefix(); + + /** + * @brief Extension of binary installer + * @return Executable suffix or value from default implementation + */ + virtual const char* GetOutputExtension(); + + virtual std::string GetComponentInstallDirNameSuffix( + const std::string& componentName); + + /** + * @brief Get Component + * @param projectName Project name + * @param componentName Component name + * + * This method calls the base implementation. + * + * @return Pointer to component + */ + virtual cmCPackComponent* GetComponent( + const std::string& projectName, + const std::string& componentName); + + /** + * @brief Get group of component + * @param projectName Project name + * @param groupName Component group name + * + * This method calls the base implementation. + * + * @return Pointer to component group + */ + virtual cmCPackComponentGroup* GetComponentGroup( + const std::string& projectName, + const std::string& groupName); + + enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const; + virtual bool SupportsAbsoluteDestination() const; + virtual bool SupportsComponentInstallation() const; + +protected: // Methods + + bool IsOnePackage() const; + + std::string GetRootPackageName() const; + + std::string GetGroupPackageName(cmCPackComponentGroup *group) const; + std::string GetComponentPackageName(cmCPackComponent *component) const; + + cmCPackIFWPackage* GetGroupPackage(cmCPackComponentGroup *group) const; + cmCPackIFWPackage* GetComponentPackage(cmCPackComponent *component) const; + +protected: // Data + + friend class cmCPackIFWPackage; + friend class cmCPackIFWInstaller; + + // Installer + cmCPackIFWInstaller Installer; + // Collection of packages + PackagesMap Packages; + // Collection of binary packages + std::set<cmCPackIFWPackage*> BinaryPackages; + // Collection of downloaded packages + std::set<cmCPackIFWPackage*> DownloadedPackages; + // Dependent packages + DependenceMap DependentPackages; + std::map<cmCPackComponent*, cmCPackIFWPackage*> ComponentPackages; + std::map<cmCPackComponentGroup*, cmCPackIFWPackage*> GroupPackages; + +private: + std::string RepoGen; + std::string BinCreator; + + std::string DownloadSite; + + bool OnlineOnly; + bool ResolveDuplicateNames; + std::vector<std::string> PkgsDirsVector; +}; + +#endif diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx new file mode 100644 index 0000000..78b2ffb --- /dev/null +++ b/Source/CPack/IFW/cmCPackIFWInstaller.cxx @@ -0,0 +1,289 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ + +#include "cmCPackIFWInstaller.h" + +#include "cmCPackIFWGenerator.h" + +#include <CPack/cmCPackLog.h> + +#include <cmGeneratedFileStream.h> +#include <cmXMLSafe.h> + +#ifdef cmCPackLogger +# undef cmCPackLogger +#endif +#define cmCPackLogger(logType, msg) \ + do { \ + cmOStringStream cmCPackLog_msg; \ + cmCPackLog_msg << msg; \ + if(Generator) { \ + Generator->Logger->Log(logType, __FILE__, __LINE__, \ + cmCPackLog_msg.str().c_str()); \ + } \ + } while ( 0 ) + +//---------------------------------------------------------------------------- +cmCPackIFWInstaller::cmCPackIFWInstaller() : + Generator(0) +{ +} + +//---------------------------------------------------------------------------- +const char *cmCPackIFWInstaller::GetOption(const std::string &op) const +{ + return Generator ? Generator->GetOption(op) : 0; +} + +//---------------------------------------------------------------------------- +void cmCPackIFWInstaller::ConfigureFromOptions() +{ + // Name; + if (const char* option = GetOption("CPACK_PACKAGE_NAME")) + { + Name = option; + } + else + { + Name = "Your package"; + } + + // Title; + if (const char* optIFW_PACKAGE_TITLE = + GetOption("CPACK_IFW_PACKAGE_TITLE")) + { + Title = optIFW_PACKAGE_TITLE; + } + else if (const char* optPACKAGE_DESCRIPTION_SUMMARY = + GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) + { + Title = optPACKAGE_DESCRIPTION_SUMMARY; + } + else + { + Title = "Your package description"; + } + + // Version; + if (const char* option = GetOption("CPACK_PACKAGE_VERSION")) + { + Version = option; + } + else + { + Version = "1.0.0"; + } + + // Publisher + if(const char* optIFW_PACKAGE_PUBLISHER = + GetOption("CPACK_IFW_PACKAGE_PUBLISHER")) + { + Publisher = optIFW_PACKAGE_PUBLISHER; + } + else if(const char* optPACKAGE_VENDOR = GetOption("CPACK_PACKAGE_VENDOR")) + { + Publisher = optPACKAGE_VENDOR; + } + + // ProductUrl + if(const char* option = GetOption("CPACK_IFW_PRODUCT_URL")) + { + ProductUrl = option; + } + + // ApplicationIcon + if(const char* option = GetOption("CPACK_IFW_PACKAGE_ICON")) + { + if(cmSystemTools::FileExists(option)) + { + InstallerApplicationIcon = option; + } + else + { + // TODO: implement warning + } + } + + // WindowIcon + if(const char* option = GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON")) + { + if(cmSystemTools::FileExists(option)) + { + InstallerWindowIcon = option; + } + else + { + // TODO: implement warning + } + } + + // Logo + if(const char* option = GetOption("CPACK_IFW_PACKAGE_LOGO")) + { + if(cmSystemTools::FileExists(option)) + { + Logo = option; + } + else + { + // TODO: implement warning + } + } + + // Default target directory for installation + if (const char* optIFW_TARGET_DIRECTORY = + GetOption("CPACK_IFW_TARGET_DIRECTORY")) + { + TargetDir = optIFW_TARGET_DIRECTORY; + } + else if (const char *optPACKAGE_INSTALL_DIRECTORY = + GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY")) + { + TargetDir = "@ApplicationsDir@/"; + TargetDir += optPACKAGE_INSTALL_DIRECTORY; + } + else + { + TargetDir = "@RootDir@/usr/local"; + } + + // Default target directory for installation with administrator rights + if (const char* option = GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY")) + { + AdminTargetDir = option; + } +} + +//---------------------------------------------------------------------------- +void cmCPackIFWInstaller::GenerateInstallerFile() +{ + // Lazy directory initialization + if(Directory.empty() && Generator) + { + Directory = Generator->toplevel; + } + + // Output stream + cmGeneratedFileStream xout((Directory + "/config/config.xml").data()); + + xout << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl; + xout << "<Installer>" << std::endl; + + xout << " <Name>" << cmXMLSafe(Name).str() << "</Name>" << std::endl; + + xout << " <Version>" << Version << "</Version>" << std::endl; + + xout << " <Title>" << cmXMLSafe(Title).str() << "</Title>" + << std::endl; + + if(!Publisher.empty()) + { + xout << " <Publisher>" << cmXMLSafe(Publisher).str() + << "</Publisher>" << std::endl; + } + + if(!ProductUrl.empty()) + { + xout << " <ProductUrl>" << ProductUrl << "</ProductUrl>" << std::endl; + } + + // ApplicationIcon + if(!InstallerApplicationIcon.empty()) + { + std::string name = + cmSystemTools::GetFilenameName(InstallerApplicationIcon); + std::string path = Directory + "/config/" + name; + name = cmSystemTools::GetFilenameWithoutExtension(name); + cmsys::SystemTools::CopyFileIfDifferent( + InstallerApplicationIcon.data(), path.data()); + xout << " <InstallerApplicationIcon>" << name + << "</InstallerApplicationIcon>" << std::endl; + } + + // WindowIcon + if(!InstallerWindowIcon.empty()) + { + std::string name = cmSystemTools::GetFilenameName(InstallerWindowIcon); + std::string path = Directory + "/config/" + name; + cmsys::SystemTools::CopyFileIfDifferent( + InstallerWindowIcon.data(), path.data()); + xout << " <InstallerWindowIcon>" << name + << "</InstallerWindowIcon>" << std::endl; + } + + // Logo + if(!Logo.empty()) + { + std::string name = cmSystemTools::GetFilenameName(Logo); + std::string path = Directory + "/config/" + name; + cmsys::SystemTools::CopyFileIfDifferent(Logo.data(), path.data()); + xout << " <Logo>" << name << "</Logo>" << std::endl; + } + + if(!TargetDir.empty()) + { + xout << " <TargetDir>" << TargetDir << "</TargetDir>" << std::endl; + } + + if(!AdminTargetDir.empty()) + { + xout << " <AdminTargetDir>" << AdminTargetDir + << "</AdminTargetDir>" << std::endl; + } + + // Site + if (!Generator->DownloadSite.empty()) + { + xout << " <RemoteRepositories>" << std::endl; + xout << " <Repository>" << std::endl; + xout << " <Url>" << Generator->DownloadSite + << "</Url>" << std::endl; + // These properties can not be set from "cpack_configure_downloads" + // <Enabled>1</Enabled> + // <Username>user</Username> + // <Password>password</Password> + // <DisplayName>Example repository</DisplayName> + xout << " </Repository>" << std::endl; + xout << " </RemoteRepositories>" << std::endl; + } + + // CPack IFW default policy + xout << " <!-- CPack IFW default policy -->" << std::endl; + xout << " <AllowNonAsciiCharacters>true</AllowNonAsciiCharacters>" + << std::endl; + xout << " <AllowSpaceInPath>true</AllowSpaceInPath>" << std::endl; + + xout << "</Installer>" << std::endl; +} + +//---------------------------------------------------------------------------- +void cmCPackIFWInstaller::GeneratePackageFiles() +{ + if (Packages.empty() || Generator->IsOnePackage()) + { + // Generate default package + cmCPackIFWPackage package; + package.Generator = Generator; + package.Installer = this; + package.ConfigureFromOptions(); + package.GeneratePackageFile(); + return; + } + + // Generate packages meta information + for(PackagesMap::iterator pit = Packages.begin(); + pit != Packages.end(); ++pit) + { + cmCPackIFWPackage* package = pit->second; + package->GeneratePackageFile(); + } +} diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.h b/Source/CPack/IFW/cmCPackIFWInstaller.h new file mode 100644 index 0000000..02cd07b --- /dev/null +++ b/Source/CPack/IFW/cmCPackIFWInstaller.h @@ -0,0 +1,84 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ + +#ifndef cmCPackIFWInstaller_h +#define cmCPackIFWInstaller_h + +#include "cmStandardIncludes.h" + +class cmCPackIFWPackage; +class cmCPackIFWGenerator; + +/** \class cmCPackIFWInstaller + * \brief A binary installer to be created CPack IFW generator + */ +class cmCPackIFWInstaller +{ +public: // Types + + typedef std::map<std::string, cmCPackIFWPackage*> PackagesMap; + +public: // Constructor + + /** + * Construct installer + */ + cmCPackIFWInstaller(); + +public: // Configuration + + /// Name of the product being installed + std::string Name; + + /// Version number of the product being installed + std::string Version; + + /// Name of the installer as displayed on the title bar + std::string Title; + + /// Publisher of the software (as shown in the Windows Control Panel) + std::string Publisher; + + /// URL to a page that contains product information on your web site + std::string ProductUrl; + + /// Filename for a custom installer icon + std::string InstallerApplicationIcon; + + /// Filename for a custom window icon + std::string InstallerWindowIcon; + + /// Filename for a logo + std::string Logo; + + /// Default target directory for installation + std::string TargetDir; + + /// Default target directory for installation with administrator rights + std::string AdminTargetDir; + +public: // Internal implementation + + const char* GetOption(const std::string& op) const; + + void ConfigureFromOptions(); + + void GenerateInstallerFile(); + + void GeneratePackageFiles(); + + cmCPackIFWGenerator* Generator; + PackagesMap Packages; + std::string Directory; +}; + +#endif // cmCPackIFWInstaller_h diff --git a/Source/CPack/IFW/cmCPackIFWPackage.cxx b/Source/CPack/IFW/cmCPackIFWPackage.cxx new file mode 100644 index 0000000..5e7a7c7 --- /dev/null +++ b/Source/CPack/IFW/cmCPackIFWPackage.cxx @@ -0,0 +1,486 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ + +#include "cmCPackIFWPackage.h" + +#include "cmCPackIFWGenerator.h" + +#include <CPack/cmCPackLog.h> + +#include <cmGeneratedFileStream.h> +#include <cmTimestamp.h> + +//----------------------------------------------------------------- Logger --- +#ifdef cmCPackLogger +# undef cmCPackLogger +#endif +#define cmCPackLogger(logType, msg) \ + do { \ + cmOStringStream cmCPackLog_msg; \ + cmCPackLog_msg << msg; \ + if(Generator) { \ + Generator->Logger->Log(logType, __FILE__, __LINE__, \ + cmCPackLog_msg.str().c_str()); \ + } \ + } while ( 0 ) + +//---------------------------------------------------------- CompareStruct --- +cmCPackIFWPackage::CompareStruct::CompareStruct() : + Type(CompareNone) +{ +} + +//------------------------------------------------------- DependenceStruct --- +cmCPackIFWPackage::DependenceStruct::DependenceStruct() +{ +} + +//---------------------------------------------------------------------------- +cmCPackIFWPackage::DependenceStruct::DependenceStruct( + const std::string &dependence) +{ + // Search compare section + size_t pos = std::string::npos; + if((pos = dependence.find("<=")) != std::string::npos) + { + Compare.Type = CompareLessOrEqual; + Compare.Value = dependence.substr(pos + 2); + } + else if((pos = dependence.find(">=")) != std::string::npos) + { + Compare.Type = CompareGreaterOrEqual; + Compare.Value = dependence.substr(pos + 2); + } + else if((pos = dependence.find("<")) != std::string::npos) + { + Compare.Type = CompareLess; + Compare.Value = dependence.substr(pos + 1); + } + else if((pos = dependence.find("=")) != std::string::npos) + { + Compare.Type = CompareEqual; + Compare.Value = dependence.substr(pos + 1); + } + else if((pos = dependence.find(">")) != std::string::npos) + { + Compare.Type = CompareGreater; + Compare.Value = dependence.substr(pos + 1); + } + Name = pos == std::string::npos ? dependence : dependence.substr(0, pos); +} + +//---------------------------------------------------------------------------- +std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const +{ + if (Compare.Type == CompareNone) return Name; + + std::string result = Name; + + if (Compare.Type == CompareLessOrEqual) + { + result += "<="; + } + else if (Compare.Type == CompareGreaterOrEqual) + { + result += ">="; + } + else if (Compare.Type == CompareLess) + { + result += "<"; + } + else if (Compare.Type == CompareEqual) + { + result += "="; + } + else if (Compare.Type == CompareGreater) + { + result += ">"; + } + + result += Compare.Value; + + return result; +} + +//------------------------------------------------------ cmCPackIFWPackage --- +cmCPackIFWPackage::cmCPackIFWPackage() : + Generator(0), + Installer(0) +{ +} + +//---------------------------------------------------------------------------- +const char *cmCPackIFWPackage::GetOption(const std::string &op) const +{ + return Generator ? Generator->GetOption(op) : 0; +} + +//---------------------------------------------------------------------------- +std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent *component) +{ + if (!component) return ""; + const char* option = GetOption( + "CPACK_IFW_COMPONENT_" + + cmsys::SystemTools::UpperCase(component->Name) + + "_NAME"); + return option ? option : component->Name; +} + +//---------------------------------------------------------------------------- +void cmCPackIFWPackage::DefaultConfiguration() +{ + DisplayName = ""; + Description = ""; + Version = ""; + ReleaseDate = ""; + Script = ""; + Licenses.clear(); + SortingPriority = ""; + Default = ""; + Virtual = ""; + ForcedInstallation = ""; +} + +//---------------------------------------------------------------------------- +// Defaul configuration (all in one package) +int cmCPackIFWPackage::ConfigureFromOptions() +{ + // Restore defaul configuration + DefaultConfiguration(); + + // Name + Name = Generator->GetRootPackageName(); + + // Display name + if (const char *option = this->GetOption("CPACK_PACKAGE_NAME")) + { + DisplayName = option; + } + else + { + DisplayName = "Your package"; + } + + // Description + if (const char* option = + this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) + { + Description = option; + } + else + { + Description = "Your package description"; + } + + // Version + if(const char* option = GetOption("CPACK_PACKAGE_VERSION")) + { + Version = option; + } + else + { + Version = "1.0.0"; + } + + ForcedInstallation = "true"; + + return 1; +} + +//---------------------------------------------------------------------------- +int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component) +{ + if(!component) return 0; + + // Restore defaul configuration + DefaultConfiguration(); + + std::string prefix = "CPACK_IFW_COMPONENT_" + + cmsys::SystemTools::UpperCase(component->Name) + + "_"; + + // Display name + DisplayName = component->DisplayName; + + // Description + Description = component->Description; + + // Version + if(const char* optVERSION = GetOption(prefix + "VERSION")) + { + Version = optVERSION; + } + else if(const char* optPACKAGE_VERSION = + GetOption("CPACK_PACKAGE_VERSION")) + { + Version = optPACKAGE_VERSION; + } + else + { + Version = "1.0.0"; + } + + // Script + if (const char* option = GetOption(prefix + "SCRIPT")) + { + // TODO: add check file exist + Script = option; + } + + // CMake dependencies + if (!component->Dependencies.empty()) + { + std::vector<cmCPackComponent*>::iterator dit; + for(dit = component->Dependencies.begin(); + dit != component->Dependencies.end(); + ++dit) + { + Dependencies.insert(Generator->ComponentPackages[*dit]); + } + } + + // QtIFW dependencies + if(const char* option = this->GetOption(prefix + "DEPENDS")) + { + std::vector<std::string> deps; + cmSystemTools::ExpandListArgument(option, + deps); + for(std::vector<std::string>::iterator + dit = deps.begin(); dit != deps.end(); ++dit) + { + DependenceStruct dep(*dit); + if (!Generator->Packages.count(dep.Name)) + { + bool hasDep = Generator->DependentPackages.count(dep.Name) > 0; + DependenceStruct &depRef = + Generator->DependentPackages[dep.Name]; + if(!hasDep) + { + depRef = dep; + } + AlienDependencies.insert(&depRef); + } + } + } + + // Licenses + if (const char* option = this->GetOption(prefix + "LICENSES")) + { + Licenses.clear(); + cmSystemTools::ExpandListArgument( option, Licenses ); + if ( Licenses.size() % 2 != 0 ) + { + cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES" + << " should contain pairs of <display_name> and <file_path>." + << std::endl); + Licenses.clear(); + } + } + + // Priority + if(const char* option = this->GetOption(prefix + "PRIORITY")) + { + SortingPriority = option; + } + + // Default + Default = component->IsDisabledByDefault ? "false" : "true"; + + // Virtual + Virtual = component->IsHidden ? "true" : ""; + + // ForcedInstallation + ForcedInstallation = component->IsRequired ? "true" : "false"; + + return 1; +} + +//---------------------------------------------------------------------------- +int +cmCPackIFWPackage::ConfigureFromComponentGroup(cmCPackComponentGroup *group) +{ + if(!group) return 0; + + // Restore defaul configuration + DefaultConfiguration(); + + std::string prefix = "CPACK_IFW_COMPONENT_GROUP_" + + cmsys::SystemTools::UpperCase(group->Name) + + "_"; + + DisplayName = group->DisplayName; + Description = group->Description; + + // Version + if(const char* optVERSION = GetOption(prefix + "VERSION")) + { + Version = optVERSION; + } + else if(const char* optPACKAGE_VERSION = + GetOption("CPACK_PACKAGE_VERSION")) + { + Version = optPACKAGE_VERSION; + } + else + { + Version = "1.0.0"; + } + + // Licenses + if (const char* option = this->GetOption(prefix + "LICENSES")) + { + Licenses.clear(); + cmSystemTools::ExpandListArgument( option, Licenses ); + if ( Licenses.size() % 2 != 0 ) + { + cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES" + << " should contain pairs of <display_name> and <file_path>." + << std::endl); + Licenses.clear(); + } + } + + // Priority + if(const char* option = this->GetOption(prefix + "PRIORITY")) + { + SortingPriority = option; + } + + return 1; +} + +//---------------------------------------------------------------------------- +void cmCPackIFWPackage::GeneratePackageFile() +{ + // Lazy directory initialization + if (Directory.empty()) + { + if(Installer) + { + Directory = Installer->Directory + "/packages/" + Name; + } + else if (Generator) + { + Directory = Generator->toplevel + "/packages/" + Name; + } + } + + // Output stream + cmGeneratedFileStream xout((Directory + "/meta/package.xml").data()); + + xout << "<?xml version=\"1.0\"?>" << std::endl; + xout << "<Package>" << std::endl; + + xout << " <DisplayName>" << DisplayName + << "</DisplayName>" << std::endl; + + xout << " <Description>" << Description + << "</Description>" << std::endl; + + xout << " <Name>" << Name << "</Name>" << std::endl; + + xout << " <Version>" << Version + << "</Version>" << std::endl; + + xout << " <ReleaseDate>"; + if(ReleaseDate.empty()) + { + xout << cmTimestamp().CurrentTime("%Y-%m-%d", true); + } + else + { + xout << ReleaseDate; + } + xout << "</ReleaseDate>" << std::endl; + + // Script (copy to meta dir) + if(!Script.empty()) + { + std::string name = cmSystemTools::GetFilenameName(Script); + std::string path = Directory + "/meta/" + name; + cmsys::SystemTools::CopyFileIfDifferent(Script.data(), path.data()); + xout << " <Script>" << name << "</Script>" << std::endl; + } + + // Dependencies + std::set<DependenceStruct> compDepSet; + for(std::set<DependenceStruct*>::iterator ait = AlienDependencies.begin(); + ait != AlienDependencies.end(); ++ait) + { + compDepSet.insert(*(*ait)); + } + for(std::set<cmCPackIFWPackage*>::iterator it = Dependencies.begin(); + it != Dependencies.end(); ++it) + { + compDepSet.insert(DependenceStruct((*it)->Name)); + } + // Write dependencies + if (!compDepSet.empty()) + { + xout << " <Dependencies>"; + std::set<DependenceStruct>::iterator it = compDepSet.begin(); + xout << it->NameWithCompare(); + ++it; + while(it != compDepSet.end()) + { + xout << "," << it->NameWithCompare(); + ++it; + } + xout << "</Dependencies>" << std::endl; + } + + // Licenses (copy to meta dir) + std::vector<std::string> licenses = Licenses; + for(size_t i = 1; i < licenses.size(); i += 2) + { + std::string name = cmSystemTools::GetFilenameName(licenses[i]); + std::string path = Directory + "/meta/" + name; + cmsys::SystemTools::CopyFileIfDifferent(licenses[i].data(), path.data()); + licenses[i] = name; + } + if(!licenses.empty()) + { + xout << " <Licenses>" << std::endl; + for(size_t i = 0; i < licenses.size(); i += 2) + { + xout << " <License " + << "name=\"" << licenses[i] << "\" " + << "file=\"" << licenses[i + 1] << "\" " + << "/>" <<std::endl; + } + xout << " </Licenses>" << std::endl; + } + + if (!ForcedInstallation.empty()) + { + xout << " <ForcedInstallation>" << ForcedInstallation + << "</ForcedInstallation>" << std::endl; + } + + if (!Virtual.empty()) + { + xout << " <Virtual>" << Virtual << "</Virtual>" << std::endl; + } + else if (!Default.empty()) + { + xout << " <Default>" << Default << "</Default>" << std::endl; + } + + // Priority + if(!SortingPriority.empty()) + { + xout << " <SortingPriority>" << SortingPriority + << "</SortingPriority>" << std::endl; + } + + xout << "</Package>" << std::endl; +} diff --git a/Source/CPack/IFW/cmCPackIFWPackage.h b/Source/CPack/IFW/cmCPackIFWPackage.h new file mode 100644 index 0000000..868c15d --- /dev/null +++ b/Source/CPack/IFW/cmCPackIFWPackage.h @@ -0,0 +1,131 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ + +#ifndef cmCPackIFWPackage_h +#define cmCPackIFWPackage_h + +#include "cmStandardIncludes.h" + +class cmCPackComponent; +class cmCPackComponentGroup; +class cmCPackIFWInstaller; +class cmCPackIFWGenerator; + +/** \class cmCPackIFWPackage + * \brief A single component to be installed by CPack IFW generator + */ +class cmCPackIFWPackage +{ +public: // Types + enum CompareTypes + { + CompareNone = 0x0, + CompareEqual = 0x1, + CompareLess = 0x2, + CompareLessOrEqual = 0x3, + CompareGreater = 0x4, + CompareGreaterOrEqual = 0x5 + }; + + struct CompareStruct + { + CompareStruct(); + + unsigned int Type; + std::string Value; + }; + + struct DependenceStruct + { + DependenceStruct(); + DependenceStruct(const std::string &dependence); + + std::string Name; + CompareStruct Compare; + + std::string NameWithCompare() const; + + bool operator < (const DependenceStruct &other) const + { + return Name < other.Name; + } + }; + +public: // [Con|De]structor + + /** + * Construct package + */ + cmCPackIFWPackage(); + +public: // Configuration + + /// Human-readable name of the component + std::string DisplayName; + + /// Human-readable description of the component + std::string Description; + + /// Version number of the component + std::string Version; + + /// Date when this component version was released + std::string ReleaseDate; + + /// Domain-like identification for this component + std::string Name; + + /// File name of a script being loaded + std::string Script; + + /// List of license agreements to be accepted by the installing user + std::vector<std::string> Licenses; + + /// Priority of the component in the tree + std::string SortingPriority; + + /// Set to true to preselect the component in the installer + std::string Default; + + /// Set to true to hide the component from the installer + std::string Virtual; + + /// Determines that the package must always be installed + std::string ForcedInstallation; + +public: // Internal implementation + + const char* GetOption(const std::string& op) const; + + std::string GetComponentName(cmCPackComponent *component); + + void DefaultConfiguration(); + + int ConfigureFromOptions(); + int ConfigureFromComponent(cmCPackComponent *component); + int ConfigureFromComponentGroup(cmCPackComponentGroup *group); + + void GeneratePackageFile(); + + // Pointer to generator + cmCPackIFWGenerator* Generator; + // Pointer to installer + cmCPackIFWInstaller* Installer; + // Collection of dependencies + std::set<cmCPackIFWPackage*> Dependencies; + // Collection of unresolved dependencies + std::set<DependenceStruct*> AlienDependencies; + // Patch to package directory + std::string Directory; +}; + +#endif // cmCPackIFWPackage_h diff --git a/Source/CPack/WiX/cmWIXAccessControlList.cxx b/Source/CPack/WiX/cmWIXAccessControlList.cxx new file mode 100644 index 0000000..aeec968 --- /dev/null +++ b/Source/CPack/WiX/cmWIXAccessControlList.cxx @@ -0,0 +1,149 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2014 Kitware, Inc. + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ + +#include "cmWIXAccessControlList.h" + +#include <CPack/cmCPackGenerator.h> + +#include <cmSystemTools.h> + +cmWIXAccessControlList::cmWIXAccessControlList( + cmCPackLog *logger, + cmInstalledFile const& installedFile, + cmWIXSourceWriter &sourceWriter): + Logger(logger), + InstalledFile(installedFile), + SourceWriter(sourceWriter) +{ + +} + +bool cmWIXAccessControlList::Apply() +{ + std::vector<std::string> entries; + this->InstalledFile.GetPropertyAsList("CPACK_WIX_ACL", entries); + + for(size_t i = 0; i < entries.size(); ++i) + { + this->CreatePermissionElement(entries[i]); + } + + return true; +} + +void cmWIXAccessControlList::CreatePermissionElement( + std::string const& entry) +{ + std::string::size_type pos = entry.find('='); + if(pos == std::string::npos) + { + this->ReportError(entry, "Did not find mandatory '='"); + return; + } + + std::string user_and_domain = entry.substr(0, pos); + std::string permission_string = entry.substr(pos + 1); + + pos = user_and_domain.find('@'); + std::string user; + std::string domain; + if(pos != std::string::npos) + { + user = user_and_domain.substr(0, pos); + domain = user_and_domain.substr(pos + 1); + } + else + { + user = user_and_domain; + } + + std::vector<std::string> permissions = + cmSystemTools::tokenize(permission_string, ","); + + this->SourceWriter.BeginElement("Permission"); + this->SourceWriter.AddAttribute("User", user); + if(domain.size()) + { + this->SourceWriter.AddAttribute("Domain", domain); + } + for(size_t i = 0; i < permissions.size(); ++i) + { + this->EmitBooleanAttribute(entry, + cmSystemTools::TrimWhitespace(permissions[i])); + } + this->SourceWriter.EndElement("Permission"); +} + +void cmWIXAccessControlList::ReportError( + std::string const& entry, + std::string const& message) +{ + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Failed processing ACL entry '" << entry << + "': " << message << std::endl); +} + +bool cmWIXAccessControlList::IsBooleanAttribute(std::string const& name) +{ + static const char* validAttributes[] = + { + "Append", + "ChangePermission", + "CreateChild", + "CreateFile", + "CreateLink", + "CreateSubkeys", + "Delete", + "DeleteChild", + "EnumerateSubkeys", + "Execute", + "FileAllRights", + "GenericAll", + "GenericExecute", + "GenericRead", + "GenericWrite", + "Notify", + "Read", + "ReadAttributes", + "ReadExtendedAttributes", + "ReadPermission", + "SpecificRightsAll", + "Synchronize", + "TakeOwnership", + "Traverse", + "Write", + "WriteAttributes", + "WriteExtendedAttributes", + 0 + }; + + size_t i = 0; + while(validAttributes[i]) + { + if(name == validAttributes[i++]) return true; + } + + return false; +} + +void cmWIXAccessControlList::EmitBooleanAttribute( + std::string const& entry, std::string const& name) +{ + if(!this->IsBooleanAttribute(name)) + { + std::stringstream message; + message << "Unknown boolean attribute '" << name << "'"; + this->ReportError(entry, message.str()); + } + + this->SourceWriter.AddAttribute(name, "yes"); +} diff --git a/Source/CPack/WiX/cmWIXAccessControlList.h b/Source/CPack/WiX/cmWIXAccessControlList.h new file mode 100644 index 0000000..20902f7 --- /dev/null +++ b/Source/CPack/WiX/cmWIXAccessControlList.h @@ -0,0 +1,46 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2014 Kitware, Inc. + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ + +#ifndef cmWIXAccessControlList_h +#define cmWIXAccessControlList_h + +#include <cmInstalledFile.h> +#include <CPack/cmCPackLog.h> + +#include "cmWIXSourceWriter.h" + +class cmWIXAccessControlList +{ +public: + cmWIXAccessControlList( + cmCPackLog *logger, + cmInstalledFile const& installedFile, + cmWIXSourceWriter &sourceWriter); + + bool Apply(); + +private: + void CreatePermissionElement(std::string const& entry); + + void ReportError(std::string const& entry, std::string const& message); + + bool IsBooleanAttribute(std::string const& name); + + void EmitBooleanAttribute( + std::string const& entry, std::string const& name); + + cmCPackLog* Logger; + cmInstalledFile const& InstalledFile; + cmWIXSourceWriter &SourceWriter; +}; + +#endif diff --git a/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx b/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx index 451188e..0ad5d0c 100644 --- a/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx +++ b/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx @@ -11,6 +11,7 @@ ============================================================================*/ #include "cmWIXFilesSourceWriter.h" +#include "cmWIXAccessControlList.h" #include <cmInstalledFile.h> @@ -175,6 +176,12 @@ std::string cmWIXFilesSourceWriter::EmitComponentFile( AddAttribute("ReadOnly", "yes"); } + if(installedFile) + { + cmWIXAccessControlList acl(Logger, *installedFile, *this); + acl.Apply(); + } + patch.ApplyFragment(fileId, *this); EndElement("File"); diff --git a/Source/CPack/WiX/cmWIXSourceWriter.h b/Source/CPack/WiX/cmWIXSourceWriter.h index 65b7240..3957d96 100644 --- a/Source/CPack/WiX/cmWIXSourceWriter.h +++ b/Source/CPack/WiX/cmWIXSourceWriter.h @@ -45,6 +45,9 @@ public: static std::string WindowsCodepageToUtf8(std::string const& value); +protected: + cmCPackLog* Logger; + private: enum State { @@ -58,8 +61,6 @@ private: static std::string EscapeAttributeValue(std::string const& value); - cmCPackLog* Logger; - cmsys::ofstream File; State State; diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx index 9336bed..1461bb1 100644 --- a/Source/CPack/cmCPackGenerator.cxx +++ b/Source/CPack/cmCPackGenerator.cxx @@ -1049,7 +1049,6 @@ int cmCPackGenerator::DoPackage() const char* tempPackageFileName = this->GetOption( "CPACK_TEMPORARY_PACKAGE_FILE_NAME"); - const char* packageFileName = this->GetOption("CPACK_OUTPUT_FILE_PATH"); const char* tempDirectory = this->GetOption("CPACK_TEMPORARY_DIRECTORY"); cmCPackLogger(cmCPackLog::LOG_DEBUG, "Find files" << std::endl); @@ -1114,7 +1113,7 @@ int cmCPackGenerator::DoPackage() std::string tmpPF(this->GetOption("CPACK_OUTPUT_FILE_PREFIX")); tempPackageFileName = it->c_str(); tmpPF += "/"+cmSystemTools::GetFilenameName(*it); - packageFileName = tmpPF.c_str(); + const char* packageFileName = tmpPF.c_str(); cmCPackLogger(cmCPackLog::LOG_DEBUG, "Copy final package(s): " << (tempPackageFileName ? tempPackageFileName : "(NULL)" ) << " to " diff --git a/Source/CPack/cmCPackGeneratorFactory.cxx b/Source/CPack/cmCPackGeneratorFactory.cxx index da97657..c8737f4 100644 --- a/Source/CPack/cmCPackGeneratorFactory.cxx +++ b/Source/CPack/cmCPackGeneratorFactory.cxx @@ -21,7 +21,7 @@ #include "cmCPack7zGenerator.h" #include "cmCPackSTGZGenerator.h" #include "cmCPackNSISGenerator.h" -#include "cmCPackIFWGenerator.h" +#include "IFW/cmCPackIFWGenerator.h" #ifdef __APPLE__ # include "cmCPackDragNDropGenerator.h" diff --git a/Source/CPack/cmCPackIFWGenerator.cxx b/Source/CPack/cmCPackIFWGenerator.cxx deleted file mode 100644 index 3a7f539..0000000 --- a/Source/CPack/cmCPackIFWGenerator.cxx +++ /dev/null @@ -1,909 +0,0 @@ -/*============================================================================ - CMake - Cross Platform Makefile Generator - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ - -#include "cmCPackIFWGenerator.h" - -#include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" -#include "cmSystemTools.h" -#include "cmMakefile.h" -#include "cmGeneratedFileStream.h" -#include "cmCPackLog.h" -#include "cmCPackComponentGroup.h" -#include "cmTimestamp.h" - -#include <cmsys/SystemTools.hxx> -#include <cmsys/Glob.hxx> -#include <cmsys/Directory.hxx> -#include <cmsys/RegularExpression.hxx> -#include <cmXMLSafe.h> - -//---------------------------------------------------------------------- -cmCPackIFWGenerator::cmCPackIFWGenerator() -{ -} - -//---------------------------------------------------------------------- -cmCPackIFWGenerator::~cmCPackIFWGenerator() -{ -} - -//---------------------------------------------------------------------- -int cmCPackIFWGenerator::PackageFiles() -{ - cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Configuration" << std::endl); - - if (!IfwCreateConfigFile()) - { - cmCPackLogger(cmCPackLog::LOG_ERROR, - "CPack error: Could not create IFW \"config.xml\" file." - << std::endl); - return false; - } - - if (Components.empty() && !IfwCreatePackageFile()) - { - cmCPackLogger(cmCPackLog::LOG_ERROR, - "CPack error: Could not create IFW " - "\"root/meta/package.xml\" file." - << std::endl); - return false; - } - - std::string ifwTLD = this->GetOption("CPACK_TOPLEVEL_DIRECTORY"); - std::string ifwTmpFile = ifwTLD; - ifwTmpFile += "/IFWOutput.log"; - - std::set<std::string> ifwDependsComponents; - std::string ifwBinaryComponents; - std::string ifwDownloadedComponents; - - // Create groups meta information - std::map<std::string, cmCPackComponentGroup>::iterator groupIt; - for(groupIt = this->ComponentGroups.begin(); - groupIt != this->ComponentGroups.end(); - ++groupIt - ) - { - std::string macroPrefix = "CPACK_IFW_COMPONENT_GROUP_" - + cmsys::SystemTools::UpperCase(groupIt->second.Name); - - std::string groupId = IfwGetGroupId(&groupIt->second); - - if(!ifwBinaryComponents.empty()) ifwBinaryComponents += ","; - ifwBinaryComponents += groupId; - - std::string pkgMetaDir = this->toplevel + "/packages/" - + groupId - + "/meta"; - - std::string pkgXmlFileName = pkgMetaDir - + "/package.xml"; - - cmGeneratedFileStream pkgXml(pkgXmlFileName.data()); - pkgXml << "<?xml version=\"1.0\"?>" << std::endl; - pkgXml << "<Package>" << std::endl; - pkgXml << " <DisplayName>" << groupIt->second.DisplayName - << "</DisplayName>" << std::endl; - pkgXml << " <Description>" << groupIt->second.Description - << "</Description>" << std::endl; - pkgXml << " <Name>" << groupId << "</Name>" << std::endl; - - // Version - const char* ifwPackageVersion = this->GetOption("CPACK_PACKAGE_VERSION"); - const char* ifwGroupVersion = this->GetOption(macroPrefix + "_VERSION"); - pkgXml << " <Version>" - << (ifwGroupVersion ? ifwGroupVersion : ifwPackageVersion) - << "</Version>" << std::endl; - pkgXml << " <ReleaseDate>" << IfwCreateCurrentDate() - << "</ReleaseDate>" << std::endl; - - // Licenses - std::vector<std::string> licenses; - if(IfwParseLicenses(licenses, macroPrefix + "_LICENSES", pkgMetaDir)) - { - pkgXml << " <Licenses>" << std::endl; - for(size_t i = 0; i < licenses.size(); i += 2) - { - pkgXml << " <License " - << "name=\"" << licenses[i] << "\" " - << "file=\"" << licenses[i + 1] << "\" " - << "/>" <<std::endl; - } - pkgXml << " </Licenses>" << std::endl; - } - - // Priority - if(const char* ifwGroupPriority = - this->GetOption(macroPrefix + "_PRIORITY")) - { - pkgXml << " <SortingPriority>" << ifwGroupPriority - << "</SortingPriority>" << std::endl; - } - pkgXml << "</Package>" << std::endl; - } - - // Create components meta information - std::map<std::string, cmCPackComponent>::iterator compIt; - for (compIt = this->Components.begin(); - compIt != this->Components.end(); - ++compIt) - { - // Component id - std::string ifwCompId = IfwGetComponentId(&compIt->second); - - std::string pkgMetaDir = this->toplevel + "/" - + GetComponentInstallDirNamePrefix(compIt->second.Name) - + ifwCompId + "/meta"; - std::string pkgXmlFileName = pkgMetaDir + "/package.xml"; - cmGeneratedFileStream pkgXml(pkgXmlFileName.data()); - - // Check IFW version for component - std::string macroPrefix = "CPACK_IFW_COMPONENT_" - + cmsys::SystemTools::UpperCase(compIt->second.Name); - - pkgXml << "<?xml version=\"1.0\"?>" << std::endl; - pkgXml << "<Package>" << std::endl; - pkgXml << " <DisplayName>" << compIt->second.DisplayName - << "</DisplayName>" << std::endl; - pkgXml << " <Description>" << compIt->second.Description - << "</Description>" << std::endl; - pkgXml << " <Name>" << ifwCompId << "</Name>" << std::endl; - - // Version - const char* ifwPackageVersion = this->GetOption("CPACK_PACKAGE_VERSION"); - const char* ifwCompVersion = - this->GetOption(macroPrefix + "_VERSION"); - pkgXml << " <Version>" - << (ifwCompVersion ? ifwCompVersion : ifwPackageVersion) - << "</Version>" << std::endl; - - pkgXml << " <ReleaseDate>" << IfwCreateCurrentDate() - << "</ReleaseDate>" << std::endl; - - // Script - const char* ifwCompScript = - this->GetOption(macroPrefix + "_SCRIPT"); - if (ifwCompScript) - { - // Copy file - std::string ifwCompScriptFile = pkgMetaDir + "/operations.qs"; - cmsys::SystemTools::CopyFileIfDifferent(ifwCompScript, - ifwCompScriptFile.data()); - pkgXml << " <Script>" << "operations.qs" << "</Script>" << std::endl; - } - - // Check dependencies - std::set<std::string> compDepSet; - // CMake dependencies - if (!compIt->second.Dependencies.empty()) - { - std::vector<cmCPackComponent *>::iterator depCompIt; - for(depCompIt = compIt->second.Dependencies.begin(); - depCompIt != compIt->second.Dependencies.end(); - ++depCompIt) - { - compDepSet.insert(IfwGetComponentId(*depCompIt)); - } - } - // QtIFW dependencies - if(const char *ifwCompDepsStr = this->GetOption(macroPrefix + "_DEPENDS")) - { - std::vector<std::string> ifwCompDepsVector; - cmSystemTools::ExpandListArgument(ifwCompDepsStr, - ifwCompDepsVector); - for(std::vector<std::string>::iterator - depCompIt = ifwCompDepsVector.begin(); - depCompIt != ifwCompDepsVector.end(); ++depCompIt) - { - compDepSet.insert(*depCompIt); - ifwDependsComponents.insert(*depCompIt); - } - } - - // Write dependencies - if (!compDepSet.empty()) - { - pkgXml << " <Dependencies>"; - std::set<std::string>::iterator it = compDepSet.begin(); - pkgXml << *it; - ++it; - while(it != compDepSet.end()) - { - pkgXml << "," << *it; - ++it; - } - pkgXml << "</Dependencies>" << std::endl; - } - - // Licenses - std::vector<std::string> licenses; - if(IfwParseLicenses(licenses, macroPrefix + "_LICENSES", pkgMetaDir)) - { - pkgXml << " <Licenses>" << std::endl; - for(size_t i = 0; i < licenses.size(); i += 2) - { - pkgXml << " <License " - << "name=\"" << licenses[i] << "\" " - << "file=\"" << licenses[i + 1] << "\" " - << "/>" <<std::endl; - } - pkgXml << " </Licenses>" << std::endl; - } - - // TODO: Check how enable virtual component (now it's allways disabled) - if (compIt->second.IsRequired) { - pkgXml << " <ForcedInstallation>true</ForcedInstallation>" - << std::endl; - } else if (compIt->second.IsDisabledByDefault) { - pkgXml << " <Default>false</Default>" << std::endl; - } else if (compIt->second.IsHidden) { - pkgXml << " <Virtual>true</Virtual>" << std::endl; - } else { - pkgXml << " <Default>true</Default>" << std::endl; - } - - // Priority - if(const char* ifwCompPriority = - this->GetOption(macroPrefix + "_PRIORITY")) - { - pkgXml << " <SortingPriority>" << ifwCompPriority - << "</SortingPriority>" << std::endl; - } - - pkgXml << "</Package>" << std::endl; - - // Downloaded - if (compIt->second.IsDownloaded) - { - if (!ifwDownloadedComponents.empty()) ifwDownloadedComponents += ","; - ifwDownloadedComponents += ifwCompId; - } - else - { - if (!ifwBinaryComponents.empty()) ifwBinaryComponents += ","; - ifwBinaryComponents += ifwCompId; - } - } - - // Run repogen - if (!ifwDownloadSite.empty()) - { - std::string ifwCmd = ifwRepoGen; - ifwCmd += " -c " + this->toplevel + "/config/config.xml"; - ifwCmd += " -p " + this->toplevel + "/packages"; - - if(!ifwPkgsDirsVector.empty()) - { - for(std::vector<std::string>::iterator it = ifwPkgsDirsVector.begin(); - it != ifwPkgsDirsVector.end(); ++it) - { - ifwCmd += " -p " + *it; - } - } - - if (!ifwOnlineOnly && !ifwDownloadedComponents.empty()) { - ifwCmd += " -i " + ifwDownloadedComponents; - } - ifwCmd += " " + this->toplevel + "/repository"; - cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd - << std::endl); - std::string output; - int retVal = 1; - cmCPackLogger(cmCPackLog::LOG_OUTPUT, - "- Generate repository" << std::endl); - bool res = cmSystemTools::RunSingleCommand( - ifwCmd.c_str(), &output, &retVal, 0, this->GeneratorVerbose, 0); - if ( !res || retVal ) - { - cmGeneratedFileStream ofs(ifwTmpFile.c_str()); - ofs << "# Run command: " << ifwCmd << std::endl - << "# Output:" << std::endl - << output << std::endl; - cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: " - << ifwCmd << std::endl - << "Please check " << ifwTmpFile << " for errors" - << std::endl); - return 0; - } - } - - // Run binary creator - { - std::string ifwCmd = ifwBinCreator; - ifwCmd += " -c " + this->toplevel + "/config/config.xml"; - ifwCmd += " -p " + this->toplevel + "/packages"; - - if(!ifwPkgsDirsVector.empty()) - { - for(std::vector<std::string>::iterator it = ifwPkgsDirsVector.begin(); - it != ifwPkgsDirsVector.end(); ++it) - { - ifwCmd += " -p " + *it; - } - } - - if (ifwOnlineOnly) - { - ifwCmd += " --online-only"; - } - else if (!ifwDownloadedComponents.empty() && !ifwDownloadSite.empty()) - { - ifwCmd += " -e " + ifwDownloadedComponents; - } - else if (!ifwDependsComponents.empty()) - { - ifwCmd += " -i "; - std::set<std::string>::iterator it = ifwDependsComponents.begin(); - ifwCmd += *it; - ++it; - while(it != ifwDependsComponents.end()) - { - ifwCmd += "," + (*it); - ++it; - } - - ifwCmd += "," + ifwBinaryComponents; - } - // TODO: set correct name for multipackages - if (this->packageFileNames.size() > 0) - { - ifwCmd += " " + packageFileNames[0]; - } - else - { - ifwCmd += " installer"; - } - cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd - << std::endl); - std::string output; - int retVal = 1; - cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate package" << std::endl); - bool res = cmSystemTools::RunSingleCommand( - ifwCmd.c_str(), &output, &retVal, 0, this->GeneratorVerbose, 0); - if ( !res || retVal ) - { - cmGeneratedFileStream ofs(ifwTmpFile.c_str()); - ofs << "# Run command: " << ifwCmd << std::endl - << "# Output:" << std::endl - << output << std::endl; - cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: " - << ifwCmd << std::endl - << "Please check " << ifwTmpFile << " for errors" - << std::endl); - return 0; - } - } - - return 1; -} - -//---------------------------------------------------------------------- -const char *cmCPackIFWGenerator::GetPackagingInstallPrefix() -{ - const char *defPrefix = cmCPackGenerator::GetPackagingInstallPrefix(); - - std::string tmpPref = defPrefix ? defPrefix : ""; - - if(this->Components.empty()) - { - tmpPref += "packages/root/data"; - } - - this->SetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX", tmpPref.c_str()); - - return this->GetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX"); -} - -//---------------------------------------------------------------------- -const char *cmCPackIFWGenerator::GetOutputExtension() -{ - const char *suffix = this->GetOption("CMAKE_EXECUTABLE_SUFFIX"); - return suffix ? suffix : ""; -} - -//---------------------------------------------------------------------- -std::string cmCPackIFWGenerator::IfwGetGroupId(cmCPackComponentGroup *group) -{ - std::string ifwGroupId; - std::string ifwGroupName; - std::list<cmCPackComponentGroup*> groups; - while(group) - { - groups.push_front(group); - group = group->ParentGroup; - } - std::list<cmCPackComponentGroup*>::iterator it = groups.begin(); - if(it != groups.end()) - { - ifwGroupId = IfwGetGroupName(*it); - ++it; - } - while(it != groups.end()) - { - ifwGroupName = IfwGetGroupName(*it); - - if(ifwResolveDuplicateNames) - { - if(ifwGroupName.substr(0, ifwGroupId.size()) == ifwGroupId) - { - ifwGroupId = ifwGroupName; - ++it; - continue; - } - } - - ifwGroupId += "." + ifwGroupName; - - ++it; - } - - return ifwGroupId; -} - -//---------------------------------------------------------------------- -std::string cmCPackIFWGenerator::IfwGetComponentId(cmCPackComponent *component) -{ - std::string ifwCompId; - if(component) { - ifwCompId = IfwGetGroupId(component->Group); - if(!ifwCompId.empty()) ifwCompId += "."; - std::string ifwCompName = IfwGetComponentName(component); - if(ifwResolveDuplicateNames && - (ifwCompName.substr(0, ifwCompId.size()) == ifwCompId)) - { - ifwCompId = ifwCompName; - } - else - { - ifwCompId += ifwCompName; - } - } - return ifwCompId; -} - -//---------------------------------------------------------------------- -std::string cmCPackIFWGenerator::IfwGetGroupName(cmCPackComponentGroup *group) -{ - std::string ifwGroupName = group->Name; - if(const char* name = - this->GetOption("CPACK_IFW_COMPONENT_GROUP_" - + cmsys::SystemTools::UpperCase(group->Name) + "_NAME")) - { - ifwGroupName = name; - } - return ifwGroupName; -} - -//---------------------------------------------------------------------- -std::string -cmCPackIFWGenerator::IfwGetComponentName(cmCPackComponent *component) -{ - return IfwGetComponentName(component->Name); -} - -//---------------------------------------------------------------------- -std::string -cmCPackIFWGenerator::IfwGetComponentName(const std::string &componentName) -{ - std::string ifwCompName = componentName; - if(const char* name = - this->GetOption("CPACK_IFW_COMPONENT_" - + cmsys::SystemTools::UpperCase(componentName) + "_NAME")) - { - ifwCompName = name; - } - return ifwCompName; -} - -//---------------------------------------------------------------------- -int cmCPackIFWGenerator::InitializeInternal() -{ - // Search Qt Installer Framework tools - - if(!this->IsOn("CPACK_IFW_BINARYCREATOR_EXECUTABLE_FOUND") || - !this->IsOn("CPACK_IFW_REPOGEN_EXECUTABLE_FOUND")) - { - this->ReadListFile("CPackIFW.cmake"); - } - - // Look 'binarycreator' executable (needs) - - if(this->IsOn("CPACK_IFW_BINARYCREATOR_EXECUTABLE_FOUND")) - { - const char *ifwBinCreatorStr = - this->GetOption("CPACK_IFW_BINARYCREATOR_EXECUTABLE"); - ifwBinCreator = ifwBinCreatorStr ? ifwBinCreatorStr : ""; - } - else - { - ifwBinCreator = ""; - } - - if (ifwBinCreator.empty()) - { - cmCPackLogger(cmCPackLog::LOG_ERROR, - "Cannot find QtIFW compiler \"binarycreator\": " - "likely it is not installed, or not in your PATH" - << std::endl); - return 0; - } - - // Look 'repogen' executable (optional) - - if(this->IsOn("CPACK_IFW_REPOGEN_EXECUTABLE_FOUND")) - { - const char *ifwRepoGenStr = - this->GetOption("CPACK_IFW_REPOGEN_EXECUTABLE"); - ifwRepoGen = ifwRepoGenStr ? ifwRepoGenStr : ""; - } - else - { - ifwRepoGen = ""; - } - - // // Variables that Change Behavior - - // Resolve duplicate names - ifwResolveDuplicateNames = this->IsOn("CPACK_IFW_RESOLVE_DUPLICATE_NAMES"); - - // Additional packages dirs - ifwPkgsDirsVector.clear(); - if(const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES")) - { - cmSystemTools::ExpandListArgument(dirs, - ifwPkgsDirsVector); - } - - // Remote repository - - if (const char *site = this->GetOption("CPACK_DOWNLOAD_SITE")) - { - ifwDownloadSite = site; - } - - ifwOnlineOnly = this->IsOn("CPACK_DOWNLOAD_ALL") ? true : false; - - if (!ifwDownloadSite.empty() && ifwRepoGen.empty()) { - cmCPackLogger(cmCPackLog::LOG_ERROR, - "Cannot find QtIFW repository generator \"repogen\": " - "likely it is not installed, or not in your PATH" - << std::endl); - return 0; - } - - return this->Superclass::InitializeInternal(); -} - -//---------------------------------------------------------------------- -std::string -cmCPackIFWGenerator::GetComponentInstallDirNamePrefix( - const std::string& /*componentName*/) -{ - return "packages/"; -} - -//---------------------------------------------------------------------- -std::string -cmCPackIFWGenerator::GetComponentInstallDirNameSuffix( - const std::string& componentName) -{ - std::map<std::string, cmCPackComponent>::iterator - compIt = this->Components.find(componentName); - - cmCPackComponent *comp = - compIt != this->Components.end() ? &compIt->second : 0; - - const std::string prefix = GetComponentInstallDirNamePrefix(componentName); - const std::string suffix = "/data"; - - if (componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) { - return prefix + IfwGetComponentId(comp) + suffix; - } - - if (componentPackageMethod == ONE_PACKAGE) { - return std::string(prefix + "ALL_COMPONENTS_IN_ONE" + suffix); - } - - return prefix + IfwGetComponentId(comp) + suffix; -} - -//---------------------------------------------------------------------- -bool cmCPackIFWGenerator::GetListOfSubdirectories( - const char* topdir, std::vector<std::string>& dirs) -{ - cmsys::Directory dir; - dir.Load(topdir); - size_t fileNum; - for (fileNum = 0; fileNum < dir.GetNumberOfFiles(); ++fileNum) - { - if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".") && - strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),"..")) - { - cmsys_stl::string fullPath = topdir; - fullPath += "/"; - fullPath += dir.GetFile(static_cast<unsigned long>(fileNum)); - if(cmsys::SystemTools::FileIsDirectory(fullPath.c_str()) && - !cmsys::SystemTools::FileIsSymlink(fullPath.c_str())) - { - if (!this->GetListOfSubdirectories(fullPath.c_str(), dirs)) - { - return false; - } - } - } - } - dirs.push_back(topdir); - return true; -} - -//---------------------------------------------------------------------- -enum cmCPackGenerator::CPackSetDestdirSupport -cmCPackIFWGenerator::SupportsSetDestdir() const -{ - return cmCPackGenerator::SETDESTDIR_SHOULD_NOT_BE_USED; -} - -//---------------------------------------------------------------------- -bool cmCPackIFWGenerator::SupportsAbsoluteDestination() const -{ - return false; -} - -//---------------------------------------------------------------------- -bool cmCPackIFWGenerator::SupportsComponentInstallation() const -{ - return true; -} - -//---------------------------------------------------------------------- -int cmCPackIFWGenerator::IfwCreateConfigFile() -{ - cmGeneratedFileStream cfg((this->toplevel + "/config/config.xml").data()); - - std::string ifwPkgName; - if (const char *name = this->GetOption("CPACK_PACKAGE_NAME")) - { - ifwPkgName = name; - } - else - { - ifwPkgName = "Your package"; - } - - std::string pkgTitle; - if (const char *title = this->GetOption("CPACK_IFW_PACKAGE_TITLE")) - { - pkgTitle = title; - } - else if (const char *description = - this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) - { - pkgTitle = description; - } - else - { - pkgTitle = "Your package description"; - } - - std::string ifwPkgVersion; - if (const char *version = this->GetOption("CPACK_PACKAGE_VERSION")) - { - ifwPkgVersion = version; - } - else - { - ifwPkgVersion = "1.0.0"; - } - - const char *ifwPkgInstDir = - this->GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY"); - const char *ifwTargetDir = - this->GetOption("CPACK_IFW_TARGET_DIRECTORY"); - const char *ifwAdminTargetDir = - this->GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY"); - - cfg << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl; - cfg << "<Installer>" << std::endl; - cfg << " <Name>" << cmXMLSafe(ifwPkgName).str() << "</Name>" << std::endl; - cfg << " <Version>" << ifwPkgVersion << "</Version>" << std::endl; - cfg << " <Title>" << cmXMLSafe(pkgTitle).str() << "</Title>" - << std::endl; - - // Publisher - std::string ifwPublisher; - if(const char *publisher = GetOption("CPACK_IFW_PACKAGE_PUBLISHER")) - { - ifwPublisher = publisher; - } - else if(const char *vendor = GetOption("CPACK_PACKAGE_VENDOR")) - { - ifwPublisher = vendor; - } - if(!ifwPublisher.empty()) - { - cfg << " <Publisher>" << cmXMLSafe(ifwPublisher).str() - << "</Publisher>" << std::endl; - } - - // ProductUrl - if(const char *url = GetOption("CPACK_IFW_PRODUCT_URL")) - { - cfg << " <ProductUrl>" << url << "</ProductUrl>" << std::endl; - } - - // ApplicationIcon - const char *pkgApplicationIcon = GetOption("CPACK_IFW_PACKAGE_ICON"); - if(pkgApplicationIcon && cmSystemTools::FileExists(pkgApplicationIcon)) - { - std::string name = cmSystemTools::GetFilenameName(pkgApplicationIcon); - std::string path = this->toplevel + "/config/" + name; - name = cmSystemTools::GetFilenameWithoutExtension(name); - cmsys::SystemTools::CopyFileIfDifferent(pkgApplicationIcon, path.data()); - cfg << " <InstallerApplicationIcon>" << name - << "</InstallerApplicationIcon>" << std::endl; - } - - // WindowIcon - const char *pkgWindowIcon = GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON"); - if(pkgWindowIcon && cmSystemTools::FileExists(pkgWindowIcon)) - { - std::string name = cmSystemTools::GetFilenameName(pkgWindowIcon); - std::string path = this->toplevel + "/config/" + name; - cmsys::SystemTools::CopyFileIfDifferent(pkgWindowIcon, path.data()); - cfg << " <InstallerWindowIcon>" << name - << "</InstallerWindowIcon>" << std::endl; - } - - // Logo - const char *pkgLogo = GetOption("CPACK_IFW_PACKAGE_LOGO"); - if(pkgLogo && cmSystemTools::FileExists(pkgLogo)) - { - std::string name = cmSystemTools::GetFilenameName(pkgLogo); - std::string path = this->toplevel + "/config/" + name; - cmsys::SystemTools::CopyFileIfDifferent(pkgLogo, path.data()); - cfg << " <Logo>" << name << "</Logo>" << std::endl; - } - - // Default target directory for installation - if (ifwTargetDir) - { - cfg << " <TargetDir>" << ifwTargetDir << "</TargetDir>" << std::endl; - } - else if (ifwPkgInstDir) - { - cfg << " <TargetDir>@ApplicationsDir@/" << ifwPkgInstDir - << "</TargetDir>" << std::endl; - } - else - { - cfg << " <TargetDir>@RootDir@/usr/local</TargetDir>" << std::endl; - } - - // Default target directory for installation with administrator rights - if (ifwAdminTargetDir) - { - cfg << " <AdminTargetDir>" << ifwAdminTargetDir - << "</AdminTargetDir>" << std::endl; - } - - if (!ifwDownloadSite.empty()) - { - cfg << " <RemoteRepositories>" << std::endl; - cfg << " <Repository>" << std::endl; - cfg << " <Url>" << ifwDownloadSite << "</Url>" << std::endl; - // These properties can now be set from "cpack_configure_downloads" - // <Enabled>1</Enabled> - // <Username>user</Username> - // <Password>password</Password> - // <DisplayName>Example repository</DisplayName> - cfg << " </Repository>" << std::endl; - cfg << " </RemoteRepositories>" << std::endl; - } - - // CPack IFW default policy - cfg << " <!-- CPack IFW default policy -->" << std::endl; - cfg << " <AllowNonAsciiCharacters>true</AllowNonAsciiCharacters>" - << std::endl; - cfg << " <AllowSpaceInPath>true</AllowSpaceInPath>" << std::endl; - - cfg << "</Installer>" << std::endl; - - return 1; -} - -//---------------------------------------------------------------------- -// Create default package file -int cmCPackIFWGenerator::IfwCreatePackageFile() -{ - std::string ifwPkgName; - if (const char *name = this->GetOption("CPACK_PACKAGE_NAME")) - { - ifwPkgName = name; - } - else - { - ifwPkgName = "Your package"; - } - - std::string ifwPkgDescription; - if (const char *name = this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) - { - ifwPkgDescription = name; - } - else - { - ifwPkgDescription = "Your package description"; - } - - cmGeneratedFileStream - pkgXml((this->toplevel + "/packages/root/meta/package.xml").data()); - pkgXml << "<?xml version=\"1.0\"?>" << std::endl; - pkgXml << "<Package>" << std::endl; - - pkgXml << " <DisplayName>" << ifwPkgName << "</DisplayName>" << std::endl; - pkgXml << " <Description>" << ifwPkgDescription - << "</Description>" << std::endl; - pkgXml << " <Name>" << "root" << "</Name>" << std::endl; - pkgXml << " <Version>" << this->GetOption("CPACK_PACKAGE_VERSION") - << "</Version>" << std::endl; - pkgXml << " <ReleaseDate>" << IfwCreateCurrentDate() << "</ReleaseDate>" - << std::endl; - - pkgXml << " <ForcedInstallation>true</ForcedInstallation>" << std::endl; - pkgXml << " <Default>true</Default>" << std::endl; - - pkgXml << "</Package>" << std::endl; - - return 1; -} - -//---------------------------------------------------------------------- -std::string cmCPackIFWGenerator::IfwCreateCurrentDate() -{ - cmTimestamp timestamp; - return timestamp.CurrentTime("%Y-%m-%d", false); -} - -//---------------------------------------------------------------------- -bool cmCPackIFWGenerator::IfwParseLicenses(std::vector<std::string> &licenses, - const std::string &variable, - const std::string &metaDir) -{ - if (const char *option = this->GetOption(variable)) - { - if(!licenses.empty()) licenses.clear(); - cmSystemTools::ExpandListArgument( option, licenses ); - } - else - { - return false; - } - - if ( licenses.size() % 2 != 0 ) - { - cmCPackLogger(cmCPackLog::LOG_ERROR, variable - << " should contain pairs of <display_name> and <file_path>." - << std::endl); - return false; - } - - for(size_t i = 1; i < licenses.size(); i += 2) - { - std::string name = cmSystemTools::GetFilenameName(licenses[i]); - std::string path = metaDir + "/" + name; - cmsys::SystemTools::CopyFileIfDifferent(licenses[i].data(), path.data()); - licenses[i] = name; - } - - return licenses.size() > 1; -} diff --git a/Source/CPack/cmCPackIFWGenerator.h b/Source/CPack/cmCPackIFWGenerator.h deleted file mode 100644 index d70e52d..0000000 --- a/Source/CPack/cmCPackIFWGenerator.h +++ /dev/null @@ -1,82 +0,0 @@ -/*============================================================================ - CMake - Cross Platform Makefile Generator - Copyright 2000-2009 Kitware, Inc. - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ - -#ifndef cmCPackIFWGenerator_h -#define cmCPackIFWGenerator_h - - -#include "cmCPackGenerator.h" -#include <set> - -/** \class cmCPackIFWGenerator - * \brief A generator for Qt Installer Framework tools - * - * http://qt-project.org/doc/qtinstallerframework/index.html - */ -class cmCPackIFWGenerator : public cmCPackGenerator -{ -public: - cmCPackTypeMacro(cmCPackIFWGenerator, cmCPackGenerator); - - /** - * Construct generator - */ - cmCPackIFWGenerator(); - virtual ~cmCPackIFWGenerator(); - -protected: - virtual int InitializeInternal(); - virtual int PackageFiles(); - virtual const char* GetPackagingInstallPrefix(); - - virtual const char* GetOutputExtension(); - - std::string IfwGetGroupId(cmCPackComponentGroup *group); - std::string IfwGetComponentId(cmCPackComponent *component); - - std::string IfwGetGroupName(cmCPackComponentGroup *group); - - std::string IfwGetComponentName(cmCPackComponent *component); - std::string IfwGetComponentName(const std::string &componentName); - - virtual std::string GetComponentInstallDirNamePrefix( - const std::string& componentName); - - virtual std::string GetComponentInstallDirNameSuffix( - const std::string& componentName); - - bool GetListOfSubdirectories(const char* dir, - std::vector<std::string>& dirs); - - enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const; - virtual bool SupportsAbsoluteDestination() const; - virtual bool SupportsComponentInstallation() const; - -private: - int IfwCreateConfigFile(); - int IfwCreatePackageFile(); - std::string IfwCreateCurrentDate(); - bool IfwParseLicenses(std::vector<std::string> &licenses, - const std::string &variable, - const std::string &metaDir); - - std::string ifwRepoGen; - std::string ifwBinCreator; - - std::string ifwDownloadSite; - - bool ifwOnlineOnly; - bool ifwResolveDuplicateNames; - std::vector<std::string> ifwPkgsDirsVector; -}; - -#endif diff --git a/Source/CPack/cpack.cxx b/Source/CPack/cpack.cxx index 98c62d5..c57028d 100644 --- a/Source/CPack/cpack.cxx +++ b/Source/CPack/cpack.cxx @@ -343,7 +343,6 @@ int main (int argc, char const* const* argv) { cmCPack_Log(&log, cmCPackLog::LOG_ERROR, "CPack generator not specified" << std::endl); - parsed = 0; } else { diff --git a/Source/CTest/cmCTestBuildAndTestHandler.cxx b/Source/CTest/cmCTestBuildAndTestHandler.cxx index b4818be..627832c 100644 --- a/Source/CTest/cmCTestBuildAndTestHandler.cxx +++ b/Source/CTest/cmCTestBuildAndTestHandler.cxx @@ -301,7 +301,7 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring) int retVal = cm.GetGlobalGenerator()->Build( this->SourceDir, this->BinaryDir, this->BuildProject, *tarIt, - &output, this->BuildMakeProgram, + output, this->BuildMakeProgram, config, !this->BuildNoClean, false, remainingTime); diff --git a/Source/CTest/cmCTestConfigureHandler.cxx b/Source/CTest/cmCTestConfigureHandler.cxx index a6e39a4..c492bf0 100644 --- a/Source/CTest/cmCTestConfigureHandler.cxx +++ b/Source/CTest/cmCTestConfigureHandler.cxx @@ -77,7 +77,7 @@ int cmCTestConfigureHandler::ProcessHandler() this->StartLogFile("Configure", ofs); cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Configure with command: " << cCommand << std::endl); - res = this->CTest->RunMakeCommand(cCommand.c_str(), &output, + res = this->CTest->RunMakeCommand(cCommand.c_str(), output, &retVal, buildDirectory.c_str(), 0, ofs); diff --git a/Source/CTest/cmCTestMemCheckHandler.cxx b/Source/CTest/cmCTestMemCheckHandler.cxx index ced7982..a7ab077 100644 --- a/Source/CTest/cmCTestMemCheckHandler.cxx +++ b/Source/CTest/cmCTestMemCheckHandler.cxx @@ -932,7 +932,6 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput( double sttime = cmSystemTools::GetTime(); cmCTestLog(this->CTest, DEBUG, "Start test: " << lines.size() << std::endl); std::string::size_type totalOutputSize = 0; - bool outputFull = false; for ( cc = 0; cc < lines.size(); cc ++ ) { cmCTestLog(this->CTest, DEBUG, "test line " @@ -1019,32 +1018,30 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput( } } // Now put all all the non valgrind output into the test output - if(!outputFull) + // This should be last in case it gets truncated by the output + // limiting code + for(std::vector<std::string::size_type>::iterator i = + nonValGrindOutput.begin(); i != nonValGrindOutput.end(); ++i) { - for(std::vector<std::string::size_type>::iterator i = - nonValGrindOutput.begin(); i != nonValGrindOutput.end(); ++i) + totalOutputSize += lines[*i].size(); + cmCTestLog(this->CTest, DEBUG, "before xml safe " + << lines[*i] << std::endl); + cmCTestLog(this->CTest, DEBUG, "after xml safe " + << cmXMLSafe(lines[*i]) << std::endl); + ostr << cmXMLSafe(lines[*i]) << std::endl; + if(!unlimitedOutput && totalOutputSize > + static_cast<size_t>(this->CustomMaximumFailedTestOutputSize)) { - totalOutputSize += lines[*i].size(); - cmCTestLog(this->CTest, DEBUG, "before xml safe " - << lines[*i] << std::endl); - cmCTestLog(this->CTest, DEBUG, "after xml safe " - << cmXMLSafe(lines[*i]) << std::endl); - - ostr << cmXMLSafe(lines[*i]) << std::endl; - if(!unlimitedOutput && totalOutputSize > - static_cast<size_t>(this->CustomMaximumFailedTestOutputSize)) - { - outputFull = true; - ostr << "....\n"; - ostr << "Test Output for this test has been truncated see testing" - " machine logs for full output,\n"; - ostr << "or put CTEST_FULL_OUTPUT in the output of " - "this test program.\n"; - } + ostr << "....\n"; + ostr << "Test Output for this test has been truncated see testing" + " machine logs for full output,\n"; + ostr << "or put CTEST_FULL_OUTPUT in the output of " + "this test program.\n"; + break; // stop the copy of output if we are full } } cmCTestLog(this->CTest, DEBUG, "End test (elapsed: " - << (cmSystemTools::GetTime() - sttime) << std::endl); + << (cmSystemTools::GetTime() - sttime) << std::endl); log = ostr.str(); if ( defects ) { diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx index d797d3b..b28f3b5 100644 --- a/Source/cmCTest.cxx +++ b/Source/cmCTest.cxx @@ -1147,7 +1147,7 @@ int cmCTest::GetTestModelFromString(const char* str) //###################################################################### //---------------------------------------------------------------------- -int cmCTest::RunMakeCommand(const char* command, std::string* output, +int cmCTest::RunMakeCommand(const char* command, std::string& output, int* retVal, const char* dir, int timeout, std::ostream& ofs) { // First generate the command and arguments @@ -1166,11 +1166,7 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output, } argv.push_back(0); - if ( output ) - { - *output = ""; - } - + output = ""; cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Run command:"); std::vector<const char*>::iterator ait; for ( ait = argv.begin(); ait != argv.end() && *ait; ++ ait ) @@ -1199,27 +1195,25 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output, << " " << std::flush); while(cmsysProcess_WaitForData(cp, &data, &length, 0)) { - if ( output ) + for(int cc =0; cc < length; ++cc) { - for(int cc =0; cc < length; ++cc) + if(data[cc] == 0) { - if(data[cc] == 0) - { - data[cc] = '\n'; - } + data[cc] = '\n'; } - - output->append(data, length); - while ( output->size() > (tick * tick_len) ) + } + output.append(data, length); + while ( output.size() > (tick * tick_len) ) + { + tick ++; + cmCTestLog(this, HANDLER_OUTPUT, "." << std::flush); + if ( tick % tick_line_len == 0 && tick > 0 ) { - tick ++; - cmCTestLog(this, HANDLER_OUTPUT, "." << std::flush); - if ( tick % tick_line_len == 0 && tick > 0 ) - { - cmCTestLog(this, HANDLER_OUTPUT, " Size: " - << int((double(output->size()) / 1024.0) + 1) << "K" << std::endl - << " " << std::flush); - } + cmCTestLog(this, HANDLER_OUTPUT, + " Size: " + << int((double(output.size()) / 1024.0) + 1) + << "K" << std::endl + << " " << std::flush); } } cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, cmCTestLogWrite(data, length)); @@ -1229,7 +1223,7 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output, } } cmCTestLog(this, OUTPUT, " Size of output: " - << int(double(output->size()) / 1024.0) << "K" << std::endl); + << int(double(output.size()) / 1024.0) << "K" << std::endl); cmsysProcess_WaitForExit(cp, 0); @@ -1253,9 +1247,9 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output, } else if(result == cmsysProcess_State_Error) { - *output += "\n*** ERROR executing: "; - *output += cmsysProcess_GetErrorString(cp); - *output += "\n***The build process failed."; + output += "\n*** ERROR executing: "; + output += cmsysProcess_GetErrorString(cp); + output += "\n***The build process failed."; cmCTestLog(this, ERROR_MESSAGE, "There was an error: " << cmsysProcess_GetErrorString(cp) << std::endl); } diff --git a/Source/cmCTest.h b/Source/cmCTest.h index 246294f..e19d32c 100644 --- a/Source/cmCTest.h +++ b/Source/cmCTest.h @@ -271,7 +271,7 @@ public: //! Run command specialized for make and configure. Returns process status // and retVal is return value or exception. - int RunMakeCommand(const char* command, std::string* output, + int RunMakeCommand(const char* command, std::string& output, int* retVal, const char* dir, int timeout, std::ostream& ofs); diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx index c13da50..b13a125 100644 --- a/Source/cmComputeLinkDepends.cxx +++ b/Source/cmComputeLinkDepends.cxx @@ -166,7 +166,8 @@ guaranteed to be acyclic. The final list of items produced by this procedure consists of the original user link line followed by minimal additional items needed to -satisfy dependencies. +satisfy dependencies. The final list is then filtered to de-duplicate +items that we know the linker will re-use automatically (shared libs). */ @@ -262,10 +263,20 @@ cmComputeLinkDepends::Compute() this->OrderLinkEntires(); // Compute the final set of link entries. + std::set<int> emmitted; for(std::vector<int>::const_iterator li = this->FinalLinkOrder.begin(); li != this->FinalLinkOrder.end(); ++li) { - this->FinalLinkEntries.push_back(this->EntryList[*li]); + int i = *li; + LinkEntry const& e = this->EntryList[i]; + cmTarget const* t = e.Target; + // Entries that we know the linker will re-use for symbols + // needed by later entries do not need to be repeated. + bool uniquify = t && t->GetType() == cmTarget::SHARED_LIBRARY; + if(!uniquify || emmitted.insert(i).second) + { + this->FinalLinkEntries.push_back(e); + } } // Display the final set. diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx index a3f3277..ed19851 100644 --- a/Source/cmCoreTryCompile.cxx +++ b/Source/cmCoreTryCompile.cxx @@ -489,7 +489,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) targetName, this->SrcFileSignature, &cmakeFlags, - &output); + output); if ( erroroc ) { cmSystemTools::SetErrorOccured(); diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx index e47365a..1325cec 100644 --- a/Source/cmFileCommand.cxx +++ b/Source/cmFileCommand.cxx @@ -428,7 +428,8 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args) arg_length_minimum, arg_length_maximum, arg__maximum, - arg_regex }; + arg_regex, + arg_encoding }; unsigned int minlen = 0; unsigned int maxlen = 0; int limit_input = -1; @@ -438,6 +439,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args) bool have_regex = false; bool newline_consume = false; bool hex_conversion_enabled = true; + bool utf8_encoding = false; int arg_mode = arg_none; for(unsigned int i=3; i < args.size(); ++i) { @@ -475,6 +477,10 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args) hex_conversion_enabled = false; arg_mode = arg_none; } + else if(args[i] == "ENCODING") + { + arg_mode = arg_encoding; + } else if(arg_mode == arg_limit_input) { if(sscanf(args[i].c_str(), "%d", &limit_input) != 1 || @@ -556,6 +562,22 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args) have_regex = true; arg_mode = arg_none; } + else if(arg_mode == arg_encoding) + { + if(args[i] == "UTF-8") + { + utf8_encoding = true; + } + else + { + cmOStringStream e; + e << "STRINGS option ENCODING \"" + << args[i] << "\" not recognized."; + this->SetError(e.str()); + return false; + } + arg_mode = arg_none; + } else { cmOStringStream e; @@ -596,11 +618,75 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args) int output_size = 0; std::vector<std::string> strings; std::string s; - int c; while((!limit_count || strings.size() < limit_count) && (limit_input < 0 || static_cast<int>(fin.tellg()) < limit_input) && - (c = fin.get(), fin)) + fin) { + std::string current_str; + + int c = fin.get(); + + if(c == '\r') + { + // Ignore CR character to make output always have UNIX newlines. + continue; + } + + else if((c >= 0x20 && c < 0x7F) || c == '\t' || + (c == '\n' && newline_consume)) + { + // This is an ASCII character that may be part of a string. + // Cast added to avoid compiler warning. Cast is ok because + // c is guaranteed to fit in char by the above if... + current_str += static_cast<char>(c); + } + else if(utf8_encoding) + { + // Check for UTF-8 encoded string (up to 4 octets) + static const unsigned char utf8_check_table[3][2] = + { + {0xE0, 0xC0}, + {0xF0, 0xE0}, + {0xF8, 0xF0}, + }; + + // how many octets are there? + unsigned int num_utf8_bytes = 0; + for(unsigned int j=0; num_utf8_bytes == 0 && j<3; j++) + { + if((c & utf8_check_table[j][0]) == utf8_check_table[j][1]) + num_utf8_bytes = j+2; + } + + // get subsequent octets and check that they are valid + for(unsigned int j=0; j<num_utf8_bytes; j++) + { + if(j != 0) + { + c = fin.get(); + if(!fin || (c & 0xC0) != 0x80) + { + fin.putback(static_cast<char>(c)); + break; + } + } + current_str += static_cast<char>(c); + } + + // if this was an invalid utf8 sequence, discard the data, and put + // back subsequent characters + if((current_str.length() != num_utf8_bytes)) + { + for(unsigned int j=0; j<current_str.size()-1; j++) + { + c = current_str[current_str.size() - 1 - j]; + fin.putback(static_cast<char>(c)); + } + current_str = ""; + } + } + + if(c == '\n' && !newline_consume) { // The current line has been terminated. Check if the current @@ -621,26 +707,13 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args) // Reset the string to empty. s = ""; } - else if(c == '\r') - { - // Ignore CR character to make output always have UNIX newlines. - } - else if((c >= 0x20 && c < 0x7F) || c == '\t' || - (c == '\n' && newline_consume)) + else if(current_str.empty()) { - // This is an ASCII character that may be part of a string. - // Cast added to avoid compiler warning. Cast is ok because - // c is guaranteed to fit in char by the above if... - s += static_cast<char>(c); - } - else - { - // TODO: Support ENCODING option. See issue #10519. // A non-string character has been found. Check if the current // string matches the requirements. We require that the length // be at least one no matter what the user specified. if(s.length() >= minlen && s.length() >= 1 && - (!have_regex || regex.find(s.c_str()))) + (!have_regex || regex.find(s.c_str()))) { output_size += static_cast<int>(s.size()) + 1; if(limit_output >= 0 && output_size >= limit_output) @@ -654,10 +727,15 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args) // Reset the string to empty. s = ""; } + else + { + s += current_str; + } + - // Terminate a string if the maximum length is reached. if(maxlen > 0 && s.size() == maxlen) { + // Terminate a string if the maximum length is reached. if(s.length() >= minlen && (!have_regex || regex.find(s.c_str()))) { diff --git a/Source/cmGeneratorExpressionEvaluator.cxx b/Source/cmGeneratorExpressionEvaluator.cxx index 35a9fcb..c1478df 100644 --- a/Source/cmGeneratorExpressionEvaluator.cxx +++ b/Source/cmGeneratorExpressionEvaluator.cxx @@ -394,9 +394,8 @@ struct CompilerIdNode : public cmGeneratorExpressionNode cmGeneratorExpressionDAGChecker *, const std::string &lang) const { - const char *compilerId = context->Makefile ? - context->Makefile->GetSafeDefinition( - "CMAKE_" + lang + "_COMPILER_ID") : ""; + const char *compilerId = + context->Makefile->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID"); if (parameters.size() == 0) { return compilerId ? compilerId : ""; @@ -500,9 +499,8 @@ struct CompilerVersionNode : public cmGeneratorExpressionNode cmGeneratorExpressionDAGChecker *, const std::string &lang) const { - const char *compilerVersion = context->Makefile ? - context->Makefile->GetSafeDefinition( - "CMAKE_" + lang + "_COMPILER_VERSION") : ""; + const char *compilerVersion = context->Makefile->GetSafeDefinition( + "CMAKE_" + lang + "_COMPILER_VERSION"); if (parameters.size() == 0) { return compilerVersion ? compilerVersion : ""; @@ -583,9 +581,8 @@ struct PlatformIdNode : public cmGeneratorExpressionNode const GeneratorExpressionContent *, cmGeneratorExpressionDAGChecker *) const { - const char *platformId = context->Makefile ? - context->Makefile->GetSafeDefinition( - "CMAKE_SYSTEM_NAME") : ""; + const char *platformId = + context->Makefile->GetSafeDefinition("CMAKE_SYSTEM_NAME"); if (parameters.size() == 0) { return platformId ? platformId : ""; @@ -1081,7 +1078,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode } } #undef POPULATE_INTERFACE_PROPERTY_NAME - cmTarget const* headTarget = context->HeadTarget + cmTarget const* headTarget = context->HeadTarget && isInterfaceProperty ? context->HeadTarget : target; if(isInterfaceProperty) @@ -1103,7 +1100,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode { linkedTargetsContent = getLinkedTargetsContent(impl->Libraries, target, - headTarget, + target, context, &dagChecker, interfacePropertyName); } diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index 249373c..3f948b5 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -844,6 +844,14 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf, case cmPolicies::OLD: // OLD behavior is to convert QCC to GNU. mf->AddDefinition(compilerIdVar, "GNU"); + if(lang == "C") + { + mf->AddDefinition("CMAKE_COMPILER_IS_GNUCC", "1"); + } + else if(lang == "CXX") + { + mf->AddDefinition("CMAKE_COMPILER_IS_GNUCXX", "1"); + } break; case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: @@ -1616,7 +1624,7 @@ int cmGlobalGenerator::TryCompile(const std::string& srcdir, const std::string& bindir, const std::string& projectName, const std::string& target, bool fast, - std::string *output, cmMakefile *mf) + std::string& output, cmMakefile *mf) { // if this is not set, then this is a first time configure // and there is a good chance that the try compile stuff will @@ -1675,7 +1683,7 @@ void cmGlobalGenerator::GenerateBuildCommand( int cmGlobalGenerator::Build( const std::string&, const std::string& bindir, const std::string& projectName, const std::string& target, - std::string *output, + std::string& output, const std::string& makeCommandCSTR, const std::string& config, bool clean, bool fast, @@ -1688,22 +1696,15 @@ int cmGlobalGenerator::Build( */ std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); cmSystemTools::ChangeDirectory(bindir.c_str()); - if(output) - { - *output += "Change Dir: "; - *output += bindir; - *output += "\n"; - } + output += "Change Dir: "; + output += bindir; + output += "\n"; int retVal; bool hideconsole = cmSystemTools::GetRunCommandHideConsole(); cmSystemTools::SetRunCommandHideConsole(true); std::string outputBuffer; - std::string* outputPtr = 0; - if(output) - { - outputPtr = &outputBuffer; - } + std::string* outputPtr = &outputBuffer; // should we do a clean first? if (clean) @@ -1711,32 +1712,23 @@ int cmGlobalGenerator::Build( std::vector<std::string> cleanCommand; this->GenerateBuildCommand(cleanCommand, makeCommandCSTR, projectName, bindir, "clean", config, fast); - if(output) - { - *output += "\nRun Clean Command:"; - *output += cmSystemTools::PrintSingleCommand(cleanCommand); - *output += "\n"; - } + output += "\nRun Clean Command:"; + output += cmSystemTools::PrintSingleCommand(cleanCommand); + output += "\n"; if (!cmSystemTools::RunSingleCommand(cleanCommand, outputPtr, &retVal, 0, outputflag, timeout)) { cmSystemTools::SetRunCommandHideConsole(hideconsole); cmSystemTools::Error("Generator: execution of make clean failed."); - if (output) - { - *output += *outputPtr; - *output += "\nGenerator: execution of make clean failed.\n"; - } + output += *outputPtr; + output += "\nGenerator: execution of make clean failed.\n"; // return to the original directory cmSystemTools::ChangeDirectory(cwd.c_str()); return 1; } - if (output) - { - *output += *outputPtr; - } + output += *outputPtr; } // now build @@ -1744,12 +1736,9 @@ int cmGlobalGenerator::Build( this->GenerateBuildCommand(makeCommand, makeCommandCSTR, projectName, bindir, target, config, fast, nativeOptions); std::string makeCommandStr = cmSystemTools::PrintSingleCommand(makeCommand); - if(output) - { - *output += "\nRun Build Command:"; - *output += makeCommandStr; - *output += "\n"; - } + output += "\nRun Build Command:"; + output += makeCommandStr; + output += "\n"; if (!cmSystemTools::RunSingleCommand(makeCommand, outputPtr, &retVal, 0, outputflag, timeout)) @@ -1758,27 +1747,21 @@ int cmGlobalGenerator::Build( cmSystemTools::Error ("Generator: execution of make failed. Make command was: ", makeCommandStr.c_str()); - if (output) - { - *output += *outputPtr; - *output += "\nGenerator: execution of make failed. Make command was: " + output += *outputPtr; + output += "\nGenerator: execution of make failed. Make command was: " + makeCommandStr + "\n"; - } // return to the original directory cmSystemTools::ChangeDirectory(cwd.c_str()); return 1; } - if (output) - { - *output += *outputPtr; - } + output += *outputPtr; cmSystemTools::SetRunCommandHideConsole(hideconsole); // The SGI MipsPro 7.3 compiler does not return an error code when // the source has a #error in it! This is a work-around for such // compilers. - if((retVal == 0) && (output->find("#error") != std::string::npos)) + if((retVal == 0) && (output.find("#error") != std::string::npos)) { retVal = 1; } diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h index 6b608bb..f80c3c7 100644 --- a/Source/cmGlobalGenerator.h +++ b/Source/cmGlobalGenerator.h @@ -116,7 +116,7 @@ public: virtual int TryCompile(const std::string& srcdir, const std::string& bindir, const std::string& projectName, const std::string& targetName, - bool fast, std::string *output, cmMakefile* mf); + bool fast, std::string& output, cmMakefile* mf); /** @@ -127,7 +127,7 @@ public: */ int Build(const std::string& srcdir, const std::string& bindir, const std::string& projectName, const std::string& targetName, - std::string *output, + std::string& output, const std::string& makeProgram, const std::string& config, bool clean, bool fast, double timeout, diff --git a/Source/cmInstalledFile.cxx b/Source/cmInstalledFile.cxx index 7813fcc..3483ecc 100644 --- a/Source/cmInstalledFile.cxx +++ b/Source/cmInstalledFile.cxx @@ -111,3 +111,14 @@ bool cmInstalledFile::GetPropertyAsBool(const std::string& prop) const bool isSet = this->GetProperty(prop, value); return isSet && cmSystemTools::IsOn(value.c_str()); } + +//---------------------------------------------------------------------------- +void cmInstalledFile::GetPropertyAsList(const std::string& prop, + std::vector<std::string>& list) const +{ + std::string value; + this->GetProperty(prop, value); + + list.clear(); + cmSystemTools::ExpandListArgument(value, list); +} diff --git a/Source/cmInstalledFile.h b/Source/cmInstalledFile.h index df28221..0292cd1 100644 --- a/Source/cmInstalledFile.h +++ b/Source/cmInstalledFile.h @@ -66,6 +66,9 @@ public: bool GetPropertyAsBool(const std::string& prop) const; + void GetPropertyAsList(const std::string& prop, + std::vector<std::string>& list) const; + void SetName(cmMakefile* mf, const std::string& name); std::string const& GetName() const; diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index d3ca34a..04b2d27 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -3510,7 +3510,7 @@ int cmMakefile::TryCompile(const std::string& srcdir, const std::string& targetName, bool fast, const std::vector<std::string> *cmakeArgs, - std::string *output) + std::string& output) { this->Internal->IsSourceFileTryCompile = fast; // does the binary directory exist ? If not create it... diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h index 3a40c1c..d728a62 100644 --- a/Source/cmMakefile.h +++ b/Source/cmMakefile.h @@ -130,7 +130,7 @@ public: const std::string& projectName, const std::string& targetName, bool fast, const std::vector<std::string> *cmakeArgs, - std::string *output); + std::string& output); bool GetIsSourceFileTryCompile() const; diff --git a/Source/cmake.cxx b/Source/cmake.cxx index 5aa1ab0..6cc3b81 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -2757,7 +2757,7 @@ int cmake::Build(const std::string& dir, projName = it.GetValue(); return gen->Build("", dir, projName, target, - &output, + output, "", config, clean, false, 0, cmSystemTools::OUTPUT_PASSTHROUGH, diff --git a/Source/kwsys/CPU.h.in b/Source/kwsys/CPU.h.in index 2e1a584..626914b 100644 --- a/Source/kwsys/CPU.h.in +++ b/Source/kwsys/CPU.h.in @@ -80,6 +80,10 @@ #elif defined(__mips) || defined(__mips__) || defined(__MIPS__) # define @KWSYS_NAMESPACE@_CPU_ENDIAN_ID @KWSYS_NAMESPACE@_CPU_ENDIAN_ID_BIG +/* OpenRISC 1000 */ +#elif defined(__or1k__) +# define @KWSYS_NAMESPACE@_CPU_ENDIAN_ID @KWSYS_NAMESPACE@_CPU_ENDIAN_ID_BIG + /* RS/6000 */ #elif defined(__THW_RS600) || defined(_IBMR2) || defined(_POWER) # define @KWSYS_NAMESPACE@_CPU_ENDIAN_ID @KWSYS_NAMESPACE@_CPU_ENDIAN_ID_BIG diff --git a/Source/kwsys/Directory.cxx b/Source/kwsys/Directory.cxx index b305fd7..741bcba 100644 --- a/Source/kwsys/Directory.cxx +++ b/Source/kwsys/Directory.cxx @@ -103,7 +103,7 @@ void Directory::Clear() namespace KWSYS_NAMESPACE { -bool Directory::Load(const char* name) +bool Directory::Load(const kwsys_stl::string& name) { this->Clear(); #if _MSC_VER < 1300 @@ -112,24 +112,24 @@ bool Directory::Load(const char* name) intptr_t srchHandle; #endif char* buf; - size_t n = strlen(name); - if ( name[n - 1] == '/' || name[n - 1] == '\\' ) + size_t n = name.size(); + if ( *name.rbegin() == '/' || *name.rbegin() == '\\' ) { buf = new char[n + 1 + 1]; - sprintf(buf, "%s*", name); + sprintf(buf, "%s*", name.c_str()); } else { // Make sure the slashes in the wildcard suffix are consistent with the // rest of the path buf = new char[n + 2 + 1]; - if ( strchr(name, '\\') ) + if ( name.find('\\') != name.npos ) { - sprintf(buf, "%s\\*", name); + sprintf(buf, "%s\\*", name.c_str()); } else { - sprintf(buf, "%s/*", name); + sprintf(buf, "%s/*", name.c_str()); } } struct _wfinddata_t data; // data of current file @@ -153,7 +153,7 @@ bool Directory::Load(const char* name) return _findclose(srchHandle) != -1; } -unsigned long Directory::GetNumberOfFilesInDirectory(const char* name) +unsigned long Directory::GetNumberOfFilesInDirectory(const kwsys_stl::string& name) { #if _MSC_VER < 1300 long srchHandle; @@ -161,16 +161,16 @@ unsigned long Directory::GetNumberOfFilesInDirectory(const char* name) intptr_t srchHandle; #endif char* buf; - size_t n = strlen(name); - if ( name[n - 1] == '/' ) + size_t n = name.size(); + if ( *name.rbegin() == '/' ) { buf = new char[n + 1 + 1]; - sprintf(buf, "%s*", name); + sprintf(buf, "%s*", name.c_str()); } else { buf = new char[n + 2 + 1]; - sprintf(buf, "%s/*", name); + sprintf(buf, "%s/*", name.c_str()); } struct _wfinddata_t data; // data of current file @@ -215,15 +215,11 @@ p=1992&sid=f16167f51964f1a68fe5041b8eb213b6 namespace KWSYS_NAMESPACE { -bool Directory::Load(const char* name) +bool Directory::Load(const kwsys_stl::string& name) { this->Clear(); - if (!name) - { - return 0; - } - DIR* dir = opendir(name); + DIR* dir = opendir(name.c_str()); if (!dir) { @@ -239,14 +235,9 @@ bool Directory::Load(const char* name) return 1; } -unsigned long Directory::GetNumberOfFilesInDirectory(const char* name) +unsigned long Directory::GetNumberOfFilesInDirectory(const kwsys_stl::string& name) { - DIR* dir = opendir(name); - - if (!dir) - { - return 0; - } + DIR* dir = opendir(name.c_str()); unsigned long count = 0; for (dirent* d = readdir(dir); d; d = readdir(dir) ) diff --git a/Source/kwsys/Directory.hxx.in b/Source/kwsys/Directory.hxx.in index 05217c4..0acb191 100644 --- a/Source/kwsys/Directory.hxx.in +++ b/Source/kwsys/Directory.hxx.in @@ -13,6 +13,13 @@ #define @KWSYS_NAMESPACE@_Directory_hxx #include <@KWSYS_NAMESPACE@/Configure.h> +#include <@KWSYS_NAMESPACE@/stl/string> + +/* Define these macros temporarily to keep the code readable. */ +#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS +# define kwsys_stl @KWSYS_NAMESPACE@_stl +# define kwsys_ios @KWSYS_NAMESPACE@_ios +#endif namespace @KWSYS_NAMESPACE@ { @@ -38,7 +45,7 @@ public: * in that directory. 0 is returned if the directory can not be * opened, 1 if it is opened. */ - bool Load(const char*); + bool Load(const kwsys_stl::string&); /** * Return the number of files in the current directory. @@ -49,7 +56,7 @@ public: * Return the number of files in the specified directory. * A higher performance static method. */ - static unsigned long GetNumberOfFilesInDirectory(const char*); + static unsigned long GetNumberOfFilesInDirectory(const kwsys_stl::string&); /** * Return the file at the given index, the indexing is 0 based @@ -77,4 +84,10 @@ private: } // namespace @KWSYS_NAMESPACE@ +/* Undefine temporary macros. */ +#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS +# undef kwsys_stl +# undef kwsys_ios +#endif + #endif diff --git a/Source/kwsys/Glob.cxx b/Source/kwsys/Glob.cxx index 8569b0e..0916d2e 100644 --- a/Source/kwsys/Glob.cxx +++ b/Source/kwsys/Glob.cxx @@ -218,7 +218,7 @@ void Glob::RecurseDirectory(kwsys_stl::string::size_type start, const kwsys_stl::string& dir) { kwsys::Directory d; - if ( !d.Load(dir.c_str()) ) + if ( !d.Load(dir) ) { return; } @@ -257,8 +257,8 @@ void Glob::RecurseDirectory(kwsys_stl::string::size_type start, fullname = dir + "/" + fname; } - bool isDir = kwsys::SystemTools::FileIsDirectory(realname.c_str()); - bool isSymLink = kwsys::SystemTools::FileIsSymlink(realname.c_str()); + bool isDir = kwsys::SystemTools::FileIsDirectory(realname); + bool isSymLink = kwsys::SystemTools::FileIsSymlink(realname); if ( isDir && (!isSymLink || this->RecurseThroughSymlinks) ) { @@ -297,7 +297,7 @@ void Glob::ProcessDirectory(kwsys_stl::string::size_type start, } kwsys::Directory d; - if ( !d.Load(dir.c_str()) ) + if ( !d.Load(dir) ) { return; } @@ -342,12 +342,12 @@ void Glob::ProcessDirectory(kwsys_stl::string::size_type start, //kwsys_ios::cout << "Full name: " << fullname << kwsys_ios::endl; if ( !last && - !kwsys::SystemTools::FileIsDirectory(realname.c_str()) ) + !kwsys::SystemTools::FileIsDirectory(realname) ) { continue; } - if ( this->Internals->Expressions[start].find(fname.c_str()) ) + if ( this->Internals->Expressions[start].find(fname) ) { if ( last ) { @@ -371,7 +371,7 @@ bool Glob::FindFiles(const kwsys_stl::string& inexpr) this->Internals->Expressions.clear(); this->Internals->Files.clear(); - if ( !kwsys::SystemTools::FileIsFullPath(expr.c_str()) ) + if ( !kwsys::SystemTools::FileIsFullPath(expr) ) { expr = kwsys::SystemTools::GetCurrentWorkingDirectory(); expr += "/" + inexpr; diff --git a/Source/kwsys/ProcessUNIX.c b/Source/kwsys/ProcessUNIX.c index 241e295..ca9d424 100644 --- a/Source/kwsys/ProcessUNIX.c +++ b/Source/kwsys/ProcessUNIX.c @@ -68,6 +68,7 @@ do. #include <signal.h> /* sigaction */ #include <dirent.h> /* DIR, dirent */ #include <ctype.h> /* isspace */ +#include <assert.h> /* assert */ #if defined(__VMS) # define KWSYSPE_VMS_NONBLOCK , O_NONBLOCK @@ -450,6 +451,7 @@ int kwsysProcess_AddCommand(kwsysProcess* cp, char const* const* command) } for(i=0; i < n; ++i) { + assert(command[i]); /* Quiet Clang scan-build. */ newCommands[cp->NumberOfCommands][i] = strdup(command[i]); if(!newCommands[cp->NumberOfCommands][i]) { diff --git a/Source/kwsys/SharedForward.h.in b/Source/kwsys/SharedForward.h.in index dd4d462..7ff29b4 100644 --- a/Source/kwsys/SharedForward.h.in +++ b/Source/kwsys/SharedForward.h.in @@ -512,7 +512,7 @@ static void kwsys_shared_forward_execvp(const char* cmd, /* Invoke the child process. */ #if defined(_MSC_VER) _execvp(cmd, argv); -#elif defined(__MINGW32__) +#elif defined(__MINGW32__) && !defined(__MINGW64__) execvp(cmd, argv); #else execvp(cmd, (char* const*)argv); diff --git a/Source/kwsys/SystemTools.cxx b/Source/kwsys/SystemTools.cxx index db94510..e34bb43 100644 --- a/Source/kwsys/SystemTools.cxx +++ b/Source/kwsys/SystemTools.cxx @@ -206,12 +206,12 @@ static time_t windows_filetime_to_posix_time(const FILETIME& ft) #include <wctype.h> -inline int Mkdir(const char* dir) +inline int Mkdir(const kwsys_stl::string& dir) { return _wmkdir( KWSYS_NAMESPACE::SystemTools::ConvertToWindowsExtendedPath(dir).c_str()); } -inline int Rmdir(const char* dir) +inline int Rmdir(const kwsys_stl::string& dir) { return _wrmdir( KWSYS_NAMESPACE::SystemTools::ConvertToWindowsExtendedPath(dir).c_str()); @@ -232,15 +232,15 @@ inline const char* Getcwd(char* buf, unsigned int len) } return 0; } -inline int Chdir(const char* dir) +inline int Chdir(const kwsys_stl::string& dir) { #if defined(__BORLANDC__) - return chdir(dir); + return chdir(dir.c_str()); #else return _wchdir(KWSYS_NAMESPACE::Encoding::ToWide(dir).c_str()); #endif } -inline void Realpath(const char *path, kwsys_stl::string & resolved_path) +inline void Realpath(const kwsys_stl::string& path, kwsys_stl::string & resolved_path) { kwsys_stl::wstring tmp = KWSYS_NAMESPACE::Encoding::ToWide(path); wchar_t *ptemp; @@ -260,28 +260,28 @@ inline void Realpath(const char *path, kwsys_stl::string & resolved_path) #include <sys/types.h> #include <fcntl.h> #include <unistd.h> -inline int Mkdir(const char* dir) +inline int Mkdir(const kwsys_stl::string& dir) { - return mkdir(dir, 00777); + return mkdir(dir.c_str(), 00777); } -inline int Rmdir(const char* dir) +inline int Rmdir(const kwsys_stl::string& dir) { - return rmdir(dir); + return rmdir(dir.c_str()); } inline const char* Getcwd(char* buf, unsigned int len) { return getcwd(buf, len); } -inline int Chdir(const char* dir) +inline int Chdir(const kwsys_stl::string& dir) { - return chdir(dir); + return chdir(dir.c_str()); } -inline void Realpath(const char *path, kwsys_stl::string & resolved_path) +inline void Realpath(const kwsys_stl::string& path, kwsys_stl::string & resolved_path) { char resolved_name[KWSYS_SYSTEMTOOLS_MAXPATH]; - char *ret = realpath(path, resolved_name); + char *ret = realpath(path.c_str(), resolved_name); if(ret) { resolved_path = ret; @@ -334,9 +334,9 @@ class SystemToolsTranslationMap : void SystemTools::GetPath(kwsys_stl::vector<kwsys_stl::string>& path, const char* env) { #if defined(_WIN32) && !defined(__CYGWIN__) - const char* pathSep = ";"; + const char pathSep = ';'; #else - const char* pathSep = ":"; + const char pathSep = ':'; #endif if(!env) { @@ -351,7 +351,7 @@ void SystemTools::GetPath(kwsys_stl::vector<kwsys_stl::string>& path, const char kwsys_stl::string pathEnv = cpathEnv; // A hack to make the below algorithm work. - if(!pathEnv.empty() && pathEnv[pathEnv.length()-1] != pathSep[0]) + if(!pathEnv.empty() && *pathEnv.rbegin() != pathSep) { pathEnv += pathSep; } @@ -623,13 +623,13 @@ const char* SystemTools::GetExecutableExtension() #endif } -FILE* SystemTools::Fopen(const char* file, const char* mode) +FILE* SystemTools::Fopen(const kwsys_stl::string& file, const char* mode) { #ifdef _WIN32 return _wfopen(SystemTools::ConvertToWindowsExtendedPath(file).c_str(), Encoding::ToWide(mode).c_str()); #else - return fopen(file, mode); + return fopen(file.c_str(), mode); #endif } @@ -639,15 +639,20 @@ bool SystemTools::MakeDirectory(const char* path) { return false; } + return SystemTools::MakeDirectory(kwsys_stl::string(path)); +} + +bool SystemTools::MakeDirectory(const kwsys_stl::string& path) +{ if(SystemTools::FileExists(path)) { return SystemTools::FileIsDirectory(path); } - kwsys_stl::string dir = path; - if(dir.empty()) + if(path.empty()) { return false; } + kwsys_stl::string dir = path; SystemTools::ConvertToUnixSlashes(dir); kwsys_stl::string::size_type pos = 0; @@ -655,11 +660,11 @@ bool SystemTools::MakeDirectory(const char* path) while((pos = dir.find('/', pos)) != kwsys_stl::string::npos) { topdir = dir.substr(0, pos); - Mkdir(topdir.c_str()); + Mkdir(topdir); pos++; } topdir = dir; - if(Mkdir(topdir.c_str()) != 0) + if(Mkdir(topdir) != 0) { // There is a bug in the Borland Run time library which makes MKDIR // return EACCES when it should return EEXISTS @@ -1021,7 +1026,7 @@ bool SystemTools::DeleteRegistryValue(const char *, KeyWOW64) } #endif -bool SystemTools::SameFile(const char* file1, const char* file2) +bool SystemTools::SameFile(const kwsys_stl::string& file1, const kwsys_stl::string& file2) { #ifdef _WIN32 HANDLE hFile1, hFile2; @@ -1066,7 +1071,7 @@ bool SystemTools::SameFile(const char* file1, const char* file2) fiBuf1.nFileIndexLow == fiBuf2.nFileIndexLow); #else struct stat fileStat1, fileStat2; - if (stat(file1, &fileStat1) == 0 && stat(file2, &fileStat2) == 0) + if (stat(file1.c_str(), &fileStat1) == 0 && stat(file2.c_str(), &fileStat2) == 0) { // see if the files are the same file // check the device inode and size @@ -1085,24 +1090,34 @@ bool SystemTools::SameFile(const char* file1, const char* file2) //---------------------------------------------------------------------------- bool SystemTools::FileExists(const char* filename) { - if(!(filename && *filename)) + if(!filename) + { + return false; + } + return SystemTools::FileExists(kwsys_stl::string(filename)); +} + +//---------------------------------------------------------------------------- +bool SystemTools::FileExists(const kwsys_stl::string& filename) +{ + if(filename.empty()) { return false; } #if defined(__CYGWIN__) // Convert filename to native windows path if possible. char winpath[MAX_PATH]; - if(SystemTools::PathCygwinToWin32(filename, winpath)) + if(SystemTools::PathCygwinToWin32(filename.c_str(), winpath)) { return (GetFileAttributesA(winpath) != INVALID_FILE_ATTRIBUTES); } - return access(filename, R_OK) == 0; + return access(filename.c_str(), R_OK) == 0; #elif defined(_WIN32) return (GetFileAttributesW( SystemTools::ConvertToWindowsExtendedPath(filename).c_str()) != INVALID_FILE_ATTRIBUTES); #else - return access(filename, R_OK) == 0; + return access(filename.c_str(), R_OK) == 0; #endif } @@ -1119,6 +1134,18 @@ bool SystemTools::FileExists(const char* filename, bool isFile) } //---------------------------------------------------------------------------- +bool SystemTools::FileExists(const kwsys_stl::string& filename, bool isFile) +{ + if(SystemTools::FileExists(filename)) + { + // If isFile is set return not FileIsDirectory, + // so this will only be true if it is a file + return !isFile || !SystemTools::FileIsDirectory(filename); + } + return false; +} + +//---------------------------------------------------------------------------- #ifdef __CYGWIN__ bool SystemTools::PathCygwinToWin32(const char *path, char *win32_path) { @@ -1142,7 +1169,7 @@ bool SystemTools::PathCygwinToWin32(const char *path, char *win32_path) } #endif -bool SystemTools::Touch(const char* filename, bool create) +bool SystemTools::Touch(const kwsys_stl::string& filename, bool create) { if(create && !SystemTools::FileExists(filename)) { @@ -1174,13 +1201,13 @@ bool SystemTools::Touch(const char* filename, bool create) CloseHandle(h); #elif KWSYS_CXX_HAS_UTIMENSAT struct timespec times[2] = {{0,UTIME_OMIT},{0,UTIME_NOW}}; - if(utimensat(AT_FDCWD, filename, times, 0) < 0) + if(utimensat(AT_FDCWD, filename.c_str(), times, 0) < 0) { return false; } #else struct stat st; - if(stat(filename, &st) < 0) + if(stat(filename.c_str(), &st) < 0) { return false; } @@ -1196,13 +1223,13 @@ bool SystemTools::Touch(const char* filename, bool create) # endif mtime }; - if(utimes(filename, times) < 0) + if(utimes(filename.c_str(), times) < 0) { return false; } # else struct utimbuf times = {st.st_atime, mtime.tv_sec}; - if(utime(filename, ×) < 0) + if(utime(filename.c_str(), ×) < 0) { return false; } @@ -1211,7 +1238,8 @@ bool SystemTools::Touch(const char* filename, bool create) return true; } -bool SystemTools::FileTimeCompare(const char* f1, const char* f2, +bool SystemTools::FileTimeCompare(const kwsys_stl::string& f1, + const kwsys_stl::string& f2, int* result) { // Default to same time. @@ -1219,12 +1247,12 @@ bool SystemTools::FileTimeCompare(const char* f1, const char* f2, #if !defined(_WIN32) || defined(__CYGWIN__) // POSIX version. Use stat function to get file modification time. struct stat s1; - if(stat(f1, &s1) != 0) + if(stat(f1.c_str(), &s1) != 0) { return false; } struct stat s2; - if(stat(f2, &s2) != 0) + if(stat(f2.c_str(), &s2) != 0) { return false; } @@ -1535,6 +1563,17 @@ bool SystemTools::StringStartsWith(const char* str1, const char* str2) return len1 >= len2 && !strncmp(str1, str2, len2) ? true : false; } +// Returns if string starts with another string +bool SystemTools::StringStartsWith(const kwsys_stl::string& str1, const char* str2) +{ + if (!str2) + { + return false; + } + size_t len1 = str1.size(), len2 = strlen(str2); + return len1 >= len2 && !strncmp(str1.c_str(), str2, len2) ? true : false; +} + // Returns if string ends with another string bool SystemTools::StringEndsWith(const char* str1, const char* str2) { @@ -1546,6 +1585,17 @@ bool SystemTools::StringEndsWith(const char* str1, const char* str2) return len1 >= len2 && !strncmp(str1 + (len1 - len2), str2, len2) ? true : false; } +// Returns if string ends with another string +bool SystemTools::StringEndsWith(const kwsys_stl::string& str1, const char* str2) +{ + if (!str2) + { + return false; + } + size_t len1 = str1.size(), len2 = strlen(str2); + return len1 >= len2 && !strncmp(str1.c_str() + (len1 - len2), str2, len2) ? true : false; +} + // Returns a pointer to the last occurence of str2 in str1 const char* SystemTools::FindLastString(const char* str1, const char* str2) { @@ -1615,7 +1665,7 @@ kwsys_stl::string SystemTools::CropString(const kwsys_stl::string& s, } //---------------------------------------------------------------------------- -kwsys_stl::vector<kwsys::String> SystemTools::SplitString(const char* p, char sep, bool isPath) +kwsys_stl::vector<kwsys::String> SystemTools::SplitString(const kwsys_stl::string& p, char sep, bool isPath) { kwsys_stl::string path = p; kwsys_stl::vector<kwsys::String> paths; @@ -1917,7 +1967,7 @@ SystemTools::ConvertToWindowsExtendedPath(const kwsys_stl::string &source) #endif // change // to /, and escape any spaces in the path -kwsys_stl::string SystemTools::ConvertToUnixOutputPath(const char* path) +kwsys_stl::string SystemTools::ConvertToUnixOutputPath(const kwsys_stl::string& path) { kwsys_stl::string ret = path; @@ -1947,7 +1997,7 @@ kwsys_stl::string SystemTools::ConvertToUnixOutputPath(const char* path) return ret; } -kwsys_stl::string SystemTools::ConvertToOutputPath(const char* path) +kwsys_stl::string SystemTools::ConvertToOutputPath(const kwsys_stl::string& path) { #if defined(_WIN32) && !defined(__CYGWIN__) return SystemTools::ConvertToWindowsOutputPath(path); @@ -1957,13 +2007,12 @@ kwsys_stl::string SystemTools::ConvertToOutputPath(const char* path) } // remove double slashes not at the start -kwsys_stl::string SystemTools::ConvertToWindowsOutputPath(const char* path) +kwsys_stl::string SystemTools::ConvertToWindowsOutputPath(const kwsys_stl::string& path) { kwsys_stl::string ret; // make it big enough for all of path and double quotes - ret.reserve(strlen(path)+3); + ret.reserve(path.size()+3); // put path into the string - ret.assign(path); ret = path; kwsys_stl::string::size_type pos = 0; // first convert all of the slashes @@ -2005,8 +2054,8 @@ kwsys_stl::string SystemTools::ConvertToWindowsOutputPath(const char* path) return ret; } -bool SystemTools::CopyFileIfDifferent(const char* source, - const char* destination) +bool SystemTools::CopyFileIfDifferent(const kwsys_stl::string& source, + const kwsys_stl::string& destination) { // special check for a destination that is a directory // FilesDiffer does not handle file to directory compare @@ -2017,7 +2066,7 @@ bool SystemTools::CopyFileIfDifferent(const char* source, new_destination += '/'; kwsys_stl::string source_name = source; new_destination += SystemTools::GetFilenameName(source_name); - if(SystemTools::FilesDiffer(source, new_destination.c_str())) + if(SystemTools::FilesDiffer(source, new_destination)) { return SystemTools::CopyFileAlways(source, destination); } @@ -2040,8 +2089,8 @@ bool SystemTools::CopyFileIfDifferent(const char* source, #define KWSYS_ST_BUFFER 4096 -bool SystemTools::FilesDiffer(const char* source, - const char* destination) +bool SystemTools::FilesDiffer(const kwsys_stl::string& source, + const kwsys_stl::string& destination) { #if defined(_WIN32) @@ -2079,13 +2128,13 @@ bool SystemTools::FilesDiffer(const char* source, #else struct stat statSource; - if (stat(source, &statSource) != 0) + if (stat(source.c_str(), &statSource) != 0) { return true; } struct stat statDestination; - if (stat(destination, &statDestination) != 0) + if (stat(destination.c_str(), &statDestination) != 0) { return true; } @@ -2103,15 +2152,15 @@ bool SystemTools::FilesDiffer(const char* source, #endif #if defined(_WIN32) - kwsys::ifstream finSource(source, + kwsys::ifstream finSource(source.c_str(), (kwsys_ios::ios::binary | kwsys_ios::ios::in)); - kwsys::ifstream finDestination(destination, + kwsys::ifstream finDestination(destination.c_str(), (kwsys_ios::ios::binary | kwsys_ios::ios::in)); #else - kwsys::ifstream finSource(source); - kwsys::ifstream finDestination(destination); + kwsys::ifstream finSource(source.c_str()); + kwsys::ifstream finDestination(destination.c_str()); #endif if(!finSource || !finDestination) { @@ -2156,7 +2205,7 @@ bool SystemTools::FilesDiffer(const char* source, /** * Copy a file named by "source" to the file named by "destination". */ -bool SystemTools::CopyFileAlways(const char* source, const char* destination) +bool SystemTools::CopyFileAlways(const kwsys_stl::string& source, const kwsys_stl::string& destination) { // If files are the same do not copy if ( SystemTools::SameFile(source, destination) ) @@ -2172,31 +2221,33 @@ bool SystemTools::CopyFileAlways(const char* source, const char* destination) // If destination is a directory, try to create a file with the same // name as the source in that directory. - kwsys_stl::string new_destination; + kwsys_stl::string real_destination = destination; + kwsys_stl::string destination_dir; if(SystemTools::FileExists(destination) && SystemTools::FileIsDirectory(destination)) { - new_destination = destination; - SystemTools::ConvertToUnixSlashes(new_destination); - new_destination += '/'; + destination_dir = real_destination; + SystemTools::ConvertToUnixSlashes(real_destination); + real_destination += '/'; kwsys_stl::string source_name = source; - new_destination += SystemTools::GetFilenameName(source_name); - destination = new_destination.c_str(); + real_destination += SystemTools::GetFilenameName(source_name); + } + else + { + destination_dir = SystemTools::GetFilenamePath(destination); } // Create destination directory - kwsys_stl::string destination_dir = destination; - destination_dir = SystemTools::GetFilenamePath(destination_dir); - SystemTools::MakeDirectory(destination_dir.c_str()); + SystemTools::MakeDirectory(destination_dir); // Open files #if defined(_WIN32) || defined(__CYGWIN__) - kwsys::ifstream fin(source, + kwsys::ifstream fin(source.c_str(), kwsys_ios::ios::binary | kwsys_ios::ios::in); #else - kwsys::ifstream fin(source); + kwsys::ifstream fin(source.c_str()); #endif if(!fin) { @@ -2207,13 +2258,13 @@ bool SystemTools::CopyFileAlways(const char* source, const char* destination) // can be written to. // If the remove fails continue so that files in read only directories // that do not allow file removal can be modified. - SystemTools::RemoveFile(destination); + SystemTools::RemoveFile(real_destination); #if defined(_WIN32) || defined(__CYGWIN__) - kwsys::ofstream fout(destination, + kwsys::ofstream fout(real_destination.c_str(), kwsys_ios::ios::binary | kwsys_ios::ios::out | kwsys_ios::ios::trunc); #else - kwsys::ofstream fout(destination, + kwsys::ofstream fout(real_destination.c_str(), kwsys_ios::ios::out | kwsys_ios::ios::trunc); #endif if(!fout) @@ -2249,7 +2300,7 @@ bool SystemTools::CopyFileAlways(const char* source, const char* destination) } if ( perms ) { - if ( !SystemTools::SetPermissions(destination, perm) ) + if ( !SystemTools::SetPermissions(real_destination, perm) ) { return false; } @@ -2258,7 +2309,7 @@ bool SystemTools::CopyFileAlways(const char* source, const char* destination) } //---------------------------------------------------------------------------- -bool SystemTools::CopyAFile(const char* source, const char* destination, +bool SystemTools::CopyAFile(const kwsys_stl::string& source, const kwsys_stl::string& destination, bool always) { if(always) @@ -2275,13 +2326,13 @@ bool SystemTools::CopyAFile(const char* source, const char* destination, * Copy a directory content from "source" directory to the directory named by * "destination". */ -bool SystemTools::CopyADirectory(const char* source, const char* destination, +bool SystemTools::CopyADirectory(const kwsys_stl::string& source, const kwsys_stl::string& destination, bool always) { Directory dir; #ifdef _WIN32 dir.Load(Encoding::ToNarrow( - SystemTools::ConvertToWindowsExtendedPath(source)).c_str()); + SystemTools::ConvertToWindowsExtendedPath(source))); #else dir.Load(source); #endif @@ -2298,13 +2349,13 @@ bool SystemTools::CopyADirectory(const char* source, const char* destination, kwsys_stl::string fullPath = source; fullPath += "/"; fullPath += dir.GetFile(static_cast<unsigned long>(fileNum)); - if(SystemTools::FileIsDirectory(fullPath.c_str())) + if(SystemTools::FileIsDirectory(fullPath)) { kwsys_stl::string fullDestPath = destination; fullDestPath += "/"; fullDestPath += dir.GetFile(static_cast<unsigned long>(fileNum)); - if (!SystemTools::CopyADirectory(fullPath.c_str(), - fullDestPath.c_str(), + if (!SystemTools::CopyADirectory(fullPath, + fullDestPath, always)) { return false; @@ -2312,7 +2363,7 @@ bool SystemTools::CopyADirectory(const char* source, const char* destination, } else { - if(!SystemTools::CopyAFile(fullPath.c_str(), destination, always)) + if(!SystemTools::CopyAFile(fullPath, destination, always)) { return false; } @@ -2365,7 +2416,7 @@ int SystemTools::Strucmp(const char *s1, const char *s2) } // return file's modified time -long int SystemTools::ModifiedTime(const char* filename) +long int SystemTools::ModifiedTime(const kwsys_stl::string& filename) { long int mt = 0; #ifdef _WIN32 @@ -2379,7 +2430,7 @@ long int SystemTools::ModifiedTime(const char* filename) } #else struct stat fs; - if (stat(filename, &fs) == 0) + if (stat(filename.c_str(), &fs) == 0) { mt = static_cast<long int>(fs.st_mtime); } @@ -2388,7 +2439,7 @@ long int SystemTools::ModifiedTime(const char* filename) } // return file's creation time -long int SystemTools::CreationTime(const char* filename) +long int SystemTools::CreationTime(const kwsys_stl::string& filename) { long int ct = 0; #ifdef _WIN32 @@ -2402,7 +2453,7 @@ long int SystemTools::CreationTime(const char* filename) } #else struct stat fs; - if (stat(filename, &fs) == 0) + if (stat(filename.c_str(), &fs) == 0) { ct = fs.st_ctime >= 0 ? static_cast<long int>(fs.st_ctime) : 0; } @@ -2518,7 +2569,7 @@ kwsys_stl::string SystemTools::GetLastSystemError() return strerror(e); } -bool SystemTools::RemoveFile(const char* source) +bool SystemTools::RemoveFile(const kwsys_stl::string& source) { #ifdef _WIN32 mode_t mode; @@ -2533,7 +2584,7 @@ bool SystemTools::RemoveFile(const char* source) bool res = _wunlink(SystemTools::ConvertToWindowsExtendedPath(source).c_str()) == 0; #else - bool res = unlink(source) != 0 ? false : true; + bool res = unlink(source.c_str()) != 0 ? false : true; #endif #ifdef _WIN32 if ( !res ) @@ -2544,7 +2595,7 @@ bool SystemTools::RemoveFile(const char* source) return res; } -bool SystemTools::RemoveADirectory(const char* source) +bool SystemTools::RemoveADirectory(const kwsys_stl::string& source) { // Add write permission to the directory so we can modify its // content to remove files and directories from it. @@ -2562,7 +2613,7 @@ bool SystemTools::RemoveADirectory(const char* source) Directory dir; #ifdef _WIN32 dir.Load(Encoding::ToNarrow( - SystemTools::ConvertToWindowsExtendedPath(source)).c_str()); + SystemTools::ConvertToWindowsExtendedPath(source))); #else dir.Load(source); #endif @@ -2575,17 +2626,17 @@ bool SystemTools::RemoveADirectory(const char* source) kwsys_stl::string fullPath = source; fullPath += "/"; fullPath += dir.GetFile(static_cast<unsigned long>(fileNum)); - if(SystemTools::FileIsDirectory(fullPath.c_str()) && - !SystemTools::FileIsSymlink(fullPath.c_str())) + if(SystemTools::FileIsDirectory(fullPath) && + !SystemTools::FileIsSymlink(fullPath)) { - if (!SystemTools::RemoveADirectory(fullPath.c_str())) + if (!SystemTools::RemoveADirectory(fullPath)) { return false; } } else { - if(!SystemTools::RemoveFile(fullPath.c_str())) + if(!SystemTools::RemoveFile(fullPath)) { return false; } @@ -2647,7 +2698,7 @@ kwsys_stl::string SystemTools { tryPath = *p; tryPath += name; - if(SystemTools::FileExists(tryPath.c_str())) + if(SystemTools::FileExists(tryPath)) { return tryPath; } @@ -2667,7 +2718,7 @@ kwsys_stl::string SystemTools bool no_system_path) { kwsys_stl::string tryPath = SystemTools::FindName(name, userPaths, no_system_path); - if(tryPath != "" && !SystemTools::FileIsDirectory(tryPath.c_str())) + if(!tryPath.empty() && !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2686,7 +2737,7 @@ kwsys_stl::string SystemTools bool no_system_path) { kwsys_stl::string tryPath = SystemTools::FindName(name, userPaths, no_system_path); - if(tryPath != "" && SystemTools::FileIsDirectory(tryPath.c_str())) + if(!tryPath.empty() && SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2708,7 +2759,14 @@ kwsys_stl::string SystemTools::FindProgram( { return ""; } - kwsys_stl::string name = nameIn; + return SystemTools::FindProgram(kwsys_stl::string(nameIn), userPaths, no_system_path); +} + +kwsys_stl::string SystemTools::FindProgram( + const kwsys_stl::string& name, + const kwsys_stl::vector<kwsys_stl::string>& userPaths, + bool no_system_path) +{ kwsys_stl::vector<kwsys_stl::string> extensions; #if defined (_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) bool hasExtension = false; @@ -2733,16 +2791,16 @@ kwsys_stl::string SystemTools::FindProgram( { tryPath = name; tryPath += *i; - if(SystemTools::FileExists(tryPath.c_str()) && - !SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) && + !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } } // now try just the name tryPath = name; - if(SystemTools::FileExists(tryPath.c_str()) && - !SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) && + !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2788,8 +2846,8 @@ kwsys_stl::string SystemTools::FindProgram( tryPath = *p; tryPath += name; tryPath += *ext; - if(SystemTools::FileExists(tryPath.c_str()) && - !SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) && + !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2797,8 +2855,8 @@ kwsys_stl::string SystemTools::FindProgram( // now try it without them tryPath = *p; tryPath += name; - if(SystemTools::FileExists(tryPath.c_str()) && - !SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) && + !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2816,7 +2874,7 @@ kwsys_stl::string SystemTools::FindProgram( it != names.end() ; ++it) { // Try to find the program. - kwsys_stl::string result = SystemTools::FindProgram(it->c_str(), + kwsys_stl::string result = SystemTools::FindProgram(*it, path, noSystemPath); if ( !result.empty() ) @@ -2833,7 +2891,7 @@ kwsys_stl::string SystemTools::FindProgram( * found. Otherwise, the empty string is returned. */ kwsys_stl::string SystemTools -::FindLibrary(const char* name, +::FindLibrary(const kwsys_stl::string& name, const kwsys_stl::vector<kwsys_stl::string>& userPaths) { // See if the executable exists as written. @@ -2874,8 +2932,8 @@ kwsys_stl::string SystemTools tryPath = *p; tryPath += name; tryPath += ".framework"; - if(SystemTools::FileExists(tryPath.c_str()) - && SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) + && SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2884,8 +2942,8 @@ kwsys_stl::string SystemTools tryPath = *p; tryPath += name; tryPath += ".lib"; - if(SystemTools::FileExists(tryPath.c_str()) - && !SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) + && !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2894,8 +2952,8 @@ kwsys_stl::string SystemTools tryPath += "lib"; tryPath += name; tryPath += ".so"; - if(SystemTools::FileExists(tryPath.c_str()) - && !SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) + && !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2903,8 +2961,8 @@ kwsys_stl::string SystemTools tryPath += "lib"; tryPath += name; tryPath += ".a"; - if(SystemTools::FileExists(tryPath.c_str()) - && !SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) + && !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2912,8 +2970,8 @@ kwsys_stl::string SystemTools tryPath += "lib"; tryPath += name; tryPath += ".sl"; - if(SystemTools::FileExists(tryPath.c_str()) - && !SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) + && !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2921,8 +2979,8 @@ kwsys_stl::string SystemTools tryPath += "lib"; tryPath += name; tryPath += ".dylib"; - if(SystemTools::FileExists(tryPath.c_str()) - && !SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) + && !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2930,8 +2988,8 @@ kwsys_stl::string SystemTools tryPath += "lib"; tryPath += name; tryPath += ".dll"; - if(SystemTools::FileExists(tryPath.c_str()) - && !SystemTools::FileIsDirectory(tryPath.c_str())) + if(SystemTools::FileExists(tryPath) + && !SystemTools::FileIsDirectory(tryPath)) { return SystemTools::CollapseFullPath(tryPath); } @@ -2942,32 +3000,33 @@ kwsys_stl::string SystemTools return ""; } -kwsys_stl::string SystemTools::GetRealPath(const char* path) +kwsys_stl::string SystemTools::GetRealPath(const kwsys_stl::string& path) { kwsys_stl::string ret; Realpath(path, ret); return ret; } -bool SystemTools::FileIsDirectory(const char* name) +bool SystemTools::FileIsDirectory(const kwsys_stl::string& inName) { - if (!*name) + if (inName.empty()) { return false; } - size_t length = strlen(name); + size_t length = inName.size(); + const char* name = inName.c_str(); // Remove any trailing slash from the name except in a root component. char local_buffer[KWSYS_SYSTEMTOOLS_MAXPATH]; std::string string_buffer; size_t last = length-1; if(last > 0 && (name[last] == '/' || name[last] == '\\') - && strcmp(name, "/") !=0 && name[last-1] != ':') + && strcmp(name, "/") != 0 && name[last-1] != ':') { - if(last < sizeof(local_buffer)) + if (last < sizeof(local_buffer)) { memcpy(local_buffer, name, last); - local_buffer[last] = 0; + local_buffer[last] = '\0'; name = local_buffer; } else @@ -2997,14 +3056,14 @@ bool SystemTools::FileIsDirectory(const char* name) } } -bool SystemTools::FileIsSymlink(const char* name) +bool SystemTools::FileIsSymlink(const kwsys_stl::string& name) { #if defined( _WIN32 ) (void)name; return false; #else struct stat fs; - if(lstat(name, &fs) == 0) + if(lstat(name.c_str(), &fs) == 0) { return S_ISLNK(fs.st_mode); } @@ -3053,7 +3112,7 @@ bool SystemTools::ReadSymlink(const char* newName, } #endif -int SystemTools::ChangeDirectory(const char *dir) +int SystemTools::ChangeDirectory(const kwsys_stl::string& dir) { return Chdir(dir); } @@ -3090,7 +3149,7 @@ bool SystemTools::SplitProgramPath(const char* in_name, file = ""; SystemTools::ConvertToUnixSlashes(dir); - if(!SystemTools::FileIsDirectory(dir.c_str())) + if(!SystemTools::FileIsDirectory(dir)) { kwsys_stl::string::size_type slashPos = dir.rfind("/"); if(slashPos != kwsys_stl::string::npos) @@ -3104,7 +3163,7 @@ bool SystemTools::SplitProgramPath(const char* in_name, dir = ""; } } - if(!(dir == "") && !SystemTools::FileIsDirectory(dir.c_str())) + if(!(dir.empty()) && !SystemTools::FileIsDirectory(dir)) { kwsys_stl::string oldDir = in_name; SystemTools::ConvertToUnixSlashes(oldDir); @@ -3125,8 +3184,8 @@ bool SystemTools::FindProgramPath(const char* argv0, kwsys_stl::string self = argv0 ? argv0 : ""; failures.push_back(self); SystemTools::ConvertToUnixSlashes(self); - self = SystemTools::FindProgram(self.c_str()); - if(!SystemTools::FileExists(self.c_str())) + self = SystemTools::FindProgram(self); + if(!SystemTools::FileExists(self)) { if(buildDir) { @@ -3144,7 +3203,7 @@ bool SystemTools::FindProgramPath(const char* argv0, } if(installPrefix) { - if(!SystemTools::FileExists(self.c_str())) + if(!SystemTools::FileExists(self)) { failures.push_back(self); self = installPrefix; @@ -3152,7 +3211,7 @@ bool SystemTools::FindProgramPath(const char* argv0, self += exeName; } } - if(!SystemTools::FileExists(self.c_str())) + if(!SystemTools::FileExists(self)) { failures.push_back(self); kwsys_ios::ostringstream msg; @@ -3193,12 +3252,12 @@ void SystemTools::AddTranslationPath(const kwsys_stl::string& a, const kwsys_stl SystemTools::ConvertToUnixSlashes(path_b); // First check this is a directory path, since we don't want the table to // grow too fat - if( SystemTools::FileIsDirectory( path_a.c_str() ) ) + if( SystemTools::FileIsDirectory( path_a ) ) { // Make sure the path is a full path and does not contain no '..' // Ken--the following code is incorrect. .. can be in a valid path // for example /home/martink/MyHubba...Hubba/Src - if( SystemTools::FileIsFullPath(path_b.c_str()) && path_b.find("..") + if( SystemTools::FileIsFullPath(path_b) && path_b.find("..") == kwsys_stl::string::npos ) { // Before inserting make sure path ends with '/' @@ -3355,7 +3414,7 @@ kwsys_stl::string SystemTools::CollapseFullPath(const kwsys_stl::string& in_path } // compute the relative path from here to there -kwsys_stl::string SystemTools::RelativePath(const char* local, const char* remote) +kwsys_stl::string SystemTools::RelativePath(const kwsys_stl::string& local, const kwsys_stl::string& remote) { if(!SystemTools::FileIsFullPath(local)) { @@ -3745,7 +3804,7 @@ bool SystemTools::ComparePath(const kwsys_stl::string& c1, const kwsys_stl::stri } //---------------------------------------------------------------------------- -bool SystemTools::Split(const char* str, kwsys_stl::vector<kwsys_stl::string>& lines, char separator) +bool SystemTools::Split(const kwsys_stl::string& str, kwsys_stl::vector<kwsys_stl::string>& lines, char separator) { kwsys_stl::string data(str); kwsys_stl::string::size_type lpos = 0; @@ -3769,7 +3828,7 @@ bool SystemTools::Split(const char* str, kwsys_stl::vector<kwsys_stl::string>& l } //---------------------------------------------------------------------------- -bool SystemTools::Split(const char* str, kwsys_stl::vector<kwsys_stl::string>& lines) +bool SystemTools::Split(const kwsys_stl::string& str, kwsys_stl::vector<kwsys_stl::string>& lines) { kwsys_stl::string data(str); kwsys_stl::string::size_type lpos = 0; @@ -4062,7 +4121,7 @@ bool SystemTools::LocateFileInDir(const char *filename, } temp += filename_base; - if (SystemTools::FileExists(temp.c_str())) + if (SystemTools::FileExists(temp)) { res = true; filename_found = temp; @@ -4111,9 +4170,18 @@ bool SystemTools::LocateFileInDir(const char *filename, return res; } +bool SystemTools::FileIsFullPath(const kwsys_stl::string& in_name) +{ + return SystemTools::FileIsFullPath(in_name.c_str(), in_name.size()); +} + bool SystemTools::FileIsFullPath(const char* in_name) { - size_t len = strlen(in_name); + return SystemTools::FileIsFullPath(in_name, in_name[0] ? (in_name[1] ? 2 : 1) : 0); +} + +bool SystemTools::FileIsFullPath(const char* in_name, size_t len) +{ #if defined(_WIN32) || defined(__CYGWIN__) // On Windows, the name must be at least two characters long. if(len < 2) @@ -4222,7 +4290,7 @@ void SystemTools::SplitProgramFromArgs(const char* path, { kwsys_stl::string tryProg = dir.substr(0, spacePos); // See if the file exists - if(SystemTools::FileExists(tryProg.c_str())) + if(SystemTools::FileExists(tryProg)) { program = tryProg; // remove trailing spaces from program @@ -4236,7 +4304,7 @@ void SystemTools::SplitProgramFromArgs(const char* path, return; } // Now try and find the program in the path - findProg = SystemTools::FindProgram(tryProg.c_str(), e); + findProg = SystemTools::FindProgram(tryProg, e); if(!findProg.empty()) { program = findProg; @@ -4408,7 +4476,11 @@ bool SystemTools::GetPermissions(const char* file, mode_t& mode) { return false; } + return SystemTools::GetPermissions(kwsys_stl::string(file), mode); +} +bool SystemTools::GetPermissions(const kwsys_stl::string& file, mode_t& mode) +{ #if defined(_WIN32) DWORD attr = GetFileAttributesW( SystemTools::ConvertToWindowsExtendedPath(file).c_str()); @@ -4433,7 +4505,8 @@ bool SystemTools::GetPermissions(const char* file, mode_t& mode) { mode |= S_IFREG; } - const char* ext = strrchr(file, '.'); + size_t dotPos = file.rfind('.'); + const char* ext = dotPos == file.npos ? 0 : (file.c_str() + dotPos); if(ext && (Strucmp(ext, ".exe") == 0 || Strucmp(ext, ".com") == 0 || Strucmp(ext, ".cmd") == 0 || @@ -4443,7 +4516,7 @@ bool SystemTools::GetPermissions(const char* file, mode_t& mode) } #else struct stat st; - if ( stat(file, &st) < 0 ) + if ( stat(file.c_str(), &st) < 0 ) { return false; } @@ -4458,6 +4531,11 @@ bool SystemTools::SetPermissions(const char* file, mode_t mode) { return false; } + return SystemTools::SetPermissions(kwsys_stl::string(file), mode); +} + +bool SystemTools::SetPermissions(const kwsys_stl::string& file, mode_t mode) +{ if ( !SystemTools::FileExists(file) ) { return false; @@ -4466,7 +4544,7 @@ bool SystemTools::SetPermissions(const char* file, mode_t mode) if ( _wchmod(SystemTools::ConvertToWindowsExtendedPath(file).c_str(), mode) < 0 ) #else - if ( chmod(file, mode) < 0 ) + if ( chmod(file.c_str(), mode) < 0 ) #endif { return false; @@ -4475,7 +4553,7 @@ bool SystemTools::SetPermissions(const char* file, mode_t mode) return true; } -kwsys_stl::string SystemTools::GetParentDirectory(const char* fileOrDir) +kwsys_stl::string SystemTools::GetParentDirectory(const kwsys_stl::string& fileOrDir) { return SystemTools::GetFilenamePath(fileOrDir); } @@ -4522,111 +4600,6 @@ void SystemTools::Delay(unsigned int msec) #endif } -void SystemTools::ConvertWindowsCommandLineToUnixArguments( - const char *cmd_line, int *argc, char ***argv) -{ - if (!cmd_line || !argc || !argv) - { - return; - } - - // A space delimites an argument except when it is inside a quote - - (*argc) = 1; - - size_t cmd_line_len = strlen(cmd_line); - - size_t i; - for (i = 0; i < cmd_line_len; i++) - { - while (isspace(cmd_line[i]) && i < cmd_line_len) - { - i++; - } - if (i < cmd_line_len) - { - if (cmd_line[i] == '\"') - { - i++; - while (cmd_line[i] != '\"' && i < cmd_line_len) - { - i++; - } - (*argc)++; - } - else - { - while (!isspace(cmd_line[i]) && i < cmd_line_len) - { - i++; - } - (*argc)++; - } - } - } - - (*argv) = new char* [(*argc) + 1]; - (*argv)[(*argc)] = NULL; - - // Set the first arg to be the exec name - - (*argv)[0] = new char [1024]; -#ifdef _WIN32 - wchar_t tmp[1024]; - ::GetModuleFileNameW(0, tmp, 1024); - strcpy((*argv)[0], Encoding::ToNarrow(tmp).c_str()); -#else - (*argv)[0][0] = '\0'; -#endif - - // Allocate the others - - int j; - for (j = 1; j < (*argc); j++) - { - (*argv)[j] = new char [cmd_line_len + 10]; - } - - // Grab the args - - size_t pos; - int argc_idx = 1; - - for (i = 0; i < cmd_line_len; i++) - { - while (isspace(cmd_line[i]) && i < cmd_line_len) - { - i++; - } - if (i < cmd_line_len) - { - if (cmd_line[i] == '\"') - { - i++; - pos = i; - while (cmd_line[i] != '\"' && i < cmd_line_len) - { - i++; - } - memcpy((*argv)[argc_idx], &cmd_line[pos], i - pos); - (*argv)[argc_idx][i - pos] = '\0'; - argc_idx++; - } - else - { - pos = i; - while (!isspace(cmd_line[i]) && i < cmd_line_len) - { - i++; - } - memcpy((*argv)[argc_idx], &cmd_line[pos], i - pos); - (*argv)[argc_idx][i - pos] = '\0'; - argc_idx++; - } - } - } - } - kwsys_stl::string SystemTools::GetOperatingSystemNameAndVersion() { kwsys_stl::string res; diff --git a/Source/kwsys/SystemTools.hxx.in b/Source/kwsys/SystemTools.hxx.in index b7c7206..e88bc8f 100644 --- a/Source/kwsys/SystemTools.hxx.in +++ b/Source/kwsys/SystemTools.hxx.in @@ -158,7 +158,9 @@ public: * Returns true if str1 starts (respectively ends) with str2 */ static bool StringStartsWith(const char* str1, const char* str2); + static bool StringStartsWith(const kwsys_stl::string& str1, const char* str2); static bool StringEndsWith(const char* str1, const char* str2); + static bool StringEndsWith(const kwsys_stl::string& str1, const char* str2); /** * Returns a pointer to the last occurence of str2 in str1 @@ -183,7 +185,7 @@ public: s starts with a / then the first element of the returned array will be /, so /foo/bar will be [/, foo, bar] */ - static kwsys_stl::vector<String> SplitString(const char* s, char separator = '/', + static kwsys_stl::vector<String> SplitString(const kwsys_stl::string& s, char separator = '/', bool isPath = false); /** * Perform a case-independent string comparison @@ -201,8 +203,8 @@ public: * Split a string on its newlines into multiple lines * Return false only if the last line stored had no newline */ - static bool Split(const char* s, kwsys_stl::vector<kwsys_stl::string>& l); - static bool Split(const char* s, kwsys_stl::vector<kwsys_stl::string>& l, char separator); + static bool Split(const kwsys_stl::string& s, kwsys_stl::vector<kwsys_stl::string>& l); + static bool Split(const kwsys_stl::string& s, kwsys_stl::vector<kwsys_stl::string>& l, char separator); /** * Return string with space added between capitalized words @@ -265,13 +267,13 @@ public: * For windows this calls ConvertToWindowsOutputPath and for unix * it calls ConvertToUnixOutputPath */ - static kwsys_stl::string ConvertToOutputPath(const char*); + static kwsys_stl::string ConvertToOutputPath(const kwsys_stl::string&); /** * Convert the path to a string that can be used in a unix makefile. * double slashes are removed, and spaces are escaped. */ - static kwsys_stl::string ConvertToUnixOutputPath(const char*); + static kwsys_stl::string ConvertToUnixOutputPath(const kwsys_stl::string&); /** * Convert the path to string that can be used in a windows project or @@ -279,7 +281,7 @@ public: * the string, the slashes are converted to windows style backslashes, and * if there are spaces in the string it is double quoted. */ - static kwsys_stl::string ConvertToWindowsOutputPath(const char*); + static kwsys_stl::string ConvertToWindowsOutputPath(const kwsys_stl::string&); /** * Return true if a file exists in the current directory. @@ -288,7 +290,9 @@ public: * if it is a file or a directory. */ static bool FileExists(const char* filename, bool isFile); + static bool FileExists(const kwsys_stl::string& filename, bool isFile); static bool FileExists(const char* filename); + static bool FileExists(const kwsys_stl::string& filename); /** * Converts Cygwin path to Win32 path. Uses dictionary container for @@ -307,7 +311,7 @@ public: /** Change the modification time or create a file */ - static bool Touch(const char* filename, bool create); + static bool Touch(const kwsys_stl::string& filename, bool create); /** * Compare file modification times. @@ -315,7 +319,8 @@ public: * When true is returned, result has -1, 0, +1 for * f1 older, same, or newer than f2. */ - static bool FileTimeCompare(const char* f1, const char* f2, + static bool FileTimeCompare(const kwsys_stl::string& f1, + const kwsys_stl::string& f2, int* result); /** @@ -377,7 +382,7 @@ public: * the event of an error (non-existent path, permissions issue, * etc.) the original path is returned. */ - static kwsys_stl::string GetRealPath(const char* path); + static kwsys_stl::string GetRealPath(const kwsys_stl::string& path); /** * Split a path name into its root component and the rest of the @@ -470,6 +475,7 @@ public: /** * Return whether the path represents a full path (not relative) */ + static bool FileIsFullPath(const kwsys_stl::string&); static bool FileIsFullPath(const char*); /** @@ -493,7 +499,7 @@ public: /** * Get the parent directory of the directory or file */ - static kwsys_stl::string GetParentDirectory(const char* fileOrDir); + static kwsys_stl::string GetParentDirectory(const kwsys_stl::string& fileOrDir); /** * Check if the given file or directory is in subdirectory of dir @@ -508,7 +514,7 @@ public: /** * Open a file considering unicode. */ - static FILE* Fopen(const char* file, const char* mode); + static FILE* Fopen(const kwsys_stl::string& file, const char* mode); /** * Make a new directory if it is not there. This function @@ -516,35 +522,36 @@ public: * prior to calling this function. */ static bool MakeDirectory(const char* path); + static bool MakeDirectory(const kwsys_stl::string& path); /** * Copy the source file to the destination file only * if the two files differ. */ - static bool CopyFileIfDifferent(const char* source, - const char* destination); + static bool CopyFileIfDifferent(const kwsys_stl::string& source, + const kwsys_stl::string& destination); /** * Compare the contents of two files. Return true if different */ - static bool FilesDiffer(const char* source, const char* destination); + static bool FilesDiffer(const kwsys_stl::string& source, const kwsys_stl::string& destination); /** * Return true if the two files are the same file */ - static bool SameFile(const char* file1, const char* file2); + static bool SameFile(const kwsys_stl::string& file1, const kwsys_stl::string& file2); /** * Copy a file. */ - static bool CopyFileAlways(const char* source, const char* destination); + static bool CopyFileAlways(const kwsys_stl::string& source, const kwsys_stl::string& destination); /** * Copy a file. If the "always" argument is true the file is always * copied. If it is false, the file is copied only if it is new or * has changed. */ - static bool CopyAFile(const char* source, const char* destination, + static bool CopyAFile(const kwsys_stl::string& source, const kwsys_stl::string& destination, bool always = true); /** @@ -553,18 +560,18 @@ public: * always copied. If it is false, only files that have changed or * are new are copied. */ - static bool CopyADirectory(const char* source, const char* destination, + static bool CopyADirectory(const kwsys_stl::string& source, const kwsys_stl::string& destination, bool always = true); /** * Remove a file */ - static bool RemoveFile(const char* source); + static bool RemoveFile(const kwsys_stl::string& source); /** * Remove a directory */ - static bool RemoveADirectory(const char* source); + static bool RemoveADirectory(const kwsys_stl::string& source); /** * Get the maximum full file path length @@ -594,12 +601,17 @@ public: */ static kwsys_stl::string FindProgram( const char* name, - const kwsys_stl::vector<kwsys_stl::string>& path = + const kwsys_stl::vector<kwsys_stl::string>& path = + kwsys_stl::vector<kwsys_stl::string>(), + bool no_system_path = false); + static kwsys_stl::string FindProgram( + const kwsys_stl::string& name, + const kwsys_stl::vector<kwsys_stl::string>& path = kwsys_stl::vector<kwsys_stl::string>(), bool no_system_path = false); static kwsys_stl::string FindProgram( const kwsys_stl::vector<kwsys_stl::string>& names, - const kwsys_stl::vector<kwsys_stl::string>& path = + const kwsys_stl::vector<kwsys_stl::string>& path = kwsys_stl::vector<kwsys_stl::string>(), bool no_system_path = false); @@ -607,18 +619,18 @@ public: * Find a library in the system PATH, with optional extra paths */ static kwsys_stl::string FindLibrary( - const char* name, + const kwsys_stl::string& name, const kwsys_stl::vector<kwsys_stl::string>& path); /** * Return true if the file is a directory */ - static bool FileIsDirectory(const char* name); + static bool FileIsDirectory(const kwsys_stl::string& name); /** * Return true if the file is a symlink */ - static bool FileIsSymlink(const char* name); + static bool FileIsSymlink(const kwsys_stl::string& name); /** * Return true if the file has a given signature (first set of bytes) @@ -686,17 +698,17 @@ public: /a/b/c/d to /a/b/c1/d1 -> ../../c1/d1 from /usr/src to /usr/src/test/blah/foo.cpp -> test/blah/foo.cpp */ - static kwsys_stl::string RelativePath(const char* local, const char* remote); + static kwsys_stl::string RelativePath(const kwsys_stl::string& local, const kwsys_stl::string& remote); /** * Return file's modified time */ - static long int ModifiedTime(const char* filename); + static long int ModifiedTime(const kwsys_stl::string& filename); /** * Return file's creation time (Win32: works only for NTFS, not FAT) */ - static long int CreationTime(const char* filename); + static long int CreationTime(const kwsys_stl::string& filename); #if defined( _MSC_VER ) typedef unsigned short mode_t; @@ -706,7 +718,9 @@ public: * Get and set permissions of the file. */ static bool GetPermissions(const char* file, mode_t& mode); + static bool GetPermissions(const kwsys_stl::string& file, mode_t& mode); static bool SetPermissions(const char* file, mode_t mode); + static bool SetPermissions(const kwsys_stl::string& file, mode_t mode); /** ----------------------------------------------------------------- * Time Manipulation Routines @@ -793,7 +807,7 @@ public: /** * Change directory to the directory specified */ - static int ChangeDirectory(const char* dir); + static int ChangeDirectory(const kwsys_stl::string& dir); /** * Get the result of strerror(errno) @@ -842,15 +856,6 @@ public: */ static kwsys_stl::string GetOperatingSystemNameAndVersion(); - /** - * Convert windows-style arguments given as a command-line string - * into more traditional argc/argv arguments. - * Note that argv[0] will be assigned the executable name using - * the GetModuleFileName() function. - */ - static void ConvertWindowsCommandLineToUnixArguments( - const char *cmd_line, int *argc, char ***argv); - /** ----------------------------------------------------------------- * URL Manipulation Routines * ----------------------------------------------------------------- @@ -901,6 +906,11 @@ private: } /** + * Actual implementation of FileIsFullPath. + */ + static bool FileIsFullPath(const char*, size_t); + + /** * Find a filename (file or directory) in the system PATH, with * optional extra paths. */ diff --git a/Source/kwsys/testCommandLineArguments1.cxx b/Source/kwsys/testCommandLineArguments1.cxx index 3b84c38..b65c37f 100644 --- a/Source/kwsys/testCommandLineArguments1.cxx +++ b/Source/kwsys/testCommandLineArguments1.cxx @@ -21,6 +21,7 @@ # include "kwsys_ios_iostream.h.in" #endif +#include <assert.h> /* assert */ #include <string.h> /* strcmp */ int testCommandLineArguments1(int argc, char* argv[]) @@ -83,6 +84,7 @@ int testCommandLineArguments1(int argc, char* argv[]) } for ( cc = 0; cc < newArgc; ++ cc ) { + assert(newArgv[cc]); /* Quiet Clang scan-build. */ kwsys_ios::cout << "Unused argument[" << cc << "] = [" << newArgv[cc] << "]" << kwsys_ios::endl; if ( cc >= 9 ) diff --git a/Source/kwsys/testProcess.c b/Source/kwsys/testProcess.c index 3d62822..47c3fb0 100644 --- a/Source/kwsys/testProcess.c +++ b/Source/kwsys/testProcess.c @@ -20,6 +20,7 @@ # include "Encoding.h.in" #endif +#include <assert.h> #include <stdio.h> #include <stdlib.h> #include <string.h> @@ -104,6 +105,7 @@ static int test4(int argc, const char* argv[]) fprintf(stderr, "Output before crash on stderr from crash test.\n"); fflush(stdout); fflush(stderr); + assert(invalidAddress); /* Quiet Clang scan-build. */ /* Provoke deliberate crash by writing to the invalid address. */ *invalidAddress = 0; fprintf(stdout, "Output after crash on stdout from crash test.\n"); diff --git a/Source/kwsys/testSystemTools.cxx b/Source/kwsys/testSystemTools.cxx index 8b21081..04ab4fc 100644 --- a/Source/kwsys/testSystemTools.cxx +++ b/Source/kwsys/testSystemTools.cxx @@ -132,7 +132,7 @@ static bool CheckFileOperations() res = false; } - if (!kwsys::SystemTools::MakeDirectory(testNewDir.c_str())) + if (!kwsys::SystemTools::MakeDirectory(testNewDir)) { kwsys_ios::cerr << "Problem with MakeDirectory for: " @@ -148,7 +148,7 @@ static bool CheckFileOperations() res = false; } - if (!kwsys::SystemTools::RemoveFile(testNewFile.c_str())) + if (!kwsys::SystemTools::RemoveFile(testNewFile)) { kwsys_ios::cerr << "Problem with RemoveFile: " @@ -157,7 +157,7 @@ static bool CheckFileOperations() } kwsys::SystemTools::Touch(testNewFile.c_str(), true); - if (!kwsys::SystemTools::RemoveADirectory(testNewDir.c_str())) + if (!kwsys::SystemTools::RemoveADirectory(testNewDir)) { kwsys_ios::cerr << "Problem with RemoveADirectory for: " @@ -183,7 +183,7 @@ static bool CheckFileOperations() "012345678901234567890123456789012345678901234567890123456789" "0123456789.txt"); - if (!kwsys::SystemTools::MakeDirectory(testNewLongDir.c_str())) + if (!kwsys::SystemTools::MakeDirectory(testNewLongDir)) { kwsys_ios::cerr << "Problem with MakeDirectory for: " @@ -199,7 +199,7 @@ static bool CheckFileOperations() res = false; } - if (!kwsys::SystemTools::RemoveFile(testNewLongFile.c_str())) + if (!kwsys::SystemTools::RemoveFile(testNewLongFile)) { kwsys_ios::cerr << "Problem with RemoveFile: " @@ -208,7 +208,7 @@ static bool CheckFileOperations() } kwsys::SystemTools::Touch(testNewLongFile.c_str(), true); - if (!kwsys::SystemTools::RemoveADirectory(testNewLongDir.c_str())) + if (!kwsys::SystemTools::RemoveADirectory(testNewLongDir)) { kwsys_ios::cerr << "Problem with RemoveADirectory for: " @@ -507,28 +507,6 @@ static bool CheckStringOperations() res = false; } - int targc; - char **targv; - kwsys::SystemTools::ConvertWindowsCommandLineToUnixArguments - ("\"Local Mojo\\Voodoo.asp\" -CastHex \"D:\\My Secret Mojo\\Voodoo.mp3\"", - &targc, &targv); - if (targc != 4 || strcmp(targv[1],"Local Mojo\\Voodoo.asp") || - strcmp(targv[2],"-CastHex") || - strcmp(targv[3],"D:\\My Secret Mojo\\Voodoo.mp3")) - { - kwsys_ios::cerr - << "Problem with ConvertWindowsCommandLineToUnixArguments" - << "\'\"Local Mojo\\Voodoo.asp\" " - << "-CastHex \"D:\\My Secret Mojo\\Voodoo.mp3\"\'" - << kwsys_ios::endl; - res = false; - } - for (;targc >=0; --targc) - { - delete [] targv[targc]; - } - delete [] targv; - return res; } diff --git a/Tests/CompileDefinitions/target_prop/CMakeLists.txt b/Tests/CompileDefinitions/target_prop/CMakeLists.txt index 2ca2869..311975c 100644 --- a/Tests/CompileDefinitions/target_prop/CMakeLists.txt +++ b/Tests/CompileDefinitions/target_prop/CMakeLists.txt @@ -53,3 +53,8 @@ set_property(TARGET target_prop_mixed_executable APPEND PROPERTY COMPILE_DEFINIT "LINK_LANGUAGE_IS_$<TARGET_PROPERTY:LINKER_LANGUAGE>" "C_EXECUTABLE_LINK_LANGUAGE_IS_$<TARGET_PROPERTY:target_prop_c_executable,LINKER_LANGUAGE>" ) + +add_library(tgt STATIC IMPORTED) +set_property(TARGET tgt APPEND PROPERTY COMPILE_DEFINITIONS TGT_DEF TGT_TYPE_$<TARGET_PROPERTY:TYPE>) +add_executable(usetgt usetgt.c) +target_compile_definitions(usetgt PRIVATE $<TARGET_PROPERTY:tgt,COMPILE_DEFINITIONS>) diff --git a/Tests/CompileDefinitions/target_prop/usetgt.c b/Tests/CompileDefinitions/target_prop/usetgt.c new file mode 100644 index 0000000..6672a3e --- /dev/null +++ b/Tests/CompileDefinitions/target_prop/usetgt.c @@ -0,0 +1,10 @@ +#ifndef TGT_DEF +# error TGT_DEF incorrectly not defined +#endif +#ifndef TGT_TYPE_STATIC_LIBRARY +# error TGT_TYPE_STATIC_LIBRARY incorrectly not defined +#endif +#ifdef TGT_TYPE_EXECUTABLE +# error TGT_TYPE_EXECUTABLE incorrectly defined +#endif +int main(void) { return 0; } diff --git a/Tests/FindPackageTest/CMakeLists.txt b/Tests/FindPackageTest/CMakeLists.txt index 092bf20..f311fb9 100644 --- a/Tests/FindPackageTest/CMakeLists.txt +++ b/Tests/FindPackageTest/CMakeLists.txt @@ -374,6 +374,7 @@ endif() include(CMakePackageConfigHelpers) +# Generate a config file ready to be installed. set(INCLUDE_INSTALL_DIR include ) set(SHARE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/share/" ) set(CURRENT_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}" ) @@ -407,6 +408,43 @@ if(Relocatable_FOUND) message(SEND_ERROR "Relocatable_FOUND set to TRUE !") endif() +# Generate a config file for the build tree. +set(INCLUDE_INSTALL_DIR include ) +set(SHARE_INSTALL_DIR "${CMAKE_CURRENT_BINARY_DIR}/share/" ) +set(CURRENT_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}" ) + +configure_package_config_file(RelocatableConfig.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/RelocatableConfig.cmake" + INSTALL_DESTINATION "${CMAKE_CURRENT_BINARY_DIR}" + PATH_VARS INCLUDE_INSTALL_DIR SHARE_INSTALL_DIR CURRENT_BUILD_DIR + INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}" + ) + +set(Relocatable_FIND_COMPONENTS AComp BComp CComp) +set(Relocatable_FIND_REQUIRED_BComp 1) +include("${CMAKE_CURRENT_BINARY_DIR}/RelocatableConfig.cmake") + +if(NOT "${RELOC_INCLUDE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/include") + message(SEND_ERROR "RELOC_INCLUDE_DIR set by configure_package_config_file() is set to \"${RELOC_INCLUDE_DIR}\" (expected \"${CMAKE_CURRENT_BINARY_DIR}/include\")") +endif() + +if(NOT "${RELOC_SHARE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/share/") + message(SEND_ERROR "RELOC_SHARE_DIR set by configure_package_config_file() is set to \"${RELOC_SHARE_DIR}\" (expected \"${CMAKE_CURRENT_BINARY_DIR}/share/\")") +endif() + +if(NOT "${RELOC_BUILD_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}") + message(SEND_ERROR "RELOC_BUILD_DIR set by configure_package_config_file() is set to \"${RELOC_BUILD_DIR}\" (expected \"${CMAKE_CURRENT_BINARY_DIR}\")") +endif() + +if(NOT DEFINED Relocatable_FOUND) + message(SEND_ERROR "Relocatable_FOUND not defined !") +endif() + +if(Relocatable_FOUND) + message(SEND_ERROR "Relocatable_FOUND set to TRUE !") +endif() + + + #----------------------------------------------------------------------------- # Test write_basic_config_version_file(). diff --git a/Tests/StringFileTest/CMakeLists.txt b/Tests/StringFileTest/CMakeLists.txt index 4fa5a86..683f969 100644 --- a/Tests/StringFileTest/CMakeLists.txt +++ b/Tests/StringFileTest/CMakeLists.txt @@ -55,6 +55,16 @@ else() "file(STRINGS) incorrectly read from srec file [${infile_strings}]") endif() +#this file has utf-8 content +file(STRINGS test.utf8 infile_strings ENCODING UTF-8) +list(LENGTH infile_strings content_len) +if(content_len MATCHES "3") + message("file(STRINGS) correctly read from utf8 file [${infile_strings}]") +else() + message(SEND_ERROR + "file(STRINGS) incorrectly read from utf8 file [${infile_strings}]") +endif() + # String test string(REGEX MATCH "[cC][mM][aA][kK][eE]" rmvar "CMake is great") string(REGEX MATCHALL "[cC][mM][aA][kK][eE]" rmallvar "CMake is better than cmake or CMake") diff --git a/Tests/StringFileTest/test.utf8 b/Tests/StringFileTest/test.utf8 new file mode 100644 index 0000000..6c29170 --- /dev/null +++ b/Tests/StringFileTest/test.utf8 @@ -0,0 +1,3 @@ +The value of Ï€ (pi) is 3.141593 +Line mixed with binary partially matches valid utf8: Ï€ is à93.1593 +à
\ No newline at end of file diff --git a/Utilities/Doxygen/doxyfile.in b/Utilities/Doxygen/doxyfile.in index 9743af7..2c131f5 100644 --- a/Utilities/Doxygen/doxyfile.in +++ b/Utilities/Doxygen/doxyfile.in @@ -6,6 +6,10 @@ PROJECT_NAME = CMake FULL_PATH_NAMES = YES +STRIP_FROM_PATH = \ + "@CMake_SOURCE_DIR@/Source/" \ + "@CMake_BINARY_DIR@/Source/" + WARN_IF_UNDOCUMENTED = NO GENERATE_TREEVIEW = NO @@ -40,6 +44,7 @@ OUTPUT_DIRECTORY = "@CMake_BINARY_DIR@/Utilities/Doxygen/doc" INPUT = \ "@CMake_SOURCE_DIR@/Source" \ "@CMake_SOURCE_DIR@/Source/CPack" \ + "@CMake_SOURCE_DIR@/Source/CPack/IFW" \ "@CMake_SOURCE_DIR@/Source/CTest" \ "@CMake_SOURCE_DIR@/Source/CursesDialog" \ "@CMake_SOURCE_DIR@/Source/MFCDialog" \ diff --git a/Utilities/KWIML/ABI.h.in b/Utilities/KWIML/ABI.h.in index b71cdfb..21c9139 100644 --- a/Utilities/KWIML/ABI.h.in +++ b/Utilities/KWIML/ABI.h.in @@ -398,6 +398,10 @@ suppression macro @KWIML@_ABI_NO_VERIFY was defined. #elif defined(__mips) || defined(__mips__) || defined(__MIPS__) # define @KWIML@_ABI_ENDIAN_ID @KWIML@_ABI_ENDIAN_ID_BIG +/* OpenRISC 1000 */ +#elif defined(__or1k__) +# define @KWIML@_ABI_ENDIAN_ID @KWIML@_ABI_ENDIAN_ID_BIG + /* RS/6000 */ #elif defined(__THW_RS600) || defined(_IBMR2) || defined(_POWER) # define @KWIML@_ABI_ENDIAN_ID @KWIML@_ABI_ENDIAN_ID_BIG diff --git a/Utilities/cmliblzma/CMakeLists.txt b/Utilities/cmliblzma/CMakeLists.txt index fc50dbe..856e41e 100644 --- a/Utilities/cmliblzma/CMakeLists.txt +++ b/Utilities/cmliblzma/CMakeLists.txt @@ -31,9 +31,15 @@ CHECK_INCLUDE_FILE(strings.h HAVE_STRINGS_H) CHECK_INCLUDE_FILE(string.h HAVE_STRING_H) CHECK_INCLUDE_FILE(sys/sysctl.h HAVE_SYS_SYSCTL_H) -CHECK_SYMBOL_EXISTS(bswap_16 byteswap.h HAVE_BSWAP_16) -CHECK_SYMBOL_EXISTS(bswap_32 byteswap.h HAVE_BSWAP_32) -CHECK_SYMBOL_EXISTS(bswap_64 byteswap.h HAVE_BSWAP_64) +CHECK_C_SOURCE_COMPILES ( + "#include<byteswap.h>\nint main(void){bswap_16(0);return 0;}" + HAVE_BSWAP_16) +CHECK_C_SOURCE_COMPILES ( + "#include<byteswap.h>\nint main(void){bswap_32(0);return 0;}" + HAVE_BSWAP_32) +CHECK_C_SOURCE_COMPILES ( + "#include<byteswap.h>\nint main(void){bswap_64(0);return 0;}" + HAVE_BSWAP_64) TEST_BIG_ENDIAN(WORDS_BIGENDIAN) diff --git a/Utilities/cmliblzma/liblzma/check/sha256.c b/Utilities/cmliblzma/liblzma/check/sha256.c index b09ccbf..c2c85eb 100644 --- a/Utilities/cmliblzma/liblzma/check/sha256.c +++ b/Utilities/cmliblzma/liblzma/check/sha256.c @@ -80,11 +80,7 @@ static const uint32_t SHA256_K[64] = { static void -#ifndef _MSC_VER -transform(uint32_t state[static 8], const uint32_t data[static 16]) -#else transform(uint32_t state[], const uint32_t data[]) -#endif { uint32_t W[16]; uint32_t T[8]; |