-
-
Notifications
You must be signed in to change notification settings - Fork 818
/
Copy pathcmake.lua
1262 lines (1191 loc) · 50.8 KB
/
cmake.lua
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
--!A cross-platform build utility based on Lua
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
--
-- Copyright (C) 2015-present, TBOOX Open Source Group.
--
-- @author ruki
-- @file cmake.lua
--
-- imports
import("core.base.option")
import("core.base.semver")
import("core.tool.toolchain")
import("core.project.config")
import("core.project.project")
import("lib.detect.find_file")
import("lib.detect.find_tool")
import("package.tools.ninja")
import("package.tools.msbuild")
import("detect.sdks.find_emsdk")
import("private.utils.toolchain", {alias = "toolchain_utils"})
-- get the number of parallel jobs
function _get_parallel_njobs(opt)
return opt.jobs or option.get("jobs") or tostring(os.default_njob())
end
-- translate paths
function _translate_paths(paths)
if is_host("windows") then
if type(paths) == "string" then
return (paths:gsub("\\", "/"))
elseif type(paths) == "table" then
local result = {}
for _, p in ipairs(paths) do
table.insert(result, (p:gsub("\\", "/")))
end
return result
end
end
return paths
end
-- translate bin path
function _translate_bin_path(bin_path)
if is_host("windows") and bin_path then
bin_path = bin_path:gsub("\\", "/")
if not bin_path:find(string.ipattern("%.exe$")) and
not bin_path:find(string.ipattern("%.cmd$")) and
not bin_path:find(string.ipattern("%.bat$")) then
bin_path = bin_path .. ".exe"
end
end
return bin_path
end
-- get pkg-config, we need force to find it, because package install environments will be changed
function _get_pkgconfig(package)
-- meson need fullpath pkgconfig
-- @see https://github.com/xmake-io/xmake/issues/5474
local dep = package:dep("pkgconf") or package:dep("pkg-config")
if dep then
local suffix = dep:is_plat("windows", "mingw") and ".exe" or ""
local pkgconf = path.join(dep:installdir("bin"), "pkgconf" .. suffix)
if os.isfile(pkgconf) then
return pkgconf
end
local pkgconfig = path.join(dep:installdir("bin"), "pkg-config" .. suffix)
if os.isfile(pkgconfig) then
return pkgconfig
end
end
if package:is_plat("windows") then
local pkgconf = find_tool("pkgconf", {force = true})
if pkgconf then
return pkgconf.program
end
end
local pkgconfig = find_tool("pkg-config", {force = true})
if pkgconfig then
return pkgconfig.program
end
end
-- is the toolchain compatible with the host?
function _is_toolchain_compatible_with_host(package)
for _, name in ipairs(package:config("toolchains")) do
if toolchain_utils.is_compatible_with_host(name) then
return true
end
end
end
-- get msvc
function _get_msvc(package)
local msvc = package:toolchain("msvc")
assert(msvc:check(), "vs not found!") -- we need to check vs envs if it has been not checked yet
return msvc
end
-- get msvc run environments
function _get_msvc_runenvs(package)
return os.joinenvs(_get_msvc(package):runenvs())
end
-- get cflags from package deps
function _get_cflags_from_packagedeps(package, opt)
local values
for _, depname in ipairs(opt.packagedeps) do
local dep = type(depname) ~= "string" and depname or package:dep(depname)
if dep then
local fetchinfo = dep:fetch()
if fetchinfo then
if values then
values = values .. fetchinfo
else
values = fetchinfo
end
end
end
end
-- @see https://github.com/xmake-io/xmake-repo/pull/4973#issuecomment-2295890196
local result = {}
if values then
if values.defines then
table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "define", values.defines))
end
if values.includedirs then
table.join2(result, _translate_paths(toolchain_utils.map_compflags_for_package(package, "cxx", "includedir", values.includedirs)))
end
if values.sysincludedirs then
table.join2(result, _translate_paths(toolchain_utils.map_compflags_for_package(package, "cxx", "sysincludedir", values.sysincludedirs)))
end
end
return result
end
-- get ldflags from package deps
function _get_ldflags_from_packagedeps(package, opt)
local values
for _, depname in ipairs(opt.packagedeps) do
local dep = type(depname) ~= "string" and depname or package:dep(depname)
if dep then
local fetchinfo = dep:fetch()
if fetchinfo then
if values then
values = values .. fetchinfo
else
values = fetchinfo
end
end
end
end
local result = {}
if values then
if values.linkdirs then
table.join2(result, _translate_paths(toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "linkdir", values.linkdirs)))
end
if values.links then
table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "link", values.links))
end
if values.syslinks then
table.join2(result, _translate_paths(toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "syslink", values.syslinks)))
end
if values.frameworks then
table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "framework", values.frameworks))
end
end
return result
end
-- get cflags
function _get_cflags(package, opt)
opt = opt or {}
local result = {}
if opt.cross then
table.join2(result, package:build_getenv("cflags"))
table.join2(result, package:build_getenv("cxflags"))
table.join2(result, toolchain_utils.map_compflags_for_package(package, "c", "define", package:build_getenv("defines")))
table.join2(result, toolchain_utils.map_compflags_for_package(package, "c", "includedir", package:build_getenv("includedirs")))
table.join2(result, toolchain_utils.map_compflags_for_package(package, "c", "sysincludedir", package:build_getenv("sysincludedirs")))
end
table.join2(result, package:config("cflags"))
table.join2(result, package:config("cxflags"))
if opt.cflags then
table.join2(result, opt.cflags)
end
if opt.cxflags then
table.join2(result, opt.cxflags)
end
if package:config("lto") then
table.join2(result, package:_generate_lto_configs("cc").cflags)
end
if package:config("asan") then
table.join2(result, package:_generate_sanitizer_configs("address", "cc").cflags)
end
table.join2(result, _get_cflags_from_packagedeps(package, opt))
if #result > 0 then
return os.args(_translate_paths(result))
end
end
-- get cxxflags
function _get_cxxflags(package, opt)
opt = opt or {}
local result = {}
if opt.cross then
table.join2(result, package:build_getenv("cxxflags"))
table.join2(result, package:build_getenv("cxflags"))
table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "define", package:build_getenv("defines")))
table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "includedir", package:build_getenv("includedirs")))
table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "sysincludedir", package:build_getenv("sysincludedirs")))
end
table.join2(result, package:config("cxxflags"))
table.join2(result, package:config("cxflags"))
if opt.cxxflags then
table.join2(result, opt.cflags)
end
if opt.cxflags then
table.join2(result, opt.cxflags)
end
if package:config("lto") then
table.join2(result, package:_generate_lto_configs("cxx").cxxflags)
end
if package:config("asan") then
table.join2(result, package:_generate_sanitizer_configs("address", "cxx").cxxflags)
end
table.join2(result, _get_cflags_from_packagedeps(package, opt))
if #result > 0 then
return os.args(_translate_paths(result))
end
end
-- get asflags
function _get_asflags(package, opt)
opt = opt or {}
local result = {}
if opt.cross then
table.join2(result, package:build_getenv("asflags"))
table.join2(result, toolchain_utils.map_compflags_for_package(package, "as", "define", package:build_getenv("defines")))
table.join2(result, toolchain_utils.map_compflags_for_package(package, "as", "includedir", package:build_getenv("includedirs")))
table.join2(result, toolchain_utils.map_compflags_for_package(package, "as", "sysincludedir", package:build_getenv("sysincludedirs")))
end
table.join2(result, package:config("asflags"))
if opt.asflags then
table.join2(result, opt.asflags)
end
if #result > 0 then
return os.args(_translate_paths(result))
end
end
-- get ldflags
function _get_ldflags(package, opt)
opt = opt or {}
local result = {}
if opt.cross then
table.join2(result, package:build_getenv("ldflags"))
table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "link", package:build_getenv("links")))
table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "syslink", package:build_getenv("syslinks")))
table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "linkdir", package:build_getenv("linkdirs")))
end
table.join2(result, package:config("ldflags"))
if package:config("lto") then
table.join2(result, package:_generate_lto_configs().ldflags)
end
if package:config("asan") then
table.join2(result, package:_generate_sanitizer_configs("address").ldflags)
end
table.join2(result, _get_ldflags_from_packagedeps(package, opt))
if opt.ldflags then
table.join2(result, opt.ldflags)
end
if #result > 0 then
return os.args(_translate_paths(result))
end
end
-- get shflags
function _get_shflags(package, opt)
opt = opt or {}
local result = {}
if opt.cross then
table.join2(result, package:build_getenv("shflags"))
table.join2(result, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "link", package:build_getenv("links")))
table.join2(result, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "syslink", package:build_getenv("syslinks")))
table.join2(result, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "linkdir", package:build_getenv("linkdirs")))
end
table.join2(result, package:config("shflags"))
if package:config("lto") then
table.join2(result, package:_generate_lto_configs().shflags)
end
if package:config("asan") then
table.join2(result, package:_generate_sanitizer_configs("address").shflags)
end
table.join2(result, _get_ldflags_from_packagedeps(package, opt))
if opt.shflags then
table.join2(result, opt.shflags)
end
if #result > 0 then
return os.args(_translate_paths(result))
end
end
-- get cmake version
function _get_cmake_version()
local cmake_version = _g.cmake_version
if not cmake_version then
local cmake = find_tool("cmake", {version = true})
if cmake and cmake.version then
cmake_version = semver.new(cmake.version)
end
_g.cmake_version = cmake_version
end
return cmake_version
end
function _get_cmake_system_processor(package)
-- on Windows, CMAKE_SYSTEM_PROCESSOR comes from PROCESSOR_ARCHITECTURE
-- on other systems it's the output of uname -m
if package:is_plat("windows") then
local archs = {
x86 = "x86",
x64 = "AMD64",
x86_64 = "AMD64",
arm = "ARM",
arm64 = "ARM64",
arm64ec = "ARM64EC"
}
return archs[package:arch()] or package:arch()
end
return package:arch()
end
-- get mingw32 make
function _get_mingw32_make(package)
local mingw = package:build_getenv("mingw") or package:build_getenv("sdk")
if mingw then
local mingw_make = _translate_bin_path(path.join(mingw, "bin", "mingw32-make.exe"))
if os.isfile(mingw_make) then
return mingw_make
end
end
end
-- get ninja
function _get_ninja(package)
local ninja = find_tool("ninja")
if ninja then
return ninja.program
end
end
-- https://github.com/xmake-io/xmake-repo/pull/1096
function _fix_cxx_compiler_cmake(package, envs)
local cxx = envs.CMAKE_CXX_COMPILER
if cxx and package:has_tool("cxx", "clang", "gcc") then
local dir = path.directory(cxx)
local name = path.filename(cxx)
name = name:gsub("clang$", "clang++")
name = name:gsub("clang%-", "clang++-")
name = name:gsub("clang%.", "clang++.")
name = name:gsub("gcc$", "g++")
name = name:gsub("gcc%-", "g++-")
name = name:gsub("gcc%.", "g++.")
if dir and dir ~= "." then
cxx = path.join(dir, name)
else
cxx = name
end
envs.CMAKE_CXX_COMPILER = _translate_bin_path(cxx)
end
end
-- insert configs from envs
function _insert_configs_from_envs(configs, envs, opt)
opt = opt or {}
local configs_str = opt._configs_str
for k, v in pairs(envs) do
if configs_str and configs_str:find(k, 1, true) then
-- use user custom configuration
else
table.insert(configs, "-D" .. k .. "=" .. v)
end
end
end
-- get configs for generic
function _get_configs_for_generic(package, configs, opt)
local cflags = _get_cflags(package, opt)
if cflags then
table.insert(configs, "-DCMAKE_C_FLAGS=" .. cflags)
end
local cxxflags = _get_cxxflags(package, opt)
if cxxflags then
table.insert(configs, "-DCMAKE_CXX_FLAGS=" .. cxxflags)
end
local asflags = _get_asflags(package, opt)
if asflags then
table.insert(configs, "-DCMAKE_ASM_FLAGS=" .. asflags)
end
local ldflags = _get_ldflags(package, opt)
if ldflags then
table.insert(configs, "-DCMAKE_EXE_LINKER_FLAGS=" .. ldflags)
end
local shflags = _get_shflags(package, opt)
if shflags then
table.insert(configs, "-DCMAKE_SHARED_LINKER_FLAGS=" .. shflags)
end
if package:config("pic") ~= false then
table.insert(configs, "-DCMAKE_POSITION_INDEPENDENT_CODE=ON")
end
if not package:use_external_includes() then
table.insert(configs, "-DCMAKE_NO_SYSTEM_FROM_IMPORTED=ON")
end
end
-- get configs for windows
function _get_configs_for_windows(package, configs, opt)
local cmake_generator = opt.cmake_generator
if not cmake_generator or cmake_generator:find("Visual Studio", 1, true) then
table.insert(configs, "-A")
if package:is_arch("x86", "i386") then
table.insert(configs, "Win32")
elseif package:is_arch("arm64") then
table.insert(configs, "ARM64")
elseif package:is_arch("arm64ec") then
table.insert(configs, "ARM64EC")
elseif package:is_arch("arm.*") then
table.insert(configs, "ARM")
else
table.insert(configs, "x64")
end
local vs_toolset = toolchain_utils.get_vs_toolset_ver(_get_msvc(package):config("vs_toolset") or config.get("vs_toolset"))
if vs_toolset then
table.insert(configs, "-DCMAKE_GENERATOR_TOOLSET=" .. vs_toolset)
end
end
-- use clang-cl
if package:has_tool("cc", "clang_cl") then
table.insert(configs, "-DCMAKE_C_COMPILER=" .. _translate_bin_path(package:build_getenv("cc")))
end
if package:has_tool("cxx", "clang_cl") then
table.insert(configs, "-DCMAKE_CXX_COMPILER=" .. _translate_bin_path(package:build_getenv("cxx")))
end
-- we maybe need patch `cmake_policy(SET CMP0091 NEW)` to enable this argument for some packages
-- @see https://cmake.org/cmake/help/latest/policy/CMP0091.html#policy:CMP0091
-- https://github.com/xmake-io/xmake-repo/pull/303
if package:has_runtime("MT") then
table.insert(configs, "-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded")
elseif package:has_runtime("MTd") then
table.insert(configs, "-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDebug")
elseif package:has_runtime("MD") then
table.insert(configs, "-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDLL")
elseif package:has_runtime("MDd") then
table.insert(configs, "-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDebugDLL")
end
if not opt._configs_str:find("CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY") then
table.insert(configs, "-DCMAKE_COMPILE_PDB_OUTPUT_DIRECTORY=pdb")
end
_get_configs_for_generic(package, configs, opt)
end
-- get configs for android
-- https://developer.android.google.cn/ndk/guides/cmake
function _get_configs_for_android(package, configs, opt)
opt = opt or {}
local ndk = get_config("ndk")
if ndk and os.isdir(ndk) then
local ndk_sdkver = get_config("ndk_sdkver")
table.insert(configs, "-DCMAKE_TOOLCHAIN_FILE=" .. path.join(ndk, "build/cmake/android.toolchain.cmake"))
table.insert(configs, "-DANDROID_USE_LEGACY_TOOLCHAIN_FILE=OFF")
table.insert(configs, "-DANDROID_ABI=" .. package:arch())
if ndk_sdkver then
table.insert(configs, "-DANDROID_PLATFORM=android-" .. ndk_sdkver)
table.insert(configs, "-DANDROID_NATIVE_API_LEVEL=" .. ndk_sdkver)
end
-- https://cmake.org/cmake/help/latest/variable/CMAKE_ANDROID_STL_TYPE.html
local runtime = package:runtimes()
if runtime then
table.insert(configs, "-DCMAKE_ANDROID_STL_TYPE=" .. runtime)
end
if is_host("windows") and opt.cmake_generator ~= "Ninja" then
local make = path.join(ndk, "prebuilt", "windows-x86_64", "bin", "make.exe")
if os.isfile(make) then
table.insert(configs, "-DCMAKE_MAKE_PROGRAM=" .. make)
end
end
-- avoid find and add system include/library path
-- @see https://github.com/xmake-io/xmake/issues/2037
table.insert(configs, "-DCMAKE_FIND_ROOT_PATH_MODE_PACKAGE=BOTH")
table.insert(configs, "-DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=BOTH")
table.insert(configs, "-DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=BOTH")
table.insert(configs, "-DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER")
end
_get_configs_for_generic(package, configs, opt)
end
-- get configs for appleos
function _get_configs_for_appleos(package, configs, opt)
opt = opt or {}
local envs = {}
opt.cross = true
envs.CMAKE_C_FLAGS = _get_cflags(package, opt)
envs.CMAKE_CXX_FLAGS = _get_cxxflags(package, opt)
envs.CMAKE_ASM_FLAGS = _get_asflags(package, opt)
envs.CMAKE_STATIC_LINKER_FLAGS = table.concat(table.wrap(package:build_getenv("arflags")), ' ')
envs.CMAKE_EXE_LINKER_FLAGS = _get_ldflags(package, opt)
envs.CMAKE_SHARED_LINKER_FLAGS = _get_shflags(package, opt)
-- https://cmake.org/cmake/help/v3.17/manual/cmake-toolchains.7.html#id25
if package:is_plat("watchos") then
envs.CMAKE_SYSTEM_NAME = "watchOS"
if package:is_arch("x86_64", "i386") then
envs.CMAKE_OSX_SYSROOT = "watchsimulator"
end
elseif package:is_plat("iphoneos") then
envs.CMAKE_SYSTEM_NAME = "iOS"
if package:is_arch("x86_64", "i386") then
envs.CMAKE_OSX_SYSROOT = "iphonesimulator"
end
elseif package:is_cross() then
envs.CMAKE_SYSTEM_NAME = "Darwin"
envs.CMAKE_SYSTEM_PROCESSOR = _get_cmake_system_processor(package)
end
envs.CMAKE_OSX_ARCHITECTURES = package:arch()
envs.CMAKE_FIND_ROOT_PATH_MODE_PACKAGE = "BOTH"
envs.CMAKE_FIND_ROOT_PATH_MODE_LIBRARY = "BOTH"
envs.CMAKE_FIND_ROOT_PATH_MODE_INCLUDE = "BOTH"
envs.CMAKE_FIND_ROOT_PATH_MODE_FRAMEWORK = "BOTH"
envs.CMAKE_FIND_ROOT_PATH_MODE_PROGRAM = "NEVER"
-- avoid install bundle targets
envs.CMAKE_MACOSX_BUNDLE = "NO"
_insert_configs_from_envs(configs, envs, opt)
end
-- get configs for mingw
function _get_configs_for_mingw(package, configs, opt)
opt = opt or {}
opt.cross = true
local envs = {}
local sdkdir = package:build_getenv("mingw") or package:build_getenv("sdk")
envs.CMAKE_C_COMPILER = _translate_bin_path(package:build_getenv("cc"))
envs.CMAKE_CXX_COMPILER = _translate_bin_path(package:build_getenv("cxx"))
envs.CMAKE_ASM_COMPILER = _translate_bin_path(package:build_getenv("as"))
envs.CMAKE_AR = _translate_bin_path(package:build_getenv("ar"))
envs.CMAKE_RANLIB = _translate_bin_path(package:build_getenv("ranlib"))
envs.CMAKE_RC_COMPILER = _translate_bin_path(package:build_getenv("mrc"))
envs.CMAKE_C_FLAGS = _get_cflags(package, opt)
envs.CMAKE_CXX_FLAGS = _get_cxxflags(package, opt)
envs.CMAKE_ASM_FLAGS = _get_asflags(package, opt)
envs.CMAKE_STATIC_LINKER_FLAGS = table.concat(table.wrap(package:build_getenv("arflags")), ' ')
envs.CMAKE_EXE_LINKER_FLAGS = _get_ldflags(package, opt)
envs.CMAKE_SHARED_LINKER_FLAGS = _get_shflags(package, opt)
envs.CMAKE_SYSTEM_NAME = "Windows"
envs.CMAKE_SYSTEM_PROCESSOR = _get_cmake_system_processor(package)
-- avoid find and add system include/library path
-- @see https://github.com/xmake-io/xmake/issues/2037
envs.CMAKE_FIND_ROOT_PATH = sdkdir
envs.CMAKE_FIND_ROOT_PATH_MODE_PACKAGE = "BOTH"
envs.CMAKE_FIND_ROOT_PATH_MODE_LIBRARY = "BOTH"
envs.CMAKE_FIND_ROOT_PATH_MODE_INCLUDE = "BOTH"
envs.CMAKE_FIND_ROOT_PATH_MODE_PROGRAM = "NEVER"
-- avoid add -isysroot on macOS
envs.CMAKE_OSX_SYSROOT = ""
-- Avoid cmake to add the flags -search_paths_first and -headerpad_max_install_names on macOS
envs.HAVE_FLAG_SEARCH_PATHS_FIRST = "0"
-- CMAKE_MAKE_PROGRAM may be required for some CMakeLists.txt (libcurl)
if is_subhost("windows") and opt.cmake_generator ~= "Ninja" then
envs.CMAKE_MAKE_PROGRAM = _get_mingw32_make(package)
end
if opt.cmake_generator == "Ninja" then
envs.CMAKE_MAKE_PROGRAM = "ninja"
end
_fix_cxx_compiler_cmake(package, envs)
_insert_configs_from_envs(configs, envs, opt)
end
-- get configs for wasm
function _get_configs_for_wasm(package, configs, opt)
opt = opt or {}
local emsdk = find_emsdk()
assert(emsdk and emsdk.emscripten, "emscripten not found!")
local emscripten_cmakefile = find_file("Emscripten.cmake", path.join(emsdk.emscripten, "cmake/Modules/Platform"))
assert(emscripten_cmakefile, "Emscripten.cmake not found!")
table.insert(configs, "-DCMAKE_TOOLCHAIN_FILE=" .. emscripten_cmakefile)
if is_subhost("windows") then
if opt.cmake_generator == "Ninja" then
local ninja = _get_ninja(package)
if ninja then
table.insert(configs, "-DCMAKE_MAKE_PROGRAM=" .. ninja)
end
else
local mingw_make = _get_mingw32_make(package)
if mingw_make then
table.insert(configs, "-DCMAKE_MAKE_PROGRAM=" .. mingw_make)
end
end
end
_get_configs_for_generic(package, configs, opt)
end
-- get configs for cross
function _get_configs_for_cross(package, configs, opt)
opt = opt or {}
opt.cross = true
local envs = {}
local sdkdir = _translate_paths(package:build_getenv("sdk"))
envs.CMAKE_C_COMPILER = _translate_bin_path(package:build_getenv("cc"))
envs.CMAKE_CXX_COMPILER = _translate_bin_path(package:build_getenv("cxx"))
envs.CMAKE_ASM_COMPILER = _translate_bin_path(package:build_getenv("as"))
envs.CMAKE_AR = _translate_bin_path(package:build_getenv("ar"))
_fix_cxx_compiler_cmake(package, envs)
-- @note The link command line is set in Modules/CMake{C,CXX,Fortran}Information.cmake and defaults to using the compiler, not CMAKE_LINKER,
-- so we need to set CMAKE_CXX_LINK_EXECUTABLE to use CMAKE_LINKER as linker.
--
-- https://github.com/xmake-io/xmake-repo/pull/1039
-- https://stackoverflow.com/questions/1867745/cmake-use-a-custom-linker/25274328#25274328
-- https://github.com/xmake-io/xmake-repo/pull/2134#issuecomment-1573195810
local ld = _translate_bin_path(package:build_getenv("ld"))
if package:has_tool("ld", "gxx", "clangxx") then
envs.CMAKE_CXX_LINK_EXECUTABLE = ld .. " <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>"
end
envs.CMAKE_RANLIB = _translate_bin_path(package:build_getenv("ranlib"))
envs.CMAKE_C_FLAGS = _get_cflags(package, opt)
envs.CMAKE_CXX_FLAGS = _get_cxxflags(package, opt)
envs.CMAKE_ASM_FLAGS = _get_asflags(package, opt)
envs.CMAKE_STATIC_LINKER_FLAGS = table.concat(table.wrap(package:build_getenv("arflags")), ' ')
envs.CMAKE_EXE_LINKER_FLAGS = _get_ldflags(package, opt)
envs.CMAKE_SHARED_LINKER_FLAGS = _get_shflags(package, opt)
-- we don't need to set it as cross compilation if we just pass toolchain
-- https://github.com/xmake-io/xmake/issues/2170
if package:is_cross() then
local system_name = package:targetos() or "Linux"
if system_name == "linux" then
system_name = "Linux"
end
envs.CMAKE_SYSTEM_NAME = system_name
else
if package:config("pic") ~= false then
table.insert(configs, "-DCMAKE_POSITION_INDEPENDENT_CODE=ON")
end
end
-- avoid find and add system include/library path
-- @see https://github.com/xmake-io/xmake/issues/2037
envs.CMAKE_FIND_ROOT_PATH = sdkdir
envs.CMAKE_FIND_ROOT_PATH_MODE_PACKAGE = "BOTH"
envs.CMAKE_FIND_ROOT_PATH_MODE_LIBRARY = "BOTH"
envs.CMAKE_FIND_ROOT_PATH_MODE_INCLUDE = "BOTH"
envs.CMAKE_FIND_ROOT_PATH_MODE_PROGRAM = "NEVER"
-- avoid add -isysroot on macOS
envs.CMAKE_OSX_SYSROOT = ""
-- avoid cmake to add the flags -search_paths_first and -headerpad_max_install_names on macOS
envs.HAVE_FLAG_SEARCH_PATHS_FIRST = "0"
-- avoids finding host include/library path
envs.CMAKE_FIND_USE_CMAKE_SYSTEM_PATH = "0"
envs.CMAKE_FIND_USE_INSTALL_PREFIX = "0"
_insert_configs_from_envs(configs, envs, opt)
end
-- get configs for host toolchain
function _get_configs_for_host_toolchain(package, configs, opt)
opt = opt or {}
opt.cross = true
local envs = {}
local sdkdir = _translate_paths(package:build_getenv("sdk"))
envs.CMAKE_C_COMPILER = _translate_bin_path(package:build_getenv("cc"))
envs.CMAKE_CXX_COMPILER = _translate_bin_path(package:build_getenv("cxx"))
envs.CMAKE_ASM_COMPILER = _translate_bin_path(package:build_getenv("as"))
envs.CMAKE_RC_COMPILER = _translate_bin_path(package:build_getenv("mrc"))
envs.CMAKE_AR = _translate_bin_path(package:build_getenv("ar"))
_fix_cxx_compiler_cmake(package, envs)
-- @note The link command line is set in Modules/CMake{C,CXX,Fortran}Information.cmake and defaults to using the compiler, not CMAKE_LINKER,
-- so we need set CMAKE_CXX_LINK_EXECUTABLE to use CMAKE_LINKER as linker.
--
-- https://github.com/xmake-io/xmake-repo/pull/1039
-- https://stackoverflow.com/questions/1867745/cmake-use-a-custom-linker/25274328#25274328
-- https://github.com/xmake-io/xmake-repo/pull/2134#issuecomment-1573195810
local ld = _translate_bin_path(package:build_getenv("ld"))
if package:has_tool("ld", "gxx", "clangxx") then
envs.CMAKE_CXX_LINK_EXECUTABLE = ld .. " <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>"
end
envs.CMAKE_RANLIB = _translate_bin_path(package:build_getenv("ranlib"))
envs.CMAKE_C_FLAGS = _get_cflags(package, opt)
envs.CMAKE_CXX_FLAGS = _get_cxxflags(package, opt)
envs.CMAKE_ASM_FLAGS = _get_asflags(package, opt)
envs.CMAKE_STATIC_LINKER_FLAGS = table.concat(table.wrap(package:build_getenv("arflags")), ' ')
envs.CMAKE_EXE_LINKER_FLAGS = _get_ldflags(package, opt)
envs.CMAKE_SHARED_LINKER_FLAGS = _get_shflags(package, opt)
-- we don't need to set it as cross compilation if we just pass toolchain
-- https://github.com/xmake-io/xmake/issues/2170
if package:is_cross() then
envs.CMAKE_SYSTEM_NAME = "Linux"
else
if package:config("pic") ~= false then
table.insert(configs, "-DCMAKE_POSITION_INDEPENDENT_CODE=ON")
end
end
_insert_configs_from_envs(configs, envs, opt)
end
-- get cmake generator for msvc
function _get_cmake_generator_for_msvc(package)
local vsvers =
{
["2022"] = "17",
["2019"] = "16",
["2017"] = "15",
["2015"] = "14",
["2013"] = "12",
["2012"] = "11",
["2010"] = "10",
["2008"] = "9"
}
local vs = _get_msvc(package):config("vs") or config.get("vs")
assert(vsvers[vs], "Unknown Visual Studio version: '" .. tostring(vs) .. "' set in project.")
return "Visual Studio " .. vsvers[vs] .. " " .. vs
end
-- get configs for cmake generator
function _get_configs_for_generator(package, configs, opt)
opt = opt or {}
configs = configs or {}
local cmake_generator = opt.cmake_generator
if cmake_generator then
if cmake_generator:find("Visual Studio", 1, true) then
cmake_generator = _get_cmake_generator_for_msvc(package)
end
table.insert(configs, "-G")
table.insert(configs, cmake_generator)
if cmake_generator:find("Ninja", 1, true) then
local jobs = _get_parallel_njobs(opt)
local linkjobs = opt.linkjobs or option.get("linkjobs")
if linkjobs then
table.insert(configs, "-DCMAKE_JOB_POOL_COMPILE:STRING=compile")
table.insert(configs, "-DCMAKE_JOB_POOL_LINK:STRING=link")
table.insert(configs, ("-DCMAKE_JOB_POOLS:STRING=compile=%s;link=%s"):format(jobs, linkjobs))
end
end
elseif package:is_plat("mingw") and is_subhost("msys") then
table.insert(configs, "-G")
table.insert(configs, "MSYS Makefiles")
elseif package:is_plat("mingw") and is_subhost("windows") then
table.insert(configs, "-G")
table.insert(configs, "MinGW Makefiles")
elseif package:is_plat("windows") then
table.insert(configs, "-G")
table.insert(configs, _get_cmake_generator_for_msvc(package))
elseif package:is_plat("wasm") and is_subhost("windows") then
table.insert(configs, "-G")
table.insert(configs, "MinGW Makefiles")
else
table.insert(configs, "-G")
table.insert(configs, "Unix Makefiles")
end
end
-- get configs for installation
function _get_configs_for_install(package, configs, opt)
-- @see https://cmake.org/cmake/help/v3.14/module/GNUInstallDirs.html
-- LIBDIR: object code libraries (lib or lib64 or lib/<multiarch-tuple> on Debian)
--
table.insert(configs, "-DCMAKE_INSTALL_PREFIX=" .. package:installdir())
if not opt._configs_str:find("CMAKE_INSTALL_LIBDIR") then
table.insert(configs, "-DCMAKE_INSTALL_LIBDIR:PATH=lib")
end
end
function _get_default_flags(package, configs, buildtype, opt)
-- The default flags are different for different platforms
-- @see https://github.com/xmake-io/xmake-repo/pull/4038#issuecomment-2116489448
local cachekey = buildtype .. package:plat() .. package:arch()
local cmake_default_flags = _g.cmake_default_flags and _g.cmake_default_flags[cachekey]
if not cmake_default_flags then
local tmpdir = path.join(os.tmpdir() .. ".dir", package:name(), package:mode())
local dummy_cmakelist = path.join(tmpdir, "CMakeLists.txt")
io.writefile(dummy_cmakelist, format([[
message(STATUS "CMAKE_C_FLAGS is ${CMAKE_C_FLAGS}")
message(STATUS "CMAKE_C_FLAGS_%s is ${CMAKE_C_FLAGS_%s}")
message(STATUS "CMAKE_CXX_FLAGS is ${CMAKE_CXX_FLAGS}")
message(STATUS "CMAKE_CXX_FLAGS_%s is ${CMAKE_CXX_FLAGS_%s}")
message(STATUS "CMAKE_EXE_LINKER_FLAGS is ${CMAKE_EXE_LINKER_FLAGS}")
message(STATUS "CMAKE_EXE_LINKER_FLAGS_%s is ${CMAKE_EXE_LINKER_FLAGS_%s}")
message(STATUS "CMAKE_SHARED_LINKER_FLAGS is ${CMAKE_SHARED_LINKER_FLAGS}")
message(STATUS "CMAKE_SHARED_LINKER_FLAGS_%s is ${CMAKE_SHARED_LINKER_FLAGS_%s}")
message(STATUS "CMAKE_STATIC_LINKER_FLAGS is ${CMAKE_STATIC_LINKER_FLAGS}")
message(STATUS "CMAKE_STATIC_LINKER_FLAGS_%s is ${CMAKE_STATIC_LINKER_FLAGS_%s}")
]], buildtype, buildtype, buildtype, buildtype, buildtype, buildtype, buildtype, buildtype, buildtype, buildtype))
local runenvs = opt.envs or buildenvs(package)
local cmake = find_tool("cmake")
local _configs = table.join(configs, "-S " .. path.directory(dummy_cmakelist), "-B " .. tmpdir)
local outdata = try{ function() return os.iorunv(cmake.program, _configs, {envs = runenvs}) end}
if outdata then
cmake_default_flags = {}
cmake_default_flags.cflags = outdata:match("CMAKE_C_FLAGS is (.-)\n") or " "
cmake_default_flags.cflags = cmake_default_flags.cflags .. " " .. outdata:match(format("CMAKE_C_FLAGS_%s is (.-)\n", buildtype)):replace("/MDd", ""):replace("/MD", "")
cmake_default_flags.cxxflags = outdata:match("CMAKE_CXX_FLAGS is (.-)\n") or " "
cmake_default_flags.cxxflags = cmake_default_flags.cxxflags .. " " .. outdata:match(format("CMAKE_CXX_FLAGS_%s is (.-)\n", buildtype)):replace("/MDd", ""):replace("/MD", "")
cmake_default_flags.ldflags = outdata:match("CMAKE_EXE_LINKER_FLAGS is (.-)\n") or " "
cmake_default_flags.ldflags = cmake_default_flags.ldflags .. " " .. outdata:match(format("CMAKE_EXE_LINKER_FLAGS_%s is (.-)\n", buildtype))
cmake_default_flags.shflags = outdata:match("CMAKE_SHARED_LINKER_FLAGS is (.-)\n") or " "
cmake_default_flags.shflags = cmake_default_flags.shflags .. " " .. outdata:match(format("CMAKE_SHARED_LINKER_FLAGS_%s is (.-)\n", buildtype))
cmake_default_flags.arflags = outdata:match("CMAKE_STATIC_LINKER_FLAGS is (.-)\n") or " "
cmake_default_flags.arflags = cmake_default_flags.arflags .. " " ..outdata:match(format("CMAKE_STATIC_LINKER_FLAGS_%s is (.-)\n", buildtype))
_g.cmake_default_flags = _g.cmake_default_flags or {}
_g.cmake_default_flags[cachekey] = cmake_default_flags
end
os.rm(tmpdir)
end
return cmake_default_flags
end
function _get_cmake_buildtype(package)
local cmake_buildtype_map = {
debug = "DEBUG",
release = "RELEASE",
releasedbg = "RELWITHDEBINFO"
}
local buildtype = package:mode()
return cmake_buildtype_map[buildtype] or "RELEASE"
end
function _get_envs_for_default_flags(package, configs, opt)
local buildtype = _get_cmake_buildtype(package)
local envs = {}
local default_flags = _get_default_flags(package, configs, buildtype, opt)
if default_flags then
if not opt.cxxflags and not opt.cxflags then
envs[format("CMAKE_CXX_FLAGS_%s", buildtype)] = default_flags.cxxflags
end
if not opt.cflags and not opt.cxflags then
envs[format("CMAKE_C_FLAGS_%s", buildtype)] = default_flags.cflags
end
if not opt.ldflags then
envs[format("CMAKE_EXE_LINKER_FLAGS_%s", buildtype)] = default_flags.ldflags
end
if not opt.arflags then
envs[format("CMAKE_STATIC_LINKER_FLAGS_%s", buildtype)] = default_flags.arflags
end
if not opt.shflags then
envs[format("CMAKE_SHARED_LINKER_FLAGS_%s", buildtype)] = default_flags.shflags
end
end
return envs
end
function _get_envs_for_runtime_flags(package, configs, opt)
local buildtype = _get_cmake_buildtype(package)
local envs = {}
local runtimes = package:runtimes()
if runtimes then
envs[format("CMAKE_C_FLAGS_%s", buildtype)] = toolchain_utils.map_compflags_for_package(package, "c", "runtime", runtimes)
envs[format("CMAKE_CXX_FLAGS_%s", buildtype)] = toolchain_utils.map_compflags_for_package(package, "cxx", "runtime", runtimes)
envs[format("CMAKE_EXE_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "runtime", runtimes)
envs[format("CMAKE_STATIC_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags_for_package(package, "static", {"cxx"}, "runtime", runtimes)
envs[format("CMAKE_SHARED_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "runtime", runtimes)
end
return envs
end
function _get_configs(package, configs, opt)
configs = configs or {}
opt._configs_str = string.serialize(configs, {indent = false, strip = true})
_get_configs_for_install(package, configs, opt)
_get_configs_for_generator(package, configs, opt)
if package:is_plat("windows") then
_get_configs_for_windows(package, configs, opt)
elseif package:is_plat("android") then
_get_configs_for_android(package, configs, opt)
elseif package:is_plat("iphoneos", "watchos") or
-- for cross-compilation on macOS, @see https://github.com/xmake-io/xmake/issues/2804
(package:is_plat("macosx") and (get_config("appledev") or not package:is_arch(os.subarch()))) then
_get_configs_for_appleos(package, configs, opt)
elseif package:is_plat("mingw") then
_get_configs_for_mingw(package, configs, opt)
elseif package:is_plat("wasm") then
_get_configs_for_wasm(package, configs, opt)
elseif package:is_cross() then
_get_configs_for_cross(package, configs, opt)
elseif package:config("toolchains") then
-- we still need find system libraries,
-- it just pass toolchain environments if the toolchain is compatible with host
if _is_toolchain_compatible_with_host(package) then
_get_configs_for_host_toolchain(package, configs, opt)
else
_get_configs_for_cross(package, configs, opt)
end
else
_get_configs_for_generic(package, configs, opt)
end
local envs = _get_envs_for_default_flags(package, configs, opt)
local runtime_envs = _get_envs_for_runtime_flags(package, configs, opt)
if runtime_envs then
envs = envs or {}
for name, value in pairs(runtime_envs) do
envs[name] = (envs[name] or " ") .. " " .. table.concat(value, " ")
end
end
_insert_configs_from_envs(configs, envs or {}, opt)
return configs
end
-- Fix pdb issue, if multiple CL.EXE write to the same .PDB file, please use /FS
-- @see https://github.com/xmake-io/xmake/issues/5353
function _fix_pdbdir_for_ninja(package)
if package:is_plat("windows") and package:has_tool("cxx", "cl") then
local pdbdir = "pdb"
if not os.isdir(pdbdir) then
os.mkdir(pdbdir)
end
end
end
-- get build environments
function buildenvs(package, opt)
-- we need to bind msvc environments manually
-- @see https://github.com/xmake-io/xmake/issues/1057
opt = opt or {}
local envs = {}
if package:is_plat("windows") then
envs = _get_msvc_runenvs(package)
end
-- we need to pass pkgconf for windows/mingw without msys2/cygwin
if package:is_plat("windows", "mingw") and is_subhost("windows") then
local pkgconf = _get_pkgconfig(package)
if pkgconf then
envs.PKG_CONFIG = pkgconf
end
end
-- add environments for cmake/find_packages
-- and we need also find them from private libraries,
-- @see https://github.com/xmake-io/xmake-repo/pull/2553
local CMAKE_LIBRARY_PATH = {}
local CMAKE_INCLUDE_PATH = {}
local CMAKE_PREFIX_PATH = {}
local PKG_CONFIG_PATH = {}
for _, dep in ipairs(package:librarydeps({private = true})) do
if dep:is_system() then
local fetchinfo = dep:fetch()
if fetchinfo then
table.join2(CMAKE_LIBRARY_PATH, fetchinfo.linkdirs)
table.join2(CMAKE_INCLUDE_PATH, fetchinfo.includedirs)
table.join2(CMAKE_INCLUDE_PATH, fetchinfo.sysincludedirs)
end
else
table.join2(CMAKE_PREFIX_PATH, dep:installdir())
local pkgconfig = path.join(dep:installdir(), "lib", "pkgconfig")
if os.isdir(pkgconfig) then
table.insert(PKG_CONFIG_PATH, pkgconfig)
end
pkgconfig = path.join(dep:installdir(), "share", "pkgconfig")
if os.isdir(pkgconfig) then
table.insert(PKG_CONFIG_PATH, pkgconfig)
end
end
end
envs.CMAKE_LIBRARY_PATH = path.joinenv(CMAKE_LIBRARY_PATH)
envs.CMAKE_INCLUDE_PATH = path.joinenv(CMAKE_INCLUDE_PATH)
envs.CMAKE_PREFIX_PATH = path.joinenv(CMAKE_PREFIX_PATH)
envs.PKG_CONFIG_PATH = path.joinenv(PKG_CONFIG_PATH)
return envs
end
-- do build for msvc
function _build_for_msvc(package, configs, opt)
local allbuild = os.isfile("ALL_BUILD.vcxproj") and "ALL_BUILD.vcxproj" or "ALL_BUILD.vcproj"
assert(os.isfile(allbuild), "ALL_BUILD project not found!")
msbuild.build(package, {allbuild, "-t:Rebuild"})
end
-- do build for make
function _build_for_make(package, configs, opt)
local argv = {}
if opt.target then
table.insert(argv, opt.target)
end
local jobs = _get_parallel_njobs(opt)