pub const Os = struct {
tag: Tag,
version_range: VersionRange,
pub const Tag = enum {
freestanding,
other,
contiki,
fuchsia,
hermit,
managarm,
haiku,
hurd,
illumos,
linux,
plan9,
rtems,
serenity,
dragonfly,
freebsd,
netbsd,
openbsd,
driverkit,
ios,
maccatalyst,
macos,
tvos,
visionos,
watchos,
windows,
uefi,
@"3ds",
wiiu,
@"switch",
gba,
psx,
ps3,
ps4,
ps5,
psp,
vita,
emscripten,
wasi,
amdhsa,
amdpal,
cuda,
mesa3d,
nvcl,
opencl,
opengl,
vulkan,
tios,
ashetos,
pub inline fn isDarwin(tag: Tag) bool {
return switch (tag) {
.driverkit,
.ios,
.maccatalyst,
.macos,
.tvos,
.visionos,
.watchos,
=> true,
else => false,
};
}
/// Deprecated; to be removed in 0.18.0. Check for relevant tags instead.
pub inline fn isBSD(tag: Tag) bool {
return tag.isDarwin() or switch (tag) {
.freebsd, .openbsd, .netbsd, .dragonfly => true,
else => false,
};
}
pub fn exeFileExt(tag: Tag, arch: Cpu.Arch) [:0]const u8 {
return switch (tag) {
.windows => ".exe",
.uefi => ".efi",
.plan9 => arch.plan9Ext(),
else => switch (arch) {
.wasm32, .wasm64 => ".wasm",
.spork8 => ".bin",
else => "",
},
};
}
pub fn staticLibSuffix(tag: Tag, abi: Abi) [:0]const u8 {
return switch (abi) {
.msvc, .itanium => ".lib",
else => switch (tag) {
.windows, .uefi => ".lib",
else => ".a",
},
};
}
pub fn dynamicLibSuffix(tag: Tag) [:0]const u8 {
return switch (tag) {
.windows, .uefi => ".dll",
.driverkit,
.ios,
.maccatalyst,
.macos,
.tvos,
.visionos,
.watchos,
=> ".dylib",
else => ".so",
};
}
pub fn libPrefix(tag: Os.Tag, abi: Abi) [:0]const u8 {
return switch (abi) {
.msvc, .itanium => "",
else => switch (tag) {
.windows, .uefi => "",
else => "lib",
},
};
}
pub fn defaultVersionRange(tag: Tag, arch: Cpu.Arch, abi: Abi) Os {
return .{
.tag = tag,
.version_range = .default(arch, tag, abi),
};
}
pub inline fn versionRangeTag(tag: Tag) @typeInfo(TaggedVersionRange).@"union".tag_type.? {
return switch (tag) {
.freestanding,
.other,
.managarm,
.haiku,
.illumos,
.plan9,
.serenity,
.psx,
.ps3,
.ps4,
.ps5,
.gba,
.emscripten,
.mesa3d,
.ashetos,
=> .none,
.contiki,
.fuchsia,
.hermit,
.rtems,
.dragonfly,
.freebsd,
.netbsd,
.openbsd,
.driverkit,
.ios,
.maccatalyst,
.macos,
.tvos,
.visionos,
.watchos,
.uefi,
.@"3ds",
.wiiu,
.@"switch",
.psp,
.vita,
.wasi,
.amdhsa,
.amdpal,
.cuda,
.nvcl,
.opencl,
.opengl,
.vulkan,
.tios,
=> .semver,
.hurd => .hurd,
.linux => .linux,
.windows => .windows,
};
}
};
/// Based on NTDDI version constants from
/// https://docs.microsoft.com/en-us/cpp/porting/modifying-winver-and-win32-winnt
pub const WindowsVersion = enum(u32) {
nt4 = 0x04000000,
win2k = 0x05000000,
xp = 0x05010000,
ws2003 = 0x05020000,
vista = 0x06000000,
win7 = 0x06010000,
win8 = 0x06020000,
win8_1 = 0x06030000,
win10 = 0x0A000000, //aka win10_th1
win10_th2 = 0x0A000001,
win10_rs1 = 0x0A000002,
win10_rs2 = 0x0A000003,
win10_rs3 = 0x0A000004,
win10_rs4 = 0x0A000005,
win10_rs5 = 0x0A000006,
win10_19h1 = 0x0A000007,
win10_vb = 0x0A000008, //aka win10_19h2
win10_mn = 0x0A000009, //aka win10_20h1
win10_fe = 0x0A00000A, //aka win10_20h2
win10_co = 0x0A00000B, //aka win10_21h1
win10_ni = 0x0A00000C, //aka win10_21h2
win10_cu = 0x0A00000D, //aka win10_22h2
win11_zn = 0x0A00000E, //aka win11_21h2
win11_ga = 0x0A00000F, //aka win11_22h2
win11_ge = 0x0A000010, //aka win11_23h2
win11_dt = 0x0A000011, //aka win11_24h2
win11_br = 0x0A000012, //aka win11_25h2
win11_kr = 0x0A000013, //aka win11_26h1
_,
/// Latest Windows version that the Zig Standard Library is aware of
pub const latest = WindowsVersion.win11_kr;
/// Compared against build numbers reported by the runtime to distinguish win10 versions,
/// where 0x0A000000 + index corresponds to the WindowsVersion u32 value.
pub const known_win10_build_numbers = [_]u32{
10240, //win10 aka win10_th1
10586, //win10_th2
14393, //win10_rs1
15063, //win10_rs2
16299, //win10_rs3
17134, //win10_rs4
17763, //win10_rs5
18362, //win10_19h1
18363, //win10_vb aka win10_19h2
19041, //win10_mn aka win10_20h1
19042, //win10_fe aka win10_20h2
19043, //win10_co aka win10_21h1
19044, //win10_ni aka win10_21h2
19045, //win10_cu aka win10_22h2
22000, //win11_zn aka win11_21h2
22621, //win11_ga aka win11_22h2
22631, //win11_ge aka win11_23h2
26100, //win11_dt aka win11_24h2
26200, //win11_br aka win11_25h2
28000, //win11_kr aka win11_26h1
};
/// Returns whether the first version `ver` is newer (greater) than or equal to the second version `ver`.
pub inline fn isAtLeast(ver: WindowsVersion, min_ver: WindowsVersion) bool {
return @backingInt(ver) >= @backingInt(min_ver);
}
pub const Range = struct {
min: WindowsVersion,
max: WindowsVersion,
pub inline fn includesVersion(range: Range, ver: WindowsVersion) bool {
return @backingInt(ver) >= @backingInt(range.min) and
@backingInt(ver) <= @backingInt(range.max);
}
/// Checks if system is guaranteed to be at least `version` or older than `version`.
/// Returns `null` if a runtime check is required.
pub inline fn isAtLeast(range: Range, min_ver: WindowsVersion) ?bool {
if (@backingInt(range.min) >= @backingInt(min_ver)) return true;
if (@backingInt(range.max) < @backingInt(min_ver)) return false;
return null;
}
};
pub fn parse(str: []const u8) !WindowsVersion {
return std.meta.stringToEnum(WindowsVersion, str) orelse
@fromBackingInt(@intCast(std.fmt.parseInt(u32, str, 0) catch
return error.InvalidOperatingSystemVersion));
}
/// This function is defined to serialize a Zig source code representation of this
/// type, that, when parsed, will deserialize into the same data.
pub fn format(wv: WindowsVersion, w: *std.Io.Writer) std.Io.Writer.Error!void {
if (std.enums.tagName(WindowsVersion, wv)) |name| {
var vecs: [2][]const u8 = .{ ".", name };
return w.writeVecAll(&vecs);
} else {
return w.print("@enumFromInt(0x{X:0>8})", .{wv});
}
}
};
pub const HurdVersionRange = struct {
range: std.SemanticVersion.Range,
glibc: std.SemanticVersion,
pub inline fn includesVersion(range: HurdVersionRange, ver: std.SemanticVersion) bool {
return range.range.includesVersion(ver);
}
/// Checks if system is guaranteed to be at least `version` or older than `version`.
/// Returns `null` if a runtime check is required.
pub inline fn isAtLeast(range: HurdVersionRange, ver: std.SemanticVersion) ?bool {
return range.range.isAtLeast(ver);
}
};
pub const LinuxVersionRange = struct {
range: std.SemanticVersion.Range,
glibc: std.SemanticVersion,
/// Android API level.
android: u32,
pub inline fn includesVersion(range: LinuxVersionRange, ver: std.SemanticVersion) bool {
return range.range.includesVersion(ver);
}
/// Checks if system is guaranteed to be at least `version` or older than `version`.
/// Returns `null` if a runtime check is required.
pub inline fn isAtLeast(range: LinuxVersionRange, ver: std.SemanticVersion) ?bool {
return range.range.isAtLeast(ver);
}
};
/// The version ranges here represent the minimum OS version to be supported
/// and the maximum OS version to be supported. The default values represent
/// the range that the Zig Standard Library bases its abstractions on.
///
/// The minimum version of the range is the main setting to tweak for a target.
/// Usually, the maximum target OS version will remain the default, which is
/// the latest released version of the OS.
///
/// To test at compile time if the target is guaranteed to support a given OS feature,
/// one should check that the minimum version of the range is greater than or equal to
/// the version the feature was introduced in.
///
/// To test at compile time if the target certainly will not support a given OS feature,
/// one should check that the maximum version of the range is less than the version the
/// feature was introduced in.
///
/// If neither of these cases apply, a runtime check should be used to determine if the
/// target supports a given OS feature.
///
/// Binaries built with a given maximum version will continue to function on newer
/// operating system versions. However, such a binary may not take full advantage of the
/// newer operating system APIs.
///
/// See `Os.isAtLeast`.
pub const VersionRange = union {
none: void,
semver: std.SemanticVersion.Range,
hurd: HurdVersionRange,
linux: LinuxVersionRange,
windows: WindowsVersion.Range,
/// The default `VersionRange` represents the range that the Zig Standard Library
/// bases its abstractions on.
pub fn default(arch: Cpu.Arch, tag: Tag, abi: Abi) VersionRange {
return switch (tag) {
.freestanding,
.other,
.managarm,
.haiku,
.illumos,
.plan9,
.serenity,
.psx,
.ps3,
.ps4,
.ps5,
.gba,
.emscripten,
.mesa3d,
.ashetos,
=> .{ .none = {} },
.contiki => .{
.semver = .{
.min = .{ .major = 5, .minor = 0, .patch = 0 },
.max = .{ .major = 5, .minor = 1, .patch = 0 },
},
},
.fuchsia => .{
.semver = .{
.min = .{ .major = 27, .minor = 0, .patch = 0 },
.max = .{ .major = 30, .minor = 0, .patch = 0 },
},
},
.hermit => .{
.semver = .{
.min = .{ .major = 0, .minor = 8, .patch = 0 },
.max = .{ .major = 0, .minor = 13, .patch = 2 },
},
},
.hurd => .{
.hurd = .{
.range = .{
.min = .{ .major = 0, .minor = 9, .patch = 0 },
.max = .{ .major = 0, .minor = 9, .patch = 0 },
},
.glibc = .{ .major = 2, .minor = 31, .patch = 0 },
},
},
.linux => .{
.linux = .{
.range = .{
.min = blk: {
const default_min: std.SemanticVersion = .{ .major = 5, .minor = 10, .patch = 0 };
for (std.zig.target.available_libcs) |libc| {
if (libc.arch != arch or libc.os != tag or libc.abi != abi) continue;
if (libc.os_ver) |min| {
if (min.order(default_min) == .gt) break :blk min;
}
}
break :blk default_min;
},
.max = .{ .major = 7, .minor = 2, .patch = 0 },
},
.glibc = blk: {
// For 32-bit targets that traditionally used 32-bit time, we require
// glibc 2.34 for full 64-bit time support. For everything else, we only
// require glibc 2.31.
const default_min: std.SemanticVersion = switch (arch) {
.arm,
.armeb,
.csky,
.m68k,
.mips,
.mipsel,
.powerpc,
.sparc,
.x86,
=> .{ .major = 2, .minor = 34, .patch = 0 },
.mips64,
.mips64el,
=> if (abi == .gnuabin32)
.{ .major = 2, .minor = 34, .patch = 0 }
else
.{ .major = 2, .minor = 31, .patch = 0 },
else => .{ .major = 2, .minor = 31, .patch = 0 },
};
for (std.zig.target.available_libcs) |libc| {
if (libc.os != tag or libc.arch != arch or libc.abi != abi) continue;
if (libc.glibc_min) |min| {
if (min.order(default_min) == .gt) break :blk min;
}
}
break :blk default_min;
},
.android = 29,
},
},
.rtems => .{
.semver = .{
.min = .{ .major = 5, .minor = 3, .patch = 0 },
.max = .{ .major = 6, .minor = 2, .patch = 0 },
},
},
.dragonfly => .{
.semver = .{
.min = .{ .major = 6, .minor = 4, .patch = 0 },
.max = .{ .major = 6, .minor = 4, .patch = 2 },
},
},
.freebsd => .{
.semver = .{
.min = blk: {
const default_min: std.SemanticVersion = .{ .major = 14, .minor = 0, .patch = 0 };
for (std.zig.target.available_libcs) |libc| {
if (libc.arch != arch or libc.os != tag or libc.abi != abi) continue;
if (libc.os_ver) |min| {
if (min.order(default_min) == .gt) break :blk min;
}
}
break :blk default_min;
},
.max = .{ .major = 15, .minor = 1, .patch = 0 },
},
},
.netbsd => .{
.semver = .{
.min = blk: {
const default_min: std.SemanticVersion = .{ .major = 10, .minor = 1, .patch = 0 };
for (std.zig.target.available_libcs) |libc| {
if (libc.arch != arch or libc.os != tag or libc.abi != abi) continue;
if (libc.os_ver) |min| {
if (min.order(default_min) == .gt) break :blk min;
}
}
break :blk default_min;
},
.max = .{ .major = 11, .minor = 0, .patch = 0 },
},
},
.openbsd => .{
.semver = .{
.min = blk: {
const default_min: std.SemanticVersion = .{ .major = 7, .minor = 8, .patch = 0 };
for (std.zig.target.available_libcs) |libc| {
if (libc.arch != arch or libc.os != tag or libc.abi != abi) continue;
if (libc.os_ver) |min| {
if (min.order(default_min) == .gt) break :blk min;
}
}
break :blk default_min;
},
.max = .{ .major = 7, .minor = 9, .patch = 0 },
},
},
.driverkit => .{
.semver = .{
.min = .{ .major = 20, .minor = 0, .patch = 0 },
.max = .{ .major = 25, .minor = 5, .patch = 0 },
},
},
.macos => .{
.semver = .{
.min = .{ .major = 14, .minor = 0, .patch = 0 },
.max = .{ .major = 26, .minor = 5, .patch = 0 },
},
},
.ios, .maccatalyst => .{
.semver = .{
.min = .{ .major = 15, .minor = 0, .patch = 0 },
.max = .{ .major = 26, .minor = 5, .patch = 0 },
},
},
.tvos => .{
.semver = .{
.min = .{ .major = 26, .minor = 0, .patch = 0 },
.max = .{ .major = 26, .minor = 5, .patch = 0 },
},
},
.visionos => .{
.semver = .{
.min = .{ .major = 26, .minor = 0, .patch = 0 },
.max = .{ .major = 26, .minor = 5, .patch = 0 },
},
},
.watchos => .{
.semver = .{
.min = .{ .major = 11, .minor = 0, .patch = 0 },
.max = .{ .major = 26, .minor = 5, .patch = 0 },
},
},
.windows => .{
.windows = .{
.min = .win10,
.max = WindowsVersion.latest,
},
},
.uefi => .{
.semver = .{
.min = .{ .major = 2, .minor = 0, .patch = 0 },
.max = .{ .major = 2, .minor = 11, .patch = 0 },
},
},
.@"3ds" => .{
.semver = .{
// These signify release versions (https://www.3dbrew.org/wiki/NCCH/Extended_Header#ARM11_Kernel_Capabilities)
// which are different from user-facing system versions (https://www.3dbrew.org/wiki/Home_Menu#System_Versions_List).
//
// Multiple system versions could refer to the same release version.
// The comment indicates the system version that release version was introduced (for minimum) and the latest (for maximum).
.min = .{ .major = 2, .minor = 27, .patch = 0 }, // 1.0.0-0
.max = .{ .major = 2, .minor = 58, .patch = 0 }, // 11.17.0-50
},
},
.wiiu => .{
.semver = .{
.min = .{ .major = 5, .minor = 5, .patch = 5 }, // Latest global release
.max = .{ .major = 5, .minor = 5, .patch = 6 }, // Latest US only release
},
},
.@"switch" => .{
.semver = .{
.min = .{ .major = 1, .minor = 0, .patch = 0 },
.max = .{ .major = 22, .minor = 5, .patch = 0 },
},
},
.psp => .{
.semver = .{
// https://www.psdevwiki.com/psp/Official_Firmware_(OFW)#1.XX_Kernel
// It appears that the kernel started with semver for 1.XX before later changing to MAJ.MINPATCH in later releases (e.g. 3.60, 6.61)
.min = .{ .major = 1, .minor = 0, .patch = 3 },
.max = .{ .major = 6, .minor = 61, .patch = 0 },
},
},
.vita => .{
.semver = .{
// 1.3 is the first public release
.min = .{ .major = 1, .minor = 3, .patch = 0 },
.max = .{ .major = 3, .minor = 60, .patch = 0 },
},
},
.wasi => .{
.semver = .{
.min = .{ .major = 0, .minor = 1, .patch = 0 },
.max = .{ .major = 0, .minor = 3, .patch = 0 },
},
},
.amdhsa => .{
.semver = .{
.min = .{ .major = 6, .minor = 1, .patch = 0 },
.max = .{ .major = 7, .minor = 2, .patch = 3 },
},
},
.amdpal => .{
.semver = .{
.min = .{ .major = 1, .minor = 1, .patch = 0 },
.max = .{ .major = 3, .minor = 5, .patch = 0 },
},
},
.cuda => .{
.semver = .{
.min = .{ .major = 12, .minor = 5, .patch = 0 },
.max = .{ .major = 13, .minor = 2, .patch = 0 },
},
},
.nvcl,
.opencl,
=> .{
.semver = .{
.min = .{ .major = 2, .minor = 2, .patch = 0 },
.max = .{ .major = 3, .minor = 0, .patch = 19 },
},
},
.opengl => .{
.semver = .{
.min = .{ .major = 4, .minor = 5, .patch = 0 },
.max = .{ .major = 4, .minor = 6, .patch = 0 },
},
},
.tios => .{
.semver = .{
.min = .{ .major = 5, .minor = 0, .patch = 0 },
.max = .{ .major = 5, .minor = 8, .patch = 4 },
},
},
.vulkan => .{
.semver = .{
.min = .{ .major = 1, .minor = 2, .patch = 0 },
.max = .{ .major = 1, .minor = 4, .patch = 352 },
},
},
};
}
};
pub const TaggedVersionRange = union(enum) {
none: void,
semver: std.SemanticVersion.Range,
hurd: HurdVersionRange,
linux: LinuxVersionRange,
windows: WindowsVersion.Range,
pub fn gnuLibCVersion(range: TaggedVersionRange) ?std.SemanticVersion {
return switch (range) {
.none, .semver, .windows => null,
.hurd => |h| h.glibc,
.linux => |l| l.glibc,
};
}
};
/// Provides a tagged union. `Target` does not store the tag because it is
/// redundant with the OS tag; this function abstracts that part away.
pub inline fn versionRange(os: Os) TaggedVersionRange {
return switch (os.tag.versionRangeTag()) {
.none => .{ .none = {} },
.semver => .{ .semver = os.version_range.semver },
.hurd => .{ .hurd = os.version_range.hurd },
.linux => .{ .linux = os.version_range.linux },
.windows => .{ .windows = os.version_range.windows },
};
}
/// Checks if system is guaranteed to be at least `version` or older than `version`.
/// Returns `null` if a runtime check is required.
pub inline fn isAtLeast(os: Os, comptime tag: Tag, ver: switch (tag.versionRangeTag()) {
.none => void,
.semver, .hurd, .linux => std.SemanticVersion,
.windows => WindowsVersion,
}) ?bool {
return if (os.tag != tag) false else switch (tag.versionRangeTag()) {
.none => true,
inline .semver,
.hurd,
.linux,
.windows,
=> |field| @field(os.version_range, @tagName(field)).isAtLeast(ver),
};
}
}
