| include(CMakeParseArguments) |
| |
| macro(WEBKIT_INCLUDE_CONFIG_FILES_IF_EXISTS) |
| set(_file ${CMAKE_CURRENT_SOURCE_DIR}/Platform${PORT}.cmake) |
| if (EXISTS ${_file}) |
| message(STATUS "Using platform-specific CMakeLists: ${_file}") |
| include(${_file}) |
| else () |
| message(STATUS "Platform-specific CMakeLists not found: ${_file}") |
| endif () |
| endmacro() |
| |
| # Append the given dependencies to the source file |
| macro(ADD_SOURCE_DEPENDENCIES _source _deps) |
| set(_tmp) |
| get_source_file_property(_tmp ${_source} OBJECT_DEPENDS) |
| if (NOT _tmp) |
| set(_tmp "") |
| endif () |
| |
| foreach (f ${_deps}) |
| list(APPEND _tmp "${f}") |
| endforeach () |
| |
| set_source_files_properties(${_source} PROPERTIES OBJECT_DEPENDS "${_tmp}") |
| endmacro() |
| |
| macro(ADD_PRECOMPILED_HEADER _header _cpp _source) |
| if (MSVC) |
| get_filename_component(PrecompiledBasename ${_cpp} NAME_WE) |
| file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${_source}") |
| set(PrecompiledBinary "${CMAKE_CURRENT_BINARY_DIR}/${_source}/${PrecompiledBasename}.pch") |
| set(_sources ${${_source}}) |
| |
| set_source_files_properties(${_cpp} |
| PROPERTIES COMPILE_FLAGS "/Yc\"${_header}\" /Fp\"${PrecompiledBinary}\"" |
| OBJECT_OUTPUTS "${PrecompiledBinary}") |
| set_source_files_properties(${_sources} |
| PROPERTIES COMPILE_FLAGS "/Yu\"${_header}\" /FI\"${_header}\" /Fp\"${PrecompiledBinary}\"" |
| OBJECT_DEPENDS "${PrecompiledBinary}") |
| list(APPEND ${_source} ${_cpp}) |
| endif () |
| #FIXME: Add support for Xcode. |
| endmacro() |
| |
| # Helper macro which wraps preprocess-idls.pl and generate-bindings.pl scripts. |
| # OUTPUT_SOURCE is a list name which will contain generated sources.(eg. WebCore_SOURCES) |
| # INPUT_FILES are IDL files to generate. |
| # BASE_DIR is base directory where script is called. |
| # IDL_INCLUDES is value of --include argument. (eg. ${WEBCORE_DIR}/bindings/js) |
| # FEATURES is a value of --defines argument. |
| # DESTINATION is a value of --outputDir argument. |
| # GENERATOR is a value of --generator argument. |
| # SUPPLEMENTAL_DEPFILE is a value of --supplementalDependencyFile. (optional) |
| # PP_EXTRA_OUTPUT is extra outputs of preprocess-idls.pl. (optional) |
| # PP_EXTRA_ARGS is extra arguments for preprocess-idls.pl. (optional) |
| function(GENERATE_BINDINGS) |
| set(options) |
| set(oneValueArgs OUTPUT_SOURCE BASE_DIR FEATURES DESTINATION GENERATOR SUPPLEMENTAL_DEPFILE) |
| set(multiValueArgs INPUT_FILES IDL_INCLUDES PP_EXTRA_OUTPUT PP_EXTRA_ARGS) |
| cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) |
| set(binding_generator ${WEBCORE_DIR}/bindings/scripts/generate-bindings.pl) |
| set(idl_attributes_file ${WEBCORE_DIR}/bindings/scripts/IDLAttributes.txt) |
| set(id ${arg_OUTPUT_SOURCE}) |
| set(idl_files_list ${CMAKE_CURRENT_BINARY_DIR}/idl_files_${id}.tmp) |
| set(_supplemental_dependency) |
| |
| set(content) |
| foreach (f ${arg_INPUT_FILES}) |
| if (NOT IS_ABSOLUTE ${f}) |
| set(f ${CMAKE_CURRENT_SOURCE_DIR}/${f}) |
| endif () |
| set(content "${content}${f}\n") |
| endforeach () |
| file(WRITE ${idl_files_list} ${content}) |
| |
| if (arg_SUPPLEMENTAL_DEPFILE) |
| set(_supplemental_dependency --supplementalDependencyFile ${arg_SUPPLEMENTAL_DEPFILE}) |
| |
| add_custom_command( |
| OUTPUT ${arg_SUPPLEMENTAL_DEPFILE} ${arg_PP_EXTRA_OUTPUT} |
| DEPENDS ${WEBCORE_DIR}/bindings/scripts/preprocess-idls.pl ${arg_INPUT_FILES} |
| COMMAND ${PERL_EXECUTABLE} -I${WEBCORE_DIR}/bindings/scripts ${WEBCORE_DIR}/bindings/scripts/preprocess-idls.pl --defines ${arg_FEATURES} --idlFilesList ${idl_files_list} --supplementalDependencyFile ${arg_SUPPLEMENTAL_DEPFILE} ${arg_PP_EXTRA_ARGS} |
| VERBATIM) |
| endif () |
| |
| set(idl_includes) |
| foreach (dir ${arg_IDL_INCLUDES}) |
| if (IS_ABSOLUTE ${dir}) |
| list(APPEND idl_includes --include=${dir}) |
| else () |
| list(APPEND idl_includes --include=${CMAKE_CURRENT_SOURCE_DIR}/${dir}) |
| endif () |
| endforeach () |
| |
| set(common_generator_dependencies |
| ${binding_generator} |
| ${WEBCORE_DIR}/bindings/scripts/CodeGenerator.pm |
| ${SCRIPTS_BINDINGS} |
| ${arg_SUPPLEMENTAL_DEPFILE} |
| ${idl_attributes_file} |
| ) |
| list(APPEND common_generator_dependencies ${arg_PP_EXTRA_OUTPUT}) |
| |
| if (EXISTS ${WEBCORE_DIR}/bindings/scripts/CodeGenerator${arg_GENERATOR}.pm) |
| list(APPEND common_generator_dependencies ${WEBCORE_DIR}/bindings/scripts/CodeGenerator${arg_GENERATOR}.pm) |
| endif () |
| if (EXISTS ${arg_BASE_DIR}/CodeGenerator${arg_GENERATOR}.pm) |
| list(APPEND common_generator_dependencies ${arg_BASE_DIR}/CodeGenerator${arg_GENERATOR}.pm) |
| endif () |
| |
| set(gen_sources) |
| foreach (_file ${arg_INPUT_FILES}) |
| get_filename_component(_name ${_file} NAME_WE) |
| |
| add_custom_command( |
| OUTPUT ${arg_DESTINATION}/JS${_name}.cpp ${arg_DESTINATION}/JS${_name}.h |
| MAIN_DEPENDENCY ${_file} |
| DEPENDS ${common_generator_dependencies} |
| COMMAND ${PERL_EXECUTABLE} -I${WEBCORE_DIR}/bindings/scripts -I${arg_BASE_DIR} ${binding_generator} --defines ${arg_FEATURES} --generator ${arg_GENERATOR} ${idl_includes} --outputDir ${arg_DESTINATION} --preprocessor ${CODE_GENERATOR_PREPROCESSOR} --idlAttributesFile ${idl_attributes_file} ${_supplemental_dependency} ${_file} |
| WORKING_DIRECTORY ${arg_BASE_DIR} |
| VERBATIM) |
| list(APPEND gen_sources ${arg_DESTINATION}/JS${_name}.cpp) |
| endforeach () |
| set(${arg_OUTPUT_SOURCE} ${${arg_OUTPUT_SOURCE}} ${gen_sources} PARENT_SCOPE) |
| endfunction() |
| |
| macro(GENERATE_FONT_NAMES _infile) |
| set(NAMES_GENERATOR ${WEBCORE_DIR}/dom/make_names.pl) |
| set(_arguments --fonts ${_infile}) |
| set(_outputfiles ${DERIVED_SOURCES_WEBCORE_DIR}/WebKitFontFamilyNames.cpp ${DERIVED_SOURCES_WEBCORE_DIR}/WebKitFontFamilyNames.h) |
| |
| add_custom_command( |
| OUTPUT ${_outputfiles} |
| MAIN_DEPENDENCY ${_infile} |
| DEPENDS ${MAKE_NAMES_DEPENDENCIES} ${NAMES_GENERATOR} ${SCRIPTS_BINDINGS} |
| COMMAND ${PERL_EXECUTABLE} -I${WEBCORE_DIR}/bindings/scripts ${NAMES_GENERATOR} --outputDir ${DERIVED_SOURCES_WEBCORE_DIR} ${_arguments} |
| VERBATIM) |
| endmacro() |
| |
| |
| macro(GENERATE_EVENT_FACTORY _infile _outfile) |
| set(NAMES_GENERATOR ${WEBCORE_DIR}/dom/make_event_factory.pl) |
| |
| add_custom_command( |
| OUTPUT ${DERIVED_SOURCES_WEBCORE_DIR}/${_outfile} |
| MAIN_DEPENDENCY ${_infile} |
| DEPENDS ${NAMES_GENERATOR} ${SCRIPTS_BINDINGS} |
| COMMAND ${PERL_EXECUTABLE} -I${WEBCORE_DIR}/bindings/scripts ${NAMES_GENERATOR} --input ${_infile} --outputDir ${DERIVED_SOURCES_WEBCORE_DIR} |
| VERBATIM) |
| endmacro() |
| |
| |
| macro(GENERATE_EXCEPTION_CODE_DESCRIPTION _infile _outfile) |
| set(NAMES_GENERATOR ${WEBCORE_DIR}/dom/make_dom_exceptions.pl) |
| |
| add_custom_command( |
| OUTPUT ${DERIVED_SOURCES_WEBCORE_DIR}/${_outfile} |
| MAIN_DEPENDENCY ${_infile} |
| DEPENDS ${NAMES_GENERATOR} ${SCRIPTS_BINDINGS} |
| COMMAND ${PERL_EXECUTABLE} -I${WEBCORE_DIR}/bindings/scripts ${NAMES_GENERATOR} --input ${_infile} --outputDir ${DERIVED_SOURCES_WEBCORE_DIR} |
| VERBATIM) |
| endmacro() |
| |
| |
| macro(GENERATE_SETTINGS_MACROS _infile _outfile) |
| set(NAMES_GENERATOR ${WEBCORE_DIR}/page/make_settings.pl) |
| |
| add_custom_command( |
| OUTPUT ${DERIVED_SOURCES_WEBCORE_DIR}/${_outfile} ${DERIVED_SOURCES_WEBCORE_DIR}/InternalSettingsGenerated.h ${DERIVED_SOURCES_WEBCORE_DIR}/InternalSettingsGenerated.cpp ${DERIVED_SOURCES_WEBCORE_DIR}/InternalSettingsGenerated.idl |
| MAIN_DEPENDENCY ${_infile} |
| DEPENDS ${NAMES_GENERATOR} ${SCRIPTS_BINDINGS} |
| COMMAND ${PERL_EXECUTABLE} -I${WEBCORE_DIR}/bindings/scripts ${NAMES_GENERATOR} --input ${_infile} --outputDir ${DERIVED_SOURCES_WEBCORE_DIR} |
| VERBATIM) |
| endmacro() |
| |
| |
| macro(GENERATE_DOM_NAMES _namespace _attrs) |
| set(NAMES_GENERATOR ${WEBCORE_DIR}/dom/make_names.pl) |
| set(_arguments --attrs ${_attrs}) |
| set(_outputfiles ${DERIVED_SOURCES_WEBCORE_DIR}/${_namespace}Names.cpp ${DERIVED_SOURCES_WEBCORE_DIR}/${_namespace}Names.h) |
| set(_extradef) |
| set(_tags) |
| |
| foreach (f ${ARGN}) |
| if (_tags) |
| set(_extradef "${_extradef} ${f}") |
| else () |
| set(_tags ${f}) |
| endif () |
| endforeach () |
| |
| if (_tags) |
| set(_arguments "${_arguments}" --tags ${_tags} --factory --wrapperFactory) |
| set(_outputfiles "${_outputfiles}" ${DERIVED_SOURCES_WEBCORE_DIR}/${_namespace}ElementFactory.cpp ${DERIVED_SOURCES_WEBCORE_DIR}/${_namespace}ElementFactory.h ${DERIVED_SOURCES_WEBCORE_DIR}/JS${_namespace}ElementWrapperFactory.cpp ${DERIVED_SOURCES_WEBCORE_DIR}/JS${_namespace}ElementWrapperFactory.h) |
| endif () |
| |
| if (_extradef) |
| set(_additionArguments "${_additionArguments}" --extraDefines=${_extradef}) |
| endif () |
| |
| add_custom_command( |
| OUTPUT ${_outputfiles} |
| DEPENDS ${MAKE_NAMES_DEPENDENCIES} ${NAMES_GENERATOR} ${SCRIPTS_BINDINGS} ${_attrs} ${_tags} |
| COMMAND ${PERL_EXECUTABLE} -I${WEBCORE_DIR}/bindings/scripts ${NAMES_GENERATOR} --preprocessor "${CODE_GENERATOR_PREPROCESSOR_WITH_LINEMARKERS}" --outputDir ${DERIVED_SOURCES_WEBCORE_DIR} ${_arguments} ${_additionArguments} |
| VERBATIM) |
| endmacro() |
| |
| |
| macro(GENERATE_GRAMMAR _prefix _input _output_header _output_source _features) |
| # This is a workaround for winflexbison, which does not work corretly when |
| # run in a different working directory than the installation directory. |
| get_filename_component(_working_directory ${BISON_EXECUTABLE} PATH) |
| |
| add_custom_command( |
| OUTPUT ${_output_header} ${_output_source} |
| MAIN_DEPENDENCY ${_input} |
| DEPENDS ${_input} |
| COMMAND ${PERL_EXECUTABLE} -I ${WEBCORE_DIR}/bindings/scripts ${WEBCORE_DIR}/css/makegrammar.pl --outputDir ${DERIVED_SOURCES_WEBCORE_DIR} --extraDefines "${_features}" --preprocessor "${CODE_GENERATOR_PREPROCESSOR}" --bison "${BISON_EXECUTABLE}" --symbolsPrefix ${_prefix} ${_input} |
| WORKING_DIRECTORY ${_working_directory} |
| VERBATIM) |
| endmacro() |
| |
| macro(MAKE_HASH_TOOLS _source) |
| get_filename_component(_name ${_source} NAME_WE) |
| |
| if (${_source} STREQUAL "DocTypeStrings") |
| set(_hash_tools_h "${DERIVED_SOURCES_WEBCORE_DIR}/HashTools.h") |
| else () |
| set(_hash_tools_h "") |
| endif () |
| |
| add_custom_command( |
| OUTPUT ${DERIVED_SOURCES_WEBCORE_DIR}/${_name}.cpp ${_hash_tools_h} |
| MAIN_DEPENDENCY ${_source}.gperf |
| COMMAND ${PERL_EXECUTABLE} ${WEBCORE_DIR}/make-hash-tools.pl ${DERIVED_SOURCES_WEBCORE_DIR} ${_source}.gperf ${GPERF_EXECUTABLE} |
| VERBATIM) |
| |
| unset(_name) |
| unset(_hash_tools_h) |
| endmacro() |
| |
| macro(WEBKIT_WRAP_SOURCELIST) |
| foreach (_file ${ARGN}) |
| get_filename_component(_basename ${_file} NAME_WE) |
| get_filename_component(_path ${_file} PATH) |
| |
| if (NOT _file MATCHES "${DERIVED_SOURCES_WEBCORE_DIR}") |
| string(REGEX REPLACE "/" "\\\\\\\\" _sourcegroup "${_path}") |
| source_group("${_sourcegroup}" FILES ${_file}) |
| endif () |
| endforeach () |
| |
| source_group("DerivedSources" REGULAR_EXPRESSION "${DERIVED_SOURCES_WEBCORE_DIR}") |
| endmacro() |
| |
| macro(WEBKIT_FRAMEWORK _target) |
| include_directories(${${_target}_INCLUDE_DIRECTORIES}) |
| include_directories(SYSTEM ${${_target}_SYSTEM_INCLUDE_DIRECTORIES}) |
| add_library(${_target} ${${_target}_LIBRARY_TYPE} |
| ${${_target}_HEADERS} |
| ${${_target}_SOURCES} |
| ) |
| target_link_libraries(${_target} ${${_target}_LIBRARIES}) |
| set_target_properties(${_target} PROPERTIES COMPILE_DEFINITIONS "BUILDING_${_target}") |
| |
| if (${_target}_OUTPUT_NAME) |
| set_target_properties(${_target} PROPERTIES OUTPUT_NAME ${${_target}_OUTPUT_NAME}) |
| ADD_TARGET_PROPERTIES(${_target} LINK_FLAGS "-Wl,-soname=lib${${_target}_OUTPUT_NAME}.so") |
| endif () |
| |
| if (${_target}_PRE_BUILD_COMMAND) |
| add_custom_target(_${_target}_PreBuild COMMAND ${${_target}_PRE_BUILD_COMMAND} VERBATIM) |
| add_dependencies(${_target} _${_target}_PreBuild) |
| endif () |
| |
| if (${_target}_POST_BUILD_COMMAND) |
| add_custom_command(TARGET ${_target} POST_BUILD COMMAND ${${_target}_POST_BUILD_COMMAND} VERBATIM) |
| endif () |
| |
| if (APPLE AND NOT PORT STREQUAL "GTK" AND NOT ${_target} STREQUAL "WTF") |
| set_target_properties(${_target} PROPERTIES FRAMEWORK TRUE) |
| install(TARGETS ${_target} FRAMEWORK DESTINATION ${LIB_INSTALL_DIR}) |
| endif () |
| endmacro() |
| |
| macro(WEBKIT_CREATE_FORWARDING_HEADER _target_directory _file) |
| get_filename_component(_source_path "${CMAKE_SOURCE_DIR}/Source/" ABSOLUTE) |
| get_filename_component(_absolute "${_file}" ABSOLUTE) |
| get_filename_component(_name "${_file}" NAME) |
| set(_target_filename "${_target_directory}/${_name}") |
| |
| # Try to make the path in the forwarding header relative to the Source directory |
| # so that these forwarding headers are compatible with the ones created by the |
| # WebKit2 generate-forwarding-headers script. |
| string(REGEX REPLACE "${_source_path}/" "" _relative ${_absolute}) |
| |
| set(_content "#include \"${_relative}\"\n") |
| |
| if (EXISTS "${_target_filename}") |
| file(READ "${_target_filename}" _old_content) |
| endif () |
| |
| if (NOT _old_content STREQUAL _content) |
| file(WRITE "${_target_filename}" "${_content}") |
| endif () |
| endmacro() |
| |
| macro(WEBKIT_CREATE_FORWARDING_HEADERS _framework) |
| # On Windows, we copy the entire contents of forwarding headers. |
| if (NOT WIN32) |
| set(_processing_directories 0) |
| set(_processing_files 0) |
| set(_target_directory "${DERIVED_SOURCES_DIR}/ForwardingHeaders/${_framework}") |
| |
| file(GLOB _files "${_target_directory}/*.h") |
| foreach (_file ${_files}) |
| file(READ "${_file}" _content) |
| string(REGEX MATCH "^#include \"([^\"]*)\"" _matched ${_content}) |
| if (_matched AND NOT EXISTS "${CMAKE_SOURCE_DIR}/Source/${CMAKE_MATCH_1}") |
| file(REMOVE "${_file}") |
| endif () |
| endforeach () |
| |
| foreach (_currentArg ${ARGN}) |
| if ("${_currentArg}" STREQUAL "DIRECTORIES") |
| set(_processing_directories 1) |
| set(_processing_files 0) |
| elseif ("${_currentArg}" STREQUAL "FILES") |
| set(_processing_directories 0) |
| set(_processing_files 1) |
| elseif (_processing_directories) |
| file(GLOB _files "${_currentArg}/*.h") |
| foreach (_file ${_files}) |
| WEBKIT_CREATE_FORWARDING_HEADER(${_target_directory} ${_file}) |
| endforeach () |
| elseif (_processing_files) |
| WEBKIT_CREATE_FORWARDING_HEADER(${_target_directory} ${_currentArg}) |
| endif () |
| endforeach () |
| endif () |
| endmacro() |
| |
| # Helper macro which wraps generate-message-receiver.py and generate-message-header.py scripts |
| # _output_source is a list name which will contain generated sources.(eg. WebKit2_SOURCES) |
| # _input_files are messages.in files to generate. |
| macro(GENERATE_WEBKIT2_MESSAGE_SOURCES _output_source _input_files) |
| foreach (_file ${_input_files}) |
| get_filename_component(_name ${_file} NAME_WE) |
| add_custom_command( |
| OUTPUT ${DERIVED_SOURCES_WEBKIT2_DIR}/${_name}MessageReceiver.cpp ${DERIVED_SOURCES_WEBKIT2_DIR}/${_name}Messages.h |
| MAIN_DEPENDENCY ${_file} |
| DEPENDS ${WEBKIT2_DIR}/Scripts/webkit/__init__.py |
| ${WEBKIT2_DIR}/Scripts/webkit/messages.py |
| ${WEBKIT2_DIR}/Scripts/webkit/model.py |
| ${WEBKIT2_DIR}/Scripts/webkit/parser.py |
| COMMAND ${PYTHON_EXECUTABLE} ${WEBKIT2_DIR}/Scripts/generate-message-receiver.py ${_file} > ${DERIVED_SOURCES_WEBKIT2_DIR}/${_name}MessageReceiver.cpp |
| COMMAND ${PYTHON_EXECUTABLE} ${WEBKIT2_DIR}/Scripts/generate-messages-header.py ${_file} > ${DERIVED_SOURCES_WEBKIT2_DIR}/${_name}Messages.h |
| WORKING_DIRECTORY ${WEBKIT2_DIR} |
| VERBATIM) |
| |
| list(APPEND ${_output_source} ${DERIVED_SOURCES_WEBKIT2_DIR}/${_name}MessageReceiver.cpp) |
| endforeach () |
| endmacro() |
| |
| macro(MAKE_JS_FILE_ARRAYS _output_cpp _output_h _scripts _scripts_dependencies) |
| if (WIN32) |
| set(_python_path set "PYTHONPATH=${JavaScriptCore_SCRIPTS_DIR}" COMMAND) |
| else () |
| set(_python_path "PYTHONPATH=${JavaScriptCore_SCRIPTS_DIR}") |
| endif () |
| |
| add_custom_command( |
| OUTPUT ${_output_h} ${_output_cpp} |
| MAIN_DEPENDENCY ${WEBCORE_DIR}/Scripts/make-js-file-arrays.py |
| DEPENDS ${${_scripts}} |
| COMMAND ${_python_path} ${PYTHON_EXECUTABLE} ${WEBCORE_DIR}/Scripts/make-js-file-arrays.py ${_output_h} ${_output_cpp} ${${_scripts}} |
| VERBATIM) |
| list(APPEND WebCore_DERIVED_SOURCES ${_output_cpp}) |
| ADD_SOURCE_DEPENDENCIES(${${_scripts_dependencies}} ${_output_h} ${_output_cpp}) |
| endmacro() |
| |
| # Helper macro for using all-in-one builds |
| # This macro removes the sources included in the _all_in_one_file from the input _file_list. |
| # _file_list is a list of source files |
| # _all_in_one_file is an all-in-one cpp file includes other cpp files |
| # _result_file_list is the output file list |
| macro(PROCESS_ALLINONE_FILE _file_list _all_in_one_file _result_file_list _no_compile) |
| file(STRINGS ${_all_in_one_file} _all_in_one_file_content) |
| set(${_result_file_list} ${_file_list}) |
| set(_allins "") |
| foreach (_line ${_all_in_one_file_content}) |
| string(REGEX MATCH "^#include [\"<](.*)[\">]" _found ${_line}) |
| if (_found) |
| list(APPEND _allins ${CMAKE_MATCH_1}) |
| endif () |
| endforeach () |
| |
| foreach (_allin ${_allins}) |
| if (${_no_compile}) |
| # For DerivedSources.cpp, we still need the derived sources to be generated, but we do not want them to be compiled |
| # individually. We add the header to the result file list so that CMake knows to keep generating the files. |
| string(REGEX REPLACE "(.*)\\.cpp" "\\1" _allin_no_ext ${_allin}) |
| string(REGEX REPLACE ";([^;]*/)${_allin_no_ext}\\.cpp;" ";\\1${_allin_no_ext}.h;" _new_result "${${_result_file_list}};") |
| else () |
| string(REGEX REPLACE ";[^;]*/${_allin};" ";" _new_result "${${_result_file_list}};") |
| endif () |
| set(${_result_file_list} ${_new_result}) |
| endforeach () |
| |
| endmacro() |
