diff --git a/scripts/cmake/vcpkg_configure_meson.cmake b/scripts/cmake/vcpkg_configure_meson.cmake
index 943631757fa4a9..e0eab209875eaf 100644
--- a/scripts/cmake/vcpkg_configure_meson.cmake
+++ b/scripts/cmake/vcpkg_configure_meson.cmake
@@ -40,8 +40,8 @@ This command supplies many common arguments to Meson. To see the full list, exam
 * [libepoxy](https://github.com/Microsoft/vcpkg/blob/master/ports/libepoxy/portfile.cmake)
 #]===]
 
-function(vcpkg_internal_meson_generate_native_file _additional_binaries) #https://mesonbuild.com/Native-environments.html
-    set(NATIVE "[binaries]\n")
+function(z_vcpkg_meson_generate_native_file additional_binaries) #https://mesonbuild.com/Native-environments.html
+    set(native_config "[binaries]\n")
     #set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT)
     if(VCPKG_TARGET_IS_WINDOWS)
         set(proglist MT)
@@ -51,116 +51,121 @@ function(vcpkg_internal_meson_generate_native_file _additional_binaries) #https:
     foreach(prog IN LISTS proglist)
         if(VCPKG_DETECTED_CMAKE_${prog})
             string(TOLOWER "${prog}" proglower)
-            string(APPEND NATIVE "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}}'\n")
+            string(APPEND native_config "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}}'\n")
         endif()
     endforeach()
-    set(compiler C CXX RC)
-    foreach(prog IN LISTS compiler)
+    set(programs C CXX RC)
+    foreach(prog IN LISTS programs)
         if(VCPKG_DETECTED_CMAKE_${prog}_COMPILER)
             string(REPLACE "CXX" "CPP" mesonprog "${prog}")
             string(REPLACE "RC" "windres" mesonprog "${mesonprog}") # https://mesonbuild.com/Windows-module.html
             string(TOLOWER "${mesonprog}" proglower)
-            string(APPEND NATIVE "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}'\n")
+            string(APPEND native_config "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}'\n")
         endif()
     endforeach()
     if(VCPKG_DETECTED_CMAKE_LINKER AND VCPKG_TARGET_IS_WINDOWS)
-        if (NOT VCPKG_DETECTED_CMAKE_C_COMPILER_ID MATCHES "^(GNU|Intel)$") # for gcc and icc the linker flag -fuse-ld is used. See https://github.com/mesonbuild/meson/issues/8647#issuecomment-878673456
-            string(APPEND NATIVE "c_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
+        # for gcc and icc the linker flag -fuse-ld is used. See https://github.com/mesonbuild/meson/issues/8647#issuecomment-878673456
+        if (NOT VCPKG_DETECTED_CMAKE_C_COMPILER_ID MATCHES "^(GNU|Intel)$")
+            string(APPEND native_config "c_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
         endif()
     endif()
     if(VCPKG_DETECTED_CMAKE_LINKER AND VCPKG_TARGET_IS_WINDOWS)
-        if (NOT VCPKG_DETECTED_CMAKE_CXX_COMPILER_ID MATCHES "^(GNU|Intel)$") # for gcc and icc the linker flag -fuse-ld is used. See https://github.com/mesonbuild/meson/issues/8647#issuecomment-878673456
-            string(APPEND NATIVE "cpp_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
+        # for gcc and icc the linker flag -fuse-ld is used. See https://github.com/mesonbuild/meson/issues/8647#issuecomment-878673456
+        if (NOT VCPKG_DETECTED_CMAKE_CXX_COMPILER_ID MATCHES "^(GNU|Intel)$")
+            string(APPEND native_config "cpp_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
         endif()
     endif()
-    string(APPEND NATIVE "cmake = '${CMAKE_COMMAND}'\n")
-    foreach(_binary IN LISTS ${_additional_binaries})
-        string(APPEND NATIVE "${_binary}\n")
+    string(APPEND native_config "cmake = '${CMAKE_COMMAND}'\n")
+    foreach(additional_binary IN LISTS additional_binaries)
+        string(APPEND native_config "${additional_binary}\n")
     endforeach()
 
-    string(APPEND NATIVE "[built-in options]\n") #https://mesonbuild.com/Builtin-options.html
+    string(APPEND native_config "[built-in options]\n") #https://mesonbuild.com/Builtin-options.html
     if(VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe")
         # This is currently wrongly documented in the meson docs or buggy. The docs say: 'none' = no flags
         # In reality however 'none' tries to deactivate eh and meson passes the flags for it resulting in a lot of warnings
         # about overriden flags. Until this is fixed in meson vcpkg should not pass this here.
-        # string(APPEND NATIVE "cpp_eh='none'\n") # To make sure meson is not adding eh flags by itself using msvc
+        # string(APPEND native_config "cpp_eh='none'\n") # To make sure meson is not adding eh flags by itself using msvc
     endif()
     if(VCPKG_TARGET_IS_WINDOWS)
-        string(REGEX REPLACE "( |^)(-|/)" ";\\2" WIN_C_STANDARD_LIBRARIES "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES}")
-        string(REGEX REPLACE "\\.lib " ".lib;" WIN_C_STANDARD_LIBRARIES "${WIN_C_STANDARD_LIBRARIES}")
-        list(TRANSFORM WIN_C_STANDARD_LIBRARIES APPEND "'")
-        list(TRANSFORM WIN_C_STANDARD_LIBRARIES PREPEND "'")
-        list(REMOVE_ITEM WIN_C_STANDARD_LIBRARIES "''")
-        list(JOIN WIN_C_STANDARD_LIBRARIES ", " WIN_C_STANDARD_LIBRARIES)
-        string(APPEND NATIVE "c_winlibs = [${WIN_C_STANDARD_LIBRARIES}]\n")
-        string(REGEX REPLACE "( |^)(-|/)" ";\\2" WIN_CXX_STANDARD_LIBRARIES "${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
-        string(REGEX REPLACE "\\.lib " ".lib;" WIN_CXX_STANDARD_LIBRARIES "${WIN_CXX_STANDARD_LIBRARIES}")
-        list(TRANSFORM WIN_CXX_STANDARD_LIBRARIES APPEND "'")
-        list(TRANSFORM WIN_CXX_STANDARD_LIBRARIES PREPEND "'")
-        list(REMOVE_ITEM WIN_CXX_STANDARD_LIBRARIES "''")
-        list(JOIN WIN_CXX_STANDARD_LIBRARIES ", " WIN_CXX_STANDARD_LIBRARIES)
-        string(APPEND NATIVE "cpp_winlibs = [${WIN_CXX_STANDARD_LIBRARIES}]\n")
-    endif()
-
-    set(_file "${CURRENT_BUILDTREES_DIR}/meson-nativ-${TARGET_TRIPLET}.log")
-    set(VCPKG_MESON_NATIVE_FILE "${_file}" PARENT_SCOPE)
-    file(WRITE "${_file}" "${NATIVE}")
+        set(c_winlibs "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES}")
+        set(cpp_winlibs "${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
+        foreach(libvar IN ITEMS c_winlibs cpp_winlibs)
+            string(REGEX REPLACE "( |^)(-|/)" [[;\2]] "${libvar}" "${${libvar}}")
+            string(REPLACE ".lib " ".lib;" "${libvar}" "${${libvar}}")
+            vcpkg_list(REMOVE_ITEM "${libvar}" "")
+            vcpkg_list(JOIN "${libvar}" "', '" "${libvar}")
+            string(APPEND native_config "${libvar} = ['${${libvar}}']\n")
+        endforeach()
+    endif()
+
+    set(native_config_name "${CURRENT_BUILDTREES_DIR}/meson-native-${TARGET_TRIPLET}.log")
+    set(vcpkg_meson_native_file "${native_config_name}" PARENT_SCOPE)
+    file(WRITE "${native_config_name}" "${native_config}")
 endfunction()
 
-function(vcpkg_internal_meson_convert_compiler_flags_to_list _out_var _compiler_flags)
-    string(REPLACE ";" "\\\;" tmp_var "${_compiler_flags}")
-    string(REGEX REPLACE [=[( +|^)((\"(\\\"|[^"])+\"|\\\"|\\ |[^ ])+)]=] ";\\2" ${_out_var} "${tmp_var}")
-    list(POP_FRONT ${_out_var}) # The first element is always empty due to the above replacement
-    list(TRANSFORM ${_out_var} STRIP) # Strip leading trailing whitespaces from each element in the list.
-    set(${_out_var} "${${_out_var}}" PARENT_SCOPE)
+function(z_vcpkg_meson_convert_compiler_flags_to_list out_var compiler_flags)
+    string(REPLACE ";" [[\;]] tmp_var "${compiler_flags}")
+    string(REGEX REPLACE [=[( +|^)((\"(\\"|[^"])+"|\\"|\\ |[^ ])+)]=] ";\\2" tmp_var "${tmp_var}")
+    vcpkg_list(POP_FRONT tmp_var) # The first element is always empty due to the above replacement
+    list(TRANSFORM tmp_var STRIP) # Strip leading trailing whitespaces from each element in the list.
+    set("${out_var}" "${tmp_var}" PARENT_SCOPE)
 endfunction()
 
-function(vcpkg_internal_meson_convert_list_to_python_array _out_var)
-    set(FLAG_LIST ${ARGN})
-    list(TRANSFORM FLAG_LIST APPEND "'")
-    list(TRANSFORM FLAG_LIST PREPEND "'")
-    list(JOIN FLAG_LIST ", " ${_out_var})
-    string(REPLACE "'', " "" ${_out_var} "${${_out_var}}") # remove empty elements if any
-    set(${_out_var} "[${${_out_var}}]" PARENT_SCOPE)
+function(z_vcpkg_meson_convert_list_to_python_array out_var)
+    z_vcpkg_function_arguments(flag_list 1)
+    vcpkg_list(REMOVE_ITEM flag_list "") # remove empty elements if any
+    vcpkg_list(JOIN flag_list "', '" flag_list)
+    set("${out_var}" "['${flag_list}']" PARENT_SCOPE)
 endfunction()
 
 # Generates the required compiler properties for meson
-function(vcpkg_internal_meson_generate_flags_properties_string _out_var _config)
+function(z_vcpkg_meson_generate_flags_properties_string out_var config_type)
+    set(result "")
+
     if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
-        set(L_FLAG /LIBPATH:)
+        set(libpath_flag /LIBPATH:)
+    else()
+        set(libpath_flag -L)
+    endif()
+    if(config_type STREQUAL "DEBUG")
+        set(path_suffix "/debug")
     else()
-        set(L_FLAG -L)
-    endif()
-    set(PATH_SUFFIX_DEBUG /debug)
-    set(LIBPATH_${_config} "${L_FLAG}${CURRENT_INSTALLED_DIR}${PATH_SUFFIX_${_config}}/lib")
-    vcpkg_internal_meson_convert_compiler_flags_to_list(MESON_CFLAGS_${_config} "${VCPKG_DETECTED_CMAKE_C_FLAGS_${_config}}")
-    list(APPEND MESON_CFLAGS_${_config} "-I${CURRENT_INSTALLED_DIR}/include")
-    vcpkg_internal_meson_convert_list_to_python_array(MESON_CFLAGS_${_config} ${MESON_CFLAGS_${_config}})
-    string(APPEND ${_out_var} "c_args = ${MESON_CFLAGS_${_config}}\n")
-    vcpkg_internal_meson_convert_compiler_flags_to_list(MESON_CXXFLAGS_${_config} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${_config}}")
-    list(APPEND MESON_CXXFLAGS_${_config} "-I${CURRENT_INSTALLED_DIR}/include")
-    vcpkg_internal_meson_convert_list_to_python_array(MESON_CXXFLAGS_${_config} ${MESON_CXXFLAGS_${_config}})
-    string(APPEND ${_out_var} "cpp_args = ${MESON_CXXFLAGS_${_config}}\n")
+        set(path_suffix "")
+    endif()
+
+    set(libpath "${libpath_flag}${CURRENT_INSTALLED_DIR}${path_suffix}/lib")
+
+    z_vcpkg_meson_convert_compiler_flags_to_list(cflags "${VCPKG_DETECTED_CMAKE_C_FLAGS_${config_type}}")
+    vcpkg_list(APPEND cflags "-I${CURRENT_INSTALLED_DIR}/include")
+    z_vcpkg_meson_convert_list_to_python_array(cflags ${cflags})
+    string(APPEND result "c_args = ${cflags}\n")
+
+    z_vcpkg_meson_convert_compiler_flags_to_list(cxxflags "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${config_type}}")
+    vcpkg_list(APPEND cxxflags "-I${CURRENT_INSTALLED_DIR}/include")
+    z_vcpkg_meson_convert_list_to_python_array(cxxflags ${cxxflags})
+    string(APPEND result "cpp_args = ${cxxflags}\n")
+
     if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
-        set(LINKER_FLAGS_${_config} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${_config}}")
+        set(linker_flags "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${config_type}}")
     else()
-        set(LINKER_FLAGS_${_config} "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${_config}}")
-    endif()
-    vcpkg_internal_meson_convert_compiler_flags_to_list(LINKER_FLAGS_${_config} "${LINKER_FLAGS_${_config}}")
-    list(APPEND LINKER_FLAGS_${_config} "${LIBPATH_${_config}}")
-    vcpkg_internal_meson_convert_list_to_python_array(LINKER_FLAGS_${_config} ${LINKER_FLAGS_${_config}})
-    string(APPEND ${_out_var} "c_link_args = ${LINKER_FLAGS_${_config}}\n")
-    string(APPEND ${_out_var} "cpp_link_args = ${LINKER_FLAGS_${_config}}\n")
-    set(${_out_var} "${${_out_var}}" PARENT_SCOPE)
+        set(linker_flags "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${config_type}}")
+    endif()
+    z_vcpkg_meson_convert_compiler_flags_to_list(linker_flags "${linker_flags}")
+    vcpkg_list(APPEND linker_flags "${libpath}")
+    z_vcpkg_meson_convert_list_to_python_array(linker_flags ${linker_flags})
+    string(APPEND result "c_link_args = ${linker_flags}\n")
+    string(APPEND result "cpp_link_args = ${linker_flags}\n")
+    set("${out_var}" "${result}" PARENT_SCOPE)
 endfunction()
 
-function(vcpkg_internal_meson_generate_native_file_config _config) #https://mesonbuild.com/Native-environments.html
-    set(NATIVE_${_config} "[properties]\n") #https://mesonbuild.com/Builtin-options.html
-    vcpkg_internal_meson_generate_flags_properties_string(NATIVE_PROPERTIES ${_config})
-    string(APPEND NATIVE_${_config} "${NATIVE_PROPERTIES}")
+function(z_vcpkg_meson_generate_native_file_config config_type) #https://mesonbuild.com/Native-environments.html
+    set(native_file "[properties]\n") #https://mesonbuild.com/Builtin-options.html
+    z_vcpkg_meson_generate_flags_properties_string(native_properties "${config_type}")
+    string(APPEND native_file "${native_properties}")
     #Setup CMake properties
-    string(APPEND NATIVE_${_config} "cmake_toolchain_file  = '${SCRIPTS}/buildsystems/vcpkg.cmake'\n")
-    string(APPEND NATIVE_${_config} "[cmake]\n")
+    string(APPEND native_file "cmake_toolchain_file  = '${SCRIPTS}/buildsystems/vcpkg.cmake'\n")
+    string(APPEND native_file "[cmake]\n")
 
     if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
         if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
@@ -182,49 +187,49 @@ function(vcpkg_internal_meson_generate_native_file_config _config) #https://meso
         endif()
     endif()
 
-    string(APPEND NATIVE_${_config} "VCPKG_TARGET_TRIPLET = '${TARGET_TRIPLET}'\n")
-    string(APPEND NATIVE_${_config} "VCPKG_CHAINLOAD_TOOLCHAIN_FILE = '${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}'\n")
-    string(APPEND NATIVE_${_config} "VCPKG_CRT_LINKAGE = '${VCPKG_CRT_LINKAGE}'\n")
+    string(APPEND native_file "VCPKG_TARGET_TRIPLET = '${TARGET_TRIPLET}'\n")
+    string(APPEND native_file "VCPKG_CHAINLOAD_TOOLCHAIN_FILE = '${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}'\n")
+    string(APPEND native_file "VCPKG_CRT_LINKAGE = '${VCPKG_CRT_LINKAGE}'\n")
 
-    string(APPEND NATIVE_${_config} "[built-in options]\n")
+    string(APPEND native_file "[built-in options]\n")
     if(VCPKG_TARGET_IS_WINDOWS)
         if(VCPKG_CRT_LINKAGE STREQUAL "static")
-            set(CRT mt)
+            set(crt_type mt)
         else()
-            set(CRT md)
+            set(crt_type md)
         endif()
-        if(${_config} STREQUAL DEBUG)
-            set(CRT ${CRT}d)
+        if("${config_type}" STREQUAL "DEBUG")
+            string(APPEND crt_type "d")
         endif()
-        string(APPEND NATIVE_${_config} "b_vscrt = '${CRT}'\n")
+        string(APPEND native_file "b_vscrt = '${crt_type}'\n")
     endif()
-    string(TOLOWER "${_config}" lowerconfig)
-    set(_file "${CURRENT_BUILDTREES_DIR}/meson-nativ-${TARGET_TRIPLET}-${lowerconfig}.log")
-    set(VCPKG_MESON_NATIVE_FILE_${_config} "${_file}" PARENT_SCOPE)
-    file(WRITE "${_file}" "${NATIVE_${_config}}")
+    string(TOLOWER "${config_type}" lowerconfig)
+    set(native_config_name "${CURRENT_BUILDTREES_DIR}/meson-native-${TARGET_TRIPLET}-${lowerconfig}.log")
+    file(WRITE "${native_config_name}" "${native_file}")
+    set("vcpkg_meson_native_file_${config_type}" "${native_config_name}" PARENT_SCOPE)
 endfunction()
 
-function(vcpkg_internal_meson_generate_cross_file _additional_binaries) #https://mesonbuild.com/Cross-compilation.html
+function(z_vcpkg_meson_generate_cross_file additional_binaries) #https://mesonbuild.com/Cross-compilation.html
     if(CMAKE_HOST_WIN32)
         if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
-            set(BUILD_ARCH $ENV{PROCESSOR_ARCHITEW6432})
+            set(build_arch $ENV{PROCESSOR_ARCHITEW6432})
         else()
-            set(BUILD_ARCH $ENV{PROCESSOR_ARCHITECTURE})
+            set(build_arch $ENV{PROCESSOR_ARCHITECTURE})
         endif()
-        if(BUILD_ARCH MATCHES "(amd|AMD)64")
-            set(BUILD_CPU_FAM x86_64)
-            set(BUILD_CPU x86_64)
-        elseif(BUILD_ARCH MATCHES "(x|X)86")
-            set(BUILD_CPU_FAM x86)
-            set(BUILD_CPU i686)
-        elseif(BUILD_ARCH MATCHES "^(ARM|arm)64$")
-            set(BUILD_CPU_FAM aarch64)
-            set(BUILD_CPU armv8)
-        elseif(BUILD_ARCH MATCHES "^(ARM|arm)$")
-            set(BUILD_CPU_FAM arm)
-            set(BUILD_CPU armv7hl)
+        if(build_arch MATCHES "(amd|AMD)64")
+            set(build_cpu_fam x86_64)
+            set(build_cpu x86_64)
+        elseif(build_arch MATCHES "(x|X)86")
+            set(build_cpu_fam x86)
+            set(build_cpu i686)
+        elseif(build_arch MATCHES "^(ARM|arm)64$")
+            set(build_cpu_fam aarch64)
+            set(build_cpu armv8)
+        elseif(build_arch MATCHES "^(ARM|arm)$")
+            set(build_cpu_fam arm)
+            set(build_cpu armv7hl)
         else()
-            message(FATAL_ERROR "Unsupported host architecture ${BUILD_ARCH}!")
+            message(FATAL_ERROR "Unsupported host architecture ${build_arch}!")
         endif()
     elseif(CMAKE_HOST_UNIX)
         # at this stage, CMAKE_HOST_SYSTEM_PROCESSOR is not defined
@@ -237,21 +242,18 @@ function(vcpkg_internal_meson_generate_cross_file _additional_binaries) #https:/
         debug_message("Machine: ${MACHINE}")
 
         if(MACHINE MATCHES "arm64")
-            set(BUILD_CPU_FAM aarch64)
-            set(BUILD_CPU armv8)
+            set(build_cpu_fam aarch64)
+            set(build_cpu armv8)
         elseif(MACHINE MATCHES "x86_64|amd64")
-            set(BUILD_CPU_FAM x86_64)
-            set(BUILD_CPU x86_64)
+            set(build_cpu_fam x86_64)
+            set(build_cpu x86_64)
         elseif(MACHINE MATCHES "x86|i686")
-            set(BUILD_CPU_FAM x86)
-            set(BUILD_CPU i686)
+            set(build_cpu_fam x86)
+            set(build_cpu i686)
         elseif(MACHINE MATCHES "i386")
-            set(BUILD_CPU_FAM x86)
-            set(BUILD_CPU i386)
+            set(build_cpu_fam x86)
+            set(build_cpu i386)
         else()
-            unset(BUILD_CPU_FAM)
-            unset(BUILD_CPU)
-
             # https://github.com/mesonbuild/meson/blob/master/docs/markdown/Reference-tables.md#cpu-families
             message(FATAL_ERROR "Unhandled machine: ${MACHINE}")
         endif()
@@ -260,21 +262,21 @@ function(vcpkg_internal_meson_generate_cross_file _additional_binaries) #https:/
     endif()
 
     if(VCPKG_TARGET_ARCHITECTURE MATCHES "(amd|AMD|x|X)64")
-        set(HOST_CPU_FAM x86_64)
-        set(HOST_CPU x86_64)
+        set(host_cpu_fam x86_64)
+        set(host_cpu x86_64)
     elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
-        set(HOST_CPU_FAM x86)
-        set(HOST_CPU i686)
+        set(host_cpu_fam x86)
+        set(host_cpu i686)
     elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$")
-        set(HOST_CPU_FAM aarch64)
-        set(HOST_CPU armv8)
+        set(host_cpu_fam aarch64)
+        set(host_cpu armv8)
     elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$")
-        set(HOST_CPU_FAM arm)
-        set(HOST_CPU armv7hl)
+        set(host_cpu_fam arm)
+        set(host_cpu armv7hl)
     else()
         message(FATAL_ERROR "Unsupported target architecture ${VCPKG_TARGET_ARCHITECTURE}!" )
     endif()
-    set(CROSS "[binaries]\n")
+    set(cross_file "[binaries]\n")
     if(VCPKG_TARGET_IS_WINDOWS)
         set(proglist MT)
     else()
@@ -283,96 +285,104 @@ function(vcpkg_internal_meson_generate_cross_file _additional_binaries) #https:/
     foreach(prog IN LISTS proglist)
         if(VCPKG_DETECTED_CMAKE_${prog})
             string(TOLOWER "${prog}" proglower)
-            string(APPEND CROSS "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}}'\n")
+            string(APPEND cross_file "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}}'\n")
         endif()
     endforeach()
-    set(compiler C CXX RC)
-    foreach(prog IN LISTS compiler)
+    set(programs C CXX RC)
+    foreach(prog IN LISTS programs)
         if(VCPKG_DETECTED_CMAKE_${prog}_COMPILER)
             string(REPLACE "CXX" "CPP" mesonprog "${prog}")
             string(REPLACE "RC" "windres" mesonprog "${mesonprog}") # https://mesonbuild.com/Windows-module.html
             string(TOLOWER "${mesonprog}" proglower)
-            string(APPEND CROSS "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}'\n")
+            string(APPEND cross_file "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}'\n")
         endif()
     endforeach()
     if(VCPKG_DETECTED_CMAKE_LINKER AND VCPKG_TARGET_IS_WINDOWS)
-        if (NOT VCPKG_DETECTED_CMAKE_C_COMPILER_ID MATCHES "^(GNU|Intel)$") # for gcc and icc the linker flag -fuse-ld is used. See https://github.com/mesonbuild/meson/issues/8647#issuecomment-878673456
-            string(APPEND CROSS "c_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
+        # for gcc and icc the linker flag -fuse-ld is used. See https://github.com/mesonbuild/meson/issues/8647#issuecomment-878673456
+        if (NOT VCPKG_DETECTED_CMAKE_C_COMPILER_ID MATCHES "^(GNU|Intel)$")
+            string(APPEND cross_file "c_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
         endif()
     endif()
     if(VCPKG_DETECTED_CMAKE_LINKER AND VCPKG_TARGET_IS_WINDOWS)
-        if (NOT VCPKG_DETECTED_CMAKE_CXX_COMPILER_ID MATCHES "^(GNU|Intel)$") # for gcc and icc the linker flag -fuse-ld is used. See https://github.com/mesonbuild/meson/issues/8647#issuecomment-878673456
-            string(APPEND CROSS "cpp_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
+        # for gcc and icc the linker flag -fuse-ld is used. See https://github.com/mesonbuild/meson/issues/8647#issuecomment-878673456
+        if (NOT VCPKG_DETECTED_CMAKE_CXX_COMPILER_ID MATCHES "^(GNU|Intel)$")
+            string(APPEND cross_file "cpp_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
         endif()
     endif()
-    string(APPEND CROSS "cmake = '${CMAKE_COMMAND}'\n")
-    foreach(_binary IN LISTS ${_additional_binaries})
-        string(APPEND CROSS "${_binary}\n")
+    string(APPEND cross_file "cmake = '${CMAKE_COMMAND}'\n")
+    foreach(additional_binary IN LISTS additional_binaries)
+        string(APPEND cross_file "${additional_binary}\n")
     endforeach()
 
-    string(APPEND CROSS "[properties]\n")
+    string(APPEND cross_file "[properties]\n")
 
-    string(APPEND CROSS "[host_machine]\n")
-    string(APPEND CROSS "endian = 'little'\n")
+    string(APPEND cross_file "[host_machine]\n")
+    string(APPEND cross_file "endian = 'little'\n")
     if(NOT VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_TARGET_IS_MINGW)
-        set(MESON_SYSTEM_NAME "windows")
+        set(meson_system_name "windows")
     else()
-        string(TOLOWER "${VCPKG_CMAKE_SYSTEM_NAME}" MESON_SYSTEM_NAME)
+        string(TOLOWER "${VCPKG_CMAKE_SYSTEM_NAME}" meson_system_name)
     endif()
-    string(APPEND CROSS "system = '${MESON_SYSTEM_NAME}'\n")
-    string(APPEND CROSS "cpu_family = '${HOST_CPU_FAM}'\n")
-    string(APPEND CROSS "cpu = '${HOST_CPU}'\n")
+    string(APPEND cross_file "system = '${meson_system_name}'\n")
+    string(APPEND cross_file "cpu_family = '${host_cpu_fam}'\n")
+    string(APPEND cross_file "cpu = '${host_cpu}'\n")
 
-    string(APPEND CROSS "[build_machine]\n")
-    string(APPEND CROSS "endian = 'little'\n")
+    string(APPEND cross_file "[build_machine]\n")
+    string(APPEND cross_file "endian = 'little'\n")
     if(WIN32)
-        string(APPEND CROSS "system = 'windows'\n")
+        string(APPEND cross_file "system = 'windows'\n")
     elseif(DARWIN)
-        string(APPEND CROSS "system = 'darwin'\n")
+        string(APPEND cross_file "system = 'darwin'\n")
     else()
-        string(APPEND CROSS "system = 'linux'\n")
+        string(APPEND cross_file "system = 'linux'\n")
     endif()
 
-    if(DEFINED BUILD_CPU_FAM)
-        string(APPEND CROSS "cpu_family = '${BUILD_CPU_FAM}'\n")
+    if(DEFINED build_cpu_fam)
+        string(APPEND cross_file "cpu_family = '${build_cpu_fam}'\n")
     endif()
-    if(DEFINED BUILD_CPU)
-        string(APPEND CROSS "cpu = '${BUILD_CPU}'\n")
+    if(DEFINED build_cpu)
+        string(APPEND cross_file "cpu = '${build_cpu}'\n")
     endif()
 
-    if(NOT BUILD_CPU_FAM MATCHES "${HOST_CPU_FAM}" OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_IOS OR VCPKG_TARGET_IS_UWP OR (VCPKG_TARGET_IS_MINGW AND NOT WIN32))
-        set(_file "${CURRENT_BUILDTREES_DIR}/meson-cross-${TARGET_TRIPLET}.log")
-        set(VCPKG_MESON_CROSS_FILE "${_file}" PARENT_SCOPE)
-        file(WRITE "${_file}" "${CROSS}")
+    if(NOT build_cpu_fam MATCHES "${host_cpu_fam}"
+       OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_IOS OR VCPKG_TARGET_IS_UWP
+       OR (VCPKG_TARGET_IS_MINGW AND NOT WIN32))
+        set(native_config_name "${CURRENT_BUILDTREES_DIR}/meson-cross-${TARGET_TRIPLET}.log")
+        set(vcpkg_meson_cross_file "${native_config_name}" PARENT_SCOPE)
+        file(WRITE "${native_config_name}" "${cross_file}")
     endif()
 endfunction()
 
-function(vcpkg_internal_meson_generate_cross_file_config _config) #https://mesonbuild.com/Native-environments.html
-    set(CROSS_${_config} "[properties]\n") #https://mesonbuild.com/Builtin-options.html
-    vcpkg_internal_meson_generate_flags_properties_string(CROSS_PROPERTIES ${_config})
-    string(APPEND CROSS_${_config} "${CROSS_PROPERTIES}")
-    string(APPEND CROSS_${_config} "[built-in options]\n")
+function(z_vcpkg_meson_generate_cross_file_config config_type) #https://mesonbuild.com/Native-environments.html
+    set(cross_${config_type}_log "[properties]\n") #https://mesonbuild.com/Builtin-options.html
+    z_vcpkg_meson_generate_flags_properties_string(cross_properties ${config_type})
+    string(APPEND cross_${config_type}_log "${cross_properties}")
+    string(APPEND cross_${config_type}_log "[built-in options]\n")
     if(VCPKG_TARGET_IS_WINDOWS)
         if(VCPKG_CRT_LINKAGE STREQUAL "static")
-            set(CRT mt)
+            set(crt_type mt)
         else()
-            set(CRT md)
+            set(crt_type md)
         endif()
-        if(${_config} STREQUAL DEBUG)
-            set(CRT ${CRT}d)
+        if(${config_type} STREQUAL "DEBUG")
+            set(crt_type ${crt_type}d)
         endif()
-        string(APPEND CROSS_${_config} "b_vscrt = '${CRT}'\n")
+        string(APPEND cross_${config_type}_log "b_vscrt = '${crt_type}'\n")
     endif()
-    string(TOLOWER "${_config}" lowerconfig)
-    set(_file "${CURRENT_BUILDTREES_DIR}/meson-cross-${TARGET_TRIPLET}-${lowerconfig}.log")
-    set(VCPKG_MESON_CROSS_FILE_${_config} "${_file}" PARENT_SCOPE)
-    file(WRITE "${_file}" "${CROSS_${_config}}")
+    string(TOLOWER "${config_type}" lowerconfig)
+    set(native_config_name "${CURRENT_BUILDTREES_DIR}/meson-cross-${TARGET_TRIPLET}-${lowerconfig}.log")
+    set(VCPKG_MESON_CROSS_FILE_${config_type} "${native_config_name}" PARENT_SCOPE)
+    file(WRITE "${native_config_name}" "${cross_${config_type}_log}")
 endfunction()
 
 
 function(vcpkg_configure_meson)
     # parse parameters such that semicolons in options arguments to COMMAND don't get erased
-    cmake_parse_arguments(PARSE_ARGV 0 _vcm "NO_PKG_CONFIG" "SOURCE_PATH" "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;ADDITIONAL_NATIVE_BINARIES;ADDITIONAL_CROSS_BINARIES")
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "NO_PKG_CONFIG"
+        "SOURCE_PATH"
+        "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;ADDITIONAL_NATIVE_BINARIES;ADDITIONAL_CROSS_BINARIES"
+    )
 
     file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
     file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
@@ -384,8 +394,8 @@ function(vcpkg_configure_meson)
     vcpkg_find_acquire_program(PYTHON3)
     get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY)
     vcpkg_add_to_path("${PYTHON3_DIR}")
-    list(APPEND _vcm_ADDITIONAL_NATIVE_BINARIES "python = '${PYTHON3}'")
-    list(APPEND _vcm_ADDITIONAL_CROSS_BINARIES "python = '${PYTHON3}'")
+    vcpkg_list(APPEND arg_ADDITIONAL_NATIVE_BINARIES "python = '${PYTHON3}'")
+    vcpkg_list(APPEND arg_ADDITIONAL_CROSS_BINARIES "python = '${PYTHON3}'")
 
     vcpkg_find_acquire_program(MESON)
 
@@ -395,158 +405,132 @@ function(vcpkg_configure_meson)
     vcpkg_find_acquire_program(NINJA)
     get_filename_component(NINJA_PATH ${NINJA} DIRECTORY)
     vcpkg_add_to_path(PREPEND "${NINJA_PATH}") # Need to prepend so that meson picks up the correct ninja from vcpkg ....
-    # list(APPEND _vcm_ADDITIONAL_NATIVE_BINARIES "ninja = '${NINJA}'") # This does not work due to meson issues ......
+    # vcpkg_list(APPEND arg_ADDITIONAL_NATIVE_BINARIES "ninja = '${NINJA}'") # This does not work due to meson issues ......
 
-    list(APPEND _vcm_OPTIONS --buildtype plain --backend ninja --wrap-mode nodownload)
+    vcpkg_list(APPEND arg_OPTIONS --buildtype plain --backend ninja --wrap-mode nodownload)
 
-    if(NOT VCPKG_MESON_CROSS_FILE)
-        vcpkg_internal_meson_generate_cross_file("_vcm_ADDITIONAL_CROSS_BINARIES")
+    if(NOT vcpkg_meson_cross_file)
+        z_vcpkg_meson_generate_cross_file("${arg_ADDITIONAL_CROSS_BINARIES}")
     endif()
-    if(NOT VCPKG_MESON_CROSS_FILE_DEBUG AND VCPKG_MESON_CROSS_FILE)
-        vcpkg_internal_meson_generate_cross_file_config(DEBUG)
+    # We must use uppercase `DEBUG` and `RELEASE` here because they matches the configuration data
+    if(NOT VCPKG_MESON_CROSS_FILE_DEBUG AND vcpkg_meson_cross_file)
+        z_vcpkg_meson_generate_cross_file_config(DEBUG)
     endif()
-    if(NOT VCPKG_MESON_CROSS_FILE_RELEASE AND VCPKG_MESON_CROSS_FILE)
-        vcpkg_internal_meson_generate_cross_file_config(RELEASE)
+    if(NOT VCPKG_MESON_CROSS_FILE_RELEASE AND vcpkg_meson_cross_file)
+        z_vcpkg_meson_generate_cross_file_config(RELEASE)
     endif()
-    if(VCPKG_MESON_CROSS_FILE)
-        list(APPEND _vcm_OPTIONS --cross "${VCPKG_MESON_CROSS_FILE}")
+    if(vcpkg_meson_cross_file)
+        vcpkg_list(APPEND arg_OPTIONS --cross "${vcpkg_meson_cross_file}")
     endif()
     if(VCPKG_MESON_CROSS_FILE_DEBUG)
-        list(APPEND _vcm_OPTIONS_DEBUG --cross "${VCPKG_MESON_CROSS_FILE_DEBUG}")
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG --cross "${VCPKG_MESON_CROSS_FILE_DEBUG}")
     endif()
     if(VCPKG_MESON_CROSS_FILE_RELEASE)
-        list(APPEND _vcm_OPTIONS_RELEASE --cross "${VCPKG_MESON_CROSS_FILE_RELEASE}")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --cross "${VCPKG_MESON_CROSS_FILE_RELEASE}")
     endif()
 
-    if(NOT VCPKG_MESON_NATIVE_FILE AND NOT VCPKG_MESON_CROSS_FILE)
-        vcpkg_internal_meson_generate_native_file("_vcm_ADDITIONAL_NATIVE_BINARIES")
+    if(NOT vcpkg_meson_native_file AND NOT vcpkg_meson_cross_file)
+        z_vcpkg_meson_generate_native_file("${arg_ADDITIONAL_NATIVE_BINARIES}")
     endif()
-    if(NOT VCPKG_MESON_NATIVE_FILE_DEBUG AND NOT VCPKG_MESON_CROSS_FILE)
-        vcpkg_internal_meson_generate_native_file_config(DEBUG)
+    if(NOT vcpkg_meson_native_file_DEBUG AND NOT vcpkg_meson_cross_file)
+        z_vcpkg_meson_generate_native_file_config(DEBUG)
     endif()
-    if(NOT VCPKG_MESON_NATIVE_FILE_RELEASE AND NOT VCPKG_MESON_CROSS_FILE)
-        vcpkg_internal_meson_generate_native_file_config(RELEASE)
+    if(NOT vcpkg_meson_native_file_RELEASE AND NOT vcpkg_meson_cross_file)
+        z_vcpkg_meson_generate_native_file_config(RELEASE)
     endif()
-    if(VCPKG_MESON_NATIVE_FILE AND NOT VCPKG_MESON_CROSS_FILE)
-        list(APPEND _vcm_OPTIONS --native "${VCPKG_MESON_NATIVE_FILE}")
-        list(APPEND _vcm_OPTIONS_DEBUG --native "${VCPKG_MESON_NATIVE_FILE_DEBUG}")
-        list(APPEND _vcm_OPTIONS_RELEASE --native "${VCPKG_MESON_NATIVE_FILE_RELEASE}")
+    if(vcpkg_meson_native_file AND NOT vcpkg_meson_cross_file)
+        vcpkg_list(APPEND arg_OPTIONS --native "${vcpkg_meson_native_file}")
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG --native "${vcpkg_meson_native_file_DEBUG}")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --native "${vcpkg_meson_native_file_RELEASE}")
     else()
-        list(APPEND _vcm_OPTIONS --native "${SCRIPTS}/buildsystems/meson/none.txt")
+        vcpkg_list(APPEND arg_OPTIONS --native "${SCRIPTS}/buildsystems/meson/none.txt")
     endif()
     if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
-        list(APPEND _vcm_OPTIONS --default-library shared)
+        vcpkg_list(APPEND arg_OPTIONS --default-library shared)
     else()
-        list(APPEND _vcm_OPTIONS --default-library static)
+        vcpkg_list(APPEND arg_OPTIONS --default-library static)
     endif()
 
-    list(APPEND _vcm_OPTIONS --libdir lib) # else meson install into an architecture describing folder
-    list(APPEND _vcm_OPTIONS_DEBUG -Ddebug=true --prefix ${CURRENT_PACKAGES_DIR}/debug --includedir ../include)
-    list(APPEND _vcm_OPTIONS_RELEASE -Ddebug=false --prefix  ${CURRENT_PACKAGES_DIR})
+    vcpkg_list(APPEND arg_OPTIONS --libdir lib) # else meson install into an architecture describing folder
+    vcpkg_list(APPEND arg_OPTIONS_DEBUG -Ddebug=true --prefix "${CURRENT_PACKAGES_DIR}/debug" --includedir ../include)
+    vcpkg_list(APPEND arg_OPTIONS_RELEASE -Ddebug=false --prefix "${CURRENT_PACKAGES_DIR}")
 
     # select meson cmd-line options
     if(VCPKG_TARGET_IS_WINDOWS)
-        list(APPEND _vcm_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/share']")
-        list(APPEND _vcm_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}/share']")
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/share']")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}/share']")
     else()
-        list(APPEND _vcm_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}']")
-        list(APPEND _vcm_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug']")
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}']")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug']")
     endif()
     
-    if(NOT _vcm_NO_PKG_CONFIG)
+    if(NOT arg_NO_PKG_CONFIG)
         vcpkg_find_acquire_program(PKGCONFIG)
         get_filename_component(PKGCONFIG_PATH ${PKGCONFIG} DIRECTORY)
         vcpkg_add_to_path("${PKGCONFIG_PATH}")
-        set(PKGCONFIG_SHARE_DIR "${CURRENT_INSTALLED_DIR}/share/pkgconfig/")
+        set(pkgconfig_share_dir "${CURRENT_INSTALLED_DIR}/share/pkgconfig/")
     endif()
     
     set(buildtypes)
     if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
-        set(BUILDNAME DEBUG)
-        list(APPEND buildtypes ${BUILDNAME})
-        set(PATH_SUFFIX_${BUILDNAME} "debug/")
-        set(SUFFIX_${BUILDNAME} "dbg")
+        set(buildname "DEBUG")
+        vcpkg_list(APPEND buildtypes ${buildname})
+        set(path_suffix_${buildname} "debug/")
+        set(suffix_${buildname} "dbg")
     endif()
     if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
-        set(BUILDNAME RELEASE)
-        list(APPEND buildtypes ${BUILDNAME})
-        set(PATH_SUFFIX_${BUILDNAME} "")
-        set(SUFFIX_${BUILDNAME} "rel")
+        set(buildname "RELEASE")
+        vcpkg_list(APPEND buildtypes ${buildname})
+        set(path_suffix_${buildname} "")
+        set(suffix_${buildname} "rel")
     endif()
 
     if(VCPKG_TARGET_IS_OSX)
-        if(DEFINED ENV{SDKROOT})
-            set(_VCPKG_ENV_SDKROOT_BACKUP $ENV{SDKROOT})
-        endif()
+        vcpkg_backup_env_variables(VARS SDKROOT MACOSX_DEPLOYMENT_TARGET)
+
         set(ENV{SDKROOT} "${VCPKG_DETECTED_CMAKE_OSX_SYSROOT}")
         set(VCPKG_DETECTED_CMAKE_OSX_SYSROOT "${VCPKG_DETECTED_CMAKE_OSX_SYSROOT}" PARENT_SCOPE)
 
-        if(DEFINED ENV{MACOSX_DEPLOYMENT_TARGET})
-            set(_VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP $ENV{MACOSX_DEPLOYMENT_TARGET})
-        endif()
         set(ENV{MACOSX_DEPLOYMENT_TARGET} "${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET}")
         set(VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET "${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET}" PARENT_SCOPE)
     endif()
 
-    if(DEFINED ENV{INCLUDE})
-        set(ENV{INCLUDE} "$ENV{INCLUDE}${VCPKG_HOST_PATH_SEPARATOR}${CURRENT_INSTALLED_DIR}/include")
-    else()
-        set(ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include")
-    endif()
+    vcpkg_backup_env_variables(VARS INCLUDE)
+    vcpkg_host_path_list(APPEND ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include")
     # configure build
     foreach(buildtype IN LISTS buildtypes)
-        message(STATUS "Configuring ${TARGET_TRIPLET}-${SUFFIX_${buildtype}}")
-        file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}")
+        message(STATUS "Configuring ${TARGET_TRIPLET}-${suffix_${buildtype}}")
+        file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}")
         #setting up PKGCONFIG
-        if(NOT _vcm_NO_PKG_CONFIG)
+        vcpkg_backup_env_variables(VARS PKG_CONFIG PKG_CONFIG_PATH)
+        if(NOT arg_NO_PKG_CONFIG)
             set(ENV{PKG_CONFIG} "${PKGCONFIG}") # Set via native file?
-            set(PKGCONFIG_INSTALLED_DIR "${CURRENT_INSTALLED_DIR}/${PATH_SUFFIX_${buildtype}}lib/pkgconfig/")
-            if(DEFINED ENV{PKG_CONFIG_PATH})
-                set(BACKUP_ENV_PKG_CONFIG_PATH_RELEASE $ENV{PKG_CONFIG_PATH})
-                set(ENV{PKG_CONFIG_PATH} "${PKGCONFIG_INSTALLED_DIR}${VCPKG_HOST_PATH_SEPARATOR}${PKGCONFIG_SHARE_DIR}${VCPKG_HOST_PATH_SEPARATOR}$ENV{PKG_CONFIG_PATH}")
-            else()
-                set(ENV{PKG_CONFIG_PATH} "${PKGCONFIG_INSTALLED_DIR}${VCPKG_HOST_PATH_SEPARATOR}${PKGCONFIG_SHARE_DIR}")
-            endif()
+            set(pkgconfig_installed_dir "${CURRENT_INSTALLED_DIR}/${path_suffix_${buildtype}}lib/pkgconfig/")
+            vcpkg_host_path_list(APPEND ENV{PKG_CONFIG_PATH} "${pkgconfig_installed_dir}" "${pkgconfig_share_dir}" "$ENV{PKG_CONFIG_PATH}")
         endif()
 
         vcpkg_execute_required_process(
-            COMMAND ${MESON} ${_vcm_OPTIONS} ${_vcm_OPTIONS_${buildtype}} ${_vcm_SOURCE_PATH}
-            WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}
-            LOGNAME config-${TARGET_TRIPLET}-${SUFFIX_${buildtype}}
+            COMMAND ${MESON} ${arg_OPTIONS} ${arg_OPTIONS_${buildtype}} ${arg_SOURCE_PATH}
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}"
+            LOGNAME config-${TARGET_TRIPLET}-${suffix_${buildtype}}
         )
 
         #Copy meson log files into buildtree for CI
-        if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/meson-log.txt")
-            file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/meson-log.txt" DESTINATION "${CURRENT_BUILDTREES_DIR}")
-            file(RENAME "${CURRENT_BUILDTREES_DIR}/meson-log.txt" "${CURRENT_BUILDTREES_DIR}/meson-log-${SUFFIX_${buildtype}}.txt")
-        endif()
-        if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/install-log.txt")
-            file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/install-log.txt" DESTINATION "${CURRENT_BUILDTREES_DIR}")
-            file(RENAME "${CURRENT_BUILDTREES_DIR}/install-log.txt" "${CURRENT_BUILDTREES_DIR}/install-log-${SUFFIX_${buildtype}}.txt")
+        if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}/meson-logs/meson-log.txt")
+            file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}/meson-logs/meson-log.txt" DESTINATION "${CURRENT_BUILDTREES_DIR}")
+            file(RENAME "${CURRENT_BUILDTREES_DIR}/meson-log.txt" "${CURRENT_BUILDTREES_DIR}/meson-log-${suffix_${buildtype}}.txt")
         endif()
-        message(STATUS "Configuring ${TARGET_TRIPLET}-${SUFFIX_${buildtype}} done")
-
-        if(NOT _vcm_NO_PKG_CONFIG)
-            #Restore PKG_CONFIG_PATH
-            if(BACKUP_ENV_PKG_CONFIG_PATH_${buildtype})
-                set(ENV{PKG_CONFIG_PATH} "${BACKUP_ENV_PKG_CONFIG_PATH_${buildtype}}")
-                unset(BACKUP_ENV_PKG_CONFIG_PATH_${buildtype})
-            else()
-                unset(ENV{PKG_CONFIG_PATH})
-            endif()
+        if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}/meson-logs/install-log.txt")
+            file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}/meson-logs/install-log.txt" DESTINATION "${CURRENT_BUILDTREES_DIR}")
+            file(RENAME "${CURRENT_BUILDTREES_DIR}/install-log.txt" "${CURRENT_BUILDTREES_DIR}/install-log-${suffix_${buildtype}}.txt")
         endif()
+        message(STATUS "Configuring ${TARGET_TRIPLET}-${suffix_${buildtype}} done")
+
+        vcpkg_restore_env_variables(VARS PKG_CONFIG PKG_CONFIG_PATH)
     endforeach()
 
     if(VCPKG_TARGET_IS_OSX)
-        if(DEFINED _VCPKG_ENV_SDKROOT_BACKUP)
-            set(ENV{SDKROOT} "${_VCPKG_ENV_SDKROOT_BACKUP}")
-        else()
-            unset(ENV{SDKROOT})
-        endif()
-        if(DEFINED _VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP)
-            set(ENV{MACOSX_DEPLOYMENT_TARGET} "${_VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP}")
-        else()
-            unset(ENV{MACOSX_DEPLOYMENT_TARGET})
-        endif()
+        vcpkg_restore_env_variables(VARS SDKROOT MACOSX_DEPLOYMENT_TARGET)
     endif()
+    vcpkg_restore_env_variables(VARS INCLUDE)
 endfunction()
diff --git a/scripts/cmake/vcpkg_install_meson.cmake b/scripts/cmake/vcpkg_install_meson.cmake
index 3e89b457e20769..e59162d0a43a73 100644
--- a/scripts/cmake/vcpkg_install_meson.cmake
+++ b/scripts/cmake/vcpkg_install_meson.cmake
@@ -19,87 +19,73 @@ Adds the appropriate Release and Debug `bin\` directories to the path during the
 #]===]
 
 function(vcpkg_install_meson)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "ADD_BIN_TO_PATH" "" "")
+
     vcpkg_find_acquire_program(NINJA)
     unset(ENV{DESTDIR}) # installation directory was already specified with '--prefix' option
-    cmake_parse_arguments(PARSE_ARGV 0 _im "ADD_BIN_TO_PATH" "" "")
 
     if(VCPKG_TARGET_IS_OSX)
-        if(DEFINED ENV{SDKROOT})
-            set(_VCPKG_ENV_SDKROOT_BACKUP $ENV{SDKROOT})
-        endif()
+        vcpkg_backup_env_variables(VARS SDKROOT MACOSX_DEPLOYMENT_TARGET)
         set(ENV{SDKROOT} "${VCPKG_DETECTED_CMAKE_OSX_SYSROOT}")
-
-        if(DEFINED ENV{MACOSX_DEPLOYMENT_TARGET})
-            set(_VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP $ENV{MACOSX_DEPLOYMENT_TARGET})
-        endif()
         set(ENV{MACOSX_DEPLOYMENT_TARGET} "${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET}")
     endif()
 
-    foreach(BUILDTYPE "debug" "release")
-        if(DEFINED VCPKG_BUILD_TYPE AND NOT VCPKG_BUILD_TYPE STREQUAL BUILDTYPE)
+    foreach(buildtype IN ITEMS "debug" "release")
+        if(DEFINED VCPKG_BUILD_TYPE AND NOT VCPKG_BUILD_TYPE STREQUAL buildtype)
             continue()
         endif()
 
-        if(BUILDTYPE STREQUAL "debug")
-            set(SHORT_BUILDTYPE "dbg")
+        if(buildtype STREQUAL "debug")
+            set(short_buildtype "dbg")
         else()
-            set(SHORT_BUILDTYPE "rel")
+            set(short_buildtype "rel")
         endif()
 
-        message(STATUS "Package ${TARGET_TRIPLET}-${SHORT_BUILDTYPE}")
-        if(_im_ADD_BIN_TO_PATH)
-            set(_BACKUP_ENV_PATH "$ENV{PATH}")
-            if(BUILDTYPE STREQUAL "debug")
+        message(STATUS "Package ${TARGET_TRIPLET}-${short_buildtype}")
+        if(arg_ADD_BIN_TO_PATH)
+            vcpkg_backup_env_variables(VARS PATH)
+            if(buildtype STREQUAL "debug")
                 vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/debug/bin")
             else()
                 vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/bin")
             endif()
         endif()
         vcpkg_execute_required_process(
-            COMMAND ${NINJA} install -v
-            WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SHORT_BUILDTYPE}
-            LOGNAME package-${TARGET_TRIPLET}-${SHORT_BUILDTYPE}
+            COMMAND "${NINJA}" install -v
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_buildtype}"
+            LOGNAME package-${TARGET_TRIPLET}-${short_buildtype}
         )
-        if(_im_ADD_BIN_TO_PATH)
-            set(ENV{PATH} "${_BACKUP_ENV_PATH}")
+        if(arg_ADD_BIN_TO_PATH)
+            vcpkg_restore_env_variables(VARS PATH)
         endif()
     endforeach()
 
-    set(RENAMED_LIBS "")
+    vcpkg_list(SET renamed_libs)
     if(VCPKG_TARGET_IS_WINDOWS AND VCPKG_LIBRARY_LINKAGE STREQUAL static AND NOT VCPKG_TARGET_IS_MINGW)
         # Meson names all static libraries lib<name>.a which basically breaks the world
-        file(GLOB_RECURSE LIBRARIES "${CURRENT_PACKAGES_DIR}*/**/lib*.a")
-        foreach(_library IN LISTS LIBRARIES)
-            get_filename_component(LIBDIR "${_library}" DIRECTORY )
-            get_filename_component(LIBNAME "${_library}" NAME)
-            string(REGEX REPLACE ".a$" ".lib" LIBNAMENEW "${LIBNAME}")
-            string(REGEX REPLACE "^lib" "" LIBNAMENEW "${LIBNAMENEW}")
-            file(RENAME "${_library}" "${LIBDIR}/${LIBNAMENEW}")
+        file(GLOB_RECURSE gen_libraries "${CURRENT_PACKAGES_DIR}*/**/lib*.a")
+        foreach(gen_library IN LISTS gen_libraries)
+            get_filename_component(libdir "${gen_library}" DIRECTORY)
+            get_filename_component(libname "${gen_library}" NAME)
+            string(REGEX REPLACE ".a$" ".lib" fixed_librawname "${libname}")
+            string(REGEX REPLACE "^lib" "" fixed_librawname "${fixed_librawname}")
+            file(RENAME "${gen_library}" "${libdir}/${fixed_librawname}")
             # For cmake fixes.
-            string(REGEX REPLACE ".a$" "" LIBRAWNAMEOLD "${LIBNAME}")
-            string(REGEX REPLACE ".lib$" "" LIBRAWNAMENEW "${LIBNAMENEW}")
-            list(APPEND RENAMED_LIBS ${LIBRAWNAMENEW})
-            set(${LIBRAWNAME}_OLD ${LIBRAWNAMEOLD})
-            set(${LIBRAWNAME}_NEW ${LIBRAWNAMENEW})
+            string(REGEX REPLACE ".a$" "" origin_librawname "${libname}")
+            string(REGEX REPLACE ".lib$" "" fixed_librawname "${fixed_librawname}")
+            vcpkg_list(APPEND renamed_libs ${fixed_librawname})
+            set(${librawname}_old ${origin_librawname})
+            set(${librawname}_new ${fixed_librawname})
         endforeach()
-        file(GLOB_RECURSE CMAKE_FILES "${CURRENT_PACKAGES_DIR}*/*.cmake")
-        foreach(_cmake IN LISTS CMAKE_FILES)
-            foreach(_lib IN LISTS RENAMED_LIBS)
-                vcpkg_replace_string("${_cmake}" "${${_lib}_OLD}" "${${_lib}_NEW}")
+        file(GLOB_RECURSE cmake_files "${CURRENT_PACKAGES_DIR}*/*.cmake")
+        foreach(cmake_file IN LISTS cmake_files)
+            foreach(current_lib IN LISTS renamed_libs)
+                vcpkg_replace_string("${cmake_file}" "${${current_lib}_old}" "${${current_lib}_new}")
             endforeach()
         endforeach()
     endif()
 
     if(VCPKG_TARGET_IS_OSX)
-        if(DEFINED _VCPKG_ENV_SDKROOT_BACKUP)
-            set(ENV{SDKROOT} "${_VCPKG_ENV_SDKROOT_BACKUP}")
-        else()
-            unset(ENV{SDKROOT})
-        endif()
-        if(DEFINED _VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP)
-            set(ENV{MACOSX_DEPLOYMENT_TARGET} "${_VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP}")
-        else()
-            unset(ENV{MACOSX_DEPLOYMENT_TARGET})
-        endif()
+        vcpkg_restore_env_variables(VARS SDKROOT MACOSX_DEPLOYMENT_TARGET)
     endif()
 endfunction()