ParaViewMacros.cmake 18.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
# File defining miscellaneous macros

#------------------------------------------------------------------------------
# GENERATE_QT_RESOURCE_FROM_FILES can be used to generate a Qt resource file
# from a given set of files.
# ARGUMENTS:
# resource_file: IN : full pathname of the qrc file to generate. 
# resource_prefix: IN : the name used in the "prefix" attribute for the
#                       generated qrc file.
# file_list: IN : list of files to be added into the resource file.
#------------------------------------------------------------------------------
MACRO(GENERATE_QT_RESOURCE_FROM_FILES resource_file resource_prefix file_list)
  SET (pq_resource_file_contents "<RCC>\n  <qresource prefix=\"${resource_prefix}\">\n")
  GET_FILENAME_COMPONENT(current_directory ${resource_file} PATH)
  FOREACH (resource ${file_list})
    GET_FILENAME_COMPONENT(alias ${resource} NAME)
    GET_FILENAME_COMPONENT(resource ${resource} ABSOLUTE)
    FILE(RELATIVE_PATH resource "${current_directory}" "${resource}")
    FILE(TO_NATIVE_PATH "${resource}" resource)
    SET (pq_resource_file_contents
      "${pq_resource_file_contents}    <file alias=\"${alias}\">${resource}</file>\n")
  ENDFOREACH (resource)
  SET (pq_resource_file_contents
    "${pq_resource_file_contents}  </qresource>\n</RCC>\n")

  # Generate the resource file.
  FILE (WRITE "${resource_file}" "${pq_resource_file_contents}")
ENDMACRO(GENERATE_QT_RESOURCE_FROM_FILES)

#----------------------------------------------------------------------------
# PV_PARSE_ARGUMENTS is a macro useful for writing macros that take a key-word
# style arguments.
#----------------------------------------------------------------------------
MACRO(PV_PARSE_ARGUMENTS prefix arg_names option_names)
  SET(DEFAULT_ARGS)
  FOREACH(arg_name ${arg_names})    
    SET(${prefix}_${arg_name})
  ENDFOREACH(arg_name)
  FOREACH(option ${option_names})
    SET(${prefix}_${option} FALSE)
  ENDFOREACH(option)

  SET(current_arg_name DEFAULT_ARGS)
  SET(current_arg_list)
  FOREACH(arg ${ARGN})            
    SET(larg_names ${arg_names})    
    LIST(FIND larg_names "${arg}" is_arg_name)                   
    IF (is_arg_name GREATER -1)
      SET(${prefix}_${current_arg_name} ${current_arg_list})
      SET(current_arg_name ${arg})
      SET(current_arg_list)
    ELSE (is_arg_name GREATER -1)
      SET(loption_names ${option_names})    
      LIST(FIND loption_names "${arg}" is_option)            
      IF (is_option GREATER -1)
       SET(${prefix}_${arg} TRUE)
      ELSE (is_option GREATER -1)
       SET(current_arg_list ${current_arg_list} ${arg})
      ENDIF (is_option GREATER -1)
    ENDIF (is_arg_name GREATER -1)
  ENDFOREACH(arg)
  SET(${prefix}_${current_arg_name} ${current_arg_list})
ENDMACRO(PV_PARSE_ARGUMENTS)
64 65 66 67 68 69 70 71 72

#----------------------------------------------------------------------------
# Macro for setting values if a user did not overwrite them
#----------------------------------------------------------------------------
MACRO(pv_set_if_not_set name value)
  IF(NOT DEFINED "${name}")
    SET(${name} "${value}")
  ENDIF(NOT DEFINED "${name}")
ENDMACRO(pv_set_if_not_set)
73

74 75 76 77 78 79 80 81
#----------------------------------------------------------------------------
# When installing system libraries, on non-windows machines, the CMake variable
# pointing to the library may be a sym-link, in which case we don't simply want
# to install the symlink, but the actual library. This macro takes care of that.
# Use it for installing system libraries. Call this only on unix boxes.
FUNCTION (pv_install_library libpath dest component)
  IF (NOT WIN32)
    GET_FILENAME_COMPONENT(dir_tmp ${libpath} PATH)
