Si estás empezando con Zig, uno de los primeros temas que necesitas entender es el soporte de plataforma que ofrece el lenguaje. Zig fue diseñado para ser un sistema de compilación cruzada de primera clase, lo que significa que puedes compilar el mismo código fuente para múltiples sistemas operativos, arquitecturas y variantes de hardware sin cambiar nada en el código fuente.
1. ¿Qué implica el soporte de plataforma en Zig?
El soporte de plataforma incluye:
- Detección automática de la plataforma de destino durante la compilación.
- Gestión de distintas arquitecturas (x86, x86_64, ARM, MIPS, PowerPC, etc.).
- Compatibilidad con múltiples sistemas operativos (Linux, macOS, Windows, FreeBSD, etc.).
- Herramientas integradas para compilación cruzada (
zig cc,zig c++,zig build). - Soporte nativo para módulos del sistema (API de Windows, syscalls de Linux, etc.).
1.1. Detección de la plataforma con std.Target
Zig expone la información de la plataforma a través del módulo std.Target. Puedes consultar el sistema operativo y la arquitectura en tiempo de compilación.
// hello.zig
const std = @import("std");
// Se define la función principal del programa.
pub fn main() anyerror!void {
// Obtener información del objetivo de compilación.
const target = std.Target.current();
// Imprimir la arquitectura y el sistema operativo.
// Esto se hace en tiempo de compilación y no en tiempo de ejecución.
std.debug.print("Arquitectura: {s}\n", .{ @tagName(target.cpu.arch) });
std.debug.print("Sistema operativo: {s}\n", .{ @tagName(target.os.tag) });
}
En este ejemplo, @import("std") trae el paquete estándar de Zig. La llamada a std.Target.current() devuelve un Target que contiene información sobre la arquitectura (target.cpu.arch) y el sistema operativo (target.os.tag). Las funciones std.debug.print se utilizan para imprimir esta información.
1.2. Compilación cruzada con zig build
Para compilar el mismo código para diferentes plataformas, Zig ofrece el comando zig build y permite especificar el objetivo con la opción --target. Por ejemplo:
# Compilar para Linux x86_64
zig build-exe hello.zig --target=x86_64-linux-gnu
# Compilar para macOS ARM64
zig build-exe hello.zig --target=arm64-macos
# Compilar para Windows x86
zig build-exe hello.zig --target=i386-windows-gnu
2. Ejemplo avanzado: Código que cambia según la plataforma
En muchos casos, quieres que tu programa haga algo distinto según la plataforma. Zig te permite hacer esto con condiciones en tiempo de compilación.
// platform_example.zig
const std = @import("std");
// Se declara el punto de entrada del programa.
pub fn main() anyerror!void {
// Detectar la plataforma de destino.
const target = std.Target.current();
// Usar un condicional compile-time para ejecutar código específico.
// La expresión "if (target.os.tag == .windows)" se evalúa en tiempo de compilación.
if (target.os.tag == .windows) {
std.debug.print("¡Estás ejecutando en Windows!\n", .{});
// Aquí podrías usar funciones específicas de Windows.
} else if (target.os.tag == .linux) {
std.debug.print("¡Estás ejecutando en Linux!\n", .{});
// Funciones específicas de Linux.
} else if (target.os.tag == .macos) {
std.debug.print("¡Estás ejecutando en macOS!\n", .{});
// Funciones específicas de macOS.
} else {
std.debug.print("Plataforma desconocida: {s}\n", .{ @tagName(target.os.tag) });
}
}
El compilador reemplaza la condición if (target.os.tag == .windows) por la rama correcta durante la compilación, de modo que el código no incluye ramas innecesarias. Así, el binario final solo contiene el código que corresponde a la plataforma objetivo.
3. Uso de bibliotecas del sistema
Zig permite llamar directamente a funciones del sistema operativo. Dependiendo de la plataforma, la firma de la función puede variar.
3.1. Llamada a la API de Windows (Win32)
// win32_example.zig
const std = @import("std");
const windows = std.os.windows;
pub fn main() anyerror!void {
// Asegurarnos de que estamos en Windows antes de usar la API.
if (std.Target.current().os.tag != .windows) {
@panic("Este código solo compila en Windows.");
}
// Abrir un archivo con la API de Windows (CreateFileW).
const file_path = windows.wchar_t.fromUtf8("C:\\temp\\hello.txt") catch {
@panic("Error al convertir la ruta del archivo.");
};
const handle = windows.CreateFileW(
file_path.ptr, // LPCWSTR lpFileName
windows.GENERIC_READ, // DWORD dwDesiredAccess
0, // DWORD dwShareMode
null, // LPSECURITY_ATTRIBUTES lpSecurityAttributes
windows.OPEN_EXISTING, // DWORD dwCreationDisposition
0, // DWORD dwFlagsAndAttributes
null); // HANDLE hTemplateFile
if (handle == windows.INVALID_HANDLE_VALUE) {
@panic("No se pudo abrir el archivo.");
}
// Cerrar el manejador al finalizar.
windows.CloseHandle(handle);
}
Este ejemplo muestra cómo usar la API de Windows directamente desde Zig. Se verifica en tiempo de compilación que el código solo se compile en Windows, y luego se llama a funciones del sistema para abrir y cerrar un archivo.
3.2. Llamada a una syscall de Linux
// linux_example.zig
const std = @import("std");
const linux = std.os.linux;
pub fn main() anyerror!void {
// Verificar que el objetivo sea Linux.
if (std.Target.current().os.tag != .linux) {
@panic("Este código solo compila en Linux.");
}
// Usar la syscall getpid() para obtener el ID del proceso actual.
const pid = linux.syscall(linux.SYS.getpid, .{}).?; // No pasa argumentos adicionales
std.debug.print("PID del proceso: {d}\n", .{ pid });
}
En este fragmento, linux.syscall permite ejecutar llamadas al sistema de bajo nivel. La función getpid devuelve el ID del proceso. Se utilizan los tipos y constantes definidos en std.os.linux.
4. Herramientas de compilación cruzada
Además de zig build-exe, Zig incluye un conjunto de herramientas que facilitan la compilación y la construcción de proyectos complejos:
zig
