Xmake es una herramienta de construcción multiplataforma ligera basada en Lua.
Es muy liviano y no tiene dependencias porque tiene un tiempo de ejecución Lua incorporado.
Utiliza xmake.lua para mantener la construcción del proyecto. En comparación con makefile/CMakeLists.txt, la sintaxis de configuración es más concisa e intuitiva. Es muy amigable para los novatos. Se puede iniciar rápidamente en poco tiempo, lo que permite a los usuarios concentrarse más en desarrollo de proyectos reales superior.
Podemos usarlo para compilar directamente proyectos como Make/Ninja, o generar archivos de proyecto como CMake/Meson, y también tiene un sistema de gestión de paquetes incorporado para ayudar a los usuarios a resolver el problema del uso integrado de bibliotecas dependientes de C/C++.
En la actualidad, Xmake se usa principalmente para construir proyectos C/C++, pero también admite la construcción de otros lenguajes nativos. Puede realizar una compilación mixta con C/C++, y la velocidad de compilación también es muy rápida, que puede ser igual a eso. de Ninja.
Xmake = Build backend + Project Generator + Package Manager + [Remote|Distributed] Build + Cache
Aunque no es muy preciso, aún podemos entender Xmake de la siguiente manera:
Xmake ≈ Make/Ninja + CMake/Meson + Vcpkg/Conan + distcc + ccache/sccache
Introducción de nuevas características
Compatibilidad con el simulador de Verilog
Simulador iVerilog
A través de la configuración, podemos extraer automáticamente el paquete de cadena de herramientas de iverilog y luego usar la cadena de herramientas de enlace automático para compilar el proyecto. add_requires("iverilog") set_toolchains("@iverilog")
add_requires("iverilog")
target("hello")
add_rules("iverilog.binary")
set_toolchains("@iverilog")
add_files("src/*.v")
Establecer configuración abstracta
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")
Podemos establecer el estándar de idioma para cambiar Verilog por . set_languages("v1800-2009")
Los valores y asignaciones admitidos actualmente son los siguientes:
["v1364-1995"] = "-g1995"
["v1364-2001"] = "-g2001"
["v1364-2005"] = "-g2005"
["v1800-2005"] = "-g2005-sv"
["v1800-2009"] = "-g2009"
["v1800-2012"] = "-g2012"
Establecer banderas personalizadas
add_requires("iverilog")
target("hello")
add_rules("iverilog.binary")
set_toolchains("@iverilog")
add_files("src/*.v")
add_values("iverilogs.flags", "-DTEST")
proyecto de construccion
$ xmake
checking for iverilog ... iverilog
checking for vvp ... vvp
[ 50%]: linking.iverilog hello.vvp
[100%]: build ok!
ejecuta el programa
$ xmake run
hello world!
LXT2 info: dumpfile hello.vcd opened for output.
src/main.v:6: $finish called at 0 (1s)
Ejemplos más completos: Ejemplos de iVerilog
emulador de verilador
A través de la configuración, podemos extraer automáticamente el paquete de cadena de herramientas de Verilator y luego usar el enlace automático a la cadena de herramientas para compilar el proyecto. 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")
proyecto verilator, necesitamos un archivo adicional para participar en la compilación, como el código de entrada del programa. 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;
}
Establecer configuración abstracta
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")
Podemos establecer el estándar de idioma para cambiar Verilog por . set_languages("v1800-2009")
Los valores y asignaciones admitidos actualmente son los siguientes:
-- 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",
Establecer banderas personalizadas
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")
proyecto de construccion
$ 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!
ejecuta el programa
$ xmake run
ruki-2:hello ruki$ xmake run
hello world!
- src/main.v:4: Verilog $finish
Ejemplos más completos: Verilator
Compatibilidad con la distribución del módulo C++
Muchas gracias a Arthapz por seguir ayudando a mejorar la compatibilidad de xmake con los módulos de C++ en la nueva versión.
Ahora, podemos distribuir módulos de C++ como paquetes y luego integrarlos y reutilizarlos rápidamente en otros proyectos.
Es una implementación prototipo basada en el diseño preliminar para la distribución de módulos en p2473r1 .
Hacer el paquete de módulos C++ de distribución
Primero usamos xmake.lua para compilar el módulo de mantenimiento y le indicamos a xmake qué archivos de módulo deben instalarse para su distribución externa especificando. {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 })
Luego, lo convertimos en un paquete, que se puede enviar al almacén xmake-repo , por supuesto, también se puede convertir directamente en un paquete local o en un paquete de almacén privado.
Aquí, para la conveniencia de la verificación de prueba, simplemente lo convertimos en un paquete local. set_sourcedir
package("foo")
set_sourcedir(path.join(os.scriptdir(), "src"))
on_install(function(package)
import("package.tools.xmake").install(package, {})
end)
Paquete de módulos integrados de C++
Luego, usamos la interfaz de integración de paquetes para integrar y usar rápidamente el paquete de Módulos de C++. add_requires("foo")
Dado que el paquete del módulo de foo se define en un almacén privado, importamos nuestro propio almacén de paquetes. add_repositories("my-repo my-repo")
Si el paquete se envió al almacén oficial de xmake-repo, no es necesario configurarlo adicionalmente.
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)
Una vez integrado el paquete, podemos ejecutar el comando para descargar, compilar e integrar el paquete de Módulos de C++ con un solo clic. 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!
Nota: Después de instalar cada paquete, el archivo de metainformación del módulo de mantenimiento se almacenará en la ruta del paquete. Esta es una especificación de formato acordada en . Tal vez no sea el estándar final, pero esto no nos afecta para usar el módulo ahora distribución. 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":{}}
Para ver un proyecto de ejemplo completo, consulte: Proyecto de ejemplo de distribución de paquetes de módulos de C++
Compatibilidad con módulos estándar C++23
Arthapz también ayudó a mejorar la compatibilidad con los módulos estándar de C++23.
El progreso actual de los tres compiladores que lo soportan:
msvc
La última vista previa de Visual Studio 17.5 ya lo admite, y los módulos estándar de ifc no estándar quedarán obsoletos.
Para los módulos estándar C++23 std, lo presentamos así.
import std;
Y para los módulos estándar de ifc, necesitamos escribir:
import std.core;
No es un estándar de C++23, solo lo proporciona msvc y no es compatible con otros compiladores, y se descartará gradualmente en las nuevas versiones de msvc en el futuro. Por lo tanto, la nueva versión de Xmake solo admitirá módulos C++ 23 std y ya no admitirá los obsoletos módulos ifc std.
Sonido metálico
En la actualidad, el último clang no parece ser totalmente compatible con los módulos estándar de C++ 23, y todavía se encuentra en el estado de borrador del parche, #D135507 .
Sin embargo, Xmake también lo admite. Si desea probarlo, puede integrar este parche usted mismo y luego usar xmake para probarlo.
Además, las versiones inferiores de clang también tienen soporte experimental para módulos estándar no estándar.
Todavía podemos intentar usar xmake para construir módulos estándar en versiones inferiores de clang, aunque todavía puede ser un juguete (y encontrará muchos problemas).
Ver discusión relacionada: #3255
CCG
Aún no es compatible.
Soporte de autocompletado de Xrepo
Antes, solo admitíamos comandos xmake incompletos. En la nueva versión, también admitimos comandos incompletos, que pueden buscar automáticamente paquetes en el almacén xmake-repo para completar nuestros comandos de instalación. xrepo install
Muchas gracias a @glcraft por su aporte.
$ xrepo install libp
libpaper libpfm libpng libpqxx libpthread-stubs
libpcap libplist libpq libpsl
actualizar contenido
nuevas características
- #3228 : Instale la versión de los módulos de C++ e importe el soporte de los módulos de C++ desde los paquetes
- #3257 : Agregue soporte para iverilog y verilator
- Soporte xp y vc6.0
- #3214 : Soporte de autocompletado para la instalación de xrepo
Mejorar
- #3255 : Mejorar la compatibilidad con el módulo clang libc++
- Admite la compilación de xmake con mingw
- Mejorar la compatibilidad de xmake en win xp
- Si las dependencias externas están habilitadas, cambie el módulo json a una implementación lua pura y elimine la dependencia en lua-cjson
Corrección de errores
- #3229 : Solucione el problema de que rc.exe no se puede encontrar en vs2015
- #3271 : Corrección del soporte para definiciones de macros con espacios
- #3273 : Corregir errores de vinculación de nim
- #3286 : Arreglar el soporte de compile_commands para clangd