]>
Commit | Line | Data |
---|---|---|
1e59de90 TL |
1 | #[===[.md: |
2 | # vcpkg_configure_meson | |
3 | ||
4 | Configure Meson for Debug and Release builds of a project. | |
5 | ||
6 | ## Usage | |
7 | ```cmake | |
8 | vcpkg_configure_meson( | |
9 | SOURCE_PATH <${SOURCE_PATH}> | |
10 | [OPTIONS <-DUSE_THIS_IN_ALL_BUILDS=1>...] | |
11 | [OPTIONS_RELEASE <-DOPTIMIZE=1>...] | |
12 | [OPTIONS_DEBUG <-DDEBUGGABLE=1>...] | |
13 | ) | |
14 | ``` | |
15 | ||
16 | ## Parameters | |
17 | ### SOURCE_PATH | |
18 | Specifies the directory containing the `meson.build`. | |
19 | By convention, this is usually set in the portfile as the variable `SOURCE_PATH`. | |
20 | ||
21 | ### OPTIONS | |
22 | Additional options passed to Meson during the configuration. | |
23 | ||
24 | ### OPTIONS_RELEASE | |
25 | Additional options passed to Meson during the Release configuration. These are in addition to `OPTIONS`. | |
26 | ||
27 | ### OPTIONS_DEBUG | |
28 | Additional options passed to Meson during the Debug configuration. These are in addition to `OPTIONS`. | |
29 | ||
30 | ## Notes | |
31 | This command supplies many common arguments to Meson. To see the full list, examine the source. | |
32 | ||
33 | ## Examples | |
34 | ||
35 | * [fribidi](https://github.com/Microsoft/vcpkg/blob/master/ports/fribidi/portfile.cmake) | |
36 | * [libepoxy](https://github.com/Microsoft/vcpkg/blob/master/ports/libepoxy/portfile.cmake) | |
37 | #]===] | |
38 | ||
39 | function(vcpkg_internal_meson_generate_native_file _additional_binaries) #https://mesonbuild.com/Native-environments.html | |
40 | set(NATIVE "[binaries]\n") | |
41 | #set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT) | |
42 | if(VCPKG_TARGET_IS_WINDOWS) | |
43 | set(proglist MT) | |
44 | else() | |
45 | set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT) | |
46 | endif() | |
47 | foreach(prog IN LISTS proglist) | |
48 | if(VCPKG_DETECTED_CMAKE_${prog}) | |
49 | string(TOLOWER "${prog}" proglower) | |
50 | string(APPEND NATIVE "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}}'\n") | |
51 | endif() | |
52 | endforeach() | |
53 | set(compiler C CXX RC) | |
54 | foreach(prog IN LISTS compiler) | |
55 | if(VCPKG_DETECTED_CMAKE_${prog}_COMPILER) | |
56 | string(REPLACE "CXX" "CPP" mesonprog "${prog}") | |
57 | string(TOLOWER "${mesonprog}" proglower) | |
58 | string(APPEND NATIVE "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}'\n") | |
59 | endif() | |
60 | endforeach() | |
61 | if(VCPKG_DETECTED_CMAKE_LINKER AND VCPKG_TARGET_IS_WINDOWS) | |
62 | string(APPEND NATIVE "c_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n") | |
63 | string(APPEND NATIVE "cpp_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n") | |
64 | endif() | |
65 | string(APPEND NATIVE "cmake = '${CMAKE_COMMAND}'\n") | |
66 | foreach(_binary IN LISTS ${_additional_binaries}) | |
67 | string(APPEND NATIVE "${_binary}\n") | |
68 | endforeach() | |
69 | ||
70 | string(APPEND NATIVE "[built-in options]\n") #https://mesonbuild.com/Builtin-options.html | |
71 | if(VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe") | |
72 | # This is currently wrongly documented in the meson docs or buggy. The docs say: 'none' = no flags | |
73 | # In reality however 'none' tries to deactivate eh and meson passes the flags for it resulting in a lot of warnings | |
74 | # about overriden flags. Until this is fixed in meson vcpkg should not pass this here. | |
75 | # string(APPEND NATIVE "cpp_eh='none'\n") # To make sure meson is not adding eh flags by itself using msvc | |
76 | endif() | |
77 | if(VCPKG_TARGET_IS_WINDOWS) | |
78 | string(REGEX REPLACE "( |^)(-|/)" ";\\2" WIN_C_STANDARD_LIBRARIES "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES}") | |
79 | string(REGEX REPLACE "\\.lib " ".lib;" WIN_C_STANDARD_LIBRARIES "${WIN_C_STANDARD_LIBRARIES}") | |
80 | list(TRANSFORM WIN_C_STANDARD_LIBRARIES APPEND "'") | |
81 | list(TRANSFORM WIN_C_STANDARD_LIBRARIES PREPEND "'") | |
82 | list(JOIN WIN_C_STANDARD_LIBRARIES ", " WIN_C_STANDARD_LIBRARIES) | |
83 | string(APPEND NATIVE "c_winlibs = [${WIN_C_STANDARD_LIBRARIES}]\n") | |
84 | string(REGEX REPLACE "( |^)(-|/)" ";\\2" WIN_CXX_STANDARD_LIBRARIES "${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}") | |
85 | string(REGEX REPLACE "\\.lib " ".lib;" WIN_CXX_STANDARD_LIBRARIES "${WIN_CXX_STANDARD_LIBRARIES}") | |
86 | list(TRANSFORM WIN_CXX_STANDARD_LIBRARIES APPEND "'") | |
87 | list(TRANSFORM WIN_CXX_STANDARD_LIBRARIES PREPEND "'") | |
88 | list(JOIN WIN_CXX_STANDARD_LIBRARIES ", " WIN_CXX_STANDARD_LIBRARIES) | |
89 | string(APPEND NATIVE "cpp_winlibs = [${WIN_CXX_STANDARD_LIBRARIES}]\n") | |
90 | endif() | |
91 | ||
92 | set(_file "${CURRENT_BUILDTREES_DIR}/meson-nativ-${TARGET_TRIPLET}.log") | |
93 | set(VCPKG_MESON_NATIVE_FILE "${_file}" PARENT_SCOPE) | |
94 | file(WRITE "${_file}" "${NATIVE}") | |
95 | endfunction() | |
96 | ||
97 | function(vcpkg_internal_meson_convert_compiler_flags_to_list _out_var _compiler_flags) | |
98 | string(REPLACE ";" "\\\;" tmp_var "${_compiler_flags}") | |
99 | string(REGEX REPLACE [=[( +|^)((\"(\\\"|[^"])+\"|\\\"|\\ |[^ ])+)]=] ";\\2" ${_out_var} "${tmp_var}") | |
100 | list(POP_FRONT ${_out_var}) # The first element is always empty due to the above replacement | |
101 | list(TRANSFORM ${_out_var} STRIP) # Strip leading trailing whitespaces from each element in the list. | |
102 | set(${_out_var} "${${_out_var}}" PARENT_SCOPE) | |
103 | endfunction() | |
104 | ||
105 | function(vcpkg_internal_meson_convert_list_to_python_array _out_var) | |
106 | set(FLAG_LIST ${ARGN}) | |
107 | list(TRANSFORM FLAG_LIST APPEND "'") | |
108 | list(TRANSFORM FLAG_LIST PREPEND "'") | |
109 | list(JOIN FLAG_LIST ", " ${_out_var}) | |
110 | string(REPLACE "'', " "" ${_out_var} "${${_out_var}}") # remove empty elements if any | |
111 | set(${_out_var} "[${${_out_var}}]" PARENT_SCOPE) | |
112 | endfunction() | |
113 | ||
114 | # Generates the required compiler properties for meson | |
115 | function(vcpkg_internal_meson_generate_flags_properties_string _out_var _config) | |
116 | if(VCPKG_TARGET_IS_WINDOWS) | |
117 | set(L_FLAG /LIBPATH:) | |
118 | else() | |
119 | set(L_FLAG -L) | |
120 | endif() | |
121 | set(PATH_SUFFIX_DEBUG /debug) | |
122 | set(LIBPATH_${_config} "${L_FLAG}${CURRENT_INSTALLED_DIR}${PATH_SUFFIX_${_config}}/lib") | |
123 | vcpkg_internal_meson_convert_compiler_flags_to_list(MESON_CFLAGS_${_config} "${VCPKG_DETECTED_CMAKE_C_FLAGS_${_config}}") | |
124 | list(APPEND MESON_CFLAGS_${_config} "-I\"${CURRENT_INSTALLED_DIR}/include\"") | |
125 | vcpkg_internal_meson_convert_list_to_python_array(MESON_CFLAGS_${_config} ${MESON_CFLAGS_${_config}}) | |
126 | string(APPEND ${_out_var} "c_args = ${MESON_CFLAGS_${_config}}\n") | |
127 | vcpkg_internal_meson_convert_compiler_flags_to_list(MESON_CXXFLAGS_${_config} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${_config}}") | |
128 | list(APPEND MESON_CXXFLAGS_${_config} "-I\"${CURRENT_INSTALLED_DIR}/include\"") | |
129 | vcpkg_internal_meson_convert_list_to_python_array(MESON_CXXFLAGS_${_config} ${MESON_CXXFLAGS_${_config}}) | |
130 | string(APPEND ${_out_var} "cpp_args = ${MESON_CXXFLAGS_${_config}}\n") | |
131 | if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic") | |
132 | set(LINKER_FLAGS_${_config} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${_config}}") | |
133 | else() | |
134 | set(LINKER_FLAGS_${_config} "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${_config}}") | |
135 | endif() | |
136 | vcpkg_internal_meson_convert_compiler_flags_to_list(LINKER_FLAGS_${_config} "${LINKER_FLAGS_${_config}}") | |
137 | list(APPEND LINKER_FLAGS_${_config} "${LIBPATH_${_config}}") | |
138 | vcpkg_internal_meson_convert_list_to_python_array(LINKER_FLAGS_${_config} ${LINKER_FLAGS_${_config}}) | |
139 | string(APPEND ${_out_var} "c_link_args = ${LINKER_FLAGS_${_config}}\n") | |
140 | string(APPEND ${_out_var} "cpp_link_args = ${LINKER_FLAGS_${_config}}\n") | |
141 | set(${_out_var} "${${_out_var}}" PARENT_SCOPE) | |
142 | endfunction() | |
143 | ||
144 | function(vcpkg_internal_meson_generate_native_file_config _config) #https://mesonbuild.com/Native-environments.html | |
145 | set(NATIVE_${_config} "[properties]\n") #https://mesonbuild.com/Builtin-options.html | |
146 | vcpkg_internal_meson_generate_flags_properties_string(NATIVE_PROPERTIES ${_config}) | |
147 | string(APPEND NATIVE_${_config} "${NATIVE_PROPERTIES}") | |
148 | #Setup CMake properties | |
149 | string(APPEND NATIVE_${_config} "cmake_toolchain_file = '${SCRIPTS}/buildsystems/vcpkg.cmake'\n") | |
150 | string(APPEND NATIVE_${_config} "[cmake]\n") | |
151 | ||
152 | if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE) | |
153 | if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW) | |
154 | set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/windows.cmake") | |
155 | elseif(VCPKG_TARGET_IS_LINUX) | |
156 | set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/linux.cmake") | |
157 | elseif(VCPKG_TARGET_IS_ANDROID) | |
158 | set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/android.cmake") | |
159 | elseif(VCPKG_TARGET_IS_OSX) | |
160 | set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/osx.cmake") | |
161 | elseif(VCPKG_TARGET_IS_IOS) | |
162 | set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/ios.cmake") | |
163 | elseif(VCPKG_TARGET_IS_FREEBSD) | |
164 | set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/freebsd.cmake") | |
165 | elseif(VCPKG_TARGET_IS_OPENBSD) | |
166 | set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/openbsd.cmake") | |
167 | elseif(VCPKG_TARGET_IS_MINGW) | |
168 | set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/mingw.cmake") | |
169 | endif() | |
170 | endif() | |
171 | ||
172 | string(APPEND NATIVE_${_config} "VCPKG_TARGET_TRIPLET = '${TARGET_TRIPLET}'\n") | |
173 | string(APPEND NATIVE_${_config} "VCPKG_CHAINLOAD_TOOLCHAIN_FILE = '${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}'\n") | |
174 | string(APPEND NATIVE_${_config} "VCPKG_CRT_LINKAGE = '${VCPKG_CRT_LINKAGE}'\n") | |
175 | ||
176 | string(APPEND NATIVE_${_config} "[built-in options]\n") | |
177 | if(VCPKG_TARGET_IS_WINDOWS) | |
178 | if(VCPKG_CRT_LINKAGE STREQUAL "static") | |
179 | set(CRT mt) | |
180 | else() | |
181 | set(CRT md) | |
182 | endif() | |
183 | if(${_config} STREQUAL DEBUG) | |
184 | set(CRT ${CRT}d) | |
185 | endif() | |
186 | string(APPEND NATIVE_${_config} "b_vscrt = '${CRT}'\n") | |
187 | endif() | |
188 | string(TOLOWER "${_config}" lowerconfig) | |
189 | set(_file "${CURRENT_BUILDTREES_DIR}/meson-nativ-${TARGET_TRIPLET}-${lowerconfig}.log") | |
190 | set(VCPKG_MESON_NATIVE_FILE_${_config} "${_file}" PARENT_SCOPE) | |
191 | file(WRITE "${_file}" "${NATIVE_${_config}}") | |
192 | endfunction() | |
193 | ||
194 | function(vcpkg_internal_meson_generate_cross_file _additional_binaries) #https://mesonbuild.com/Cross-compilation.html | |
195 | if(CMAKE_HOST_WIN32) | |
196 | if(DEFINED ENV{PROCESSOR_ARCHITEW6432}) | |
197 | set(BUILD_ARCH $ENV{PROCESSOR_ARCHITEW6432}) | |
198 | else() | |
199 | set(BUILD_ARCH $ENV{PROCESSOR_ARCHITECTURE}) | |
200 | endif() | |
201 | if(BUILD_ARCH MATCHES "(amd|AMD)64") | |
202 | set(BUILD_CPU_FAM x86_x64) | |
203 | set(BUILD_CPU x86_x64) | |
204 | elseif(BUILD_ARCH MATCHES "(x|X)86") | |
205 | set(BUILD_CPU_FAM x86) | |
206 | set(BUILD_CPU i686) | |
207 | elseif(BUILD_ARCH MATCHES "^(ARM|arm)64$") | |
208 | set(BUILD_CPU_FAM aarch64) | |
209 | set(BUILD_CPU armv8) | |
210 | elseif(BUILD_ARCH MATCHES "^(ARM|arm)$") | |
211 | set(BUILD_CPU_FAM arm) | |
212 | set(BUILD_CPU armv7hl) | |
213 | else() | |
214 | message(FATAL_ERROR "Unsupported host architecture ${BUILD_ARCH}!" ) | |
215 | endif() | |
216 | else() # TODO: add correct detection for OSX and Linux. Currently only x64 triplets are available in official vcpkg. | |
217 | set(BUILD_CPU_FAM x86_x64) | |
218 | set(BUILD_CPU x86_x64) | |
219 | endif() | |
220 | ||
221 | if(VCPKG_TARGET_ARCHITECTURE MATCHES "(amd|AMD|x|X)64") | |
222 | set(HOST_CPU_FAM x86_x64) | |
223 | set(HOST_CPU x86_x64) | |
224 | elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86") | |
225 | set(HOST_CPU_FAM x86) | |
226 | set(HOST_CPU i686) | |
227 | elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$") | |
228 | set(HOST_CPU_FAM aarch64) | |
229 | set(HOST_CPU armv8) | |
230 | elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$") | |
231 | set(HOST_CPU_FAM arm) | |
232 | set(HOST_CPU armv7hl) | |
233 | else() | |
234 | message(FATAL_ERROR "Unsupported target architecture ${VCPKG_TARGET_ARCHITECTURE}!" ) | |
235 | endif() | |
236 | set(CROSS "[binaries]\n") | |
237 | if(VCPKG_TARGET_IS_WINDOWS) | |
238 | set(proglist MT) | |
239 | else() | |
240 | set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT) | |
241 | endif() | |
242 | foreach(prog IN LISTS proglist) | |
243 | if(VCPKG_DETECTED_CMAKE_${prog}) | |
244 | string(TOLOWER "${prog}" proglower) | |
245 | string(APPEND CROSS "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}}'\n") | |
246 | endif() | |
247 | endforeach() | |
248 | set(compiler C CXX RC) | |
249 | foreach(prog IN LISTS compiler) | |
250 | if(VCPKG_DETECTED_CMAKE_${prog}_COMPILER) | |
251 | string(REPLACE "CXX" "CPP" mesonprog "${prog}") | |
252 | string(TOLOWER "${mesonprog}" proglower) | |
253 | string(APPEND CROSS "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}'\n") | |
254 | endif() | |
255 | endforeach() | |
256 | if(VCPKG_DETECTED_CMAKE_LINKER AND VCPKG_TARGET_IS_WINDOWS) | |
257 | string(APPEND CROSS "c_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n") | |
258 | string(APPEND CROSS "cpp_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n") | |
259 | endif() | |
260 | foreach(_binary IN LISTS ${_additional_binaries}) | |
261 | string(APPEND CROSS "${_binary}\n") | |
262 | endforeach() | |
263 | ||
264 | string(APPEND CROSS "[properties]\n") | |
265 | ||
266 | string(APPEND CROSS "[host_machine]\n") | |
267 | string(APPEND CROSS "endian = 'little'\n") | |
268 | if(NOT VCPKG_CMAKE_SYSTEM_NAME) | |
269 | set(MESON_SYSTEM_NAME "windows") | |
270 | else() | |
271 | string(TOLOWER "${VCPKG_CMAKE_SYSTEM_NAME}" MESON_SYSTEM_NAME) | |
272 | endif() | |
273 | string(APPEND CROSS "system = '${MESON_SYSTEM_NAME}'\n") | |
274 | string(APPEND CROSS "cpu_family = '${HOST_CPU_FAM}'\n") | |
275 | string(APPEND CROSS "cpu = '${HOST_CPU}'\n") | |
276 | ||
277 | string(APPEND CROSS "[build_machine]\n") | |
278 | string(APPEND CROSS "endian = 'little'\n") | |
279 | if(WIN32) | |
280 | string(APPEND CROSS "system = 'windows'\n") | |
281 | elseif(DARWIN) | |
282 | string(APPEND CROSS "system = 'darwin'\n") | |
283 | else() | |
284 | string(APPEND CROSS "system = 'linux'\n") | |
285 | endif() | |
286 | string(APPEND CROSS "cpu_family = '${BUILD_CPU_FAM}'\n") | |
287 | string(APPEND CROSS "cpu = '${BUILD_CPU}'\n") | |
288 | ||
289 | if(NOT BUILD_CPU_FAM MATCHES "${HOST_CPU_FAM}" OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_IOS OR VCPKG_TARGET_IS_UWP) | |
290 | set(_file "${CURRENT_BUILDTREES_DIR}/meson-cross-${TARGET_TRIPLET}.log") | |
291 | set(VCPKG_MESON_CROSS_FILE "${_file}" PARENT_SCOPE) | |
292 | file(WRITE "${_file}" "${CROSS}") | |
293 | endif() | |
294 | endfunction() | |
295 | ||
296 | function(vcpkg_internal_meson_generate_cross_file_config _config) #https://mesonbuild.com/Native-environments.html | |
297 | set(CROSS_${_config} "[properties]\n") #https://mesonbuild.com/Builtin-options.html | |
298 | vcpkg_internal_meson_generate_flags_properties_string(CROSS_PROPERTIES ${_config}) | |
299 | string(APPEND CROSS_${_config} "${CROSS_PROPERTIES}") | |
300 | string(APPEND CROSS_${_config} "[built-in options]\n") | |
301 | if(VCPKG_TARGET_IS_WINDOWS) | |
302 | if(VCPKG_CRT_LINKAGE STREQUAL "static") | |
303 | set(CRT mt) | |
304 | else() | |
305 | set(CRT md) | |
306 | endif() | |
307 | if(${_config} STREQUAL DEBUG) | |
308 | set(CRT ${CRT}d) | |
309 | endif() | |
310 | string(APPEND CROSS_${_config} "b_vscrt = '${CRT}'\n") | |
311 | endif() | |
312 | string(TOLOWER "${_config}" lowerconfig) | |
313 | set(_file "${CURRENT_BUILDTREES_DIR}/meson-cross-${TARGET_TRIPLET}-${lowerconfig}.log") | |
314 | set(VCPKG_MESON_CROSS_FILE_${_config} "${_file}" PARENT_SCOPE) | |
315 | file(WRITE "${_file}" "${CROSS_${_config}}") | |
316 | endfunction() | |
317 | ||
318 | ||
319 | function(vcpkg_configure_meson) | |
320 | # parse parameters such that semicolons in options arguments to COMMAND don't get erased | |
321 | cmake_parse_arguments(PARSE_ARGV 0 _vcm "" "SOURCE_PATH" "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;ADDITIONAL_NATIVE_BINARIES;ADDITIONAL_CROSS_BINARIES") | |
322 | ||
323 | file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel") | |
324 | file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg") | |
325 | ||
326 | vcpkg_internal_get_cmake_vars(OUTPUT_FILE _VCPKG_CMAKE_VARS_FILE) | |
327 | set(_VCPKG_CMAKE_VARS_FILE "${_VCPKG_CMAKE_VARS_FILE}" PARENT_SCOPE) | |
328 | debug_message("Including cmake vars from: ${_VCPKG_CMAKE_VARS_FILE}") | |
329 | include("${_VCPKG_CMAKE_VARS_FILE}") | |
330 | ||
331 | vcpkg_find_acquire_program(PYTHON3) | |
332 | get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY) | |
333 | vcpkg_add_to_path("${PYTHON3_DIR}") | |
334 | list(APPEND _vcm_ADDITIONAL_NATIVE_BINARIES "python = '${PYTHON3}'") | |
335 | list(APPEND _vcm_ADDITIONAL_CROSS_BINARIES "python = '${PYTHON3}'") | |
336 | ||
337 | vcpkg_find_acquire_program(MESON) | |
338 | ||
339 | get_filename_component(CMAKE_PATH ${CMAKE_COMMAND} DIRECTORY) | |
340 | vcpkg_add_to_path("${CMAKE_PATH}") # Make CMake invokeable for Meson | |
341 | ||
342 | vcpkg_find_acquire_program(NINJA) | |
343 | get_filename_component(NINJA_PATH ${NINJA} DIRECTORY) | |
344 | vcpkg_add_to_path(PREPEND "${NINJA_PATH}") # Need to prepend so that meson picks up the correct ninja from vcpkg .... | |
345 | # list(APPEND _vcm_ADDITIONAL_NATIVE_BINARIES "ninja = '${NINJA}'") # This does not work due to meson issues ...... | |
346 | ||
347 | list(APPEND _vcm_OPTIONS --buildtype plain --backend ninja --wrap-mode nodownload) | |
348 | ||
349 | if(NOT VCPKG_MESON_CROSS_FILE) | |
350 | vcpkg_internal_meson_generate_cross_file("_vcm_ADDITIONAL_CROSS_BINARIES") | |
351 | endif() | |
352 | if(NOT VCPKG_MESON_CROSS_FILE_DEBUG AND VCPKG_MESON_CROSS_FILE) | |
353 | vcpkg_internal_meson_generate_cross_file_config(DEBUG) | |
354 | endif() | |
355 | if(NOT VCPKG_MESON_CROSS_FILE_RELEASE AND VCPKG_MESON_CROSS_FILE) | |
356 | vcpkg_internal_meson_generate_cross_file_config(RELEASE) | |
357 | endif() | |
358 | if(VCPKG_MESON_CROSS_FILE) | |
359 | list(APPEND _vcm_OPTIONS --cross "${VCPKG_MESON_CROSS_FILE}") | |
360 | endif() | |
361 | if(VCPKG_MESON_CROSS_FILE_DEBUG) | |
362 | list(APPEND _vcm_OPTIONS_DEBUG --cross "${VCPKG_MESON_CROSS_FILE_DEBUG}") | |
363 | endif() | |
364 | if(VCPKG_MESON_CROSS_FILE_RELEASE) | |
365 | list(APPEND _vcm_OPTIONS_RELEASE --cross "${VCPKG_MESON_CROSS_FILE_RELEASE}") | |
366 | endif() | |
367 | ||
368 | if(NOT VCPKG_MESON_NATIVE_FILE AND NOT VCPKG_MESON_CROSS_FILE) | |
369 | vcpkg_internal_meson_generate_native_file("_vcm_ADDITIONAL_NATIVE_BINARIES") | |
370 | endif() | |
371 | if(NOT VCPKG_MESON_NATIVE_FILE_DEBUG AND NOT VCPKG_MESON_CROSS_FILE) | |
372 | vcpkg_internal_meson_generate_native_file_config(DEBUG) | |
373 | endif() | |
374 | if(NOT VCPKG_MESON_NATIVE_FILE_RELEASE AND NOT VCPKG_MESON_CROSS_FILE) | |
375 | vcpkg_internal_meson_generate_native_file_config(RELEASE) | |
376 | endif() | |
377 | if(VCPKG_MESON_NATIVE_FILE AND NOT VCPKG_MESON_CROSS_FILE) | |
378 | list(APPEND _vcm_OPTIONS --native "${VCPKG_MESON_NATIVE_FILE}") | |
379 | list(APPEND _vcm_OPTIONS_DEBUG --native "${VCPKG_MESON_NATIVE_FILE_DEBUG}") | |
380 | list(APPEND _vcm_OPTIONS_RELEASE --native "${VCPKG_MESON_NATIVE_FILE_RELEASE}") | |
381 | else() | |
382 | list(APPEND _vcm_OPTIONS --native "${SCRIPTS}/buildsystems/meson/none.txt") | |
383 | endif() | |
384 | if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic") | |
385 | list(APPEND _vcm_OPTIONS --default-library shared) | |
386 | else() | |
387 | list(APPEND _vcm_OPTIONS --default-library static) | |
388 | endif() | |
389 | ||
390 | list(APPEND _vcm_OPTIONS --libdir lib) # else meson install into an architecture describing folder | |
391 | list(APPEND _vcm_OPTIONS_DEBUG -Ddebug=true --prefix ${CURRENT_PACKAGES_DIR}/debug --includedir ../include) | |
392 | list(APPEND _vcm_OPTIONS_RELEASE -Ddebug=false --prefix ${CURRENT_PACKAGES_DIR}) | |
393 | ||
394 | # select meson cmd-line options | |
395 | if(VCPKG_TARGET_IS_WINDOWS) | |
396 | list(APPEND _vcm_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/share']") | |
397 | list(APPEND _vcm_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}/share']") | |
398 | else() | |
399 | list(APPEND _vcm_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}']") | |
400 | list(APPEND _vcm_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug']") | |
401 | endif() | |
402 | ||
403 | vcpkg_find_acquire_program(PKGCONFIG) | |
404 | get_filename_component(PKGCONFIG_PATH ${PKGCONFIG} DIRECTORY) | |
405 | vcpkg_add_to_path("${PKGCONFIG_PATH}") | |
406 | set(PKGCONFIG_SHARE_DIR "${CURRENT_INSTALLED_DIR}/share/pkgconfig/") | |
407 | ||
408 | set(buildtypes) | |
409 | if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug") | |
410 | set(BUILDNAME DEBUG) | |
411 | list(APPEND buildtypes ${BUILDNAME}) | |
412 | set(PATH_SUFFIX_${BUILDNAME} "debug/") | |
413 | set(SUFFIX_${BUILDNAME} "dbg") | |
414 | endif() | |
415 | if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release") | |
416 | set(BUILDNAME RELEASE) | |
417 | list(APPEND buildtypes ${BUILDNAME}) | |
418 | set(PATH_SUFFIX_${BUILDNAME} "") | |
419 | set(SUFFIX_${BUILDNAME} "rel") | |
420 | endif() | |
421 | ||
422 | if(VCPKG_TARGET_IS_OSX) | |
423 | if(DEFINED ENV{SDKROOT}) | |
424 | set(_VCPKG_ENV_SDKROOT_BACKUP $ENV{SDKROOT}) | |
425 | endif() | |
426 | set(ENV{SDKROOT} "${VCPKG_DETECTED_CMAKE_OSX_SYSROOT}") | |
427 | set(VCPKG_DETECTED_CMAKE_OSX_SYSROOT "${VCPKG_DETECTED_CMAKE_OSX_SYSROOT}" PARENT_SCOPE) | |
428 | ||
429 | if(DEFINED ENV{MACOSX_DEPLOYMENT_TARGET}) | |
430 | set(_VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP $ENV{MACOSX_DEPLOYMENT_TARGET}) | |
431 | endif() | |
432 | set(ENV{MACOSX_DEPLOYMENT_TARGET} "${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET}") | |
433 | set(VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET "${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET}" PARENT_SCOPE) | |
434 | endif() | |
435 | ||
436 | if(DEFINED ENV{INCLUDE}) | |
437 | set(ENV{INCLUDE} "$ENV{INCLUDE}${VCPKG_HOST_PATH_SEPARATOR}${CURRENT_INSTALLED_DIR}/include") | |
438 | else() | |
439 | set(ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include") | |
440 | endif() | |
441 | # configure build | |
442 | foreach(buildtype IN LISTS buildtypes) | |
443 | message(STATUS "Configuring ${TARGET_TRIPLET}-${SUFFIX_${buildtype}}") | |
444 | file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}") | |
445 | #setting up PKGCONFIG | |
446 | set(ENV{PKG_CONFIG} "${PKGCONFIG}") # Set via native file? | |
447 | set(PKGCONFIG_INSTALLED_DIR "${CURRENT_INSTALLED_DIR}/${PATH_SUFFIX_${buildtype}}lib/pkgconfig/") | |
448 | if(DEFINED ENV{PKG_CONFIG_PATH}) | |
449 | set(BACKUP_ENV_PKG_CONFIG_PATH_RELEASE $ENV{PKG_CONFIG_PATH}) | |
450 | set(ENV{PKG_CONFIG_PATH} "${PKGCONFIG_INSTALLED_DIR}${VCPKG_HOST_PATH_SEPARATOR}${PKGCONFIG_SHARE_DIR}${VCPKG_HOST_PATH_SEPARATOR}$ENV{PKG_CONFIG_PATH}") | |
451 | else() | |
452 | set(ENV{PKG_CONFIG_PATH} "${PKGCONFIG_INSTALLED_DIR}${VCPKG_HOST_PATH_SEPARATOR}${PKGCONFIG_SHARE_DIR}") | |
453 | endif() | |
454 | ||
455 | vcpkg_execute_required_process( | |
456 | COMMAND ${MESON} ${_vcm_OPTIONS} ${_vcm_OPTIONS_${buildtype}} ${_vcm_SOURCE_PATH} | |
457 | WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}} | |
458 | LOGNAME config-${TARGET_TRIPLET}-${SUFFIX_${buildtype}} | |
459 | ) | |
460 | ||
461 | #Copy meson log files into buildtree for CI | |
462 | if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/meson-log.txt") | |
463 | file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/meson-log.txt" DESTINATION "${CURRENT_BUILDTREES_DIR}") | |
464 | file(RENAME "${CURRENT_BUILDTREES_DIR}/meson-log.txt" "${CURRENT_BUILDTREES_DIR}/meson-log-${SUFFIX_${buildtype}}.txt") | |
465 | endif() | |
466 | if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/install-log.txt") | |
467 | file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${SUFFIX_${buildtype}}/meson-logs/install-log.txt" DESTINATION "${CURRENT_BUILDTREES_DIR}") | |
468 | file(RENAME "${CURRENT_BUILDTREES_DIR}/install-log.txt" "${CURRENT_BUILDTREES_DIR}/install-log-${SUFFIX_${buildtype}}.txt") | |
469 | endif() | |
470 | message(STATUS "Configuring ${TARGET_TRIPLET}-${SUFFIX_${buildtype}} done") | |
471 | ||
472 | #Restore PKG_CONFIG_PATH | |
473 | if(BACKUP_ENV_PKG_CONFIG_PATH_${buildtype}) | |
474 | set(ENV{PKG_CONFIG_PATH} "${BACKUP_ENV_PKG_CONFIG_PATH_${buildtype}}") | |
475 | unset(BACKUP_ENV_PKG_CONFIG_PATH_${buildtype}) | |
476 | else() | |
477 | unset(ENV{PKG_CONFIG_PATH}) | |
478 | endif() | |
479 | endforeach() | |
480 | ||
481 | if(VCPKG_TARGET_IS_OSX) | |
482 | if(DEFINED _VCPKG_ENV_SDKROOT_BACKUP) | |
483 | set(ENV{SDKROOT} "${_VCPKG_ENV_SDKROOT_BACKUP}") | |
484 | else() | |
485 | unset(ENV{SDKROOT}) | |
486 | endif() | |
487 | if(DEFINED _VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP) | |
488 | set(ENV{MACOSX_DEPLOYMENT_TARGET} "${_VCPKG_ENV_MACOSX_DEPLOYMENT_TARGET_BACKUP}") | |
489 | else() | |
490 | unset(ENV{MACOSX_DEPLOYMENT_TARGET}) | |
491 | endif() | |
492 | endif() | |
493 | endfunction() |