Warning, /system/qtcurve/cmake/CMakeHelperMacros.cmake is written in an unsupported language. File is not indexed.
0001 # Copyright (C) 2013~2014 by Yichao Yu
0002 # yyc1992@gmail.com
0003 #
0004 # Redistribution and use in source and binary forms, with or without
0005 # modification, are permitted provided that the following conditions
0006 # are met:
0007 #
0008 # 1. Redistributions of source code must retain the above copyright
0009 # notice, this list of conditions and the following disclaimer.
0010 # 2. Redistributions in binary form must reproduce the above copyright
0011 # notice, this list of conditions and the following disclaimer in the
0012 # documentation and/or other materials provided with the distribution.
0013 #
0014 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
0015 # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
0016 # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
0017 # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
0018 # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
0019 # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
0020 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
0021 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
0022 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
0023 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
0024
0025 # Public functions and macros provided by this file
0026 # (See comment of each for more detail):
0027 # cmake_utils_reconf_on
0028 # cmake_helper_clear_cache
0029 # cmake_helper_reg
0030 # cmake_helper_wrap_shell
0031 # cmake_helper_wrap_helper
0032 # cmake_helper_add_command
0033 # cmake_helper_set_command
0034 # cmake_helper_add_env
0035
0036 if(COMMAND cmake_helper_reg)
0037 return()
0038 endif()
0039
0040 include(CMakeArgumentMacros)
0041 include(CMakeStringMacros)
0042 include(CMakePathMacros)
0043
0044 ## reconfigure
0045 macro(__cmake_utils_reconf_on_foreach)
0046 string(MD5 fname "${__cmake_utils_reconf_on_value}")
0047 configure_file("${__cmake_utils_reconf_on_value}"
0048 "${reconf_cache}/${fname}" COPYONLY)
0049 # file(REMOVE "${reconf_cache}/${fname}")
0050 endmacro()
0051
0052 # cmake_utils_reconf_on([filenames...])
0053 # @filenames: names of files to trigger reconfigure when changed.
0054 #
0055 # This function add @filenames to the configure dependencies so that
0056 # the configure stage (i.e. the cmake scripts) will be run again if these
0057 # files are modified. This is useful if the file is read/parsed/executed
0058 # in the configure stage which may produce a different configure result
0059 # when changed.
0060 function(cmake_utils_reconf_on)
0061 cmake_utils_get_global(___CMAKE_UTILS_RECONF_CACHE reconf_cache)
0062 cmake_array_foreach(__cmake_utils_reconf_on_value
0063 __cmake_utils_reconf_on_foreach)
0064 endfunction()
0065
0066 ## clear cache
0067 macro(__cmake_helper_clear_cache_foreach)
0068 execute_process(COMMAND "${helper_wrapper}"
0069 --clear-cache "${__cmake_helper_clear_cache_value}")
0070 endmacro()
0071
0072 # cmake_helper_clear_cache([dirs...])
0073 # @dirs: directories names to be cleared.
0074 #
0075 # This function removes the content and recreate @dirs.
0076 # Used for cache dir cleanup.
0077 function(cmake_helper_clear_cache)
0078 cmake_utils_get_global(_CMAKE_HELPER_RUN_HELPER_WRAPPER helper_wrapper)
0079 cmake_array_foreach(__cmake_helper_clear_cache_value
0080 __cmake_helper_clear_cache_foreach)
0081 endfunction()
0082
0083 ## write shell script helpers
0084 ### init
0085 macro(__cmake_helper_init_script_foreach)
0086 file(WRITE "${fname}"
0087 "#!/bin/sh\n# Automatically generated. DO NOT EDIT\n")
0088 endmacro()
0089
0090 function(_cmake_helper_init_script)
0091 cmake_array_foreach(fname __cmake_helper_init_script_foreach)
0092 endfunction()
0093
0094 ### command
0095 macro(__cmake_helper_escape_cmd var)
0096 macro(__cmake_helper_escape_cmd_foreach)
0097 cmake_str_quote_shell("${arg}" arg)
0098 if(_first_arg)
0099 set("${var}" "${${var}}${arg}")
0100 set(_first_arg False)
0101 else()
0102 set("${var}" "${${var}} ${arg}")
0103 endif()
0104 endmacro()
0105 foreach(_first_arg True)
0106 cmake_array_foreach(arg __cmake_helper_escape_cmd_foreach ${ARGN})
0107 endforeach()
0108 endmacro()
0109
0110 function(_cmake_helper_escape_cmd var)
0111 set(escaped_cmd "${${var}}")
0112 __cmake_helper_escape_cmd(escaped_cmd 1)
0113 set("${var}" "${escaped_cmd}" PARENT_SCOPE)
0114 endfunction()
0115
0116 macro(__cmake_helper_escape_envs varname)
0117 macro(__cmake_helper_escape_envs_foreach)
0118 if(__cmake_helper_add_env_is_name)
0119 set(__cmake_helper_add_env_is_name 0)
0120 set(__cmake_helper_add_env_name "${__cmake_helper_escape_envs_value}")
0121 else()
0122 set(__cmake_helper_add_env_is_name 1)
0123 _cmake_helper_escape_cmd("${varname}" export
0124 "${__cmake_helper_add_env_name}=${__cmake_helper_escape_envs_value}")
0125 set("${varname}" "${${varname}}\n")
0126 endif()
0127 endmacro()
0128 foreach(__cmake_helper_add_env_is_name 1)
0129 foreach(__cmake_helper_add_env_name "")
0130 cmake_array_foreach(__cmake_helper_escape_envs_value
0131 __cmake_helper_escape_envs_foreach ${ARGN})
0132 endforeach()
0133 endforeach()
0134 endmacro()
0135
0136 function(_cmake_helper_write_export file)
0137 set(escaped_envs)
0138 __cmake_helper_escape_envs(escaped_envs 1)
0139 file(APPEND "${file}" "${escaped_envs}")
0140 endfunction()
0141
0142 macro(__cmake_helper_wrap_shell command_ret)
0143 __cmake_helper_escape_cmd(quoted_command_line ${ARGN})
0144 cmake_utils_get_global(___CMAKE_HELPER_UTILS_CACHE helper_cache)
0145 cmake_utils_get_global(_CMAKE_HELPER_SCRIPT_DIR
0146 cmake_run_helper_script_dir)
0147 cmake_utils_get_unique_name(cmake_helper_wrap_shell "${command_ret}")
0148 set("${command_ret}" "${helper_cache}/${${command_ret}}.sh")
0149 set(quoted_command_line "${quoted_command_line} \"\$@\"")
0150 configure_file(
0151 "${cmake_run_helper_script_dir}/cmake-utils-cmd-wrapper.sh.in"
0152 "${${command_ret}}" @ONLY)
0153 cmake_utils_reconf_on("${${command_ret}}")
0154 endmacro()
0155
0156 function(_cmake_helper_wrap_shell command_ret)
0157 __cmake_helper_wrap_shell(file_name 1)
0158 set("${command_ret}" "${file_name}" PARENT_SCOPE)
0159 endfunction()
0160
0161 ### variables
0162 function(__cmake_helper_write_vars fname name value)
0163 cmake_str_quote_shell("${value}" value)
0164 file(APPEND "${fname}" "${name}=${value}\n")
0165 endfunction()
0166
0167 ### execute with environment
0168 macro(____cmake_helper_wrap_commands_foreach)
0169 foreach(command_str "")
0170 __cmake_helper_escape_cmd(command_str "${command}")
0171 file(APPEND "${fname}" " ${command_str} \"$@\"\n")
0172 endforeach()
0173 endmacro()
0174
0175 function(__cmake_helper_wrap_commands_write_commands fname name commands)
0176 file(APPEND "${fname}" "__command_${name}_run() {\n")
0177 cmake_array_foreach(command ____cmake_helper_wrap_commands_foreach
0178 "${commands}")
0179 file(APPEND "${fname}" "}\n")
0180 endfunction()
0181
0182 function(__cmake_helper_wrap_commands env_fname name
0183 commands working_dir input output error envs)
0184 cmake_utils_get_global(___CMAKE_HELPER_UTILS_CACHE helper_cache)
0185 set(fname "${helper_cache}/command_${name}_setting.sh")
0186 _cmake_helper_init_script("${fname}")
0187 # envs
0188 if(NOT "x${env_fname}x" STREQUAL xx)
0189 if((NOT "x${envs}x" STREQUAL xx) AND DEFINED "${envs}.length"
0190 AND "${${envs}.length}")
0191 __cmake_helper_escape_envs(envs_string "${envs}")
0192 file(APPEND "${env_fname}" "${envs_string}")
0193 endif()
0194 __cmake_helper_write_vars("${fname}" "__command_${name}_env_file"
0195 "${env_fname}")
0196 endif()
0197 # settings
0198 __cmake_helper_write_vars("${fname}" "__command_${name}_input_file"
0199 "${input}")
0200 __cmake_helper_write_vars("${fname}" "__command_${name}_output_file"
0201 "${output}")
0202 __cmake_helper_write_vars("${fname}" "__command_${name}_error_file"
0203 "${error}")
0204 __cmake_helper_write_vars("${fname}" "__command_${name}_working_dir"
0205 "${working_dir}")
0206 # commands
0207 __cmake_helper_wrap_commands_write_commands("${fname}" "${name}"
0208 "${commands}")
0209 cmake_utils_reconf_on("${fname}")
0210 endfunction()
0211
0212 function(cmake_helper_to_cur_file abs_path file)
0213 if(IS_ABSOLUTE "${file}")
0214 set("${abs_path}" "${file}" PARENT_SCOPE)
0215 else()
0216 get_filename_component(list_file_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)
0217 set(file_path "${list_file_dir}/${file}")
0218 cmake_utils_to_abs(file_path)
0219 set("${abs_path}" "${file_path}" PARENT_SCOPE)
0220 endif()
0221 endfunction()
0222
0223 function(__cmake_helper_macro_init)
0224 cmake_utils_get_global(CMAKE_GENERAL_BASE base_dir)
0225
0226 # helper cache
0227 cmake_utils_set_and_make_dir("${base_dir}/cmake_helper_cache"
0228 ___CMAKE_HELPER_UTILS_CACHE helper_cache)
0229 get_filename_component(cmake_run_helper_script_dir
0230 "${CMAKE_CURRENT_LIST_FILE}" PATH)
0231 set(cmake_run_helper_script
0232 "${cmake_run_helper_script_dir}/cmake-utils-run-helper.sh")
0233 cmake_str_quote_shell("${helper_cache}" cmake_helper_utils_cache_quoted)
0234 cmake_str_quote_shell("${cmake_run_helper_script_dir}"
0235 cmake_helper_script_dir_quoted)
0236 cmake_str_quote_shell("${base_dir}" base_dir_quoted)
0237 set(cmake_run_helper_wrapper "${base_dir}/cmake-utils-run-helper-wrapper.sh")
0238 configure_file(
0239 "${cmake_run_helper_script_dir}/cmake-utils-run-helper-wrapper.sh.in"
0240 "${cmake_run_helper_wrapper}" @ONLY)
0241 cmake_utils_set_global(_CMAKE_HELPER_RUN_HELPER_WRAPPER
0242 "${cmake_run_helper_wrapper}")
0243 cmake_utils_set_global(_CMAKE_HELPER_SCRIPT_DIR
0244 "${cmake_run_helper_script_dir}")
0245 set(general_export_script "${base_dir}/cmake_helper_general_export.sh")
0246 _cmake_helper_init_script("${general_export_script}")
0247 _cmake_helper_write_export("${general_export_script}"
0248 CMAKE_HELPER_CMAKE_COMMAND "${CMAKE_COMMAND}")
0249 cmake_helper_clear_cache("${helper_cache}")
0250
0251 # reconfigure
0252 cmake_utils_set_and_make_dir("${base_dir}/cmake_reconf_cache"
0253 ___CMAKE_UTILS_RECONF_CACHE reconf_cache)
0254 cmake_helper_clear_cache("${reconf_cache}")
0255 cmake_utils_reconf_on("${cmake_run_helper_script}")
0256 cmake_utils_reconf_on("${cmake_run_helper_wrapper}")
0257 cmake_utils_reconf_on("${general_export_script}")
0258 endfunction()
0259 cmake_utils_call_once(__cmake_helper_macro_init)
0260
0261 # cmake_helper_reg(name file command_ret
0262 # [ENVS:] (env_name env_value)...
0263 # WORKING_DIR: working_directory)
0264 # @name: name of the helper.
0265 # @file: executable file name of the helper. Relative path
0266 # is resolved using the directory of the current script.
0267 # @command_ret: variable to return the wrapper command used to
0268 # run the helper.
0269 # @env_name: name of environment variable.
0270 # @env_value: value of environment variable.
0271 # @working_directory: working directory to run the helper.
0272 # default to the directory of the current script.
0273 #
0274 # This function registers a helper script @file as @name. The variable
0275 # @command_ret will be set to command prefix that can be used to run the
0276 # helper. The difference between a helper and a normal command is that
0277 # a set of environment variable defined using @env_name and @env_value
0278 # can be passed to the helper script when ever it is executed. These
0279 # variables can be useful for a cmake helper script to access cmake
0280 # variables. More environment variables can also be added later using
0281 # #cmake_helper_add_env. There are also pre-defined variables that
0282 # will be defined for every script. These are the variables that are
0283 # currently defined:
0284 # CMAKE_HELPER_CMAKE_COMMAND: defined to the full path to the
0285 # cmake command. Use this variable instead of `cmake` to run
0286 # cmake (e.g. for `cmake -E`).
0287 # CMAKE_GENERAL_BASE: defined to the cache directory for build files.
0288 # See also #cmake_helper_add_env.
0289 function(cmake_helper_reg name file command_ret)
0290 set(bool_name "__cmake_helper_reg_${name}")
0291 cmake_utils_check_and_set_bool("${bool_name}" registered)
0292 if(registered)
0293 message(WARNING
0294 "Helper script ${name} already registered. Will not register again.")
0295 return()
0296 endif()
0297 cmake_utils_get_global(___CMAKE_HELPER_UTILS_CACHE helper_cache)
0298 cmake_utils_get_global(_CMAKE_HELPER_RUN_HELPER_WRAPPER helper_wrapper)
0299
0300 set(OPTIONS)
0301 set(SINGLES
0302 WORKING_DIR)
0303 set(MULTIPLES
0304 ENVS)
0305 set(LISTS)
0306 cmake_parse_array_default(REG_HELPER 3)
0307 cmake_array_concat("${REG_HELPER_ENVS}" "${REG_HELPER_UNUSED}")
0308 cmake_helper_to_cur_file(file "${file}")
0309 cmake_helper_to_cur_file(REG_HELPER_WORKING_DIR "${REG_HELPER_WORKING_DIR}")
0310
0311 cmake_utils_reconf_on("${file}")
0312 cmake_utils_get_unique_name("cmake_helper_${name}_default" default_dir_name)
0313 cmake_utils_get_unique_name("cmake_helper_${name}_raw" raw_name)
0314 cmake_array_new(command exec "${file}")
0315 cmake_array_new(commands "${command}")
0316
0317 set(env_fname "${helper_cache}/command_${name}_export.sh")
0318 _cmake_helper_init_script("${env_fname}")
0319
0320 __cmake_helper_wrap_commands("${env_fname}"
0321 "${default_dir_name}" "${commands}" "${REG_HELPER_WORKING_DIR}"
0322 "" "" "" "${REG_HELPER_ENVS}")
0323 __cmake_helper_wrap_commands("${env_fname}"
0324 "${raw_name}" "${commands}" "" "" "" "" "")
0325
0326 _cmake_helper_wrap_shell(wrapper_file "${helper_wrapper}"
0327 "--run-command" "${default_dir_name}")
0328 _cmake_helper_wrap_shell(wrapper_file_raw "${helper_wrapper}"
0329 "--run-command" "${raw_name}")
0330
0331 cmake_utils_set_global("_cmake_helper_${name}_script" "${file}")
0332 cmake_utils_set_global("_cmake_helper_${name}_working_dir"
0333 "${REG_HELPER_WORKING_DIR}")
0334 cmake_utils_set_global("_cmake_helper_${name}_wrapper_raw"
0335 "${wrapper_file_raw}")
0336 cmake_utils_set_global("_cmake_helper_${name}_wrapper" "${wrapper_file}")
0337 # cmake_utils_set_global("_cmake_helper_${name}_setting_raw" "${raw_name}")
0338 # cmake_utils_set_global("_cmake_helper_${name}_setting" "${default_dir_name}")
0339 set("${command_ret}" "${wrapper_file}" PARENT_SCOPE)
0340 cmake_utils_reconf_on("${env_fname}")
0341 endfunction()
0342
0343 macro(_cmake_helper_save_commands name save_commands_list)
0344 cmake_array_set_global("_cmake_helper_save_commands_${name}"
0345 "${save_commands_list}" 2)
0346 endmacro()
0347
0348 macro(_cmake_helper_retrieve_commands name save_commands_list)
0349 cmake_array_get_global("_cmake_helper_save_commands_${name}"
0350 "${save_commands_list}" 2)
0351 endmacro()
0352
0353 # cmake_helper_wrap_shell(command_ret
0354 # (COMMAND: command...)...
0355 # [WORKING_DIR: working_dir]
0356 # [ID_RET: id_ret]
0357 # [INPUT_FILE: input_file]
0358 # [OUTPUT_FILE: output_file]
0359 # [ERROR_FILE: error_file]
0360 # [ENVS: (env_name env_value)...])
0361 # @command_ret: variable to return the wrapper command used to
0362 # run the original command.
0363 # @command: a single shell command to be wrapped,
0364 #
0365 # This function wrap a shell command and return a wrapper command. All
0366 # the arguments including the command itself will be quoted properly.
0367 # See also #cmake_helper_wrap_helper.
0368 function(cmake_helper_wrap_shell command_ret)
0369 set(OPTIONS)
0370 set(SINGLES INPUT_FILE OUTPUT_FILE ERROR_FILE WORKING_DIR ID_RET)
0371 set(MULTIPLES ENVS)
0372 set(LISTS COMMAND)
0373 cmake_parse_array_default(WRAP_SHELL 1)
0374 if("${WRAP_SHELL_UNUSED}.length")
0375 cmake_array_append("${WRAP_SHELL_COMMAND}" "${WRAP_SHELL_UNUSED}")
0376 endif()
0377 cmake_utils_to_abs(WRAP_SHELL_WORKING_DIR WRAP_SHELL_INPUT_FILE
0378 WRAP_SHELL_OUTPUT_FILE WRAP_SHELL_ERROR_FILE)
0379
0380 cmake_utils_get_global(___CMAKE_HELPER_UTILS_CACHE helper_cache)
0381 cmake_utils_get_global(_CMAKE_HELPER_RUN_HELPER_WRAPPER helper_wrapper)
0382
0383 cmake_utils_get_unique_name(cmake_helper_wrap_shell wrapper_name)
0384 set(env_fname "${helper_cache}/command_${wrapper_name}_export.sh")
0385 _cmake_helper_init_script("${env_fname}")
0386 __cmake_helper_wrap_commands("${env_fname}" "${wrapper_name}"
0387 "${WRAP_SHELL_COMMAND}" "${WRAP_SHELL_WORKING_DIR}"
0388 "${WRAP_SHELL_INPUT_FILE}" "${WRAP_SHELL_OUTPUT_FILE}"
0389 "${WRAP_SHELL_ERROR_FILE}" "${WRAP_SHELL_ENVS}")
0390 _cmake_helper_save_commands("${wrapper_name}" "${WRAP_SHELL_COMMAND}")
0391 _cmake_helper_wrap_shell(wrapper_file "${helper_wrapper}" "--run-command"
0392 "${wrapper_name}")
0393 set("${command_ret}" "${wrapper_file}" PARENT_SCOPE)
0394 if(NOT "x${WRAP_SHELL_ID_RET}x" STREQUAL xx)
0395 set("${WRAP_SHELL_ID_RET}" "${wrapper_name}" PARENT_SCOPE)
0396 endif()
0397 cmake_utils_reconf_on("${env_fname}")
0398 endfunction()
0399
0400 # cmake_helper_wrap_helper(name command_ret [args...]
0401 # (ARGS: args...)...
0402 # [WORKING_DIR: working_dir]
0403 # [INPUT_FILE: input_file]
0404 # [OUTPUT_FILE: output_file]
0405 # [ERROR_FILE: error_file]
0406 # [ENVS: (env_name env_value)...])
0407 # @name: name of the helper.
0408 # @command_ret: variable to return the wrapper command used to
0409 # run the original command.
0410 # @args: arguments passed to the helper script.
0411 #
0412 # This function wrap a helper command and return a wrapper command. All
0413 # the arguments will be quoted properly. See also #cmake_helper_wrap_shell.
0414 function(cmake_helper_wrap_helper name command_ret)
0415 set(bool_name "__cmake_helper_reg_${name}")
0416 cmake_utils_get_bool("${bool_name}" registered)
0417 if(NOT registered)
0418 message(FATAL_ERROR
0419 "Helper script ${name} have not been registered yet.")
0420 return()
0421 endif()
0422
0423 set(OPTIONS)
0424 set(SINGLES INPUT_FILE OUTPUT_FILE ERROR_FILE WORKING_DIR ID_RET)
0425 set(MULTIPLES ENVS)
0426 set(LISTS ARGS)
0427 cmake_parse_array_default(WRAP_HELPER 2)
0428 cmake_utils_to_abs(WRAP_HELPER_WORKING_DIR WRAP_HELPER_INPUT_FILE
0429 WRAP_HELPER_OUTPUT_FILE WRAP_HELPER_ERROR_FILE)
0430 if(DEFINED "${WRAP_HELPER_UNUSED}.length" AND
0431 "${${WRAP_HELPER_UNUSED}.length}")
0432 cmake_array_append("${WRAP_HELPER_ARGS}" "${WRAP_HELPER_UNUSED}")
0433 endif()
0434
0435 cmake_utils_get_global(___CMAKE_HELPER_UTILS_CACHE helper_cache)
0436 cmake_utils_get_global(_CMAKE_HELPER_RUN_HELPER_WRAPPER helper_wrapper)
0437
0438 if("x${WRAP_HELPER_WORKING_DIR}x" STREQUAL "xx")
0439 cmake_utils_get_global("_cmake_helper_${name}_wrapper" wrapper_file)
0440 else()
0441 cmake_utils_get_global("_cmake_helper_${name}_wrapper_raw" wrapper_file)
0442 endif()
0443 cmake_array_new(command_prefix "${wrapper_file}")
0444
0445 cmake_array_new(commands)
0446 macro(__cmake_helper_wrap_helper_foreach)
0447 foreach(array_name "")
0448 cmake_array_copy("${command_prefix}" array_name)
0449 cmake_array_concat("${array_name}" "${helper_arg}")
0450 cmake_array_append("${commands}" "${array_name}")
0451 endforeach()
0452 endmacro()
0453 cmake_array_foreach(helper_arg __cmake_helper_wrap_helper_foreach
0454 "${WRAP_HELPER_ARGS}")
0455
0456 cmake_utils_get_unique_name(cmake_helper_wrap_helper wrapper_name)
0457 set(env_fname "${helper_cache}/command_${wrapper_name}_export.sh")
0458 _cmake_helper_init_script("${env_fname}")
0459 __cmake_helper_wrap_commands("${env_fname}" "${wrapper_name}"
0460 "${commands}" "${WRAP_HELPER_WORKING_DIR}" "${WRAP_HELPER_INPUT_FILE}"
0461 "${WRAP_HELPER_OUTPUT_FILE}" "${WRAP_HELPER_ERROR_FILE}"
0462 "${WRAP_HELPER_ENVS}")
0463 _cmake_helper_save_commands("${wrapper_name}" "${commands}")
0464 _cmake_helper_wrap_shell(wrapper_file "${helper_wrapper}" "--run-command"
0465 "${wrapper_name}")
0466 set("${command_ret}" "${wrapper_file}" PARENT_SCOPE)
0467 if(NOT "x${WRAP_HELPER_ID_RET}x" STREQUAL xx)
0468 set("${WRAP_HELPER_ID_RET}" "${wrapper_name}" PARENT_SCOPE)
0469 endif()
0470 cmake_utils_reconf_on("${env_fname}")
0471 endfunction()
0472
0473 function(_cmake_helper_set_command name commands)
0474 _cmake_helper_save_commands("${name}" "${commands}")
0475 cmake_utils_get_global(_CMAKE_HELPER_RUN_HELPER_WRAPPER helper_wrapper)
0476 execute_process(COMMAND "${helper_wrapper}" --rewrite-cmd-settings "${name}")
0477 cmake_utils_get_global(___CMAKE_HELPER_UTILS_CACHE helper_cache)
0478 set(fname "${helper_cache}/command_${name}_setting.sh")
0479 __cmake_helper_wrap_commands_write_commands("${fname}" "${name}"
0480 "${commands}")
0481 cmake_utils_reconf_on("${fname}")
0482 endfunction()
0483
0484 macro(cmake_helper_get_command name ret_commands)
0485 _cmake_helper_retrieve_commands("${name}" "${ret_commands}")
0486 endmacro()
0487
0488 function(cmake_helper_add_command name)
0489 set(OPTIONS)
0490 set(SINGLES)
0491 set(MULTIPLES)
0492 set(LISTS COMMAND)
0493 cmake_parse_array_default(ADD_COMMAND 1)
0494 _cmake_helper_retrieve_commands("${name}" retrieved_commands)
0495 cmake_array_concat("${retrieved_commands}" "${ADD_COMMAND_COMMAND}")
0496 _cmake_helper_set_command("${name}" "${retrieved_commands}")
0497 endfunction()
0498
0499 function(cmake_helper_set_command name)
0500 set(OPTIONS)
0501 set(SINGLES)
0502 set(MULTIPLES)
0503 set(LISTS COMMAND)
0504 cmake_parse_array_default(SET_COMMAND 1)
0505 _cmake_helper_set_command("${name}" "${SET_COMMAND_COMMAND}")
0506 endfunction()
0507
0508 # cmake_helper_add_env(name [[env_name env_value]...])
0509 # @name: name of the helper.
0510 # @env_name: name of environment variable.
0511 # @env_value: value of environment variable.
0512 #
0513 # This function add more environment variables for a previously
0514 # registered helper script @name. See #cmake_helper_reg for more detail.
0515 function(cmake_helper_add_env name)
0516 cmake_utils_get_global(___CMAKE_HELPER_UTILS_CACHE helper_cache)
0517 set(env_fname "${helper_cache}/command_${name}_export.sh")
0518 __cmake_helper_escape_envs(envs_string 1)
0519 file(APPEND "${env_fname}" "${envs_string}")
0520 cmake_utils_reconf_on("${env_fname}")
0521 endfunction()