Xmake ist ein leichtes, plattformübergreifendes Build-Tool, das auf Lua basiert.
Es ist sehr leicht und hat keine Abhängigkeiten, da es über eine integrierte Lua-Laufzeit verfügt.
Es verwendet xmake.lua, um die Projektkonstruktion aufrechtzuerhalten. Im Vergleich zu makefile/CMakeLists.txt ist die Konfigurationssyntax prägnanter und intuitiver. Es ist sehr anfängerfreundlich. Es kann in kurzer Zeit schnell gestartet werden, sodass Benutzer sich mehr darauf konzentrieren können eigentliche Projektentwicklung überlegen.
Wir können es verwenden, um Projekte wie Make/Ninja direkt zu kompilieren oder Projektdateien wie CMake/Meson zu generieren, und es hat auch ein eingebautes Paketverwaltungssystem, um Benutzern zu helfen, das Problem der integrierten Verwendung von C/C++-abhängigen Bibliotheken zu lösen.
Derzeit wird Xmake hauptsächlich zum Erstellen von C/C++-Projekten verwendet, unterstützt aber auch die Erstellung anderer nativer Sprachen, kann eine gemischte Kompilierung mit C/C++ realisieren und die Kompilierungsgeschwindigkeit ist auch sehr schnell, was dem entsprechen kann von Ninja.
Xmake = Build backend + Project Generator + Package Manager + [Remote|Distributed] Build + Cache
Obwohl nicht sehr genau, können wir Xmake dennoch auf folgende Weise verstehen:
Xmake ≈ Make/Ninja + CMake/Meson + Vcpkg/Conan + distcc + ccache/sccache
Einführung neuer Funktionen
Verilog-Simulator-Unterstützung
iVerilog-Simulator
Durch die Konfiguration können wir das Iverilog-Toolchain-Paket automatisch abrufen und dann die automatische Bindungs-Toolchain verwenden, um das Projekt zu kompilieren. add_requires("iverilog") set_toolchains("@iverilog")
add_requires("iverilog")
target("hello")
add_rules("iverilog.binary")
set_toolchains("@iverilog")
add_files("src/*.v")
Abstrakte Konfiguration festlegen
add_requires("iverilog")
target("hello")
add_rules("iverilog.binary")
set_toolchains("@iverilog")
add_files("src/*.v")
add_defines("TEST")
add_includedirs("inc")
set_languages("v1800-2009")
Wir können den Sprachstandard für das Umschalten von Verilog per festlegen. set_languages("v1800-2009")
Derzeit unterstützte Werte und Zuordnungen sind wie folgt:
["v1364-1995"] = "-g1995"
["v1364-2001"] = "-g2001"
["v1364-2005"] = "-g2005"
["v1800-2005"] = "-g2005-sv"
["v1800-2009"] = "-g2009"
["v1800-2012"] = "-g2012"
Legen Sie benutzerdefinierte Flags fest
add_requires("iverilog")
target("hello")
add_rules("iverilog.binary")
set_toolchains("@iverilog")
add_files("src/*.v")
add_values("iverilogs.flags", "-DTEST")
Bauvorhaben
$ xmake
checking for iverilog ... iverilog
checking for vvp ... vvp
[ 50%]: linking.iverilog hello.vvp
[100%]: build ok!
führen Sie das Programm aus
$ xmake run
hello world!
LXT2 info: dumpfile hello.vcd opened for output.
src/main.v:6: $finish called at 0 (1s)
Vollständigere Beispiele: iVerilog-Beispiele
Verilator-Emulator
Durch die Konfiguration können wir das Verilator-Toolchain-Paket automatisch abrufen und dann die automatische Bindung an die Toolchain verwenden, um das Projekt zu kompilieren. add_requires("verilator") set_toolchains("@verilator")
add_requires("verilator")
target("hello")
add_rules("verilator.binary")
set_toolchains("@verilator")
add_files("src/*.v")
add_files("src/*.cpp")
verilator-Projekt benötigen wir eine zusätzliche Datei, um an der Kompilierung teilzunehmen, als den Zugangscode des Programms. sim_main.cpp
#include "hello.h"
#include "verilated.h"
int main(int argc, char** argv) {
VerilatedContext* contextp = new VerilatedContext;
contextp->commandArgs(argc, argv);
hello* top = new hello{contextp};
while (!contextp->gotFinish()) { top->eval(); }
delete top;
delete contextp;
return 0;
}
Abstrakte Konfiguration festlegen
add_requires("verilator")
target("hello")
add_rules("verilator.binary")
set_toolchains("@verilator")
add_files("src/*.v")
add_defines("TEST")
add_includedirs("inc")
set_languages("v1800-2009")
Wir können den Sprachstandard für das Umschalten von Verilog per festlegen. set_languages("v1800-2009")
Derzeit unterstützte Werte und Zuordnungen sind wie folgt:
-- Verilog
["v1364-1995"] = "+1364-1995ext+v",
["v1364-2001"] = "+1364-2001ext+v",
["v1364-2005"] = "+1364-2005ext+v",
-- SystemVerilog
["v1800-2005"] = "+1800-2005ext+v",
["v1800-2009"] = "+1800-2009ext+v",
["v1800-2012"] = "+1800-2012ext+v",
["v1800-2017"] = "+1800-2017ext+v",
Legen Sie benutzerdefinierte Flags fest
add_requires("verilator")
target("hello")
add_rules("verilator.binary")
set_toolchains("@verilator")
add_files("src/*.v")
add_files("src/*.cpp")
add_values("verilator.flags", "--trace", "--timing")
Bauvorhaben
$ xmake
[ 0%]: compiling.verilog src/main.v
[ 15%]: cache compiling.release /Users/ruki/.xmake/packages/v/verilator/2023.1.10/cd2268409c1d44799288c7759b3cbd56/share/verilator/include/verilated.cpp
[ 15%]: cache compiling.release build/.gens/hello/macosx/x86_64/release/rules/verilator/hello___024root__Slow.cpp
[ 15%]: cache compiling.release build/.gens/hello/macosx/x86_64/release/rules/verilator/hello___024root__DepSet_h9053a130__0__Slow.cpp
[ 15%]: cache compiling.release build/.gens/hello/macosx/x86_64/release/rules/verilator/hello.cpp
[ 15%]: cache compiling.release /Users/ruki/.xmake/packages/v/verilator/2023.1.10/cd2268409c1d44799288c7759b3cbd56/share/verilator/include/verilated_threads.cpp
[ 15%]: cache compiling.release build/.gens/hello/macosx/x86_64/release/rules/verilator/hello__Syms.cpp
[ 15%]: cache compiling.release build/.gens/hello/macosx/x86_64/release/rules/verilator/hello___024root__DepSet_h07139e86__0.cpp
[ 15%]: cache compiling.release src/sim_main.cpp
[ 15%]: cache compiling.release build/.gens/hello/macosx/x86_64/release/rules/verilator/hello___024root__DepSet_h9053a130__0.cpp
[ 84%]: linking.release hello
[100%]: build ok!
führen Sie das Programm aus
$ xmake run
ruki-2:hello ruki$ xmake run
hello world!
- src/main.v:4: Verilog $finish
Vollständigere Beispiele: Verilator
Unterstützung für die C++-Modulverteilung
Vielen Dank an Arthapz für die weitere Verbesserung der xmake-Unterstützung für C++-Module in der neuen Version.
Jetzt können wir C++-Module als Pakete verteilen und sie dann schnell in andere Projekte integrieren und wiederverwenden.
Es handelt sich um eine Prototyp-Implementierung, die auf dem Designentwurf für die Modulverteilung in p2473r1 basiert .
Verteilungspaket für C++-Module erstellen
Wir verwenden zunächst xmake.lua, um das Wartungsmodul zu erstellen, und teilen xmake mit, welche Moduldateien für die externe Verteilung installiert werden müssen, indem wir angeben. {install = true}
add_rules("mode.release", "mode.debug")
set_languages("c++20")
target("foo")
set_kind("static")
add_files("*.cpp")
add_files("*.mpp", { install = true })
Dann machen wir es zu einem Paket, das an das xmake-repo- Lagerhaus gesendet werden kann. Natürlich kann es auch direkt zu einem lokalen Paket oder einem privaten Lagerhauspaket gemacht werden.
Hier machen wir es zur Vereinfachung der Testüberprüfung einfach zu einem lokalen Paket. set_sourcedir
package("foo")
set_sourcedir(path.join(os.scriptdir(), "src"))
on_install(function(package)
import("package.tools.xmake").install(package, {})
end)
Integriertes C++-Modulpaket
Anschließend verwenden wir die Paketintegrationsschnittstelle, um das C++-Modulpaket schnell zu integrieren und zu verwenden. add_requires("foo")
Da das Modulpaket von foo in einem privaten Lager definiert ist, importieren wir unser eigenes Paketlager. add_repositories("my-repo my-repo")
Wenn das Paket an das offizielle Warehouse von xmake-repo übermittelt wurde, muss es nicht zusätzlich konfiguriert werden.
add_rules("mode.release", "mode.debug")
set_languages("c++20")
add_repositories("my-repo my-repo")
add_requires("foo", "bar")
target("packages")
set_kind("binary")
add_files("src/*.cpp")
add_packages("foo", "bar")
set_policy("build.c++.modules", true)
Nachdem das Paket integriert ist, können wir den Befehl zum Herunterladen, Kompilieren und Integrieren des C++-Modulpakets mit einem Klick ausführen. xmake
$ xmake
checking for platform ... linux
checking for architecture ... x86_64
note: install or modify (m) these packages (pass -y to skip confirm)?
in my-repo:
-> foo latest
-> bar latest
please input: y (y/n/m)
=> install bar latest .. ok
=> install foo latest .. ok
[ 0%]: generating.module.deps src/main.cpp
[ 0%]: generating.module.deps /mnt/xmake/tests/projects/c++/modules/packages/build/.packages/b/bar/latest/4e0143c97b65425b855ad5fd03038b6a/modules/bar/bar.mpp
[ 0%]: generating.module.deps /mnt/xmake/tests/projects/c++/modules/packages/build/.packages/f/foo/latest/4e0143c97b65425b855ad5fd03038b6a/modules/foo/foo.mpp
[ 14%]: compiling.module.release bar
[ 14%]: compiling.module.release foo
[ 57%]: compiling.release src/main.cpp
[ 71%]: linking.release packages
[100%]: build ok!
Hinweis: Nach der Installation jedes Pakets wird die Meta-Info-Datei des Wartungsmoduls im Paketpfad gespeichert. Dies ist eine in vereinbarte Formatspezifikation. Möglicherweise ist dies nicht der endgültige Standard, aber dies hat keinen Einfluss auf die Verwendung des Modul jetzt Verteilung. p2473r1.pdf
$ cat ./build/.packages/f/foo/latest/4e0143c97b65425b855ad5fd03038b6a/modules/foo/foo.mpp.meta-info
{"_VENDOR_extension":{"xmake":{"name":"foo","file":"foo.mpp"}},"definitions":{},"include_paths":{}}
Ein vollständiges Beispielprojekt finden Sie unter: C++ Modules Package Distribution Example Project
Unterstützt C++23-Std-Module
Arthapz half auch bei der Verbesserung der Unterstützung für C++23-Std-Module.
Der aktuelle Fortschritt der drei Compiler, die es unterstützen:
Msvc
Die neueste Visual Studio 17.5-Vorschau unterstützt dies bereits, und die nicht standardmäßigen ifc std-Module werden veraltet sein.
Für die standardmäßigen C++23-Std-Module haben wir es so eingeführt.
import std;
Und für ifc std-Module müssen wir schreiben:
import std.core;
Es ist kein C++23-Standard, es wird nur von msvc bereitgestellt, ist nicht mit anderen Compilern kompatibel und wird in Zukunft in neuen Versionen von msvc schrittweise verworfen. Daher wird die neue Version von Xmake nur C++23 std-Module unterstützen und die veralteten ifc std-Module nicht mehr unterstützen.
Klirren
Derzeit scheint der neueste Clang C++23-Standardmodule nicht vollständig zu unterstützen, und er befindet sich immer noch im Entwurfs-Patch-Status #D135507 .
Aber auch Xmake unterstützt das. Wer es ausprobieren möchte, kann diesen Patch selbst einbinden und dann mit xmake testen.
Darüber hinaus haben niedrigere Versionen von clang auch experimentelle Unterstützung für nicht standardmäßige std-Module.
Wir können immer noch versuchen, xmake zu verwenden, um std-Module in niedrigeren Versionen von Clang zu bauen, obwohl es immer noch ein Spielzeug sein kann (und viele Probleme haben wird).
Siehe verwandte Diskussion: #3255
Gcc
Noch nicht unterstützt.
Xrepo-Unterstützung für die automatische Vervollständigung
Bisher haben wir nur unvollständige xmake-Befehle unterstützt, in der neuen Version unterstützen wir auch unvollständige Befehle, die automatisch nach Paketen im xmake-repo- Warehouse suchen können, um unsere Installationsbefehle zu vervollständigen. xrepo install
Vielen Dank an @glcraft für seinen Beitrag.
$ xrepo install libp
libpaper libpfm libpng libpqxx libpthread-stubs
libpcap libplist libpq libpsl
Inhalt aktualisieren
Neue Eigenschaften
- #3228 : Installieren Sie die Version von C++-Modulen und importieren Sie C++-Modulunterstützung aus Paketen
- #3257 : Unterstützung für Iverilog und Verilator hinzugefügt
- Unterstützt xp und vc6.0
- #3214 : Unterstützung der automatischen Vervollständigung für die xrepo-Installation
Verbessern
- #3255 : Verbesserte Unterstützung des clang libc++ Moduls
- Unterstützung beim Kompilieren von xmake mit mingw
- Verbessern Sie die Kompatibilität von xmake auf Win XP
- Wenn externe Abhängigkeiten aktiviert sind, stellen Sie das json-Modul auf eine reine Lua-Implementierung um und entfernen Sie die Abhängigkeit von lua-cjson
Fehlerbehebung
- #3229 : Beheben Sie das Problem, dass rc.exe unter vs2015 nicht gefunden werden kann
- #3271 : Unterstützung für Makrodefinitionen mit Leerzeichen korrigiert
- #3273 : Nim-Verknüpfungsfehler behoben
- #3286 : Kompilieren Sie die Unterstützung von compile_commands für clangd