82 83 84 85 86 87 88 89 90 91 92
    SET(name_tmp)
    # libs symlinks are always named lib.*.dylib on mac
    # libs symlinks are always named lib.so.* on linux
    IF (APPLE)
      GET_FILENAME_COMPONENT(name_tmp ${libpath} NAME_WE)
      FILE(GLOB lib_list "${dir_tmp}/${name_tmp}*")
    ELSE (APPLE)
      GET_FILENAME_COMPONENT(dir_tmp ${libpath} PATH)
      GET_FILENAME_COMPONENT(name_tmp ${libpath} NAME)
      FILE(GLOB lib_list RELATIVE "${dir_tmp}" "${libpath}*")
    ENDIF (APPLE)
93 94 95 96 97 98 99 100
    INSTALL(CODE "
          MESSAGE(STATUS \"Installing ${name_tmp}\")
          EXECUTE_PROCESS (WORKING_DIRECTORY ${dir_tmp}
               COMMAND tar c ${lib_list}
               COMMAND tar -xC \${CMAKE_INSTALL_PREFIX}/${dest})
               " COMPONENT ${component})
  ENDIF (NOT WIN32)
ENDFUNCTION (pv_install_library)
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128

#----------------------------------------------------------------------------
# Function for adding an executable with support for shared forwarding.
# Typically, one just uses ADD_EXECUTABLE to add an executable target. However
# on linuxes when rpath is off, and shared libararies are on, to over come the
# need for setting the LD_LIBRARY_PATH, we use shared-forwarding. This macro
# makes it easier to employ shared forwarding if needed. 
# ARGUMENTS:
# out_real_exe_suffix -- (out) suffix to be added to the exe-target to locate the
#                     real executable target when shared forwarding is employed.
#                     This is empty when shared forwarding is not needed.
# exe_name        -- (in)  exe target name i.e. the first argument to
#                    ADD_EXECUTABLE.
# Any remaining arguments are simply passed on to the ADD_EXECUTABLE call.
# While writing install rules for this executable. One typically does the
# following.
#   INSTALL(TARGETS exe_name
#           DESTINATION "bin"
#           COMPONENT Runtime)
#   IF (pv_exe_suffix)
#     # Shared forwarding enabled.
#     INSTALL(TARGETS exe_name${out_real_exe_suffix}
#             DESTINATION "lib"
#             COMPONENT Runtime)
#   ENDIF (pv_exe_suffix)
#----------------------------------------------------------------------------
FUNCTION (add_executable_with_forwarding
            out_real_exe_suffix
129 130
            exe_name
            )
131 132 133 134 135 136
  if (NOT DEFINED PV_INSTALL_LIB_DIR)
    MESSAGE(FATAL_ERROR
      "PV_INSTALL_LIB_DIR variable must be set before calling add_executable_with_forwarding"
    )
  endif (NOT DEFINED PV_INSTALL_LIB_DIR)

137 138 139 140 141 142 143 144 145 146 147 148 149 150
  add_executable_with_forwarding2(out_var "" "" 
    ${PV_INSTALL_LIB_DIR}
    ${exe_name} ${ARGN})
  set (${out_real_exe_suffix} "${out_var}" PARENT_SCOPE)
ENDFUNCTION(add_executable_with_forwarding)

#----------------------------------------------------------------------------
FUNCTION (add_executable_with_forwarding2
            out_real_exe_suffix
            extra_build_dirs
            extra_install_dirs
            install_lib_dir
            exe_name
            )
151

152 153 154 155 156 157 158 159 160
  SET(mac_bundle)
  IF (APPLE)
    set (largs ${ARGN})
    LIST (FIND largs "MACOSX_BUNDLE" mac_bundle_index)
    IF (mac_bundle_index GREATER -1)
      SET (mac_bundle TRUE)
    ENDIF (mac_bundle_index GREATER -1)
  ENDIF (APPLE)

161
  SET(PV_EXE_SUFFIX)
162
  IF (BUILD_SHARED_LIBS AND NOT mac_bundle)
163
    IF(NOT WIN32)
164 165 166 167
      SET(exe_output_path ${EXECUTABLE_OUTPUT_PATH})
      IF (NOT EXECUTABLE_OUTPUT_PATH)
        SET (exe_output_path ${CMAKE_BINARY_DIR})
      ENDIF (NOT EXECUTABLE_OUTPUT_PATH)
168
      SET(PV_EXE_SUFFIX -real)
169 170
      SET(PV_FORWARD_DIR_BUILD "${exe_output_path}")
      SET(PV_FORWARD_DIR_INSTALL "../${install_lib_dir}")
171 172
      SET(PV_FORWARD_PATH_BUILD "\"${PV_FORWARD_DIR_BUILD}\"")
      SET(PV_FORWARD_PATH_INSTALL "\"${PV_FORWARD_DIR_INSTALL}\"")
173 174 175 176 177 178 179
      FOREACH(dir ${extra_build_dirs})
        SET (PV_FORWARD_PATH_BUILD "${PV_FORWARD_PATH_BUILD},\"${dir}\"")
      ENDFOREACH(dir)
      FOREACH(dir ${extra_install_dirs})
        SET (PV_FORWARD_PATH_INSTALL "${PV_FORWARD_PATH_INSTALL},\"${dir}\"")
      ENDFOREACH(dir)

180
      SET(PV_FORWARD_EXE ${exe_name})
181
      CONFIGURE_FILE(
182
        ${ParaView_CMAKE_DIR}/pv-forward.c.in
183 184 185 186
        ${CMAKE_CURRENT_BINARY_DIR}/${exe_name}-forward.c
        @ONLY IMMEDIATE)
      add_executable(${exe_name}
        ${CMAKE_CURRENT_BINARY_DIR}/${exe_name}-forward.c)
187 188
      set_target_properties(${exe_name} PROPERTIES
        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/launcher)
189 190
      ADD_DEPENDENCIES(${exe_name} ${exe_name}${PV_EXE_SUFFIX})
    ENDIF(NOT WIN32)
191
  ENDIF (BUILD_SHARED_LIBS AND NOT mac_bundle)
192 193

  add_executable(${exe_name}${PV_EXE_SUFFIX} ${ARGN})
194
  set_target_properties(${exe_name}${PV_EXE_SUFFIX} PROPERTIES
195
        OUTPUT_NAME ${exe_name})
196 197

  set (${out_real_exe_suffix} "${PV_EXE_SUFFIX}" PARENT_SCOPE)
198
ENDFUNCTION (add_executable_with_forwarding2)
199
          
200 201 202 203 204 205 206 207 208 209
#########################################################################
# Function to compile a proto file to generate a .h and .cc file
# Arguments:
# out_cpp_file_variable: variable that gets set with the full path to output file
# in_proto_file: full path to input file (e.g. ${CMAKE_CURRENT_SOURCE_DIR}/foo.pb)

FUNCTION (protobuf_generate out_cpp_file in_proto_file)
  GET_FILENAME_COMPONENT(basename ${in_proto_file} NAME_WE)
  GET_FILENAME_COMPONENT(absolute ${in_proto_file} ABSOLUTE)
  GET_FILENAME_COMPONENT(path ${absolute} PATH)
210
  SET (out_file ${CMAKE_CURRENT_BINARY_DIR}/${basename}.pb.h)
211
  SET(${out_cpp_file}  ${out_file} PARENT_SCOPE)
212
  ADD_CUSTOM_COMMAND(
213
    OUTPUT ${out_file}
214
    COMMAND protoc_compiler
215
      --cpp_out=dllexport_decl=VTK_PROTOBUF_EXPORT:${CMAKE_CURRENT_BINARY_DIR}
216
      --proto_path ${path} ${absolute}
217 218 219
    DEPENDS ${in_proto_file} protoc_compiler
  )
ENDFUNCTION (protobuf_generate)
220

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
#########################################################################
# Function to generate header file from any file(s). Support ASCII as well as
# binary files.
# Usage:
# generate_header(name
#                 [PREFIX prefix_text]
#                 [SUFFIX suffix_text]
#                 [VARIABLE variablename]
#                 [BINARY]
#                 FILES <list-of-files>
# name :- name of the header file e.g. ${CMAKE_CURRENT_BINARY_DIR}/FooBar.h
# PREFIX :- (optional) when specified, used as the prefix for the generated
#           function/variable names.
# SUFFIX :- (optional) when specified, used as the suffix for the generated
#           function/variable names.
# BINARY :-(optional) when specified, all files are treated as binary and
#           encoded using base64.
# VARIABLE :- (optional) when specified, all the generate functions used to
#             access the compiled files are listed.
# FILES   :- list of files to compile in.
241
#------------------------------------------------------------------------------
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
function(generate_header name)
  pv_parse_arguments(arg
    "PREFIX;SUFFIX;VARIABLE;FILES"
    "BINARY"
    ${ARGN}
    )

  if (NOT PARAVIEW_PROCESS_XML_EXECUTABLE)
    MESSAGE (FATAL_ERROR
      "No PARAVIEW_PROCESS_XML_EXECUTABLE specified
      Could not locate kwProcessXML executable")
  endif ()

  set (function_names)
  set (input_files)
  set (have_xmls)
  foreach (input_file ${arg_FILES})
    get_filename_component(absolute_file "${input_file}" ABSOLUTE)
    get_filename_component(file_name "${absolute_file}" NAME_WE)
    list (APPEND function_names "${arg_PREFIX}${file_name}${arg_SUFFIX}")
    list (APPEND input_files "${absolute_file}")
    set (have_xmls TRUE)
  endforeach()

  set (base_64)
  if (arg_BINARY)
    set (base_64 "-base64")
  endif()

  if (have_xmls)
    add_custom_command(
      OUTPUT "${name}"
      COMMAND "${PARAVIEW_PROCESS_XML_EXECUTABLE}"
              ${base_64}
              ${name}
              \"${arg_PREFIX}\" 
              \"${arg_SUFFIX}\"
              \"${arg_SUFFIX}\"
              ${input_files}
      DEPENDS ${arg_FILES}
              ${PARAVIEW_PROCESS_XML_EXECUTABLE}
     ) 
  endif ()

  if (DEFINED arg_VARIABLE)
    set (${arg_VARIABLE} ${function_names} PARENT_SCOPE)
  endif()
endfunction()


Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
292
# GENERATE_HTMLS_FROM_XMLS can be used to generate HTML files for
293 294
# from a given list of xml files that correspond to server manager xmls.
# ARGUMENTS:
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
295
# output_files: OUT: variables set to the output files
296 297 298
# xmls: IN : full pathnames to xml files.
# output_dir : IN : full path to output directory where to generate the htmls.
#------------------------------------------------------------------------------
299
function (generate_htmls_from_xmls output_files xmls gui_xmls output_dir)
300
  # create a string from the xmls list to pass
301 302 303
  # since this list needs to be passed as an argument, we cannot escape the ";".
  # generate_proxydocumentation.cmake has code to convert these strings back to
  # lists.
304 305
  set (xmls_string)
  foreach (xml ${xmls})
306
    get_filename_component(xml "${xml}" ABSOLUTE)
307 308 309 310 311
    set (xmls_string "${xmls_string}${xml}+")
  endforeach()
  
  set (gui_xmls_string)
  foreach (gui_xml ${gui_xmls})
312
    get_filename_component(gui_xml "${gui_xml}" ABSOLUTE)
313 314
    set (gui_xmls_string "${gui_xmls_string}${gui_xml}+")
  endforeach()
315

316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
  set (all_xmls ${xmls} ${gui_xmls})
  list (GET all_xmls 0 first_xml)
  if (NOT first_xml)
    message(FATAL_ERROR "No xml specified!!!")
  endif()

  find_program(QT_XMLPATTERNS_EXECUTABLE
    xmlpatterns
    PATHS "${QT_BINARY_DIR}"
    DOC "xmlpatterns used to generate html from Proxy documentation.")
  mark_as_advanced(QT_XMLPATTERNS_EXECUTABLE)

  if (NOT EXISTS ${QT_XMLPATTERNS_EXECUTABLE})
    message(WARNING "Valid QT_XMLPATTERNS_EXECUTABLE not specified.")
  endif()

332
  add_custom_command(
333
    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${first_xml}.xml"
334

335 336
    # process each html file to sperate it out into files for each proxy.
    COMMAND "${CMAKE_COMMAND}"
337
            -Dxmlpatterns="${QT_XMLPATTERNS_EXECUTABLE}"
338
            -Dxml_to_xml_xsl="${ParaView_CMAKE_DIR}/smxml_to_xml.xsl"
339 340 341 342
            -Dxml_to_html_xsl="${ParaView_CMAKE_DIR}/xml_to_html.xsl"
            -Dinput_xmls:STRING="${xmls_string}"
            -Dinput_gui_xmls:STRING="${gui_xmls_string}"
            -Doutput_dir="${output_dir}"
343
            -Doutput_file="${CMAKE_CURRENT_BINARY_DIR}/${first_xml}.xml"
344
            -P "${ParaView_CMAKE_DIR}/generate_proxydocumentation.cmake"
345

346
    DEPENDS ${xmls}
347
            "${ParaView_CMAKE_DIR}/smxml_to_xml.xsl"
348
            "${ParaView_CMAKE_DIR}/xml_to_html.xsl"
349
            "${ParaView_CMAKE_DIR}/generate_proxydocumentation.cmake"
350

351
    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
352

353
    COMMENT "Generating Documentation HTMLs from xmls")
354

355
    set (dependencies ${dependencies}
356
          "${CMAKE_CURRENT_BINARY_DIR}/${first_xml}.xml")
357 358
  set (${output_files} ${dependencies} PARENT_SCOPE)
endfunction()
359

360
#------------------------------------------------------------------------------
361 362
# Function used to build a qhp (and qch) file. Adds a custom command to generate
# a ${DESTINATION_DIRECTORY}/${name}.qch.
363
# build_help_project(name 
364 365
#                    DESTINATION_DIRECTORY directory
#                    [DOCUMENTATION_SOURCE_DIR directory]
366 367
#                    [NAMESPACE namespacename (default:${name}.org)]
#                    [FOLDER virtualfoldername (default:${name})]
368 369 370 371
#                    [TABLE_OF_CONTENTS toc]
#                    [TABLE_OF_CONTENTS_FILE toc_file_name]
#                    [FILES relative filenames/wildcard-expressions]
#                   )
372
# name :- specifies the name for the qhp. The generated qhp file will be
373 374 375 376 377
#         ${DESTINATION_DIRECTORY}/${name}.qhp
# DESTINATION_DIRECTORY :- output-directory for the qhp file.
# DOCUMENTATION_SOURCE_DIR :- (optional) when specified, all files in this
#                             directory are copied over to the
#                             DESTINATION_DIRECTORY.
378 379 380 381 382 383
# NAMESPACE :- (optional; default=${name}.org") Namespace to use in qhp file.
# FOLDER :- (optional; default=${name}") virtual folder in qhp file.
# TABLE_OF_CONTENTS :- (optional) XML string <toc>..</toc> (see qhp file
#                      documentation). Used only when TABLE_OF_CONTENTS_FILE is
#                      not specified.
# TABLE_OF_CONTENTS_FILE :- file to read in to obtain the TABLE_OF_CONTENTS
384
# FILEPATTERNS :- (optional: default="*.*") list of files (names or wildcards) to list
385
#          in the qhp file. Note that these files/paths are relative to the
386 387
#          DESTINATION_DIRECTORY.
# DEPENDS :- (optional) targets or files that the qch generation target depends on.
388 389 390
#
# If neither TABLE_OF_CONTENTS or TABLE_OF_CONTENTS_FILE is specified, then the
# TOC is auto-generated.
391
#------------------------------------------------------------------------------
392 393
function(build_help_project name)
  pv_parse_arguments(arg
394
    "DESTINATION_DIRECTORY;DOCUMENTATION_SOURCE_DIR;NAMESPACE;FOLDER;TABLE_OF_CONTENTS;TABLE_OF_CONTENTS_FILE;FILEPATTERNS;DEPENDS"
395 396 397 398
    ""
    ${ARGN}
    )

399 400
  if (NOT DEFINED arg_DESTINATION_DIRECTORY)
    message(FATAL_ERROR "No DESTINATION_DIRECTORY specified in build_help_project()")
401 402
  endif()

403 404 405 406 407 408 409 410 411 412
  find_program(QT_HELP_GENERATOR
    qhelpgenerator
    PATHS "${QT_BINARY_DIR}"
    DOC "qhelpgenerator used to compile Qt help project files")
  mark_as_advanced(QT_HELP_GENERATOR)

  if (NOT EXISTS ${QT_HELP_GENERATOR})
    message(WARNING "Valid QT_HELP_GENERATOR not specified.")
  endif()

413 414
  # set default values for optional arguments.
  pv_set_if_not_set(arg_FILEPATTERNS "*.*")
415 416
  pv_set_if_not_set(arg_NAMESPACE "${name}.org")
  pv_set_if_not_set(arg_FOLDER "${name}")
417
  pv_set_if_not_set(arg_DEPENDS "")
418 419 420 421 422 423 424

  # if filename is specified, it takes precendence.
  # setup toc variable to refer to the TOC xml dom.
  if (DEFINED arg_TABLE_OF_CONTENTS_FILE)
    file(READ ${arg_TABLE_OF_CONTENTS_FILE} arg_TABLE_OF_CONTENTS)
  endif()

425
  set (qhp_filename ${arg_DESTINATION_DIRECTORY}/${name}.qhp)
426 427 428 429 430 431 432 433 434 435 436 437

  set (extra_args)
  if (DEFINED arg_DOCUMENTATION_SOURCE_DIR)
    set (extra_args
      # copy all htmls from source to destination directory (same location where the
      # qhp file is present.
      COMMAND ${CMAKE_COMMAND} -E copy_directory
              "${arg_DOCUMENTATION_SOURCE_DIR}"
              "${arg_DESTINATION_DIRECTORY}"
      )
  endif()

438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
  if (NOT DEFINED arg_TABLE_OF_CONTENTS)
    # sanitize arg_FILEPATTERNS since we pass it as a command line argument.
    string (REPLACE ";" "+" arg_FILEPATTERNS "${arg_FILEPATTERNS}")
    set (extra_args ${extra_args}

    # generate the toc at run-time.
    COMMAND ${CMAKE_COMMAND}
            -Doutput_file="${qhp_filename}"
            -Dfile_patterns="${arg_FILEPATTERNS}"
            -Dnamespace="${arg_NAMESPACE}"
            -Dfolder="${arg_FOLDER}"
            -Dname="${name}"
            -P "${ParaView_CMAKE_DIR}/generate_qhp.cmake"
    )
  else ()
    # toc is provided, we'll just configure the file.
    set (files)
    foreach(filename ${arg_FILEPATTERNS})
      set (files "${files}<file>${filename}</file>\n")
    endforeach()

    configure_file(${ParaView_CMAKE_DIR}/build_help_project.qhp.in
      ${qhp_filename})
    list (APPEND arg_DEPENDS ${qhp_filename})
  endif()

464 465
  ADD_CUSTOM_COMMAND(
    OUTPUT "${arg_DESTINATION_DIRECTORY}/${name}.qch"
466 467
    DEPENDS ${arg_DEPENDS}
            "${ParaView_CMAKE_DIR}/generate_qhp.cmake"
468 469
  
    ${extra_args}
470

471 472
    # Now, compile the qhp file to generate the qch.
    COMMAND ${QT_HELP_GENERATOR}
473
            "${qhp_filename}"
474
            -o "${arg_DESTINATION_DIRECTORY}/${name}.qch"
475 476
  
    COMMENT "Compiling Qt help project ${name}.qhp"
477 478

    WORKING_DIRECTORY "${arg_DESTINATION_DIRECTORY}"
479
  )
480
endfunction(build_help_project)