Modules/Internal/CPack/CPackRPM.cmake

   1 # Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2 # file Copyright.txt or https://cmake.org/licensing for details.
   3
   4 # Author: Eric Noulard with the help of Alexander Neundorf.
   5
   6 cmake_policy(PUSH)
   7 cmake_policy(SET CMP0057 NEW) # if IN_LIST
   8
   9 function(set_spec_script_if_enabled TYPE PACKAGE_NAME VAR)
  10   if(NOT "${VAR}" STREQUAL "" AND NOT "${VAR}" STREQUAL "\n")
  11     if(PACKAGE_NAME)
  12       set(PACKAGE_NAME " -n ${PACKAGE_NAME}")
  13     endif()
  14     set(${TYPE}_ "%${TYPE}${PACKAGE_NAME}\n${VAR}\n" PARENT_SCOPE)
  15   else()
  16     set(${TYPE} "" PARENT_SCOPE)
  17   endif()
  18 endfunction()
  19
  20 macro(set_spec_scripts PACKAGE_NAME)
  21   # we should only set scripts that were provided
  22   # as script announcement without content inside
  23   # spec file will generate unneeded dependency
  24   # on shell
  25
  26   set_spec_script_if_enabled(
  27     "post"
  28     "${PACKAGE_NAME}"
  29     "${RPM_SYMLINK_POSTINSTALL}\n${CPACK_RPM_SPEC_POSTINSTALL}")
  30
  31   set_spec_script_if_enabled(
  32     "posttrans"
  33     "${PACKAGE_NAME}"
  34     "${CPACK_RPM_SPEC_POSTTRANS}")
  35
  36   set_spec_script_if_enabled(
  37     "postun"
  38     "${PACKAGE_NAME}"
  39     "${CPACK_RPM_SPEC_POSTUNINSTALL}")
  40
  41   set_spec_script_if_enabled(
  42     "pre"
  43     "${PACKAGE_NAME}"
  44     "${CPACK_RPM_SPEC_PREINSTALL}")
  45
  46   set_spec_script_if_enabled(
  47     "pretrans"
  48     "${PACKAGE_NAME}"
  49     "${CPACK_RPM_SPEC_PRETRANS}")
  50
  51   set_spec_script_if_enabled(
  52     "preun"
  53     "${PACKAGE_NAME}"
  54     "${CPACK_RPM_SPEC_PREUNINSTALL}")
  55 endmacro()
  56
  57 function(get_file_permissions FILE RETURN_VAR)
  58   execute_process(COMMAND ls -l ${FILE}
  59           OUTPUT_VARIABLE permissions_
  60           ERROR_QUIET
  61           OUTPUT_STRIP_TRAILING_WHITESPACE)
  62
  63   string(REPLACE " " ";" permissions_ "${permissions_}")
  64   list(GET permissions_ 0 permissions_)
  65
  66   unset(text_notation_)
  67   set(any_chars_ ".")
  68   foreach(PERMISSION_TYPE "OWNER" "GROUP" "WORLD")
  69     if(permissions_ MATCHES "${any_chars_}r.*")
  70       list(APPEND text_notation_ "${PERMISSION_TYPE}_READ")
  71     endif()
  72     string(APPEND any_chars_ ".")
  73     if(permissions_ MATCHES "${any_chars_}w.*")
  74       list(APPEND text_notation_ "${PERMISSION_TYPE}_WRITE")
  75     endif()
  76     string(APPEND any_chars_ ".")
  77     if(permissions_ MATCHES "${any_chars_}x.*")
  78       list(APPEND text_notation_ "${PERMISSION_TYPE}_EXECUTE")
  79     endif()
  80   endforeach()
  81
  82   set(${RETURN_VAR} "${text_notation_}" PARENT_SCOPE)
  83 endfunction()
  84
  85 function(get_unix_permissions_octal_notation PERMISSIONS_VAR RETURN_VAR)
  86   set(PERMISSIONS ${${PERMISSIONS_VAR}})
  87   list(LENGTH PERMISSIONS PERM_LEN_PRE)
  88   list(REMOVE_DUPLICATES PERMISSIONS)
  89   list(LENGTH PERMISSIONS PERM_LEN_POST)
  90
  91   if(NOT ${PERM_LEN_PRE} EQUAL ${PERM_LEN_POST})
  92     message(FATAL_ERROR "${PERMISSIONS_VAR} contains duplicate values.")
  93   endif()
  94
  95   foreach(PERMISSION_TYPE "OWNER" "GROUP" "WORLD")
  96     set(${PERMISSION_TYPE}_PERMISSIONS 0)
  97
  98     foreach(PERMISSION ${PERMISSIONS})
  99       if("${PERMISSION}" STREQUAL "${PERMISSION_TYPE}_READ")
 100         math(EXPR ${PERMISSION_TYPE}_PERMISSIONS "${${PERMISSION_TYPE}_PERMISSIONS} + 4")
 101       elseif("${PERMISSION}" STREQUAL "${PERMISSION_TYPE}_WRITE")
 102         math(EXPR ${PERMISSION_TYPE}_PERMISSIONS "${${PERMISSION_TYPE}_PERMISSIONS} + 2")
 103       elseif("${PERMISSION}" STREQUAL "${PERMISSION_TYPE}_EXECUTE")
 104         math(EXPR ${PERMISSION_TYPE}_PERMISSIONS "${${PERMISSION_TYPE}_PERMISSIONS} + 1")
 105       elseif(PERMISSION MATCHES "${PERMISSION_TYPE}.*")
 106         message(FATAL_ERROR "${PERMISSIONS_VAR} contains invalid values.")
 107       endif()
 108     endforeach()
 109   endforeach()
 110
 111   set(${RETURN_VAR} "${OWNER_PERMISSIONS}${GROUP_PERMISSIONS}${WORLD_PERMISSIONS}" PARENT_SCOPE)
 112 endfunction()
 113
 114 function(cpack_rpm_exact_regex regex_var string)
 115   string(REGEX REPLACE "([][+.*()^])" "\\\\\\1" regex "${string}")
 116   set("${regex_var}" "${regex}" PARENT_SCOPE)
 117 endfunction()
 118
 119 function(cpack_rpm_prepare_relocation_paths)
 120   # set appropriate prefix, remove possible trailing slash and convert backslashes to slashes
 121   if(CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_PACKAGE_PREFIX)
 122     file(TO_CMAKE_PATH "${CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_PACKAGE_PREFIX}" PATH_PREFIX)
 123   elseif(CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_PACKAGE_PREFIX)
 124     file(TO_CMAKE_PATH "${CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_PACKAGE_PREFIX}" PATH_PREFIX)
 125   else()
 126     file(TO_CMAKE_PATH "${CPACK_PACKAGING_INSTALL_PREFIX}" PATH_PREFIX)
 127   endif()
 128
 129   set(RPM_RELOCATION_PATHS "${CPACK_RPM_RELOCATION_PATHS}")
 130   list(REMOVE_DUPLICATES RPM_RELOCATION_PATHS)
 131
 132   # set base path prefix
 133   if(EXISTS "${WDIR}/${PATH_PREFIX}")
 134     if(NOT CPACK_RPM_NO_INSTALL_PREFIX_RELOCATION AND
 135        NOT CPACK_RPM_NO_${CPACK_RPM_PACKAGE_COMPONENT}_INSTALL_PREFIX_RELOCATION AND
 136        NOT CPACK_RPM_NO_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_INSTALL_PREFIX_RELOCATION)
 137       string(APPEND TMP_RPM_PREFIXES "Prefix: ${PATH_PREFIX}\n")
 138       list(APPEND RPM_USED_PACKAGE_PREFIXES "${PATH_PREFIX}")
 139
 140       if(CPACK_RPM_PACKAGE_DEBUG)
 141         message("CPackRPM:Debug: removing '${PATH_PREFIX}' from relocation paths")
 142       endif()
 143     endif()
 144   endif()
 145
 146   # set other path prefixes
 147   foreach(RELOCATION_PATH ${RPM_RELOCATION_PATHS})
 148     if(IS_ABSOLUTE "${RELOCATION_PATH}")
 149       set(PREPARED_RELOCATION_PATH "${RELOCATION_PATH}")
 150     elseif(PATH_PREFIX STREQUAL "/")
 151       # don't prefix path with a second slash as "//" is treated as network path
 152       # by get_filename_component() so it remains in path even inside rpm
 153       # package where it may cause problems with relocation
 154       set(PREPARED_RELOCATION_PATH "/${RELOCATION_PATH}")
 155     else()
 156       set(PREPARED_RELOCATION_PATH "${PATH_PREFIX}/${RELOCATION_PATH}")
 157     endif()
 158
 159     # handle cases where path contains extra slashes (e.g. /a//b/ instead of
 160     # /a/b)
 161     get_filename_component(PREPARED_RELOCATION_PATH
 162       "${PREPARED_RELOCATION_PATH}" ABSOLUTE)
 163
 164     if(EXISTS "${WDIR}/${PREPARED_RELOCATION_PATH}")
 165       string(APPEND TMP_RPM_PREFIXES "Prefix: ${PREPARED_RELOCATION_PATH}\n")
 166       list(APPEND RPM_USED_PACKAGE_PREFIXES "${PREPARED_RELOCATION_PATH}")
 167     endif()
 168   endforeach()
 169
 170   # warn about all the paths that are not relocatable
 171   file(GLOB_RECURSE FILE_PATHS_ "${WDIR}/*")
 172   foreach(TMP_PATH ${FILE_PATHS_})
 173     string(LENGTH "${WDIR}" WDIR_LEN)
 174     string(SUBSTRING "${TMP_PATH}" ${WDIR_LEN} -1 TMP_PATH)
 175     unset(TMP_PATH_FOUND_)
 176
 177     foreach(RELOCATION_PATH ${RPM_USED_PACKAGE_PREFIXES})
 178       file(RELATIVE_PATH REL_PATH_ "${RELOCATION_PATH}" "${TMP_PATH}")
 179       string(SUBSTRING "${REL_PATH_}" 0 2 PREFIX_)
 180
 181       if(NOT "${PREFIX_}" STREQUAL "..")
 182         set(TPM_PATH_FOUND_ TRUE)
 183         break()
 184       endif()
 185     endforeach()
 186
 187     if(NOT TPM_PATH_FOUND_)
 188       message(AUTHOR_WARNING "CPackRPM:Warning: Path ${TMP_PATH} is not on one of the relocatable paths! Package will be partially relocatable.")
 189     endif()
 190   endforeach()
 191
 192   set(RPM_USED_PACKAGE_PREFIXES "${RPM_USED_PACKAGE_PREFIXES}" PARENT_SCOPE)
 193   set(TMP_RPM_PREFIXES "${TMP_RPM_PREFIXES}" PARENT_SCOPE)
 194 endfunction()
 195
 196 function(cpack_rpm_prepare_content_list)
 197   # get files list
 198   file(GLOB_RECURSE CPACK_RPM_INSTALL_FILES LIST_DIRECTORIES true RELATIVE "${WDIR}" "${WDIR}/*")
 199   set(CPACK_RPM_INSTALL_FILES "/${CPACK_RPM_INSTALL_FILES}")
 200   string(REPLACE ";" ";/" CPACK_RPM_INSTALL_FILES "${CPACK_RPM_INSTALL_FILES}")
 201
 202   # if we are creating a relocatable package, omit parent directories of
 203   # CPACK_RPM_PACKAGE_PREFIX. This is achieved by building a "filter list"
 204   # which is passed to the find command that generates the content-list
 205   if(CPACK_RPM_PACKAGE_RELOCATABLE)
 206     # get a list of the elements in CPACK_RPM_PACKAGE_PREFIXES that are
 207     # destinct parent paths of other relocation paths and remove the
 208     # final element (so the install-prefix dir itself is not omitted
 209     # from the RPM's content-list)
 210     list(SORT RPM_USED_PACKAGE_PREFIXES)
 211     set(_DISTINCT_PATH "NOT_SET")
 212     foreach(_RPM_RELOCATION_PREFIX ${RPM_USED_PACKAGE_PREFIXES})
 213       if(NOT "${_RPM_RELOCATION_PREFIX}" MATCHES "${_DISTINCT_PATH}/.*")
 214         set(_DISTINCT_PATH "${_RPM_RELOCATION_PREFIX}")
 215
 216         string(REPLACE "/" ";" _CPACK_RPM_PACKAGE_PREFIX_ELEMS " ${_RPM_RELOCATION_PREFIX}")
 217         list(REMOVE_AT _CPACK_RPM_PACKAGE_PREFIX_ELEMS -1)
 218         unset(_TMP_LIST)
 219         # Now generate all of the parent dirs of the relocation path
 220         foreach(_PREFIX_PATH_ELEM ${_CPACK_RPM_PACKAGE_PREFIX_ELEMS})
 221           list(APPEND _TMP_LIST "${_PREFIX_PATH_ELEM}")
 222           string(REPLACE ";" "/" _OMIT_DIR "${_TMP_LIST}")
 223           separate_arguments(_OMIT_DIR)
 224           list(APPEND _RPM_DIRS_TO_OMIT ${_OMIT_DIR})
 225         endforeach()
 226       endif()
 227     endforeach()
 228   endif()
 229
 230   if(CPACK_RPM_PACKAGE_DEBUG)
 231     message("CPackRPM:Debug: Initial list of path to OMIT in RPM: ${_RPM_DIRS_TO_OMIT}")
 232   endif()
 233
 234   if(NOT DEFINED CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST)
 235     set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST /etc /etc/init.d /usr /usr/bin
 236         /usr/include /usr/lib /usr/libx32 /usr/lib64
 237         /usr/share /usr/share/aclocal /usr/share/doc )
 238     if(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION)
 239       if(CPACK_RPM_PACKAGE_DEBUG)
 240         message("CPackRPM:Debug: Adding ${CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION} to builtin omit list.")
 241       endif()
 242       list(APPEND CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST "${CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION}")
 243     endif()
 244   endif()
 245
 246   if(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST)
 247     if(CPACK_RPM_PACKAGE_DEBUG)
 248       message("CPackRPM:Debug: CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST= ${CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST}")
 249     endif()
 250     list(APPEND _RPM_DIRS_TO_OMIT ${CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST})
 251   endif()
 252
 253   if(CPACK_RPM_PACKAGE_DEBUG)
 254     message("CPackRPM:Debug: Final list of path to OMIT in RPM: ${_RPM_DIRS_TO_OMIT}")
 255   endif()
 256
 257   list(REMOVE_ITEM CPACK_RPM_INSTALL_FILES ${_RPM_DIRS_TO_OMIT})
 258
 259   # add man paths that will be compressed
 260   # (copied from /usr/lib/rpm/brp-compress - script that does the actual
 261   # compressing)
 262   list(APPEND MAN_LOCATIONS "/usr/man/man.*" "/usr/man/.*/man.*" "/usr/info.*"
 263     "/usr/share/man/man.*" "/usr/share/man/.*/man.*" "/usr/share/info.*"
 264     "/usr/kerberos/man.*" "/usr/X11R6/man/man.*" "/usr/lib/perl5/man/man.*"
 265     "/usr/share/doc/.*/man/man.*" "/usr/lib/.*/man/man.*")
 266
 267   if(CPACK_RPM_ADDITIONAL_MAN_DIRS)
 268     if(CPACK_RPM_PACKAGE_DEBUG)
 269       message("CPackRPM:Debug: CPACK_RPM_ADDITIONAL_MAN_DIRS= ${CPACK_RPM_ADDITIONAL_MAN_DIRS}")
 270     endif()
 271     list(APPEND MAN_LOCATIONS ${CPACK_RPM_ADDITIONAL_MAN_DIRS})
 272   endif()
 273
 274   foreach(PACK_LOCATION IN LISTS CPACK_RPM_INSTALL_FILES)
 275     foreach(MAN_LOCATION IN LISTS MAN_LOCATIONS)
 276       # man pages are files inside a certain location
 277       if(PACK_LOCATION MATCHES "${MAN_LOCATION}/"
 278         AND NOT IS_DIRECTORY "${WDIR}${PACK_LOCATION}"
 279         AND NOT IS_SYMLINK "${WDIR}${PACK_LOCATION}")
 280         list(FIND CPACK_RPM_INSTALL_FILES "${PACK_LOCATION}" INDEX)
 281         # insert file location that covers compressed man pages
 282         # even if using a wildcard causes duplicates as those are
 283         # handled by RPM and we still keep the same file list
 284         # in spec file - wildcard only represents file type (e.g. .gz)
 285         list(INSERT CPACK_RPM_INSTALL_FILES ${INDEX} "${PACK_LOCATION}*")
 286         # remove file location that doesn't cover compressed man pages
 287         math(EXPR INDEX ${INDEX}+1)
 288         list(REMOVE_AT CPACK_RPM_INSTALL_FILES ${INDEX})
 289
 290         break()
 291       endif()
 292     endforeach()
 293   endforeach()
 294
 295   set(CPACK_RPM_INSTALL_FILES "${CPACK_RPM_INSTALL_FILES}" PARENT_SCOPE)
 296 endfunction()
 297
 298 function(cpack_rpm_symlink_get_relocation_prefixes LOCATION PACKAGE_PREFIXES RETURN_VARIABLE)
 299   foreach(PKG_PREFIX IN LISTS PACKAGE_PREFIXES)
 300     string(REGEX MATCH "^${PKG_PREFIX}/.*" FOUND_ "${LOCATION}")
 301     if(FOUND_)
 302       list(APPEND TMP_PREFIXES "${PKG_PREFIX}")
 303     endif()
 304   endforeach()
 305
 306   set(${RETURN_VARIABLE} "${TMP_PREFIXES}" PARENT_SCOPE)
 307 endfunction()
 308
 309 function(cpack_rpm_symlink_create_relocation_script PACKAGE_PREFIXES)
 310   list(LENGTH PACKAGE_PREFIXES LAST_INDEX)
 311   set(SORTED_PACKAGE_PREFIXES "${PACKAGE_PREFIXES}")
 312   list(SORT SORTED_PACKAGE_PREFIXES)
 313   list(REVERSE SORTED_PACKAGE_PREFIXES)
 314   math(EXPR LAST_INDEX ${LAST_INDEX}-1)
 315
 316   foreach(SYMLINK_INDEX RANGE ${LAST_INDEX})
 317     list(GET SORTED_PACKAGE_PREFIXES ${SYMLINK_INDEX} SRC_PATH)
 318     list(FIND PACKAGE_PREFIXES "${SRC_PATH}" SYMLINK_INDEX) # reverse magic
 319     string(LENGTH "${SRC_PATH}" SRC_PATH_LEN)
 320
 321     set(PARTS_CNT 0)
 322     set(SCRIPT_PART "if [ \"$RPM_INSTALL_PREFIX${SYMLINK_INDEX}\" != \"${SRC_PATH}\" ]; then\n")
 323
 324     # both paths relocated
 325     foreach(POINT_INDEX RANGE ${LAST_INDEX})
 326       list(GET SORTED_PACKAGE_PREFIXES ${POINT_INDEX} POINT_PATH)
 327       list(FIND PACKAGE_PREFIXES "${POINT_PATH}" POINT_INDEX) # reverse magic
 328       string(LENGTH "${POINT_PATH}" POINT_PATH_LEN)
 329
 330       if(_RPM_RELOCATION_SCRIPT_${SYMLINK_INDEX}_${POINT_INDEX})
 331         if("${SYMLINK_INDEX}" EQUAL "${POINT_INDEX}")
 332           set(INDENT "")
 333         else()
 334           string(APPEND SCRIPT_PART "  if [ \"$RPM_INSTALL_PREFIX${POINT_INDEX}\" != \"${POINT_PATH}\" ]; then\n")
 335           set(INDENT "  ")
 336         endif()
 337
 338         foreach(RELOCATION_NO IN LISTS _RPM_RELOCATION_SCRIPT_${SYMLINK_INDEX}_${POINT_INDEX})
 339           math(EXPR PARTS_CNT ${PARTS_CNT}+1)
 340
 341           math(EXPR RELOCATION_INDEX ${RELOCATION_NO}-1)
 342           list(GET _RPM_RELOCATION_SCRIPT_PAIRS ${RELOCATION_INDEX} RELOCATION_SCRIPT_PAIR)
 343           string(FIND "${RELOCATION_SCRIPT_PAIR}" ":" SPLIT_INDEX)
 344
 345           math(EXPR SRC_PATH_END ${SPLIT_INDEX}-${SRC_PATH_LEN})
 346           string(SUBSTRING ${RELOCATION_SCRIPT_PAIR} ${SRC_PATH_LEN} ${SRC_PATH_END} SYMLINK_)
 347
 348           math(EXPR POINT_PATH_START ${SPLIT_INDEX}+1+${POINT_PATH_LEN})
 349           string(SUBSTRING ${RELOCATION_SCRIPT_PAIR} ${POINT_PATH_START} -1 POINT_)
 350
 351           string(APPEND SCRIPT_PART "  ${INDENT}if [ -z \"$CPACK_RPM_RELOCATED_SYMLINK_${RELOCATION_INDEX}\" ]; then\n")
 352           string(APPEND SCRIPT_PART "    ${INDENT}ln -s \"$RPM_INSTALL_PREFIX${POINT_INDEX}${POINT_}\" \"$RPM_INSTALL_PREFIX${SYMLINK_INDEX}${SYMLINK_}\"\n")
 353           string(APPEND SCRIPT_PART "    ${INDENT}CPACK_RPM_RELOCATED_SYMLINK_${RELOCATION_INDEX}=true\n")
 354           string(APPEND SCRIPT_PART "  ${INDENT}fi\n")
 355         endforeach()
 356
 357         if(NOT "${SYMLINK_INDEX}" EQUAL "${POINT_INDEX}")
 358           string(APPEND SCRIPT_PART "  fi\n")
 359         endif()
 360       endif()
 361     endforeach()
 362
 363     # source path relocated
 364     if(_RPM_RELOCATION_SCRIPT_${SYMLINK_INDEX}_X)
 365       foreach(RELOCATION_NO IN LISTS _RPM_RELOCATION_SCRIPT_${SYMLINK_INDEX}_X)
 366         math(EXPR PARTS_CNT ${PARTS_CNT}+1)
 367
 368         math(EXPR RELOCATION_INDEX ${RELOCATION_NO}-1)
 369         list(GET _RPM_RELOCATION_SCRIPT_PAIRS ${RELOCATION_INDEX} RELOCATION_SCRIPT_PAIR)
 370         string(FIND "${RELOCATION_SCRIPT_PAIR}" ":" SPLIT_INDEX)
 371
 372         math(EXPR SRC_PATH_END ${SPLIT_INDEX}-${SRC_PATH_LEN})
 373         string(SUBSTRING ${RELOCATION_SCRIPT_PAIR} ${SRC_PATH_LEN} ${SRC_PATH_END} SYMLINK_)
 374
 375         math(EXPR POINT_PATH_START ${SPLIT_INDEX}+1)
 376         string(SUBSTRING ${RELOCATION_SCRIPT_PAIR} ${POINT_PATH_START} -1 POINT_)
 377
 378         string(APPEND SCRIPT_PART "  if [ -z \"$CPACK_RPM_RELOCATED_SYMLINK_${RELOCATION_INDEX}\" ]; then\n")
 379         string(APPEND SCRIPT_PART "    ln -s \"${POINT_}\" \"$RPM_INSTALL_PREFIX${SYMLINK_INDEX}${SYMLINK_}\"\n")
 380         string(APPEND SCRIPT_PART "    CPACK_RPM_RELOCATED_SYMLINK_${RELOCATION_INDEX}=true\n")
 381         string(APPEND SCRIPT_PART "  fi\n")
 382       endforeach()
 383     endif()
 384
 385     if(PARTS_CNT)
 386       set(SCRIPT "${SCRIPT_PART}")
 387       string(APPEND SCRIPT "fi\n")
 388     endif()
 389   endforeach()
 390
 391   # point path relocated
 392   foreach(POINT_INDEX RANGE ${LAST_INDEX})
 393     list(GET SORTED_PACKAGE_PREFIXES ${POINT_INDEX} POINT_PATH)
 394     list(FIND PACKAGE_PREFIXES "${POINT_PATH}" POINT_INDEX) # reverse magic
 395     string(LENGTH "${POINT_PATH}" POINT_PATH_LEN)
 396
 397     if(_RPM_RELOCATION_SCRIPT_X_${POINT_INDEX})
 398       string(APPEND SCRIPT "if [ \"$RPM_INSTALL_PREFIX${POINT_INDEX}\" != \"${POINT_PATH}\" ]; then\n")
 399
 400       foreach(RELOCATION_NO IN LISTS _RPM_RELOCATION_SCRIPT_X_${POINT_INDEX})
 401         math(EXPR RELOCATION_INDEX ${RELOCATION_NO}-1)
 402         list(GET _RPM_RELOCATION_SCRIPT_PAIRS ${RELOCATION_INDEX} RELOCATION_SCRIPT_PAIR)
 403         string(FIND "${RELOCATION_SCRIPT_PAIR}" ":" SPLIT_INDEX)
 404
 405         string(SUBSTRING ${RELOCATION_SCRIPT_PAIR} 0 ${SPLIT_INDEX} SYMLINK_)
 406
 407         math(EXPR POINT_PATH_START ${SPLIT_INDEX}+1+${POINT_PATH_LEN})
 408         string(SUBSTRING ${RELOCATION_SCRIPT_PAIR} ${POINT_PATH_START} -1 POINT_)
 409
 410         string(APPEND SCRIPT "  if [ -z \"$CPACK_RPM_RELOCATED_SYMLINK_${RELOCATION_INDEX}\" ]; then\n")
 411         string(APPEND SCRIPT "    ln -s \"$RPM_INSTALL_PREFIX${POINT_INDEX}${POINT_}\" \"${SYMLINK_}\"\n")
 412         string(APPEND SCRIPT "    CPACK_RPM_RELOCATED_SYMLINK_${RELOCATION_INDEX}=true\n")
 413         string(APPEND SCRIPT "  fi\n")
 414       endforeach()
 415
 416       string(APPEND SCRIPT "fi\n")
 417     endif()
 418   endforeach()
 419
 420   # no path relocated
 421   if(_RPM_RELOCATION_SCRIPT_X_X)
 422     foreach(RELOCATION_NO IN LISTS _RPM_RELOCATION_SCRIPT_X_X)
 423       math(EXPR RELOCATION_INDEX ${RELOCATION_NO}-1)
 424       list(GET _RPM_RELOCATION_SCRIPT_PAIRS ${RELOCATION_INDEX} RELOCATION_SCRIPT_PAIR)
 425       string(FIND "${RELOCATION_SCRIPT_PAIR}" ":" SPLIT_INDEX)
 426
 427       string(SUBSTRING ${RELOCATION_SCRIPT_PAIR} 0 ${SPLIT_INDEX} SYMLINK_)
 428
 429       math(EXPR POINT_PATH_START ${SPLIT_INDEX}+1)
 430       string(SUBSTRING ${RELOCATION_SCRIPT_PAIR} ${POINT_PATH_START} -1 POINT_)
 431
 432       string(APPEND SCRIPT "if [ -z \"$CPACK_RPM_RELOCATED_SYMLINK_${RELOCATION_INDEX}\" ]; then\n")
 433       string(APPEND SCRIPT "  ln -s \"${POINT_}\" \"${SYMLINK_}\"\n")
 434       string(APPEND SCRIPT "fi\n")
 435     endforeach()
 436   endif()
 437
 438   set(RPM_SYMLINK_POSTINSTALL "${SCRIPT}" PARENT_SCOPE)
 439 endfunction()
 440
 441 function(cpack_rpm_symlink_add_for_relocation_script PACKAGE_PREFIXES SYMLINK SYMLINK_RELOCATION_PATHS POINT POINT_RELOCATION_PATHS)
 442   list(LENGTH SYMLINK_RELOCATION_PATHS SYMLINK_PATHS_COUTN)
 443   list(LENGTH POINT_RELOCATION_PATHS POINT_PATHS_COUNT)
 444
 445   list(APPEND _RPM_RELOCATION_SCRIPT_PAIRS "${SYMLINK}:${POINT}")
 446   list(LENGTH _RPM_RELOCATION_SCRIPT_PAIRS PAIR_NO)
 447
 448   if(SYMLINK_PATHS_COUTN)
 449     foreach(SYMLINK_RELOC_PATH IN LISTS SYMLINK_RELOCATION_PATHS)
 450       list(FIND PACKAGE_PREFIXES "${SYMLINK_RELOC_PATH}" SYMLINK_INDEX)
 451
 452       # source path relocated
 453       list(APPEND _RPM_RELOCATION_SCRIPT_${SYMLINK_INDEX}_X "${PAIR_NO}")
 454       list(APPEND RELOCATION_VARS "_RPM_RELOCATION_SCRIPT_${SYMLINK_INDEX}_X")
 455
 456       foreach(POINT_RELOC_PATH IN LISTS POINT_RELOCATION_PATHS)
 457         list(FIND PACKAGE_PREFIXES "${POINT_RELOC_PATH}" POINT_INDEX)
 458
 459         # both paths relocated
 460         list(APPEND _RPM_RELOCATION_SCRIPT_${SYMLINK_INDEX}_${POINT_INDEX} "${PAIR_NO}")
 461         list(APPEND RELOCATION_VARS "_RPM_RELOCATION_SCRIPT_${SYMLINK_INDEX}_${POINT_INDEX}")
 462
 463         # point path relocated
 464         list(APPEND _RPM_RELOCATION_SCRIPT_X_${POINT_INDEX} "${PAIR_NO}")
 465         list(APPEND RELOCATION_VARS "_RPM_RELOCATION_SCRIPT_X_${POINT_INDEX}")
 466       endforeach()
 467     endforeach()
 468   elseif(POINT_PATHS_COUNT)
 469     foreach(POINT_RELOC_PATH IN LISTS POINT_RELOCATION_PATHS)
 470       list(FIND PACKAGE_PREFIXES "${POINT_RELOC_PATH}" POINT_INDEX)
 471
 472       # point path relocated
 473       list(APPEND _RPM_RELOCATION_SCRIPT_X_${POINT_INDEX} "${PAIR_NO}")
 474       list(APPEND RELOCATION_VARS "_RPM_RELOCATION_SCRIPT_X_${POINT_INDEX}")
 475     endforeach()
 476   endif()
 477
 478   # no path relocated
 479   list(APPEND _RPM_RELOCATION_SCRIPT_X_X "${PAIR_NO}")
 480   list(APPEND RELOCATION_VARS "_RPM_RELOCATION_SCRIPT_X_X")
 481
 482   # place variables into parent scope
 483   foreach(VAR IN LISTS RELOCATION_VARS)
 484     set(${VAR} "${${VAR}}" PARENT_SCOPE)
 485   endforeach()
 486   set(_RPM_RELOCATION_SCRIPT_PAIRS "${_RPM_RELOCATION_SCRIPT_PAIRS}" PARENT_SCOPE)
 487   set(REQUIRES_SYMLINK_RELOCATION_SCRIPT "true" PARENT_SCOPE)
 488   set(DIRECTIVE "%ghost " PARENT_SCOPE)
 489 endfunction()
 490
 491 function(cpack_rpm_prepare_install_files INSTALL_FILES_LIST WDIR PACKAGE_PREFIXES IS_RELOCATABLE)
 492   # Prepend directories in ${CPACK_RPM_INSTALL_FILES} with %dir
 493   # This is necessary to avoid duplicate files since rpmbuild does
 494   # recursion on its own when encountering a pathname which is a directory
 495   # which is not flagged as %dir
 496   string(STRIP "${INSTALL_FILES_LIST}" INSTALL_FILES_LIST)
 497   string(REPLACE "\n" ";" INSTALL_FILES_LIST
 498                           "${INSTALL_FILES_LIST}")
 499   string(REPLACE "\"" "" INSTALL_FILES_LIST
 500                           "${INSTALL_FILES_LIST}")
 501   string(LENGTH "${WDIR}" WDR_LEN_)
 502
 503   list(SORT INSTALL_FILES_LIST) # make file order consistent on all platforms
 504
 505   foreach(F IN LISTS INSTALL_FILES_LIST)
 506     unset(DIRECTIVE)
 507
 508     if(IS_SYMLINK "${WDIR}/${F}")
 509       if(IS_RELOCATABLE)
 510         # check that symlink has relocatable format
 511         get_filename_component(SYMLINK_LOCATION_ "${WDIR}/${F}" DIRECTORY)
 512         execute_process(COMMAND ls -la "${WDIR}/${F}"
 513                   WORKING_DIRECTORY "${WDIR}"
 514                   OUTPUT_VARIABLE SYMLINK_POINT_
 515                   OUTPUT_STRIP_TRAILING_WHITESPACE)
 516
 517         string(FIND "${SYMLINK_POINT_}" "->" SYMLINK_POINT_INDEX_ REVERSE)
 518         math(EXPR SYMLINK_POINT_INDEX_ ${SYMLINK_POINT_INDEX_}+3)
 519         string(LENGTH "${SYMLINK_POINT_}" SYMLINK_POINT_LENGTH_)
 520
 521         # get destination path
 522         string(SUBSTRING "${SYMLINK_POINT_}" ${SYMLINK_POINT_INDEX_} ${SYMLINK_POINT_LENGTH_} SYMLINK_POINT_)
 523
 524         # check if path is relative or absolute
 525         string(SUBSTRING "${SYMLINK_POINT_}" 0 1 SYMLINK_IS_ABSOLUTE_)
 526
 527         if(${SYMLINK_IS_ABSOLUTE_} STREQUAL "/")
 528           # prevent absolute paths from having /../ or /./ section inside of them
 529           get_filename_component(SYMLINK_POINT_ "${SYMLINK_POINT_}" ABSOLUTE)
 530         else()
 531           # handle relative path
 532           get_filename_component(SYMLINK_POINT_ "${SYMLINK_LOCATION_}/${SYMLINK_POINT_}" ABSOLUTE)
 533         endif()
 534
 535         # recalculate path length after conversion to canonical form
 536         string(LENGTH "${SYMLINK_POINT_}" SYMLINK_POINT_LENGTH_)
 537
 538         cpack_rpm_exact_regex(IN_SYMLINK_POINT_REGEX "${WDIR}")
 539         string(APPEND IN_SYMLINK_POINT_REGEX "/.*")
 540         if(SYMLINK_POINT_ MATCHES "${IN_SYMLINK_POINT_REGEX}")
 541           # only symlinks that are pointing inside the packaging structure should be checked for relocation
 542           string(SUBSTRING "${SYMLINK_POINT_}" ${WDR_LEN_} -1 SYMLINK_POINT_WD_)
 543           cpack_rpm_symlink_get_relocation_prefixes("${F}" "${PACKAGE_PREFIXES}" "SYMLINK_RELOCATIONS")
 544           cpack_rpm_symlink_get_relocation_prefixes("${SYMLINK_POINT_WD_}" "${PACKAGE_PREFIXES}" "POINT_RELOCATIONS")
 545
 546           list(LENGTH SYMLINK_RELOCATIONS SYMLINK_RELOCATIONS_COUNT)
 547           list(LENGTH POINT_RELOCATIONS POINT_RELOCATIONS_COUNT)
 548         else()
 549           # location pointed to is outside WDR so it should be treated as a permanent symlink
 550           set(SYMLINK_POINT_WD_ "${SYMLINK_POINT_}")
 551
 552           unset(SYMLINK_RELOCATIONS)
 553           unset(POINT_RELOCATIONS)
 554           unset(SYMLINK_RELOCATIONS_COUNT)
 555           unset(POINT_RELOCATIONS_COUNT)
 556
 557           message(AUTHOR_WARNING "CPackRPM:Warning: Symbolic link '${F}' points to location that is outside packaging path! Link will possibly not be relocatable.")
 558         endif()
 559
 560         if(SYMLINK_RELOCATIONS_COUNT AND POINT_RELOCATIONS_COUNT)
 561           # find matching
 562           foreach(SYMLINK_RELOCATION_PREFIX IN LISTS SYMLINK_RELOCATIONS)
 563             list(FIND POINT_RELOCATIONS "${SYMLINK_RELOCATION_PREFIX}" FOUND_INDEX)
 564             if(NOT ${FOUND_INDEX} EQUAL -1)
 565               break()
 566             endif()
 567           endforeach()
 568
 569           if(NOT ${FOUND_INDEX} EQUAL -1)
 570             # symlinks have the same subpath
 571             if(${SYMLINK_RELOCATIONS_COUNT} EQUAL 1 AND ${POINT_RELOCATIONS_COUNT} EQUAL 1)
 572               # permanent symlink
 573               get_filename_component(SYMLINK_LOCATION_ "${F}" DIRECTORY)
 574               file(RELATIVE_PATH FINAL_PATH_ ${SYMLINK_LOCATION_} ${SYMLINK_POINT_WD_})
 575               execute_process(COMMAND "${CMAKE_COMMAND}" -E create_symlink "${FINAL_PATH_}" "${WDIR}/${F}")
 576             else()
 577               # relocation subpaths
 578               cpack_rpm_symlink_add_for_relocation_script("${PACKAGE_PREFIXES}" "${F}" "${SYMLINK_RELOCATIONS}"
 579                   "${SYMLINK_POINT_WD_}" "${POINT_RELOCATIONS}")
 580             endif()
 581           else()
 582             # not on the same relocation path
 583             cpack_rpm_symlink_add_for_relocation_script("${PACKAGE_PREFIXES}" "${F}" "${SYMLINK_RELOCATIONS}"
 584                 "${SYMLINK_POINT_WD_}" "${POINT_RELOCATIONS}")
 585           endif()
 586         elseif(POINT_RELOCATIONS_COUNT)
 587           # point is relocatable
 588           cpack_rpm_symlink_add_for_relocation_script("${PACKAGE_PREFIXES}" "${F}" "${SYMLINK_RELOCATIONS}"
 589               "${SYMLINK_POINT_WD_}" "${POINT_RELOCATIONS}")
 590         else()
 591           # is not relocatable or points to non relocatable path - permanent symlink
 592           execute_process(COMMAND "${CMAKE_COMMAND}" -E create_symlink "${SYMLINK_POINT_WD_}" "${WDIR}/${F}")
 593         endif()
 594       endif()
 595     elseif(IS_DIRECTORY "${WDIR}/${F}")
 596       set(DIRECTIVE "%dir ")
 597     endif()
 598
 599     string(APPEND INSTALL_FILES "${DIRECTIVE}\"${F}\"\n")
 600   endforeach()
 601
 602   if(REQUIRES_SYMLINK_RELOCATION_SCRIPT)
 603     cpack_rpm_symlink_create_relocation_script("${PACKAGE_PREFIXES}")
 604   endif()
 605
 606   set(RPM_SYMLINK_POSTINSTALL "${RPM_SYMLINK_POSTINSTALL}" PARENT_SCOPE)
 607   set(CPACK_RPM_INSTALL_FILES "${INSTALL_FILES}" PARENT_SCOPE)
 608 endfunction()
 609
 610 if(CMAKE_BINARY_DIR)
 611   message(FATAL_ERROR "CPackRPM.cmake may only be used by CPack internally.")
 612 endif()
 613
 614 if(NOT UNIX)
 615   message(FATAL_ERROR "CPackRPM.cmake may only be used under UNIX.")
 616 endif()
 617
 618 # We need to check if the binaries were compiled with debug symbols
 619 # because without them the package will be useless
 620 function(cpack_rpm_debugsymbol_check INSTALL_FILES WORKING_DIR)
 621   if(NOT CPACK_BUILD_SOURCE_DIRS)
 622     message(FATAL_ERROR "CPackRPM: CPACK_BUILD_SOURCE_DIRS variable is not set!"
 623       " Required for debuginfo packaging. See documentation of"
 624       " CPACK_RPM_DEBUGINFO_PACKAGE variable for details.")
 625   endif()
 626
 627   # With objdump we should check the debug symbols
 628   find_program(OBJDUMP_EXECUTABLE objdump)
 629   if(NOT OBJDUMP_EXECUTABLE)
 630     message(FATAL_ERROR "CPackRPM: objdump binary could not be found!"
 631       " Required for debuginfo packaging. See documentation of"
 632       " CPACK_RPM_DEBUGINFO_PACKAGE variable for details.")
 633   endif()
 634
 635   # With debugedit we prepare source files list
 636   find_program(DEBUGEDIT_EXECUTABLE debugedit "/usr/lib/rpm/")
 637   if(NOT DEBUGEDIT_EXECUTABLE)
 638     message(FATAL_ERROR "CPackRPM: debugedit binary could not be found!"
 639       " Required for debuginfo packaging. See documentation of"
 640       " CPACK_RPM_DEBUGINFO_PACKAGE variable for details.")
 641   endif()
 642
 643   unset(mkdir_list_)
 644   unset(cp_list_)
 645   unset(additional_sources_)
 646
 647   foreach(F IN LISTS INSTALL_FILES)
 648     if(IS_DIRECTORY "${WORKING_DIR}/${F}" OR IS_SYMLINK "${WORKING_DIR}/${F}")
 649       continue()
 650     endif()
 651
 652     execute_process(COMMAND "${OBJDUMP_EXECUTABLE}" -h ${WORKING_DIR}/${F}
 653                     WORKING_DIRECTORY "${CPACK_TOPLEVEL_DIRECTORY}"
 654                     RESULT_VARIABLE OBJDUMP_EXEC_RESULT
 655                     OUTPUT_VARIABLE OBJDUMP_OUT
 656                     ERROR_QUIET)
 657     # Check if the given file is an executable or not
 658     if(NOT OBJDUMP_EXEC_RESULT)
 659       string(FIND "${OBJDUMP_OUT}" "debug" FIND_RESULT)
 660       if(FIND_RESULT GREATER -1)
 661         set(index_ 0)
 662         foreach(source_dir_ IN LISTS CPACK_BUILD_SOURCE_DIRS)
 663           string(LENGTH "${source_dir_}" source_dir_len_)
 664           string(LENGTH "${CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX}/src_${index_}" debuginfo_dir_len)
 665           if(source_dir_len_ LESS debuginfo_dir_len)
 666             message(FATAL_ERROR "CPackRPM: source dir path '${source_dir_}' is"
 667               " shorter than debuginfo sources dir path '${CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX}/src_${index_}'!"
 668               " Source dir path must be longer than debuginfo sources dir path."
 669               " Set CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX variable to a shorter value"
 670               " or make source dir path longer."
 671               " Required for debuginfo packaging. See documentation of"
 672               " CPACK_RPM_DEBUGINFO_PACKAGE variable for details.")
 673           endif()
 674
 675           file(REMOVE "${CPACK_RPM_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}${CPACK_RPM_PACKAGE_COMPONENT_PART_PATH}/debugsources_add.list")
 676           execute_process(COMMAND "${DEBUGEDIT_EXECUTABLE}" -b "${source_dir_}" -d "${CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX}/src_${index_}" -i -l "${CPACK_RPM_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}${CPACK_RPM_PACKAGE_COMPONENT_PART_PATH}/debugsources_add.list" "${WORKING_DIR}/${F}"
 677               RESULT_VARIABLE res_
 678               OUTPUT_VARIABLE opt_
 679               ERROR_VARIABLE err_
 680             )
 681
 682           file(STRINGS
 683             "${CPACK_RPM_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}${CPACK_RPM_PACKAGE_COMPONENT_PART_PATH}/debugsources_add.list"
 684             sources_)
 685           list(REMOVE_DUPLICATES sources_)
 686
 687           foreach(source_ IN LISTS sources_)
 688             if(EXISTS "${source_dir_}/${source_}" AND NOT IS_DIRECTORY "${source_dir_}/${source_}")
 689               get_filename_component(path_part_ "${source_}" DIRECTORY)
 690               list(APPEND mkdir_list_ "%{buildroot}${CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX}/src_${index_}/${path_part_}")
 691               list(APPEND cp_list_ "cp \"${source_dir_}/${source_}\" \"%{buildroot}${CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX}/src_${index_}/${path_part_}\"")
 692
 693               list(APPEND additional_sources_ "${CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX}/src_${index_}/${source_}")
 694             endif()
 695           endforeach()
 696
 697           math(EXPR index_ "${index_} + 1")
 698         endforeach()
 699       else()
 700         message(WARNING "CPackRPM: File: ${F} does not contain debug symbols. They will possibly be missing from debuginfo package!")
 701       endif()
 702
 703       get_file_permissions("${WORKING_DIR}/${F}" permissions_)
 704       if(NOT "USER_EXECUTE" IN_LIST permissions_ AND
 705          NOT "GROUP_EXECUTE" IN_LIST permissions_ AND
 706          NOT "WORLD_EXECUTE" IN_LIST permissions_)
 707         if(CPACK_RPM_INSTALL_WITH_EXEC)
 708           execute_process(COMMAND chmod a+x ${WORKING_DIR}/${F}
 709                   RESULT_VARIABLE res_
 710                   ERROR_VARIABLE err_
 711                   OUTPUT_QUIET)
 712
 713           if(res_)
 714             message(FATAL_ERROR "CPackRPM: could not apply execute permissions "
 715               "requested by CPACK_RPM_INSTALL_WITH_EXEC variable on "
 716               "'${WORKING_DIR}/${F}'! Reason: '${err_}'")
 717           endif()
 718         else()
 719           message(AUTHOR_WARNING "CPackRPM: File: ${WORKING_DIR}/${F} does not "
 720             "have execute permissions. Debuginfo symbols will not be extracted"
 721             "! Missing debuginfo may cause packaging failure. Consider setting "
 722             "execute permissions or setting 'CPACK_RPM_INSTALL_WITH_EXEC' "
 723             "variable.")
 724         endif()
 725       endif()
 726     endif()
 727   endforeach()
 728
 729   list(LENGTH mkdir_list_ len_)
 730   if(len_)
 731     list(REMOVE_DUPLICATES mkdir_list_)
 732     unset(TMP_RPM_DEBUGINFO_INSTALL)
 733     foreach(part_ IN LISTS mkdir_list_)
 734       string(APPEND TMP_RPM_DEBUGINFO_INSTALL "mkdir -p \"${part_}\"\n")
 735     endforeach()
 736   endif()
 737
 738   list(LENGTH cp_list_ len_)
 739   if(len_)
 740     list(REMOVE_DUPLICATES cp_list_)
 741     foreach(part_ IN LISTS cp_list_)
 742       string(APPEND TMP_RPM_DEBUGINFO_INSTALL "${part_}\n")
 743     endforeach()
 744   endif()
 745
 746   if(NOT DEFINED CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS)
 747     set(CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS /usr /usr/src /usr/src/debug)
 748     if(CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS_ADDITION)
 749       if(CPACK_RPM_PACKAGE_DEBUG)
 750         message("CPackRPM:Debug: Adding ${CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS_ADDITION} to builtin omit list.")
 751       endif()
 752       list(APPEND CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS "${CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS_ADDITION}")
 753     endif()
 754   endif()
 755   if(CPACK_RPM_PACKAGE_DEBUG)
 756     message("CPackRPM:Debug: CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS= ${CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS}")
 757   endif()
 758
 759   list(LENGTH additional_sources_ len_)
 760   if(len_)
 761     list(REMOVE_DUPLICATES additional_sources_)
 762     unset(additional_sources_all_)
 763     foreach(source_ IN LISTS additional_sources_)
 764       string(REPLACE "/" ";" split_source_ " ${source_}")
 765       list(REMOVE_AT split_source_ 0)
 766       unset(tmp_path_)
 767       # Now generate all segments of the path
 768       foreach(segment_ IN LISTS split_source_)
 769         string(APPEND tmp_path_ "/${segment_}")
 770         list(APPEND additional_sources_all_ "${tmp_path_}")
 771       endforeach()
 772     endforeach()
 773
 774     list(REMOVE_DUPLICATES additional_sources_all_)
 775     list(REMOVE_ITEM additional_sources_all_
 776       ${CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS})
 777
 778     unset(TMP_DEBUGINFO_ADDITIONAL_SOURCES)
 779     foreach(source_ IN LISTS additional_sources_all_)
 780       string(APPEND TMP_DEBUGINFO_ADDITIONAL_SOURCES "${source_}\n")
 781     endforeach()
 782   endif()
 783
 784   set(TMP_RPM_DEBUGINFO_INSTALL "${TMP_RPM_DEBUGINFO_INSTALL}" PARENT_SCOPE)
 785   set(TMP_DEBUGINFO_ADDITIONAL_SOURCES "${TMP_DEBUGINFO_ADDITIONAL_SOURCES}"
 786     PARENT_SCOPE)
 787 endfunction()
 788
 789 function(cpack_rpm_variable_fallback OUTPUT_VAR_NAME)
 790   set(FALLBACK_VAR_NAMES ${ARGN})
 791
 792   foreach(variable_name IN LISTS FALLBACK_VAR_NAMES)
 793     if(DEFINED ${variable_name})
 794       set(${OUTPUT_VAR_NAME} "${${variable_name}}" PARENT_SCOPE)
 795       break()
 796     endif()
 797   endforeach()
 798 endfunction()
 799
 800 function(cpack_rpm_generate_package)
 801   # rpmbuild is the basic command for building RPM package
 802   # it may be a simple (symbolic) link to rpm command.
 803   find_program(RPMBUILD_EXECUTABLE rpmbuild)
 804
 805   # Check version of the rpmbuild tool this would be easier to
 806   # track bugs with users and CPackRPM debug mode.
 807   # We may use RPM version in order to check for available version dependent features
 808   if(RPMBUILD_EXECUTABLE)
 809     execute_process(COMMAND ${RPMBUILD_EXECUTABLE} --version
 810                     OUTPUT_VARIABLE _TMP_VERSION
 811                     ERROR_QUIET
 812                     OUTPUT_STRIP_TRAILING_WHITESPACE)
 813     string(REGEX REPLACE "^.* " ""
 814            RPMBUILD_EXECUTABLE_VERSION
 815            ${_TMP_VERSION})
 816     if(CPACK_RPM_PACKAGE_DEBUG)
 817       message("CPackRPM:Debug: rpmbuild version is <${RPMBUILD_EXECUTABLE_VERSION}>")
 818     endif()
 819   endif()
 820
 821   if(NOT RPMBUILD_EXECUTABLE)
 822     message(FATAL_ERROR "RPM package requires rpmbuild executable")
 823   endif()
 824
 825   # Display lsb_release output if DEBUG mode enable
 826   # This will help to diagnose problem with CPackRPM
 827   # because we will know on which kind of Linux we are
 828   if(CPACK_RPM_PACKAGE_DEBUG)
 829     find_program(LSB_RELEASE_EXECUTABLE lsb_release)
 830     if(LSB_RELEASE_EXECUTABLE)
 831       execute_process(COMMAND ${LSB_RELEASE_EXECUTABLE} -a
 832                       OUTPUT_VARIABLE _TMP_LSB_RELEASE_OUTPUT
 833                       ERROR_QUIET
 834                       OUTPUT_STRIP_TRAILING_WHITESPACE)
 835       string(REGEX REPLACE "\n" ", "
 836              LSB_RELEASE_OUTPUT
 837              ${_TMP_LSB_RELEASE_OUTPUT})
 838     else ()
 839       set(LSB_RELEASE_OUTPUT "lsb_release not installed/found!")
 840     endif()
 841     message("CPackRPM:Debug: LSB_RELEASE  = ${LSB_RELEASE_OUTPUT}")
 842   endif()
 843
 844   # We may use RPM version in the future in order
 845   # to shut down warning about space in buildtree
 846   # some recent RPM version should support space in different places.
 847   # not checked [yet].
 848   if(CPACK_TOPLEVEL_DIRECTORY MATCHES ".* .*")
 849     message(FATAL_ERROR "${RPMBUILD_EXECUTABLE} can't handle paths with spaces, use a build directory without spaces for building RPMs.")
 850   endif()
 851
 852   # If rpmbuild is found
 853   # we try to discover alien since we may be on non RPM distro like Debian.
 854   # In this case we may try to to use more advanced features
 855   # like generating RPM directly from DEB using alien.
 856   # FIXME feature not finished (yet)
 857   find_program(ALIEN_EXECUTABLE alien)
 858   if(ALIEN_EXECUTABLE)
 859     message(STATUS "alien found, we may be on a Debian based distro.")
 860   endif()
 861
 862   # Are we packaging components ?
 863   if(CPACK_RPM_PACKAGE_COMPONENT)
 864     string(TOUPPER ${CPACK_RPM_PACKAGE_COMPONENT} CPACK_RPM_PACKAGE_COMPONENT_UPPER)
 865   endif()
 866
 867   set(WDIR "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}${CPACK_RPM_PACKAGE_COMPONENT_PART_PATH}")
 868
 869   #
 870   # Use user-defined RPM specific variables value
 871   # or generate reasonable default value from
 872   # CPACK_xxx generic values.
 873   # The variables comes from the needed (mandatory or not)
 874   # values found in the RPM specification file aka ".spec" file.
 875   # The variables which may/should be defined are:
 876   #
 877
 878   # CPACK_RPM_PACKAGE_SUMMARY (mandatory)
 879
 880   if(CPACK_RPM_PACKAGE_COMPONENT)
 881     cpack_rpm_variable_fallback("CPACK_RPM_PACKAGE_SUMMARY"
 882       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_PACKAGE_SUMMARY"
 883       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_PACKAGE_SUMMARY")
 884   endif()
 885
 886   if(NOT CPACK_RPM_PACKAGE_SUMMARY)
 887     if(CPACK_PACKAGE_DESCRIPTION_SUMMARY)
 888       set(CPACK_RPM_PACKAGE_SUMMARY ${CPACK_PACKAGE_DESCRIPTION_SUMMARY})
 889     else()
 890       # if neither var is defined lets use the name as summary
 891       string(TOLOWER "${CPACK_PACKAGE_NAME}" CPACK_RPM_PACKAGE_SUMMARY)
 892     endif()
 893   endif()
 894
 895   if(NOT CPACK_RPM_PACKAGE_URL AND CPACK_PACKAGE_HOMEPAGE_URL)
 896     set(CPACK_RPM_PACKAGE_URL "${CPACK_PACKAGE_HOMEPAGE_URL}")
 897   endif()
 898
 899   # CPACK_RPM_PACKAGE_NAME (mandatory)
 900   if(NOT CPACK_RPM_PACKAGE_NAME)
 901     string(TOLOWER "${CPACK_PACKAGE_NAME}" CPACK_RPM_PACKAGE_NAME)
 902   endif()
 903
 904   if(CPACK_RPM_PACKAGE_COMPONENT)
 905     string(TOUPPER "${CPACK_RPM_MAIN_COMPONENT}"
 906       CPACK_RPM_MAIN_COMPONENT_UPPER)
 907
 908     if(NOT CPACK_RPM_MAIN_COMPONENT_UPPER STREQUAL CPACK_RPM_PACKAGE_COMPONENT_UPPER)
 909       string(APPEND CPACK_RPM_PACKAGE_NAME "-${CPACK_RPM_PACKAGE_COMPONENT}")
 910
 911       cpack_rpm_variable_fallback("CPACK_RPM_PACKAGE_NAME"
 912         "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_PACKAGE_NAME"
 913         "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_PACKAGE_NAME")
 914     endif()
 915   endif()
 916
 917   # CPACK_RPM_PACKAGE_VERSION (mandatory)
 918   if(NOT CPACK_RPM_PACKAGE_VERSION)
 919     if(NOT CPACK_PACKAGE_VERSION)
 920       message(FATAL_ERROR "RPM package requires a package version")
 921     endif()
 922     set(CPACK_RPM_PACKAGE_VERSION ${CPACK_PACKAGE_VERSION})
 923   endif()
 924   # Replace '-' in version with '_'
 925   # '-' character is  an Illegal RPM version character
 926   # it is illegal because it is used to separate
 927   # RPM "Version" from RPM "Release"
 928   string(REPLACE "-" "_" CPACK_RPM_PACKAGE_VERSION ${CPACK_RPM_PACKAGE_VERSION})
 929
 930   # CPACK_RPM_PACKAGE_ARCHITECTURE (mandatory)
 931   if(NOT CPACK_RPM_PACKAGE_ARCHITECTURE)
 932     execute_process(COMMAND uname "-m"
 933                     OUTPUT_VARIABLE CPACK_RPM_PACKAGE_ARCHITECTURE
 934                     OUTPUT_STRIP_TRAILING_WHITESPACE)
 935   else()
 936     if(CPACK_RPM_PACKAGE_DEBUG)
 937       message("CPackRPM:Debug: using user-specified build arch = ${CPACK_RPM_PACKAGE_ARCHITECTURE}")
 938     endif()
 939   endif()
 940
 941   if(CPACK_RPM_PACKAGE_COMPONENT)
 942     cpack_rpm_variable_fallback("CPACK_RPM_PACKAGE_ARCHITECTURE"
 943       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_PACKAGE_ARCHITECTURE"
 944       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_PACKAGE_ARCHITECTURE")
 945
 946     if(CPACK_RPM_PACKAGE_DEBUG)
 947       message("CPackRPM:Debug: using component build arch = ${CPACK_RPM_PACKAGE_ARCHITECTURE}")
 948     endif()
 949   endif()
 950
 951   if(${CPACK_RPM_PACKAGE_ARCHITECTURE} STREQUAL "noarch")
 952     set(TMP_RPM_BUILDARCH "Buildarch: ${CPACK_RPM_PACKAGE_ARCHITECTURE}")
 953   else()
 954     set(TMP_RPM_BUILDARCH "")
 955   endif()
 956
 957   # CPACK_RPM_PACKAGE_RELEASE
 958   # The RPM release is the numbering of the RPM package ITSELF
 959   # this is the version of the PACKAGING and NOT the version
 960   # of the CONTENT of the package.
 961   # You may well need to generate a new RPM package release
 962   # without changing the version of the packaged software.
 963   # This is the case when the packaging is buggy (not) the software :=)
 964   # If not set, 1 is a good candidate
 965   if(NOT CPACK_RPM_PACKAGE_RELEASE)
 966     set(CPACK_RPM_PACKAGE_RELEASE "1")
 967   endif()
 968
 969   if(CPACK_RPM_PACKAGE_RELEASE_DIST)
 970     string(APPEND CPACK_RPM_PACKAGE_RELEASE "%{?dist}")
 971   endif()
 972
 973   # CPACK_RPM_PACKAGE_LICENSE
 974   if(NOT CPACK_RPM_PACKAGE_LICENSE)
 975     set(CPACK_RPM_PACKAGE_LICENSE "unknown")
 976   endif()
 977
 978   # CPACK_RPM_PACKAGE_GROUP
 979   if(CPACK_RPM_PACKAGE_COMPONENT)
 980     cpack_rpm_variable_fallback("CPACK_RPM_PACKAGE_GROUP"
 981       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_PACKAGE_GROUP"
 982       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_PACKAGE_GROUP")
 983   endif()
 984
 985   if(NOT CPACK_RPM_PACKAGE_GROUP)
 986     set(CPACK_RPM_PACKAGE_GROUP "unknown")
 987   endif()
 988
 989   # CPACK_RPM_PACKAGE_VENDOR
 990   if(NOT CPACK_RPM_PACKAGE_VENDOR)
 991     if(CPACK_PACKAGE_VENDOR)
 992       set(CPACK_RPM_PACKAGE_VENDOR "${CPACK_PACKAGE_VENDOR}")
 993     else()
 994       set(CPACK_RPM_PACKAGE_VENDOR "unknown")
 995     endif()
 996   endif()
 997
 998   # CPACK_RPM_PACKAGE_SOURCE
 999   # The name of the source tarball in case we generate a source RPM
1000
1001   # CPACK_RPM_PACKAGE_DESCRIPTION
1002   # The variable content may be either
1003   #   - explicitly given by the user or
1004   #   - filled with the content of CPACK_PACKAGE_DESCRIPTION_FILE
1005   #     if it is defined
1006   #   - set to a default value
1007   #
1008
1009   if(CPACK_RPM_PACKAGE_COMPONENT)
1010     cpack_rpm_variable_fallback("CPACK_RPM_PACKAGE_DESCRIPTION"
1011       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_PACKAGE_DESCRIPTION"
1012       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_PACKAGE_DESCRIPTION"
1013       "CPACK_COMPONENT_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_DESCRIPTION")
1014   endif()
1015
1016   if(NOT CPACK_RPM_PACKAGE_DESCRIPTION)
1017     if(CPACK_PACKAGE_DESCRIPTION_FILE)
1018       file(READ ${CPACK_PACKAGE_DESCRIPTION_FILE} CPACK_RPM_PACKAGE_DESCRIPTION)
1019     else ()
1020       set(CPACK_RPM_PACKAGE_DESCRIPTION "no package description available")
1021     endif ()
1022   endif ()
1023
1024   # CPACK_RPM_COMPRESSION_TYPE
1025   #
1026   if (CPACK_RPM_COMPRESSION_TYPE)
1027      if(CPACK_RPM_PACKAGE_DEBUG)
1028        message("CPackRPM:Debug: User Specified RPM compression type: ${CPACK_RPM_COMPRESSION_TYPE}")
1029      endif()
1030      if(CPACK_RPM_COMPRESSION_TYPE STREQUAL "lzma")
1031        set(CPACK_RPM_COMPRESSION_TYPE_TMP "%define _binary_payload w9.lzdio")
1032      endif()
1033      if(CPACK_RPM_COMPRESSION_TYPE STREQUAL "xz")
1034        set(CPACK_RPM_COMPRESSION_TYPE_TMP "%define _binary_payload w7.xzdio")
1035      endif()
1036      if(CPACK_RPM_COMPRESSION_TYPE STREQUAL "bzip2")
1037        set(CPACK_RPM_COMPRESSION_TYPE_TMP "%define _binary_payload w9.bzdio")
1038      endif()
1039      if(CPACK_RPM_COMPRESSION_TYPE STREQUAL "gzip")
1040        set(CPACK_RPM_COMPRESSION_TYPE_TMP "%define _binary_payload w9.gzdio")
1041      endif()
1042   else()
1043      set(CPACK_RPM_COMPRESSION_TYPE_TMP "")
1044   endif()
1045
1046   if(NOT CPACK_RPM_PACKAGE_SOURCES)
1047     if(CPACK_PACKAGE_RELOCATABLE OR CPACK_RPM_PACKAGE_RELOCATABLE)
1048       if(CPACK_RPM_PACKAGE_DEBUG)
1049         message("CPackRPM:Debug: Trying to build a relocatable package")
1050       endif()
1051       if(CPACK_SET_DESTDIR AND (NOT CPACK_SET_DESTDIR STREQUAL "I_ON"))
1052         message("CPackRPM:Warning: CPACK_SET_DESTDIR is set (=${CPACK_SET_DESTDIR}) while requesting a relocatable package (CPACK_RPM_PACKAGE_RELOCATABLE is set): this is not supported, the package won't be relocatable.")
1053         set(CPACK_RPM_PACKAGE_RELOCATABLE FALSE)
1054       else()
1055         set(CPACK_RPM_PACKAGE_PREFIX ${CPACK_PACKAGING_INSTALL_PREFIX}) # kept for back compatibility (provided external RPM spec files)
1056         cpack_rpm_prepare_relocation_paths()
1057         set(CPACK_RPM_PACKAGE_RELOCATABLE TRUE)
1058       endif()
1059     endif()
1060   else()
1061     if(CPACK_RPM_PACKAGE_COMPONENT)
1062       message(FATAL_ERROR "CPACK_RPM_PACKAGE_SOURCES parameter can not be used"
1063         " in combination with CPACK_RPM_PACKAGE_COMPONENT parameter!")
1064     endif()
1065
1066     set(CPACK_RPM_PACKAGE_RELOCATABLE FALSE) # disable relocatable option if building source RPM
1067   endif()
1068
1069   execute_process(
1070     COMMAND "${RPMBUILD_EXECUTABLE}" --querytags
1071     OUTPUT_VARIABLE RPMBUILD_TAG_LIST
1072     OUTPUT_STRIP_TRAILING_WHITESPACE)
1073   string(REPLACE "\n" ";" RPMBUILD_TAG_LIST "${RPMBUILD_TAG_LIST}")
1074
1075   # In some versions of RPM, weak dependency tags are present in the --querytags
1076   # list, but unsupported by rpmbuild. A different method must be used to check
1077   # if they are supported.
1078
1079   execute_process(
1080     COMMAND ${RPM_EXECUTABLE} --suggests
1081     ERROR_QUIET
1082     RESULT_VARIABLE RPMBUILD_SUGGESTS_RESULT)
1083
1084   if(NOT RPMBUILD_SUGGESTS_RESULT EQUAL 0)
1085     foreach(_WEAK_DEP SUGGESTS RECOMMENDS SUPPLEMENTS ENHANCES)
1086       list(REMOVE_ITEM RPMBUILD_TAG_LIST ${_WEAK_DEP})
1087     endforeach()
1088   endif()
1089
1090   if(CPACK_RPM_PACKAGE_EPOCH)
1091     set(TMP_RPM_EPOCH "Epoch: ${CPACK_RPM_PACKAGE_EPOCH}")
1092   endif()
1093
1094   # Check if additional fields for RPM spec header are given
1095   # There may be some COMPONENT specific variables as well
1096   # If component specific var is not provided we use the global one
1097   # for each component
1098   foreach(_RPM_SPEC_HEADER URL REQUIRES SUGGESTS PROVIDES OBSOLETES PREFIX CONFLICTS AUTOPROV AUTOREQ AUTOREQPROV REQUIRES_PRE REQUIRES_POST REQUIRES_PREUN REQUIRES_POSTUN)
1099
1100     if(CPACK_RPM_PACKAGE_DEBUG)
1101       message("CPackRPM:Debug: processing ${_RPM_SPEC_HEADER}")
1102     endif()
1103
1104     if(CPACK_RPM_PACKAGE_COMPONENT)
1105       cpack_rpm_variable_fallback("CPACK_RPM_PACKAGE_${_RPM_SPEC_HEADER}"
1106         "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_PACKAGE_${_RPM_SPEC_HEADER}"
1107         "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_PACKAGE_${_RPM_SPEC_HEADER}")
1108     endif()
1109
1110     if(DEFINED CPACK_RPM_PACKAGE_${_RPM_SPEC_HEADER})
1111       # Prefix can be replaced by Prefixes but the old version still works so we'll ignore it for now
1112       # Requires* is a special case because it gets transformed to Requires(pre/post/preun/postun)
1113       # Auto* is a special case because the tags can not be queried by querytags rpmbuild flag
1114       set(special_case_tags_ PREFIX REQUIRES_PRE REQUIRES_POST REQUIRES_PREUN REQUIRES_POSTUN AUTOPROV AUTOREQ AUTOREQPROV)
1115       if(NOT _RPM_SPEC_HEADER IN_LIST RPMBUILD_TAG_LIST AND NOT _RPM_SPEC_HEADER IN_LIST special_case_tags_)
1116         message(AUTHOR_WARNING "CPackRPM:Warning: ${_RPM_SPEC_HEADER} not "
1117             "supported in provided rpmbuild. Tag will not be used.")
1118         continue()
1119       endif()
1120
1121       if(CPACK_RPM_PACKAGE_DEBUG)
1122         message("CPackRPM:Debug: using CPACK_RPM_PACKAGE_${_RPM_SPEC_HEADER}")
1123       endif()
1124
1125       set(CPACK_RPM_PACKAGE_${_RPM_SPEC_HEADER}_TMP ${CPACK_RPM_PACKAGE_${_RPM_SPEC_HEADER}})
1126     endif()
1127
1128     # Treat the RPM Spec keyword iff it has been properly defined
1129     if(DEFINED CPACK_RPM_PACKAGE_${_RPM_SPEC_HEADER}_TMP)
1130       # Transform NAME --> Name e.g. PROVIDES --> Provides
1131       # The Upper-case first letter and lowercase tail is the
1132       # appropriate value required in the final RPM spec file.
1133       string(SUBSTRING ${_RPM_SPEC_HEADER} 1 -1 _PACKAGE_HEADER_TAIL)
1134       string(TOLOWER "${_PACKAGE_HEADER_TAIL}" _PACKAGE_HEADER_TAIL)
1135       string(SUBSTRING ${_RPM_SPEC_HEADER} 0 1 _PACKAGE_HEADER_NAME)
1136       string(APPEND _PACKAGE_HEADER_NAME "${_PACKAGE_HEADER_TAIL}")
1137       # The following keywords require parentheses around the "pre" or "post" suffix in the final RPM spec file.
1138       set(SCRIPTS_REQUIREMENTS_LIST REQUIRES_PRE REQUIRES_POST REQUIRES_PREUN REQUIRES_POSTUN)
1139       list(FIND SCRIPTS_REQUIREMENTS_LIST ${_RPM_SPEC_HEADER} IS_SCRIPTS_REQUIREMENT_FOUND)
1140       if(NOT ${IS_SCRIPTS_REQUIREMENT_FOUND} EQUAL -1)
1141         string(REPLACE "_" "(" _PACKAGE_HEADER_NAME "${_PACKAGE_HEADER_NAME}")
1142         string(APPEND _PACKAGE_HEADER_NAME ")")
1143       endif()
1144       if(CPACK_RPM_PACKAGE_DEBUG)
1145         message("CPackRPM:Debug: User defined ${_PACKAGE_HEADER_NAME}:\n ${CPACK_RPM_PACKAGE_${_RPM_SPEC_HEADER}_TMP}")
1146       endif()
1147       set(TMP_RPM_${_RPM_SPEC_HEADER} "${_PACKAGE_HEADER_NAME}: ${CPACK_RPM_PACKAGE_${_RPM_SPEC_HEADER}_TMP}")
1148       unset(CPACK_RPM_PACKAGE_${_RPM_SPEC_HEADER}_TMP)
1149     endif()
1150   endforeach()
1151
1152   # CPACK_RPM_SPEC_INSTALL_POST
1153   # May be used to define a RPM post intallation script
1154   # for example setting it to "/bin/true" may prevent
1155   # rpmbuild from stripping binaries.
1156   if(CPACK_RPM_SPEC_INSTALL_POST)
1157     if(CPACK_RPM_PACKAGE_DEBUG)
1158       message("CPackRPM:Debug: User defined CPACK_RPM_SPEC_INSTALL_POST = ${CPACK_RPM_SPEC_INSTALL_POST}")
1159     endif()
1160     set(TMP_RPM_SPEC_INSTALL_POST "%define __spec_install_post ${CPACK_RPM_SPEC_INSTALL_POST}")
1161   endif()
1162
1163   # CPACK_RPM_REQUIRES_EXCLUDE_FROM
1164   # May be defined to keep the dependency generator from
1165   # scanning specific files or directories for deps.
1166   if(CPACK_RPM_REQUIRES_EXCLUDE_FROM)
1167     if(CPACK_RPM_PACKAGE_DEBUG)
1168       message("CPackRPM:Debug: User defined CPACK_RPM_REQUIRES_EXCLUDE_FROM = ${CPACK_RPM_REQUIRES_EXCLUDE_FROM}")
1169     endif()
1170     set(TMP_RPM_REQUIRES_EXCLUDE_FROM "%global __requires_exclude_from ${CPACK_RPM_REQUIRES_EXCLUDE_FROM}")
1171   endif()
1172
1173   # CPACK_RPM_POST_INSTALL_SCRIPT_FILE (or CPACK_RPM_<COMPONENT>_POST_INSTALL_SCRIPT_FILE)
1174   # CPACK_RPM_POST_UNINSTALL_SCRIPT_FILE (or CPACK_RPM_<COMPONENT>_POST_UNINSTALL_SCRIPT_FILE)
1175   # CPACK_RPM_POST_TRANS_SCRIPT_FILE (or CPACK_RPM_<COMPONENT>_POST_TRANS_SCRIPT_FILE)
1176   # May be used to embed a post installation/uninstallation/transaction script in the spec file.
1177   # The referred script file(s) will be read and directly
1178   # put after the %post or %postun or %posttrans section
1179   # ----------------------------------------------------------------
1180   # CPACK_RPM_PRE_INSTALL_SCRIPT_FILE (or CPACK_RPM_<COMPONENT>_PRE_INSTALL_SCRIPT_FILE)
1181   # CPACK_RPM_PRE_UNINSTALL_SCRIPT_FILE (or CPACK_RPM_<COMPONENT>_PRE_UNINSTALL_SCRIPT_FILE)
1182   # CPACK_RPM_PRE_TRANS_SCRIPT_FILE (or CPACK_RPM_<COMPONENT>_PRE_TRANS_SCRIPT_FILE)
1183   # May be used to embed a pre installation/uninstallation/transaction script in the spec file.
1184   # The referred script file(s) will be read and directly
1185   # put after the %pre or %preun or %pretrans section
1186   foreach(RPM_SCRIPT_FILE_TYPE_ "INSTALL" "UNINSTALL" "TRANS")
1187     foreach(RPM_SCRIPT_FILE_TIME_ "PRE" "POST")
1188       set("CPACK_RPM_${RPM_SCRIPT_FILE_TIME_}_${RPM_SCRIPT_FILE_TYPE_}_READ_FILE"
1189         "${CPACK_RPM_${RPM_SCRIPT_FILE_TIME_}_${RPM_SCRIPT_FILE_TYPE_}_SCRIPT_FILE}")
1190
1191       if(CPACK_RPM_PACKAGE_COMPONENT)
1192         cpack_rpm_variable_fallback("CPACK_RPM_${RPM_SCRIPT_FILE_TIME_}_${RPM_SCRIPT_FILE_TYPE_}_READ_FILE"
1193           "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_${RPM_SCRIPT_FILE_TIME_}_${RPM_SCRIPT_FILE_TYPE_}_SCRIPT_FILE"
1194           "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_${RPM_SCRIPT_FILE_TIME_}_${RPM_SCRIPT_FILE_TYPE_}_SCRIPT_FILE")
1195       endif()
1196
1197       # Handle file if it has been specified
1198       if(CPACK_RPM_${RPM_SCRIPT_FILE_TIME_}_${RPM_SCRIPT_FILE_TYPE_}_READ_FILE)
1199         if(EXISTS ${CPACK_RPM_${RPM_SCRIPT_FILE_TIME_}_${RPM_SCRIPT_FILE_TYPE_}_READ_FILE})
1200           file(READ ${CPACK_RPM_${RPM_SCRIPT_FILE_TIME_}_${RPM_SCRIPT_FILE_TYPE_}_READ_FILE}
1201             "CPACK_RPM_SPEC_${RPM_SCRIPT_FILE_TIME_}${RPM_SCRIPT_FILE_TYPE_}")
1202         else()
1203           message("CPackRPM:Warning: CPACK_RPM_${RPM_SCRIPT_FILE_TIME_}_${RPM_SCRIPT_FILE_TYPE_}_SCRIPT_FILE <${CPACK_RPM_${RPM_SCRIPT_FILE_TIME_}_${RPM_SCRIPT_FILE_TYPE_}_READ_FILE}> does not exists - ignoring")
1204         endif()
1205       else()
1206         # reset SPEC var value if no file has been specified
1207         # (either globally or component-wise)
1208         set("CPACK_RPM_SPEC_${RPM_SCRIPT_FILE_TIME_}${RPM_SCRIPT_FILE_TYPE_}" "")
1209       endif()
1210     endforeach()
1211   endforeach()
1212
1213   # CPACK_RPM_CHANGELOG_FILE
1214   # May be used to embed a changelog in the spec file.
1215   # The referred file will be read and directly put after the %changelog section
1216   if(CPACK_RPM_CHANGELOG_FILE)
1217     if(EXISTS ${CPACK_RPM_CHANGELOG_FILE})
1218       file(READ ${CPACK_RPM_CHANGELOG_FILE} CPACK_RPM_SPEC_CHANGELOG)
1219     else()
1220       message(SEND_ERROR "CPackRPM:Warning: CPACK_RPM_CHANGELOG_FILE <${CPACK_RPM_CHANGELOG_FILE}> does not exists - ignoring")
1221     endif()
1222   else()
1223     set(CPACK_RPM_SPEC_CHANGELOG "* Sun Jul 4 2010 Eric Noulard <eric.noulard@gmail.com> - ${CPACK_RPM_PACKAGE_VERSION}-${CPACK_RPM_PACKAGE_RELEASE}\n  Generated by CPack RPM (no Changelog file were provided)")
1224   endif()
1225
1226   # CPACK_RPM_SPEC_MORE_DEFINE
1227   # This is a generated spec rpm file spaceholder
1228   if(CPACK_RPM_SPEC_MORE_DEFINE)
1229     if(CPACK_RPM_PACKAGE_DEBUG)
1230       message("CPackRPM:Debug: User defined more define spec line specified:\n ${CPACK_RPM_SPEC_MORE_DEFINE}")
1231     endif()
1232   endif()
1233
1234   # Now we may create the RPM build tree structure
1235   set(CPACK_RPM_ROOTDIR "${CPACK_TOPLEVEL_DIRECTORY}")
1236   if(CPACK_RPM_PACKAGE_DEBUG)
1237     message("CPackRPM:Debug: Using CPACK_RPM_ROOTDIR=${CPACK_RPM_ROOTDIR}")
1238   endif()
1239   # Prepare RPM build tree
1240   file(MAKE_DIRECTORY ${CPACK_RPM_ROOTDIR})
1241   file(MAKE_DIRECTORY ${CPACK_RPM_ROOTDIR}/tmp)
1242   file(MAKE_DIRECTORY ${CPACK_RPM_ROOTDIR}/BUILD)
1243   file(MAKE_DIRECTORY ${CPACK_RPM_ROOTDIR}/RPMS)
1244   file(MAKE_DIRECTORY ${CPACK_RPM_ROOTDIR}/SOURCES)
1245   file(MAKE_DIRECTORY ${CPACK_RPM_ROOTDIR}/SPECS)
1246   file(MAKE_DIRECTORY ${CPACK_RPM_ROOTDIR}/SRPMS)
1247
1248   # it seems rpmbuild can't handle spaces in the path
1249   # neither escaping (as below) nor putting quotes around the path seem to help
1250   #string(REGEX REPLACE " " "\\\\ " CPACK_RPM_DIRECTORY "${CPACK_TOPLEVEL_DIRECTORY}")
1251   set(CPACK_RPM_DIRECTORY "${CPACK_TOPLEVEL_DIRECTORY}")
1252
1253   cpack_rpm_prepare_content_list()
1254
1255   # In component case, put CPACK_ABSOLUTE_DESTINATION_FILES_<COMPONENT>
1256   #                   into CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL
1257   #         otherwise, put CPACK_ABSOLUTE_DESTINATION_FILES
1258   # This must be done BEFORE the CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL handling
1259   if(CPACK_RPM_PACKAGE_COMPONENT)
1260     if(CPACK_ABSOLUTE_DESTINATION_FILES)
1261       cpack_rpm_variable_fallback("COMPONENT_FILES_TAG"
1262         "CPACK_ABSOLUTE_DESTINATION_FILES_${CPACK_RPM_PACKAGE_COMPONENT}"
1263         "CPACK_ABSOLUTE_DESTINATION_FILES_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}")
1264       set(CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL "${${COMPONENT_FILES_TAG}}")
1265       if(CPACK_RPM_PACKAGE_DEBUG)
1266         message("CPackRPM:Debug: Handling Absolute Destination Files: <${CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL}>")
1267         message("CPackRPM:Debug: in component = ${CPACK_RPM_PACKAGE_COMPONENT}")
1268       endif()
1269     endif()
1270   else()
1271     if(CPACK_ABSOLUTE_DESTINATION_FILES)
1272       set(CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL "${CPACK_ABSOLUTE_DESTINATION_FILES}")
1273     endif()
1274   endif()
1275
1276   # In component case, set CPACK_RPM_USER_FILELIST_INTERNAL with CPACK_RPM_<COMPONENT>_USER_FILELIST.
1277   set(CPACK_RPM_USER_FILELIST_INTERNAL "")
1278   if(CPACK_RPM_PACKAGE_COMPONENT)
1279     cpack_rpm_variable_fallback("CPACK_RPM_USER_FILELIST_INTERNAL"
1280       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_USER_FILELIST"
1281       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_USER_FILELIST")
1282
1283     if(CPACK_RPM_PACKAGE_DEBUG AND CPACK_RPM_USER_FILELIST_INTERNAL)
1284       message("CPackRPM:Debug: Handling User Filelist: <${CPACK_RPM_USER_FILELIST_INTERNAL}>")
1285       message("CPackRPM:Debug: in component = ${CPACK_RPM_PACKAGE_COMPONENT}")
1286     endif()
1287   elseif(CPACK_RPM_USER_FILELIST)
1288     set(CPACK_RPM_USER_FILELIST_INTERNAL "${CPACK_RPM_USER_FILELIST}")
1289   endif()
1290
1291   # Handle user specified file line list in CPACK_RPM_USER_FILELIST_INTERNAL
1292   # Remove those files from CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL
1293   #                      or CPACK_RPM_INSTALL_FILES,
1294   # hence it must be done before these auto-generated lists are processed.
1295   if(CPACK_RPM_USER_FILELIST_INTERNAL)
1296     if(CPACK_RPM_PACKAGE_DEBUG)
1297       message("CPackRPM:Debug: Handling User Filelist: <${CPACK_RPM_USER_FILELIST_INTERNAL}>")
1298     endif()
1299
1300     # Create CMake list from CPACK_RPM_INSTALL_FILES
1301     string(STRIP "${CPACK_RPM_INSTALL_FILES}" CPACK_RPM_INSTALL_FILES_LIST)
1302     string(REPLACE "\n" ";" CPACK_RPM_INSTALL_FILES_LIST
1303                             "${CPACK_RPM_INSTALL_FILES_LIST}")
1304     string(REPLACE "\"" "" CPACK_RPM_INSTALL_FILES_LIST
1305                             "${CPACK_RPM_INSTALL_FILES_LIST}")
1306
1307     set(CPACK_RPM_USER_INSTALL_FILES "")
1308     foreach(F IN LISTS CPACK_RPM_USER_FILELIST_INTERNAL)
1309       string(REGEX REPLACE "%[A-Za-z]+(\\([^()]*\\))? " "" F_PATH ${F})
1310       string(REGEX MATCH "(%[A-Za-z]+(\\([^()]*\\))? )*" F_PREFIX ${F})
1311       string(STRIP ${F_PREFIX} F_PREFIX)
1312
1313       if(CPACK_RPM_PACKAGE_DEBUG)
1314         message("CPackRPM:Debug: F_PREFIX=<${F_PREFIX}>, F_PATH=<${F_PATH}>")
1315       endif()
1316       if(F_PREFIX)
1317         string(APPEND F_PREFIX " ")
1318       endif()
1319       # Rebuild the user list file
1320       string(APPEND CPACK_RPM_USER_INSTALL_FILES "${F_PREFIX}\"${F_PATH}\"\n")
1321
1322       # Remove from CPACK_RPM_INSTALL_FILES and CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL
1323       list(REMOVE_ITEM CPACK_RPM_INSTALL_FILES_LIST ${F_PATH})
1324       # ABSOLUTE destination files list may not exists at all
1325       if (CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL)
1326         list(REMOVE_ITEM CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL ${F_PATH})
1327       endif()
1328     endforeach()
1329
1330     # Rebuild CPACK_RPM_INSTALL_FILES
1331     set(CPACK_RPM_INSTALL_FILES "")
1332     foreach(F IN LISTS CPACK_RPM_INSTALL_FILES_LIST)
1333       string(APPEND CPACK_RPM_INSTALL_FILES "\"${F}\"\n")
1334     endforeach()
1335   else()
1336     set(CPACK_RPM_USER_INSTALL_FILES "")
1337   endif()
1338
1339   if (CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL)
1340     if(CPACK_RPM_PACKAGE_DEBUG)
1341       message("CPackRPM:Debug: Handling Absolute Destination Files: ${CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL}")
1342     endif()
1343     # Remove trailing space
1344     string(STRIP "${CPACK_RPM_INSTALL_FILES}" CPACK_RPM_INSTALL_FILES_LIST)
1345     # Transform endline separated - string into CMake List
1346     string(REPLACE "\n" ";" CPACK_RPM_INSTALL_FILES_LIST "${CPACK_RPM_INSTALL_FILES_LIST}")
1347     # Remove unnecessary quotes
1348     string(REPLACE "\"" "" CPACK_RPM_INSTALL_FILES_LIST "${CPACK_RPM_INSTALL_FILES_LIST}")
1349     # Remove ABSOLUTE install file from INSTALL FILE LIST
1350     list(REMOVE_ITEM CPACK_RPM_INSTALL_FILES_LIST ${CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL})
1351     # Rebuild INSTALL_FILES
1352     set(CPACK_RPM_INSTALL_FILES "")
1353     foreach(F IN LISTS CPACK_RPM_INSTALL_FILES_LIST)
1354       string(APPEND CPACK_RPM_INSTALL_FILES "\"${F}\"\n")
1355     endforeach()
1356     # Build ABSOLUTE_INSTALL_FILES
1357     set(CPACK_RPM_ABSOLUTE_INSTALL_FILES "")
1358     foreach(F IN LISTS CPACK_ABSOLUTE_DESTINATION_FILES_INTERNAL)
1359       string(APPEND CPACK_RPM_ABSOLUTE_INSTALL_FILES "%config \"${F}\"\n")
1360     endforeach()
1361     if(CPACK_RPM_PACKAGE_DEBUG)
1362       message("CPackRPM:Debug: CPACK_RPM_ABSOLUTE_INSTALL_FILES=${CPACK_RPM_ABSOLUTE_INSTALL_FILES}")
1363       message("CPackRPM:Debug: CPACK_RPM_INSTALL_FILES=${CPACK_RPM_INSTALL_FILES}")
1364     endif()
1365   else()
1366     # reset vars in order to avoid leakage of value(s) from one component to another
1367     set(CPACK_RPM_ABSOLUTE_INSTALL_FILES "")
1368   endif()
1369
1370   cpack_rpm_variable_fallback("CPACK_RPM_DEBUGINFO_PACKAGE"
1371     "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_DEBUGINFO_PACKAGE"
1372     "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_DEBUGINFO_PACKAGE"
1373     "CPACK_RPM_DEBUGINFO_PACKAGE")
1374   if(CPACK_RPM_DEBUGINFO_PACKAGE OR (CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE AND NOT GENERATE_SPEC_PARTS))
1375     cpack_rpm_variable_fallback("CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX"
1376       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_BUILD_SOURCE_DIRS_PREFIX"
1377       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_BUILD_SOURCE_DIRS_PREFIX"
1378       "CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX")
1379     if(NOT CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX)
1380       set(CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX "/usr/src/debug/${CPACK_PACKAGE_FILE_NAME}${CPACK_RPM_PACKAGE_COMPONENT_PART_PATH}")
1381     endif()
1382
1383     # handle cases where path contains extra slashes (e.g. /a//b/ instead of
1384     # /a/b)
1385     get_filename_component(CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX
1386       "${CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX}" ABSOLUTE)
1387
1388     if(CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE AND GENERATE_SPEC_PARTS)
1389       file(WRITE "${CPACK_RPM_ROOTDIR}/SPECS/${CPACK_RPM_PACKAGE_COMPONENT}.files"
1390         "${CPACK_RPM_INSTALL_FILES}")
1391     else()
1392       if(CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE AND CPACK_RPM_PACKAGE_COMPONENT)
1393         # this part is only required by components packaging - with monolithic
1394         # packages we can be certain that there are no other components present
1395         # so CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE is a noop
1396         if(CPACK_RPM_DEBUGINFO_PACKAGE)
1397           # only add current package files to debuginfo list if debuginfo
1398           # generation is enabled for current package
1399           string(STRIP "${CPACK_RPM_INSTALL_FILES}" install_files_)
1400           string(REPLACE "\n" ";" install_files_ "${install_files_}")
1401           string(REPLACE "\"" "" install_files_ "${install_files_}")
1402         else()
1403           unset(install_files_)
1404         endif()
1405
1406         file(GLOB files_ "${CPACK_RPM_DIRECTORY}/SPECS/*.files")
1407
1408         foreach(f_ IN LISTS files_)
1409           file(READ "${f_}" tmp_)
1410           string(APPEND install_files_ ";${tmp_}")
1411         endforeach()
1412
1413         # if there were other components/groups so we need to move files from them
1414         # to current component otherwise those files won't be found
1415         file(GLOB components_ LIST_DIRECTORIES true RELATIVE
1416           "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}"
1417           "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}/*")
1418         foreach(component_ IN LISTS components_)
1419           string(TOUPPER "${component_}" component_dir_upper_)
1420           if(component_dir_upper_ STREQUAL CPACK_RPM_PACKAGE_COMPONENT_UPPER)
1421             # skip current component
1422             continue()
1423           endif()
1424
1425           file(GLOB_RECURSE files_for_move_ LIST_DIRECTORIES true RELATIVE
1426             "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}/${component_}"
1427             "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}/${component_}/*")
1428
1429           foreach(f_ IN LISTS files_for_move_)
1430             set(src_file_
1431               "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}/${component_}/${f_}")
1432
1433             if(IS_DIRECTORY "${src_file_}")
1434               file(MAKE_DIRECTORY "${WDIR}/${f_}")
1435               continue()
1436             endif()
1437
1438             get_filename_component(dir_path_ "${f_}" DIRECTORY)
1439
1440             # check that we are not overriding an existing file that doesn't
1441             # match the file that we want to copy
1442             if(EXISTS "${src_file_}" AND EXISTS "${WDIR}/${f_}")
1443               execute_process(
1444                   COMMAND ${CMAKE_COMMAND} -E compare_files "${src_file_}" "${WDIR}/${f_}"
1445                   RESULT_VARIABLE res_
1446                 )
1447               if(res_)
1448                 message(FATAL_ERROR "CPackRPM:Error: File on path '${WDIR}/${f_}'"
1449                   " already exists but is a different than the one in component"
1450                   " '${component_}'! Packages will not be generated.")
1451               endif()
1452             endif()
1453
1454             file(MAKE_DIRECTORY "${WDIR}/${dir_path_}")
1455             file(RENAME "${src_file_}"
1456               "${WDIR}/${f_}")
1457           endforeach()
1458         endforeach()
1459
1460         cpack_rpm_debugsymbol_check("${install_files_}" "${WDIR}")
1461       else()
1462         string(STRIP "${CPACK_RPM_INSTALL_FILES}" install_files_)
1463         string(REPLACE "\n" ";" install_files_ "${install_files_}")
1464         string(REPLACE "\"" "" install_files_ "${install_files_}")
1465
1466         cpack_rpm_debugsymbol_check("${install_files_}" "${WDIR}")
1467       endif()
1468
1469       if(TMP_DEBUGINFO_ADDITIONAL_SOURCES)
1470         set(TMP_RPM_DEBUGINFO "
1471 # Modified version of %%debug_package macro
1472 # defined in /usr/lib/rpm/macros as that one
1473 # can't handle injection of extra source files.
1474 %ifnarch noarch
1475 %global __debug_package 1
1476 %package debuginfo
1477 Summary: Debug information for package %{name}
1478 Group: Development/Debug
1479 AutoReqProv: 0
1480 %description debuginfo
1481 This package provides debug information for package %{name}.
1482 Debug information is useful when developing applications that use this
1483 package or when debugging this package.
1484 %files debuginfo -f debugfiles.list
1485 %defattr(-,root,root)
1486 ${TMP_DEBUGINFO_ADDITIONAL_SOURCES}
1487 %endif
1488 ")
1489       elseif(CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE)
1490         message(AUTHOR_WARNING "CPackRPM:Warning: debuginfo package was requested"
1491           " but will not be generated as no source files were found!")
1492       else()
1493         message(AUTHOR_WARNING "CPackRPM:Warning: debuginfo package was requested"
1494           " but will not be generated as no source files were found! Component: '"
1495           "${CPACK_RPM_PACKAGE_COMPONENT}'.")
1496       endif()
1497     endif()
1498   endif()
1499
1500   # Prepare install files
1501   cpack_rpm_prepare_install_files(
1502       "${CPACK_RPM_INSTALL_FILES}"
1503       "${WDIR}"
1504       "${RPM_USED_PACKAGE_PREFIXES}"
1505       "${CPACK_RPM_PACKAGE_RELOCATABLE}"
1506     )
1507
1508   # set default user and group
1509   foreach(_PERM_TYPE "USER" "GROUP")
1510     if(CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_DEFAULT_${_PERM_TYPE})
1511       set(TMP_DEFAULT_${_PERM_TYPE} "${CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_DEFAULT_${_PERM_TYPE}}")
1512     elseif(CPACK_RPM_DEFAULT_${_PERM_TYPE})
1513       set(TMP_DEFAULT_${_PERM_TYPE} "${CPACK_RPM_DEFAULT_${_PERM_TYPE}}")
1514     else()
1515       set(TMP_DEFAULT_${_PERM_TYPE} "root")
1516     endif()
1517   endforeach()
1518
1519   # set default file and dir permissions
1520   foreach(_PERM_TYPE "FILE" "DIR")
1521     if(CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_DEFAULT_${_PERM_TYPE}_PERMISSIONS)
1522       get_unix_permissions_octal_notation("CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_DEFAULT_${_PERM_TYPE}_PERMISSIONS" "TMP_DEFAULT_${_PERM_TYPE}_PERMISSIONS")
1523       set(_PERMISSIONS_VAR "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_DEFAULT_${_PERM_TYPE}_PERMISSIONS")
1524     elseif(CPACK_RPM_DEFAULT_${_PERM_TYPE}_PERMISSIONS)
1525       get_unix_permissions_octal_notation("CPACK_RPM_DEFAULT_${_PERM_TYPE}_PERMISSIONS" "TMP_DEFAULT_${_PERM_TYPE}_PERMISSIONS")
1526       set(_PERMISSIONS_VAR "CPACK_RPM_DEFAULT_${_PERM_TYPE}_PERMISSIONS")
1527     else()
1528       set(TMP_DEFAULT_${_PERM_TYPE}_PERMISSIONS "-")
1529     endif()
1530   endforeach()
1531
1532   # The name of the final spec file to be used by rpmbuild
1533   set(CPACK_RPM_BINARY_SPECFILE "${CPACK_RPM_ROOTDIR}/SPECS/${CPACK_RPM_PACKAGE_NAME}.spec")
1534
1535   # Print out some debug information if we were asked for that
1536   if(CPACK_RPM_PACKAGE_DEBUG)
1537      message("CPackRPM:Debug: CPACK_TOPLEVEL_DIRECTORY          = ${CPACK_TOPLEVEL_DIRECTORY}")
1538      message("CPackRPM:Debug: CPACK_TOPLEVEL_TAG                = ${CPACK_TOPLEVEL_TAG}")
1539      message("CPackRPM:Debug: CPACK_TEMPORARY_DIRECTORY         = ${CPACK_TEMPORARY_DIRECTORY}")
1540      message("CPackRPM:Debug: CPACK_OUTPUT_FILE_NAME            = ${CPACK_OUTPUT_FILE_NAME}")
1541      message("CPackRPM:Debug: CPACK_OUTPUT_FILE_PATH            = ${CPACK_OUTPUT_FILE_PATH}")
1542      message("CPackRPM:Debug: CPACK_PACKAGE_FILE_NAME           = ${CPACK_PACKAGE_FILE_NAME}")
1543      message("CPackRPM:Debug: CPACK_RPM_BINARY_SPECFILE         = ${CPACK_RPM_BINARY_SPECFILE}")
1544      message("CPackRPM:Debug: CPACK_PACKAGE_INSTALL_DIRECTORY   = ${CPACK_PACKAGE_INSTALL_DIRECTORY}")
1545      message("CPackRPM:Debug: CPACK_TEMPORARY_PACKAGE_FILE_NAME = ${CPACK_TEMPORARY_PACKAGE_FILE_NAME}")
1546   endif()
1547
1548   #
1549   # USER generated/provided spec file handling.
1550   #
1551
1552   # We can have a component specific spec file.
1553   if(CPACK_RPM_PACKAGE_COMPONENT)
1554     cpack_rpm_variable_fallback("CPACK_RPM_USER_BINARY_SPECFILE"
1555       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_USER_BINARY_SPECFILE"
1556       "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_USER_BINARY_SPECFILE")
1557   endif()
1558
1559   cpack_rpm_variable_fallback("CPACK_RPM_FILE_NAME"
1560     "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_FILE_NAME"
1561     "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_FILE_NAME"
1562     "CPACK_RPM_FILE_NAME")
1563   if(NOT CPACK_RPM_FILE_NAME STREQUAL "RPM-DEFAULT")
1564     if(CPACK_RPM_FILE_NAME)
1565       if(NOT CPACK_RPM_FILE_NAME MATCHES ".*\\.rpm")
1566         message(FATAL_ERROR "'${CPACK_RPM_FILE_NAME}' is not a valid RPM package file name as it must end with '.rpm'!")
1567       endif()
1568     else()
1569       # old file name format for back compatibility
1570       string(TOUPPER "${CPACK_RPM_MAIN_COMPONENT}"
1571         CPACK_RPM_MAIN_COMPONENT_UPPER)
1572
1573       if(CPACK_RPM_MAIN_COMPONENT_UPPER STREQUAL CPACK_RPM_PACKAGE_COMPONENT_UPPER)
1574         # this is the main component so ignore the component filename part
1575         set(CPACK_RPM_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}.rpm")
1576       else()
1577         set(CPACK_RPM_FILE_NAME "${CPACK_OUTPUT_FILE_NAME}")
1578       endif()
1579     endif()
1580     # else example:
1581     #set(CPACK_RPM_FILE_NAME "${CPACK_RPM_PACKAGE_NAME}-${CPACK_RPM_PACKAGE_VERSION}-${CPACK_RPM_PACKAGE_RELEASE}-${CPACK_RPM_PACKAGE_ARCHITECTURE}.rpm")
1582
1583     if(CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE AND GENERATE_SPEC_PARTS)
1584       string(TOLOWER "${CPACK_RPM_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}.*\\.rpm" expected_filename_)
1585
1586       file(WRITE "${CPACK_RPM_ROOTDIR}/SPECS/${CPACK_RPM_PACKAGE_COMPONENT}.rpm_name"
1587         "${expected_filename_};${CPACK_RPM_FILE_NAME}")
1588     elseif(NOT CPACK_RPM_DEBUGINFO_PACKAGE)
1589       set(FILE_NAME_DEFINE "%define _rpmfilename ${CPACK_RPM_FILE_NAME}")
1590     endif()
1591   endif()
1592
1593   if(CPACK_RPM_PACKAGE_SOURCES) # source rpm
1594     set(archive_name_ "${CPACK_RPM_PACKAGE_NAME}-${CPACK_RPM_PACKAGE_VERSION}")
1595
1596     execute_process(
1597         COMMAND ${CMAKE_COMMAND} -E tar "cfvz" "${CPACK_RPM_DIRECTORY}/SOURCES/${archive_name_}.tar.gz" "${CPACK_PACKAGE_FILE_NAME}"
1598         WORKING_DIRECTORY ${CPACK_RPM_DIRECTORY}
1599       )
1600     set(TMP_RPM_SOURCE "Source: ${archive_name_}.tar.gz")
1601
1602     if(CPACK_RPM_BUILDREQUIRES)
1603       set(TMP_RPM_BUILD_REQUIRES "BuildRequires: ${CPACK_RPM_BUILDREQUIRES}")
1604     endif()
1605
1606     # Disable debuginfo packages - srpm generates invalid packages due to
1607     # releasing control to cpack to generate binary packages.
1608     # Note however that this doesn't prevent cpack to generate debuginfo
1609     # packages when run from srpm with --rebuild.
1610     set(TMP_RPM_DISABLE_DEBUGINFO "%define debug_package %{nil}")
1611
1612     if(NOT CPACK_RPM_SOURCE_PKG_PACKAGING_INSTALL_PREFIX)
1613       set(CPACK_RPM_SOURCE_PKG_PACKAGING_INSTALL_PREFIX "/")
1614     endif()
1615
1616     set(TMP_RPM_BUILD
1617       "
1618 %build
1619 mkdir cpack_rpm_build_dir
1620 cd cpack_rpm_build_dir
1621 '${CMAKE_COMMAND}' ${CPACK_RPM_SOURCE_PKG_BUILD_PARAMS} -DCPACK_PACKAGING_INSTALL_PREFIX=${CPACK_RPM_SOURCE_PKG_PACKAGING_INSTALL_PREFIX} ../${CPACK_PACKAGE_FILE_NAME}
1622 make %{?_smp_mflags}" # %{?_smp_mflags} -> -j option
1623       )
1624     set(TMP_RPM_INSTALL
1625       "
1626 cd cpack_rpm_build_dir
1627 cpack -G RPM
1628 mv *.rpm %_rpmdir"
1629       )
1630     set(TMP_RPM_PREP "%setup -c")
1631
1632     set(RPMBUILD_FLAGS "-bs")
1633
1634      file(WRITE ${CPACK_RPM_BINARY_SPECFILE}.in
1635       "# Restore old style debuginfo creation for rpm >= 4.14.
1636 %undefine _debugsource_packages
1637 %undefine _debuginfo_subpackages
1638
1639 # -*- rpm-spec -*-
1640 BuildRoot:      %_topdir/\@CPACK_PACKAGE_FILE_NAME\@
1641 Summary:        \@CPACK_RPM_PACKAGE_SUMMARY\@
1642 Name:           \@CPACK_RPM_PACKAGE_NAME\@
1643 Version:        \@CPACK_RPM_PACKAGE_VERSION\@
1644 Release:        \@CPACK_RPM_PACKAGE_RELEASE\@
1645 License:        \@CPACK_RPM_PACKAGE_LICENSE\@
1646 Group:          \@CPACK_RPM_PACKAGE_GROUP\@
1647 Vendor:         \@CPACK_RPM_PACKAGE_VENDOR\@
1648
1649 \@TMP_RPM_SOURCE\@
1650 \@TMP_RPM_BUILD_REQUIRES\@
1651 \@TMP_RPM_BUILDARCH\@
1652 \@TMP_RPM_PREFIXES\@
1653
1654 \@TMP_RPM_DISABLE_DEBUGINFO\@
1655
1656 %define _rpmdir %_topdir/RPMS
1657 %define _srcrpmdir %_topdir/SRPMS
1658 \@FILE_NAME_DEFINE\@
1659 %define _unpackaged_files_terminate_build 0
1660 \@TMP_RPM_SPEC_INSTALL_POST\@
1661 \@TMP_RPM_REQUIRES_EXCLUDE_FROM\@
1662 \@CPACK_RPM_SPEC_MORE_DEFINE\@
1663 \@CPACK_RPM_COMPRESSION_TYPE_TMP\@
1664
1665 %description
1666 \@CPACK_RPM_PACKAGE_DESCRIPTION\@
1667
1668 # This is a shortcutted spec file generated by CMake RPM generator
1669 # we skip _install step because CPack does that for us.
1670 # We do only save CPack installed tree in _prepr
1671 # and then restore it in build.
1672 %prep
1673 \@TMP_RPM_PREP\@
1674
1675 \@TMP_RPM_BUILD\@
1676
1677 #p build
1678
1679 %install
1680 \@TMP_RPM_INSTALL\@
1681
1682 %clean
1683
1684 %changelog
1685 \@CPACK_RPM_SPEC_CHANGELOG\@
1686 "
1687     )
1688
1689   elseif(GENERATE_SPEC_PARTS) # binary rpm with single debuginfo package
1690
1691     set_spec_scripts("${CPACK_RPM_PACKAGE_NAME}")
1692
1693     file(WRITE ${CPACK_RPM_BINARY_SPECFILE}.in
1694         "# -*- rpm-spec -*-
1695 %package -n \@CPACK_RPM_PACKAGE_NAME\@
1696 Summary:        \@CPACK_RPM_PACKAGE_SUMMARY\@
1697 Version:        \@CPACK_RPM_PACKAGE_VERSION\@
1698 Release:        \@CPACK_RPM_PACKAGE_RELEASE\@
1699 License:        \@CPACK_RPM_PACKAGE_LICENSE\@
1700 Group:          \@CPACK_RPM_PACKAGE_GROUP\@
1701 Vendor:         \@CPACK_RPM_PACKAGE_VENDOR\@
1702
1703 \@TMP_RPM_URL\@
1704 \@TMP_RPM_REQUIRES\@
1705 \@TMP_RPM_REQUIRES_PRE\@
1706 \@TMP_RPM_REQUIRES_POST\@
1707 \@TMP_RPM_REQUIRES_PREUN\@
1708 \@TMP_RPM_REQUIRES_POSTUN\@
1709 \@TMP_RPM_PROVIDES\@
1710 \@TMP_RPM_OBSOLETES\@
1711 \@TMP_RPM_CONFLICTS\@
1712 \@TMP_RPM_SUGGESTS\@
1713 \@TMP_RPM_AUTOPROV\@
1714 \@TMP_RPM_AUTOREQ\@
1715 \@TMP_RPM_AUTOREQPROV\@
1716 \@TMP_RPM_BUILDARCH\@
1717 \@TMP_RPM_PREFIXES\@
1718 \@TMP_RPM_EPOCH\@
1719
1720 %description -n \@CPACK_RPM_PACKAGE_NAME\@
1721 \@CPACK_RPM_PACKAGE_DESCRIPTION\@
1722
1723 \@post_\@
1724 \@posttrans_\@
1725 \@postun_\@
1726 \@pre_\@
1727 \@pretrans_\@
1728 \@preun_\@
1729
1730 %files -n \@CPACK_RPM_PACKAGE_NAME\@
1731 %defattr(\@TMP_DEFAULT_FILE_PERMISSIONS\@,\@TMP_DEFAULT_USER\@,\@TMP_DEFAULT_GROUP\@,\@TMP_DEFAULT_DIR_PERMISSIONS\@)
1732 \@CPACK_RPM_INSTALL_FILES\@
1733 \@CPACK_RPM_ABSOLUTE_INSTALL_FILES\@
1734 \@CPACK_RPM_USER_INSTALL_FILES\@
1735 "
1736     )
1737
1738   else()  # binary rpm
1739     if(CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE)
1740       # find generated spec file and take its name
1741       file(GLOB spec_files_ "${CPACK_RPM_DIRECTORY}/SPECS/*.spec")
1742
1743       foreach(f_ IN LISTS spec_files_)
1744         file(READ "${f_}" tmp_)
1745         string(APPEND TMP_OTHER_COMPONENTS "\n${tmp_}\n")
1746       endforeach()
1747     endif()
1748
1749     # We should generate a USER spec file template:
1750     #  - either because the user asked for it : CPACK_RPM_GENERATE_USER_BINARY_SPECFILE_TEMPLATE
1751     #  - or the user did not provide one : NOT CPACK_RPM_USER_BINARY_SPECFILE
1752     set(RPMBUILD_FLAGS "-bb")
1753     if(CPACK_RPM_GENERATE_USER_BINARY_SPECFILE_TEMPLATE OR NOT CPACK_RPM_USER_BINARY_SPECFILE)
1754
1755       set_spec_scripts("")
1756
1757       file(WRITE ${CPACK_RPM_BINARY_SPECFILE}.in
1758         "# Restore old style debuginfo creation for rpm >= 4.14.
1759 %undefine _debugsource_packages
1760 %undefine _debuginfo_subpackages
1761
1762 # -*- rpm-spec -*-
1763 BuildRoot:      %_topdir/\@CPACK_PACKAGE_FILE_NAME\@\@CPACK_RPM_PACKAGE_COMPONENT_PART_PATH\@
1764 Summary:        \@CPACK_RPM_PACKAGE_SUMMARY\@
1765 Name:           \@CPACK_RPM_PACKAGE_NAME\@
1766 Version:        \@CPACK_RPM_PACKAGE_VERSION\@
1767 Release:        \@CPACK_RPM_PACKAGE_RELEASE\@
1768 License:        \@CPACK_RPM_PACKAGE_LICENSE\@
1769 Group:          \@CPACK_RPM_PACKAGE_GROUP\@
1770 Vendor:         \@CPACK_RPM_PACKAGE_VENDOR\@
1771
1772 \@TMP_RPM_URL\@
1773 \@TMP_RPM_REQUIRES\@
1774 \@TMP_RPM_REQUIRES_PRE\@
1775 \@TMP_RPM_REQUIRES_POST\@
1776 \@TMP_RPM_REQUIRES_PREUN\@
1777 \@TMP_RPM_REQUIRES_POSTUN\@
1778 \@TMP_RPM_PROVIDES\@
1779 \@TMP_RPM_OBSOLETES\@
1780 \@TMP_RPM_CONFLICTS\@
1781 \@TMP_RPM_SUGGESTS\@
1782 \@TMP_RPM_AUTOPROV\@
1783 \@TMP_RPM_AUTOREQ\@
1784 \@TMP_RPM_AUTOREQPROV\@
1785 \@TMP_RPM_BUILDARCH\@
1786 \@TMP_RPM_PREFIXES\@
1787 \@TMP_RPM_EPOCH\@
1788
1789 \@TMP_RPM_DEBUGINFO\@
1790
1791 %define _rpmdir %_topdir/RPMS
1792 %define _srcrpmdir %_topdir/SRPMS
1793 \@FILE_NAME_DEFINE\@
1794 %define _unpackaged_files_terminate_build 0
1795 \@TMP_RPM_SPEC_INSTALL_POST\@
1796 \@TMP_RPM_REQUIRES_EXCLUDE_FROM\@
1797 \@CPACK_RPM_SPEC_MORE_DEFINE\@
1798 \@CPACK_RPM_COMPRESSION_TYPE_TMP\@
1799
1800 %description
1801 \@CPACK_RPM_PACKAGE_DESCRIPTION\@
1802
1803 # This is a shortcutted spec file generated by CMake RPM generator
1804 # we skip _install step because CPack does that for us.
1805 # We do only save CPack installed tree in _prepr
1806 # and then restore it in build.
1807 %prep
1808 mv $RPM_BUILD_ROOT %_topdir/tmpBBroot
1809
1810 %install
1811 if [ -e $RPM_BUILD_ROOT ];
1812 then
1813   rm -rf $RPM_BUILD_ROOT
1814 fi
1815 mv %_topdir/tmpBBroot $RPM_BUILD_ROOT
1816
1817 \@TMP_RPM_DEBUGINFO_INSTALL\@
1818
1819 %clean
1820
1821 \@post_\@
1822 \@posttrans_\@
1823 \@postun_\@
1824 \@pre_\@
1825 \@pretrans_\@
1826 \@preun_\@
1827
1828 %files
1829 %defattr(\@TMP_DEFAULT_FILE_PERMISSIONS\@,\@TMP_DEFAULT_USER\@,\@TMP_DEFAULT_GROUP\@,\@TMP_DEFAULT_DIR_PERMISSIONS\@)
1830 \@CPACK_RPM_INSTALL_FILES\@
1831 \@CPACK_RPM_ABSOLUTE_INSTALL_FILES\@
1832 \@CPACK_RPM_USER_INSTALL_FILES\@
1833
1834 %changelog
1835 \@CPACK_RPM_SPEC_CHANGELOG\@
1836
1837 \@TMP_OTHER_COMPONENTS\@
1838 "
1839       )
1840     endif()
1841
1842     # Stop here if we were asked to only generate a template USER spec file
1843     # The generated file may then be used as a template by user who wants
1844     # to customize their own spec file.
1845     if(CPACK_RPM_GENERATE_USER_BINARY_SPECFILE_TEMPLATE)
1846       message(FATAL_ERROR "CPackRPM: STOP here Generated USER binary spec file template is: ${CPACK_RPM_BINARY_SPECFILE}.in")
1847     endif()
1848   endif()
1849
1850   # After that we may either use a user provided spec file
1851   # or generate one using appropriate variables value.
1852   if(CPACK_RPM_USER_BINARY_SPECFILE)
1853     # User may have specified SPECFILE just use it
1854     message("CPackRPM: Will use USER specified spec file: ${CPACK_RPM_USER_BINARY_SPECFILE}")
1855     # The user provided file is processed for @var replacement
1856     configure_file(${CPACK_RPM_USER_BINARY_SPECFILE} ${CPACK_RPM_BINARY_SPECFILE} @ONLY)
1857   else()
1858     # No User specified spec file, will use the generated spec file
1859     message("CPackRPM: Will use GENERATED spec file: ${CPACK_RPM_BINARY_SPECFILE}")
1860     # Note the just created file is processed for @var replacement
1861     configure_file(${CPACK_RPM_BINARY_SPECFILE}.in ${CPACK_RPM_BINARY_SPECFILE} @ONLY)
1862   endif()
1863
1864   if(NOT GENERATE_SPEC_PARTS) # generate package
1865     if(RPMBUILD_EXECUTABLE)
1866       # Now call rpmbuild using the SPECFILE
1867       execute_process(
1868         COMMAND "${RPMBUILD_EXECUTABLE}" ${RPMBUILD_FLAGS}
1869                 --define "_topdir ${CPACK_RPM_DIRECTORY}"
1870                 --buildroot "%_topdir/${CPACK_PACKAGE_FILE_NAME}${CPACK_RPM_PACKAGE_COMPONENT_PART_PATH}"
1871                 --target "${CPACK_RPM_PACKAGE_ARCHITECTURE}"
1872                 "${CPACK_RPM_BINARY_SPECFILE}"
1873         WORKING_DIRECTORY "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}${CPACK_RPM_PACKAGE_COMPONENT_PART_PATH}"
1874         RESULT_VARIABLE CPACK_RPMBUILD_EXEC_RESULT
1875         ERROR_FILE "${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild${CPACK_RPM_PACKAGE_NAME}.err"
1876         OUTPUT_FILE "${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild${CPACK_RPM_PACKAGE_NAME}.out")
1877       if(CPACK_RPM_PACKAGE_DEBUG OR CPACK_RPMBUILD_EXEC_RESULT)
1878         file(READ ${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild${CPACK_RPM_PACKAGE_NAME}.err RPMBUILDERR)
1879         file(READ ${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild${CPACK_RPM_PACKAGE_NAME}.out RPMBUILDOUT)
1880         message("CPackRPM:Debug: You may consult rpmbuild logs in: ")
1881         message("CPackRPM:Debug:    - ${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild${CPACK_RPM_PACKAGE_NAME}.err")
1882         message("CPackRPM:Debug: *** ${RPMBUILDERR} ***")
1883         message("CPackRPM:Debug:    - ${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild${CPACK_RPM_PACKAGE_NAME}.out")
1884         message("CPackRPM:Debug: *** ${RPMBUILDOUT} ***")
1885       endif()
1886     else()
1887       if(ALIEN_EXECUTABLE)
1888         message(FATAL_ERROR "RPM packaging through alien not done (yet)")
1889       endif()
1890     endif()
1891
1892     # find generated rpm files and take their names
1893     file(GLOB_RECURSE GENERATED_FILES "${CPACK_RPM_DIRECTORY}/RPMS/*.rpm"
1894       "${CPACK_RPM_DIRECTORY}/SRPMS/*.rpm")
1895
1896     if(NOT GENERATED_FILES)
1897       message(FATAL_ERROR "RPM package was not generated! ${CPACK_RPM_DIRECTORY}")
1898     endif()
1899
1900     unset(expected_filenames_)
1901     unset(filenames_)
1902     if(CPACK_RPM_DEBUGINFO_PACKAGE AND NOT CPACK_RPM_FILE_NAME STREQUAL "RPM-DEFAULT")
1903       list(APPEND expected_filenames_
1904         "${CPACK_RPM_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}.*\\.rpm")
1905       list(APPEND filenames_ "${CPACK_RPM_FILE_NAME}")
1906     endif()
1907
1908     if(CPACK_RPM_DEBUGINFO_PACKAGE)
1909       cpack_rpm_variable_fallback("CPACK_RPM_DEBUGINFO_FILE_NAME"
1910         "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT}_DEBUGINFO_FILE_NAME"
1911         "CPACK_RPM_${CPACK_RPM_PACKAGE_COMPONENT_UPPER}_DEBUGINFO_FILE_NAME"
1912         "CPACK_RPM_DEBUGINFO_FILE_NAME")
1913
1914       if(CPACK_RPM_DEBUGINFO_FILE_NAME AND
1915         NOT CPACK_RPM_DEBUGINFO_FILE_NAME STREQUAL "RPM-DEFAULT")
1916         list(APPEND expected_filenames_
1917           "${CPACK_RPM_PACKAGE_NAME}-debuginfo-${CPACK_PACKAGE_VERSION}.*\\.rpm")
1918         string(REPLACE "@cpack_component@" "${CPACK_RPM_PACKAGE_COMPONENT}"
1919           CPACK_RPM_DEBUGINFO_FILE_NAME "${CPACK_RPM_DEBUGINFO_FILE_NAME}")
1920         list(APPEND filenames_ "${CPACK_RPM_DEBUGINFO_FILE_NAME}")
1921       endif()
1922     endif()
1923
1924     # check if other files have to be renamed
1925     file(GLOB rename_files_ "${CPACK_RPM_DIRECTORY}/SPECS/*.rpm_name")
1926     if(rename_files_)
1927       foreach(f_ IN LISTS rename_files_)
1928         file(READ "${f_}" tmp_)
1929         list(GET tmp_ 0 efn_)
1930         list(APPEND expected_filenames_ "${efn_}")
1931         list(GET tmp_ 1 fn_)
1932         list(APPEND filenames_ "${fn_}")
1933       endforeach()
1934     endif()
1935
1936     if(expected_filenames_)
1937       foreach(F IN LISTS GENERATED_FILES)
1938         unset(matched_)
1939         foreach(expected_ IN LISTS expected_filenames_)
1940           if(F MATCHES ".*/${expected_}")
1941             list(FIND expected_filenames_ "${expected_}" idx_)
1942             list(GET filenames_ ${idx_} filename_)
1943             get_filename_component(FILE_PATH "${F}" DIRECTORY)
1944             file(RENAME "${F}" "${FILE_PATH}/${filename_}")
1945             list(APPEND new_files_list_ "${FILE_PATH}/${filename_}")
1946             set(matched_ "YES")
1947
1948             break()
1949           endif()
1950         endforeach()
1951
1952         if(NOT matched_)
1953           list(APPEND new_files_list_ "${F}")
1954         endif()
1955       endforeach()
1956
1957       set(GENERATED_FILES "${new_files_list_}")
1958     endif()
1959   endif()
1960
1961   set(GEN_CPACK_OUTPUT_FILES "${GENERATED_FILES}" PARENT_SCOPE)
1962
1963   if(CPACK_RPM_PACKAGE_DEBUG)
1964      message("CPackRPM:Debug: GEN_CPACK_OUTPUT_FILES = ${GENERATED_FILES}")
1965   endif()
1966 endfunction()
1967
1968 cpack_rpm_generate_package()
1969
1970 cmake_policy(POP)