Commit 6e84f469904a24615a6721265a88ad8dcb4ed83a | zig

build.zig+2-2

...	...	@@ -9,7 +9,7 @@ const fs = std.fs;
9	9	const InstallDirectoryOptions = std.Build.InstallDirectoryOptions;
10	10	const assert = std.debug.assert;
11	11
12		const zig_version = std.builtin.Version{ .major = 0, .minor = 11, .patch = 0 };
	12	const zig_version = std.SemanticVersion{ .major = 0, .minor = 11, .patch = 0 };
13	13	const stack_size = 32 * 1024 * 1024;
14	14
15	15	pub fn build(b: *std.Build) !void {
...	...	@@ -242,7 +242,7 @@ pub fn build(b: *std.Build) !void {
242	242	const commit_height = it.next().?;
243	243	const commit_id = it.next().?;
244	244
245		const ancestor_ver = try std.builtin.Version.parse(tagged_ancestor);
	245	const ancestor_ver = try std.SemanticVersion.parse(tagged_ancestor);
246	246	if (zig_version.order(ancestor_ver) != .gt) {
247	247	std.debug.print("Zig version '{}' must be greater than tagged ancestor '{}'\n", .{ zig_version, ancestor_ver });
248	248	std.process.exit(1);

lib/std/Build.zig+4-4

...	...	@@ -472,7 +472,7 @@ pub fn addOptions(self: Build) Step.Options {
472	472	pub const ExecutableOptions = struct {
473	473	name: []const u8,
474	474	root_source_file: ?FileSource = null,
475		version: ?std.builtin.Version = null,
	475	version: ?std.SemanticVersion = null,
476	476	target: CrossTarget = .{},
477	477	optimize: std.builtin.Mode = .Debug,
478	478	linkage: ?Step.Compile.Linkage = null,
...	...	@@ -530,7 +530,7 @@ pub fn addObject(b: Build, options: ObjectOptions) Step.Compile {
530	530	pub const SharedLibraryOptions = struct {
531	531	name: []const u8,
532	532	root_source_file: ?FileSource = null,
533		version: ?std.builtin.Version = null,
	533	version: ?std.SemanticVersion = null,
534	534	target: CrossTarget,
535	535	optimize: std.builtin.Mode,
536	536	max_rss: usize = 0,
...	...	@@ -562,7 +562,7 @@ pub const StaticLibraryOptions = struct {
562	562	root_source_file: ?FileSource = null,
563	563	target: CrossTarget,
564	564	optimize: std.builtin.Mode,
565		version: ?std.builtin.Version = null,
	565	version: ?std.SemanticVersion = null,
566	566	max_rss: usize = 0,
567	567	link_libc: ?bool = null,
568	568	single_threaded: ?bool = null,
...	...	@@ -592,7 +592,7 @@ pub const TestOptions = struct {
592	592	root_source_file: FileSource,
593	593	target: CrossTarget = .{},
594	594	optimize: std.builtin.Mode = .Debug,
595		version: ?std.builtin.Version = null,
	595	version: ?std.SemanticVersion = null,
596	596	max_rss: usize = 0,
597	597	filter: ?[]const u8 = null,
598	598	test_runner: ?[]const u8 = null,

lib/std/Build/Cache.zig+1-1

...	...	@@ -212,7 +212,7 @@ pub const HashHelper = struct {
212	212	/// Convert the input value into bytes and record it as a dependency of the process being cached.
213	213	pub fn add(hh: *HashHelper, x: anytype) void {
214	214	switch (@TypeOf(x)) {
215		std.builtin.Version => {
	215	std.SemanticVersion => {
216	216	hh.add(x.major);
217	217	hh.add(x.minor);
218	218	hh.add(x.patch);

lib/std/Build/Step/Compile.zig+2-2

...	...	@@ -32,7 +32,7 @@ linker_script: ?FileSource = null,
32	32	version_script: ?[]const u8 = null,
33	33	out_filename: []const u8,
34	34	linkage: ?Linkage = null,
35		version: ?std.builtin.Version,
	35	version: ?std.SemanticVersion,
36	36	kind: Kind,
37	37	major_only_filename: ?[]const u8,
38	38	name_only_filename: ?[]const u8,
...	...	@@ -278,7 +278,7 @@ pub const Options = struct {
278	278	optimize: std.builtin.Mode,
279	279	kind: Kind,
280	280	linkage: ?Linkage = null,
281		version: ?std.builtin.Version = null,
	281	version: ?std.SemanticVersion = null,
282	282	max_rss: usize = 0,
283	283	filter: ?[]const u8 = null,
284	284	test_runner: ?[]const u8 = null,

lib/std/Build/Step/Options.zig-23

...	...	@@ -76,23 +76,6 @@ fn addOptionFallible(self: *Options, comptime T: type, name: []const u8, value:
76	76	}
77	77	return;
78	78	},
79		std.builtin.Version => {
80		try out.print(
81		\\pub const {}: @import("std").builtin.Version = .{{
82		\\ .major = {d},
83		\\ .minor = {d},
84		\\ .patch = {d},
85		\\}};
86		\\
87		, .{
88		std.zig.fmtId(name),
89
90		value.major,
91		value.minor,
92		value.patch,
93		});
94		return;
95		},
96	79	std.SemanticVersion => {
97	80	try out.print(
98	81	\\pub const {}: @import("std").SemanticVersion = .{{
...	...	@@ -367,7 +350,6 @@ test Options {
367	350	options.addOption([2][2]u16, "nested_array", nested_array);
368	351	options.addOption([]const []const u16, "nested_slice", nested_slice);
369	352	//options.addOption(KeywordEnum, "keyword_enum", .@"0.8.1");
370		options.addOption(std.builtin.Version, "version", try std.builtin.Version.parse("0.1.2"));
371	353	options.addOption(std.SemanticVersion, "semantic_version", try std.SemanticVersion.parse("0.1.2-foo+bar"));
372	354
373	355	try std.testing.expectEqualStrings(
...	...	@@ -401,11 +383,6 @@ test Options {
401	383	//\\ @"0.8.1",
402	384	//\\};
403	385	//\\pub const keyword_enum: KeywordEnum = KeywordEnum.@"0.8.1";
404		\\pub const version: @import("std").builtin.Version = .{
405		\\ .major = 0,
406		\\ .minor = 1,
407		\\ .patch = 2,
408		\\};
409	386	\\pub const semantic_version: @import("std").SemanticVersion = .{
410	387	\\ .major = 0,
411	388	\\ .minor = 1,

lib/std/Build/Step/TranslateC.zig+1-1

...	...	@@ -47,7 +47,7 @@ pub fn create(owner: std.Build, options: Options) TranslateC {
47	47
48	48	pub const AddExecutableOptions = struct {
49	49	name: ?[]const u8 = null,
50		version: ?std.builtin.Version = null,
	50	version: ?std.SemanticVersion = null,
51	51	target: ?CrossTarget = null,
52	52	optimize: ?std.builtin.Mode = null,
53	53	linkage: ?Step.Compile.Linkage = null,

lib/std/SemanticVersion.zig+22-2

...	...	@@ -1,4 +1,4 @@
1		//! A software version formatted according to the Semantic Version 2 specification.
	1	//! A software version formatted according to the Semantic Versioning 2.0.0 specification.
2	2	//!
3	3	//! See: https://semver.org
4	4
...	...	@@ -167,7 +167,7 @@ const expect = std.testing.expect;
167	167	const expectError = std.testing.expectError;
168	168
169	169	test "SemanticVersion format" {
170		// Test vectors are from https://github.com/semver/semver.org/issues/59#issuecomment-390854010.
	170	// Many of these test strings are from https://github.com/semver/semver.org/issues/59#issuecomment-390854010.
171	171
172	172	// Valid version strings should be accepted.
173	173	for ([_][]const u8{
...	...	@@ -200,6 +200,8 @@ test "SemanticVersion format" {
200	200	"1.2.3----R-S.12.9.1--.12+meta",
201	201	"1.2.3----RC-SNAPSHOT.12.9.1--.12",
202	202	"1.0.0+0.build.1-rc.10000aaa-kk-0.1",
	203	"5.4.0-1018-raspi",
	204	"5.7.123",
203	205	}) \|valid\| try std.testing.expectFmt(valid, "{}", .{try parse(valid)});
204	206
205	207	// Invalid version strings should be rejected.
...	...	@@ -244,6 +246,24 @@ test "SemanticVersion format" {
244	246	"+justmeta",
245	247	"9.8.7+meta+meta",
246	248	"9.8.7-whatever+meta+meta",
	249	"2.6.32.11-svn21605",
	250	"2.11.2(0.329/5/3)",
	251	"2.13-DEVELOPMENT",
	252	"2.3-35",
	253	"1a.4",
	254	"3.b1.0",
	255	"1.4beta",
	256	"2.7.pre",
	257	"0..3",
	258	"8.008.",
	259	"01...",
	260	"55",
	261	"foobar",
	262	"",
	263	"-1",
	264	"+4",
	265	".",
	266	"....3",
247	267	}) \|invalid\| try expectError(error.InvalidVersion, parse(invalid));
248	268
249	269	// Valid version string that may overflow.

lib/std/builtin.zig-133

...	...	@@ -483,139 +483,6 @@ pub const WasiExecModel = enum {
483	483	reactor,
484	484	};
485	485
486		/// This data structure is used by the Zig language code generation and
487		/// therefore must be kept in sync with the compiler implementation.
488		pub const Version = struct {
489		major: u32,
490		minor: u32,
491		patch: u32 = 0,
492
493		pub const Range = struct {
494		min: Version,
495		max: Version,
496
497		pub fn includesVersion(self: Range, ver: Version) bool {
498		if (self.min.order(ver) == .gt) return false;
499		if (self.max.order(ver) == .lt) return false;
500		return true;
501		}
502
503		/// Checks if system is guaranteed to be at least `version` or older than `version`.
504		/// Returns `null` if a runtime check is required.
505		pub fn isAtLeast(self: Range, ver: Version) ?bool {
506		if (self.min.order(ver) != .lt) return true;
507		if (self.max.order(ver) == .lt) return false;
508		return null;
509		}
510		};
511
512		pub fn order(lhs: Version, rhs: Version) std.math.Order {
513		if (lhs.major < rhs.major) return .lt;
514		if (lhs.major > rhs.major) return .gt;
515		if (lhs.minor < rhs.minor) return .lt;
516		if (lhs.minor > rhs.minor) return .gt;
517		if (lhs.patch < rhs.patch) return .lt;
518		if (lhs.patch > rhs.patch) return .gt;
519		return .eq;
520		}
521
522		pub fn parse(text: []const u8) !Version {
523		var end: usize = 0;
524		while (end < text.len) : (end += 1) {
525		const c = text[end];
526		if (!std.ascii.isDigit(c) and c != '.') break;
527		}
528		// found no digits or '.' before unexpected character
529		if (end == 0) return error.InvalidVersion;
530
531		var it = std.mem.splitScalar(u8, text[0..end], '.');
532		// substring is not empty, first call will succeed
533		const major = it.first();
534		if (major.len == 0) return error.InvalidVersion;
535		const minor = it.next() orelse "0";
536		// ignore 'patch' if 'minor' is invalid
537		const patch = if (minor.len == 0) "0" else (it.next() orelse "0");
538
539		return Version{
540		.major = try std.fmt.parseUnsigned(u32, major, 10),
541		.minor = try std.fmt.parseUnsigned(u32, if (minor.len == 0) "0" else minor, 10),
542		.patch = try std.fmt.parseUnsigned(u32, if (patch.len == 0) "0" else patch, 10),
543		};
544		}
545
546		pub fn format(
547		self: Version,
548		comptime fmt: []const u8,
549		options: std.fmt.FormatOptions,
550		out_stream: anytype,
551		) !void {
552		_ = options;
553		if (fmt.len == 0) {
554		if (self.patch == 0) {
555		if (self.minor == 0) {
556		return std.fmt.format(out_stream, "{d}", .{self.major});
557		} else {
558		return std.fmt.format(out_stream, "{d}.{d}", .{ self.major, self.minor });
559		}
560		} else {
561		return std.fmt.format(out_stream, "{d}.{d}.{d}", .{ self.major, self.minor, self.patch });
562		}
563		} else {
564		std.fmt.invalidFmtError(fmt, self);
565		}
566		}
567		};
568
569		test "Version.parse" {
570		@setEvalBranchQuota(3000);
571		try testVersionParse();
572		comptime (try testVersionParse());
573		}
574
575		fn testVersionParse() !void {
576		const f = struct {
577		fn eql(text: []const u8, v1: u32, v2: u32, v3: u32) !void {
578		const v = try Version.parse(text);
579		try std.testing.expect(v.major == v1 and v.minor == v2 and v.patch == v3);
580		}
581
582		fn err(text: []const u8, expected_err: anyerror) !void {
583		_ = Version.parse(text) catch \|actual_err\| {
584		if (actual_err == expected_err) return;
585		return actual_err;
586		};
587		return error.Unreachable;
588		}
589		};
590
591		try f.eql("2.6.32.11-svn21605", 2, 6, 32); // Debian PPC
592		try f.eql("2.11.2(0.329/5/3)", 2, 11, 2); // MinGW
593		try f.eql("5.4.0-1018-raspi", 5, 4, 0); // Ubuntu
594		try f.eql("5.7.12_3", 5, 7, 12); // Void
595		try f.eql("2.13-DEVELOPMENT", 2, 13, 0); // DragonFly
596		try f.eql("2.3-35", 2, 3, 0);
597		try f.eql("1a.4", 1, 0, 0);
598		try f.eql("3.b1.0", 3, 0, 0);
599		try f.eql("1.4beta", 1, 4, 0);
600		try f.eql("2.7.pre", 2, 7, 0);
601		try f.eql("0..3", 0, 0, 0);
602		try f.eql("8.008.", 8, 8, 0);
603		try f.eql("01...", 1, 0, 0);
604		try f.eql("55", 55, 0, 0);
605		try f.eql("4294967295.0.1", 4294967295, 0, 1);
606		try f.eql("429496729_6", 429496729, 0, 0);
607
608		try f.err("foobar", error.InvalidVersion);
609		try f.err("", error.InvalidVersion);
610		try f.err("-1", error.InvalidVersion);
611		try f.err("+4", error.InvalidVersion);
612		try f.err(".", error.InvalidVersion);
613		try f.err("....3", error.InvalidVersion);
614		try f.err("4294967296", error.Overflow);
615		try f.err("5000877755", error.Overflow);
616		// error.InvalidCharacter is not possible anymore
617		}
618
619	486	/// This data structure is used by the Zig language code generation and
620	487	/// therefore must be kept in sync with the compiler implementation.
621	488	pub const CallModifier = enum {

lib/std/c.zig+1-1

...	...	@@ -20,7 +20,7 @@ pub const Tokenizer = tokenizer.Tokenizer;
20	20	/// If linking gnu libc (glibc), the `ok` value will be true if the target
21	21	/// version is greater than or equal to `glibc_version`.
22	22	/// If linking a libc other than these, returns `false`.
23		pub fn versionCheck(comptime glibc_version: std.builtin.Version) type {
	23	pub fn versionCheck(comptime glibc_version: std.SemanticVersion) type {
24	24	return struct {
25	25	pub const ok = blk: {
26	26	if (!builtin.link_libc) break :blk false;

lib/std/crypto/tlcsprng.zig+1

...	...	@@ -38,6 +38,7 @@ const want_fork_safety = os_has_fork and !os_has_arc4random and
38	38	const maybe_have_wipe_on_fork = builtin.os.isAtLeast(.linux, .{
39	39	.major = 4,
40	40	.minor = 14,
	41	.patch = 0,
41	42	}) orelse true;
42	43	const is_haiku = builtin.os.tag == .haiku;
43	44

lib/std/os.zig+9-9

...	...	@@ -488,7 +488,7 @@ pub fn getrandom(buffer: []u8) GetRandomError!void {
488	488	if (builtin.os.tag == .linux or builtin.os.tag == .freebsd) {
489	489	var buf = buffer;
490	490	const use_c = builtin.os.tag != .linux or
491		std.c.versionCheck(std.builtin.Version{ .major = 2, .minor = 25, .patch = 0 }).ok;
	491	std.c.versionCheck(std.SemanticVersion{ .major = 2, .minor = 25, .patch = 0 }).ok;
492	492
493	493	while (buf.len != 0) {
494	494	const res = if (use_c) blk: {
...	...	@@ -5272,7 +5272,7 @@ pub fn getFdPath(fd: fd_t, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {
5272	5272	return target;
5273	5273	},
5274	5274	.freebsd => {
5275		if (comptime builtin.os.version_range.semver.max.order(.{ .major = 13, .minor = 0 }) == .gt) {
	5275	if (comptime builtin.os.version_range.semver.max.order(.{ .major = 13, .minor = 0, .patch = 0 }) == .gt) {
5276	5276	var kfile: system.kinfo_file = undefined;
5277	5277	kfile.structsize = system.KINFO_FILE_SIZE;
5278	5278	switch (errno(system.fcntl(fd, system.F.KINFO, @ptrToInt(&kfile)))) {
...	...	@@ -5325,7 +5325,7 @@ pub fn getFdPath(fd: fd_t, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {
5325	5325	}
5326	5326	},
5327	5327	.dragonfly => {
5328		if (comptime builtin.os.version_range.semver.max.order(.{ .major = 6, .minor = 0 }) == .lt) {
	5328	if (comptime builtin.os.version_range.semver.max.order(.{ .major = 6, .minor = 0, .patch = 0 }) == .lt) {
5329	5329	@compileError("querying for canonical path of a handle is unsupported on this host");
5330	5330	}
5331	5331	@memset(out_buffer[0..MAX_PATH_BYTES], 0);
...	...	@@ -5339,7 +5339,7 @@ pub fn getFdPath(fd: fd_t, out_buffer: *[MAX_PATH_BYTES]u8) RealPathError![]u8 {
5339	5339	return out_buffer[0..len];
5340	5340	},
5341	5341	.netbsd => {
5342		if (comptime builtin.os.version_range.semver.max.order(.{ .major = 10, .minor = 0 }) == .lt) {
	5342	if (comptime builtin.os.version_range.semver.max.order(.{ .major = 10, .minor = 0, .patch = 0 }) == .lt) {
5343	5343	@compileError("querying for canonical path of a handle is unsupported on this host");
5344	5344	}
5345	5345	@memset(out_buffer[0..MAX_PATH_BYTES], 0);
...	...	@@ -6152,9 +6152,9 @@ pub fn sendfile(
6152	6152	.linux => sf: {
6153	6153	// sendfile() first appeared in Linux 2.2, glibc 2.1.
6154	6154	const call_sf = comptime if (builtin.link_libc)
6155		std.c.versionCheck(.{ .major = 2, .minor = 1 }).ok
	6155	std.c.versionCheck(.{ .major = 2, .minor = 1, .patch = 0 }).ok
6156	6156	else
6157		builtin.os.version_range.linux.range.max.order(.{ .major = 2, .minor = 2 }) != .lt;
	6157	builtin.os.version_range.linux.range.max.order(.{ .major = 2, .minor = 2, .patch = 0 }) != .lt;
6158	6158	if (!call_sf) break :sf;
6159	6159
6160	6160	if (headers.len != 0) {
...	...	@@ -6453,8 +6453,8 @@ var has_copy_file_range_syscall = std.atomic.Atomic(bool).init(true);
6453	6453	///
6454	6454	/// Maximum offsets on Linux and FreeBSD are `math.maxInt(i64)`.
6455	6455	pub fn copy_file_range(fd_in: fd_t, off_in: u64, fd_out: fd_t, off_out: u64, len: usize, flags: u32) CopyFileRangeError!usize {
6456		if ((comptime builtin.os.isAtLeast(.freebsd, .{ .major = 13, .minor = 0 }) orelse false) or
6457		((comptime builtin.os.isAtLeast(.linux, .{ .major = 4, .minor = 5 }) orelse false and
	6456	if ((comptime builtin.os.isAtLeast(.freebsd, .{ .major = 13, .minor = 0, .patch = 0 }) orelse false) or
	6457	((comptime builtin.os.isAtLeast(.linux, .{ .major = 4, .minor = 5, .patch = 0 }) orelse false and
6458	6458	std.c.versionCheck(.{ .major = 2, .minor = 27, .patch = 0 }).ok) and
6459	6459	has_copy_file_range_syscall.load(.Monotonic)))
6460	6460	{
...	...	@@ -6787,7 +6787,7 @@ pub fn memfd_createZ(name: [*:0]const u8, flags: u32) MemFdCreateError!fd_t {
6787	6787	}
6788	6788	},
6789	6789	.freebsd => {
6790		if (comptime builtin.os.version_range.semver.max.order(.{ .major = 13, .minor = 0 }) == .lt)
	6790	if (comptime builtin.os.version_range.semver.max.order(.{ .major = 13, .minor = 0, .patch = 0 }) == .lt)
6791	6791	@compileError("memfd_create is unavailable on FreeBSD < 13.0");
6792	6792	const rc = system.memfd_create(name, flags);
6793	6793	switch (errno(rc)) {

lib/std/os/test.zig+1-1

...	...	@@ -541,7 +541,7 @@ test "memfd_create" {
541	541	switch (native_os) {
542	542	.linux => {},
543	543	.freebsd => {
544		if (comptime builtin.os.version_range.semver.max.order(.{ .major = 13, .minor = 0 }) == .lt)
	544	if (comptime builtin.os.version_range.semver.max.order(.{ .major = 13, .minor = 0, .patch = 0 }) == .lt)
545	545	return error.SkipZigTest;
546	546	},
547	547	else => return error.SkipZigTest,

lib/std/target.zig+18-18

...	...	@@ -1,7 +1,7 @@
1	1	const std = @import("std.zig");
2	2	const builtin = @import("builtin");
3	3	const mem = std.mem;
4		const Version = std.builtin.Version;
	4	const Version = std.SemanticVersion;
5	5
6	6	/// TODO Nearly all the functions in this namespace would be
7	7	/// better off if https://github.com/ziglang/zig/issues/425
...	...	@@ -272,75 +272,75 @@ pub const Target = struct {
272	272
273	273	.freebsd => return .{
274	274	.semver = Version.Range{
275		.min = .{ .major = 12, .minor = 0 },
276		.max = .{ .major = 13, .minor = 1 },
	275	.min = .{ .major = 12, .minor = 0, .patch = 0 },
	276	.max = .{ .major = 13, .minor = 1, .patch = 0 },
277	277	},
278	278	},
279	279	.macos => return switch (arch) {
280	280	.aarch64 => VersionRange{
281	281	.semver = .{
282	282	.min = .{ .major = 11, .minor = 7, .patch = 1 },
283		.max = .{ .major = 13, .minor = 3 },
	283	.max = .{ .major = 13, .minor = 3, .patch = 0 },
284	284	},
285	285	},
286	286	.x86_64 => VersionRange{
287	287	.semver = .{
288	288	.min = .{ .major = 11, .minor = 7, .patch = 1 },
289		.max = .{ .major = 13, .minor = 3 },
	289	.max = .{ .major = 13, .minor = 3, .patch = 0 },
290	290	},
291	291	},
292	292	else => unreachable,
293	293	},
294	294	.ios => return .{
295	295	.semver = .{
296		.min = .{ .major = 12, .minor = 0 },
	296	.min = .{ .major = 12, .minor = 0, .patch = 0 },
297	297	.max = .{ .major = 13, .minor = 4, .patch = 0 },
298	298	},
299	299	},
300	300	.watchos => return .{
301	301	.semver = .{
302		.min = .{ .major = 6, .minor = 0 },
	302	.min = .{ .major = 6, .minor = 0, .patch = 0 },
303	303	.max = .{ .major = 6, .minor = 2, .patch = 0 },
304	304	},
305	305	},
306	306	.tvos => return .{
307	307	.semver = .{
308		.min = .{ .major = 13, .minor = 0 },
	308	.min = .{ .major = 13, .minor = 0, .patch = 0 },
309	309	.max = .{ .major = 13, .minor = 4, .patch = 0 },
310	310	},
311	311	},
312	312	.netbsd => return .{
313	313	.semver = .{
314		.min = .{ .major = 8, .minor = 0 },
315		.max = .{ .major = 10, .minor = 0 },
	314	.min = .{ .major = 8, .minor = 0, .patch = 0 },
	315	.max = .{ .major = 10, .minor = 0, .patch = 0 },
316	316	},
317	317	},
318	318	.openbsd => return .{
319	319	.semver = .{
320		.min = .{ .major = 6, .minor = 8 },
321		.max = .{ .major = 7, .minor = 2 },
	320	.min = .{ .major = 6, .minor = 8, .patch = 0 },
	321	.max = .{ .major = 7, .minor = 2, .patch = 0 },
322	322	},
323	323	},
324	324	.dragonfly => return .{
325	325	.semver = .{
326		.min = .{ .major = 5, .minor = 8 },
327		.max = .{ .major = 6, .minor = 4 },
	326	.min = .{ .major = 5, .minor = 8, .patch = 0 },
	327	.max = .{ .major = 6, .minor = 4, .patch = 0 },
328	328	},
329	329	},
330	330	.solaris => return .{
331	331	.semver = .{
332		.min = .{ .major = 5, .minor = 11 },
333		.max = .{ .major = 5, .minor = 11 },
	332	.min = .{ .major = 5, .minor = 11, .patch = 0 },
	333	.max = .{ .major = 5, .minor = 11, .patch = 0 },
334	334	},
335	335	},
336	336
337	337	.linux => return .{
338	338	.linux = .{
339	339	.range = .{
340		.min = .{ .major = 3, .minor = 16 },
	340	.min = .{ .major = 3, .minor = 16, .patch = 0 },
341	341	.max = .{ .major = 5, .minor = 10, .patch = 81 },
342	342	},
343		.glibc = .{ .major = 2, .minor = 19 },
	343	.glibc = .{ .major = 2, .minor = 19, .patch = 0 },
344	344	},
345	345	},
346	346

lib/std/zig.zig+1-1

...	...	@@ -108,7 +108,7 @@ pub const BinNameOptions = struct {
108	108	target: std.Target,
109	109	output_mode: std.builtin.OutputMode,
110	110	link_mode: ?std.builtin.LinkMode = null,
111		version: ?std.builtin.Version = null,
	111	version: ?std.SemanticVersion = null,
112	112	};
113	113
114	114	/// Returns the standard file system basename of a binary generated by the Zig compiler.

lib/std/zig/CrossTarget.zig+52-13

...	...	@@ -33,7 +33,7 @@ os_version_max: ?OsVersion = null,
33	33
34	34	/// `null` means default when cross compiling, or native when os_tag is native.
35	35	/// If `isGnuLibC()` is `false`, this must be `null` and is ignored.
36		glibc_version: ?SemVer = null,
	36	glibc_version: ?SemanticVersion = null,
37	37
38	38	/// `null` means the native C ABI, if `os_tag` is native, otherwise it means the default C ABI.
39	39	abi: ?Target.Abi = null,
...	...	@@ -61,11 +61,11 @@ pub const CpuModel = union(enum) {
61	61
62	62	pub const OsVersion = union(enum) {
63	63	none: void,
64		semver: SemVer,
	64	semver: SemanticVersion,
65	65	windows: Target.Os.WindowsVersion,
66	66	};
67	67
68		pub const SemVer = std.builtin.Version;
	68	pub const SemanticVersion = std.SemanticVersion;
69	69
70	70	pub const DynamicLinker = Target.DynamicLinker;
71	71
...	...	@@ -266,9 +266,8 @@ pub fn parse(args: ParseOptions) !CrossTarget {
266	266	const abi_ver_text = abi_it.rest();
267	267	if (abi_it.next() != null) {
268	268	if (result.isGnuLibC()) {
269		result.glibc_version = SemVer.parse(abi_ver_text) catch \|err\| switch (err) {
	269	result.glibc_version = parseVersion(abi_ver_text) catch \|err\| switch (err) {
270	270	error.Overflow => return error.InvalidAbiVersion,
271		error.InvalidCharacter => return error.InvalidAbiVersion,
272	271	error.InvalidVersion => return error.InvalidAbiVersion,
273	272	};
274	273	} else {
...	...	@@ -353,6 +352,31 @@ pub fn parseCpuArch(args: ParseOptions) ?Target.Cpu.Arch {
353	352	}
354	353	}
355	354
	355	/// Parses a version with an omitted patch component, such as "1.0",
	356	/// which SemanticVersion.parse is not capable of.
	357	fn parseVersion(ver: []const u8) !SemanticVersion {
	358	const parseVersionComponent = struct {
	359	fn parseVersionComponent(component: []const u8) !usize {
	360	return std.fmt.parseUnsigned(usize, component, 10) catch \|err\| {
	361	switch (err) {
	362	error.InvalidCharacter => return error.InvalidVersion,
	363	error.Overflow => return error.Overflow,
	364	}
	365	};
	366	}
	367	}.parseVersionComponent;
	368	var version_components = mem.split(u8, ver, ".");
	369	const major = version_components.first();
	370	const minor = version_components.next() orelse return error.InvalidVersion;
	371	const patch = version_components.next() orelse "0";
	372	if (version_components.next() != null) return error.InvalidVersion;
	373	return .{
	374	.major = try parseVersionComponent(major),
	375	.minor = try parseVersionComponent(minor),
	376	.patch = try parseVersionComponent(patch),
	377	};
	378	}
	379
356	380	/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`.
357	381	pub fn getCpu(self: CrossTarget) Target.Cpu {
358	382	switch (self.cpu_model) {
...	...	@@ -534,6 +558,16 @@ pub fn isNative(self: CrossTarget) bool {
534	558	return self.isNativeCpu() and self.isNativeOs() and self.isNativeAbi();
535	559	}
536	560
	561	/// Formats a version with the patch component omitted if it is zero,
	562	/// unlike SemanticVersion.format which formats all its version components regardless.
	563	fn formatVersion(version: SemanticVersion, writer: anytype) !void {
	564	if (version.patch == 0) {
	565	try writer.print("{d}.{d}", .{ version.major, version.minor });
	566	} else {
	567	try writer.print("{d}.{d}.{d}", .{ version.major, version.minor, version.patch });
	568	}
	569	}
	570
537	571	pub fn zigTriple(self: CrossTarget, allocator: mem.Allocator) error{OutOfMemory}![]u8 {
538	572	if (self.isNative()) {
539	573	return allocator.dupe(u8, "native");
...	...	@@ -552,20 +586,27 @@ pub fn zigTriple(self: CrossTarget, allocator: mem.Allocator) error{OutOfMemory}
552	586	if (self.os_version_min != null or self.os_version_max != null) {
553	587	switch (self.getOsVersionMin()) {
554	588	.none => {},
555		.semver => \|v\| try result.writer().print(".{}", .{v}),
	589	.semver => \|v\| {
	590	try result.writer().writeAll(".");
	591	try formatVersion(v, result.writer());
	592	},
556	593	.windows => \|v\| try result.writer().print("{s}", .{v}),
557	594	}
558	595	}
559	596	if (self.os_version_max) \|max\| {
560	597	switch (max) {
561	598	.none => {},
562		.semver => \|v\| try result.writer().print("...{}", .{v}),
	599	.semver => \|v\| {
	600	try result.writer().writeAll("...");
	601	try formatVersion(v, result.writer());
	602	},
563	603	.windows => \|v\| try result.writer().print("..{s}", .{v}),
564	604	}
565	605	}
566	606
567	607	if (self.glibc_version) \|v\| {
568		try result.writer().print("-{s}.{}", .{ @tagName(self.getAbi()), v });
	608	try result.writer().print("-{s}.", .{@tagName(self.getAbi())});
	609	try formatVersion(v, result.writer());
569	610	} else if (self.abi) \|abi\| {
570	611	try result.writer().print("-{s}", .{@tagName(abi)});
571	612	}
...	...	@@ -630,7 +671,7 @@ pub fn isGnuLibC(self: CrossTarget) bool {
630	671
631	672	pub fn setGnuLibCVersion(self: *CrossTarget, major: u32, minor: u32, patch: u32) void {
632	673	assert(self.isGnuLibC());
633		self.glibc_version = SemVer{ .major = major, .minor = minor, .patch = patch };
	674	self.glibc_version = SemanticVersion{ .major = major, .minor = minor, .patch = patch };
634	675	}
635	676
636	677	pub fn getObjectFormat(self: CrossTarget) Target.ObjectFormat {
...	...	@@ -709,17 +750,15 @@ fn parseOs(result: CrossTarget, diags: ParseOptions.Diagnostics, text: []const
709	750	var range_it = mem.splitSequence(u8, version_text, "...");
710	751
711	752	const min_text = range_it.next().?;
712		const min_ver = SemVer.parse(min_text) catch \|err\| switch (err) {
	753	const min_ver = parseVersion(min_text) catch \|err\| switch (err) {
713	754	error.Overflow => return error.InvalidOperatingSystemVersion,
714		error.InvalidCharacter => return error.InvalidOperatingSystemVersion,
715	755	error.InvalidVersion => return error.InvalidOperatingSystemVersion,
716	756	};
717	757	result.os_version_min = .{ .semver = min_ver };
718	758
719	759	const max_text = range_it.next() orelse return;
720		const max_ver = SemVer.parse(max_text) catch \|err\| switch (err) {
	760	const max_ver = parseVersion(max_text) catch \|err\| switch (err) {
721	761	error.Overflow => return error.InvalidOperatingSystemVersion,
722		error.InvalidCharacter => return error.InvalidOperatingSystemVersion,
723	762	error.InvalidVersion => return error.InvalidOperatingSystemVersion,
724	763	};
725	764	result.os_version_max = .{ .semver = max_ver };

lib/std/zig/system/NativeTargetInfo.zig+9-13

...	...	@@ -43,24 +43,22 @@ pub fn detect(cross_target: CrossTarget) DetectError!NativeTargetInfo {
43	43	const release = mem.sliceTo(&uts.release, 0);
44	44	// The release field sometimes has a weird format,
45	45	// `Version.parse` will attempt to find some meaningful interpretation.
46		if (std.builtin.Version.parse(release)) \|ver\| {
	46	if (std.SemanticVersion.parse(release)) \|ver\| {
47	47	os.version_range.linux.range.min = ver;
48	48	os.version_range.linux.range.max = ver;
49	49	} else \|err\| switch (err) {
50	50	error.Overflow => {},
51		error.InvalidCharacter => {},
52	51	error.InvalidVersion => {},
53	52	}
54	53	},
55	54	.solaris => {
56	55	const uts = std.os.uname();
57	56	const release = mem.sliceTo(&uts.release, 0);
58		if (std.builtin.Version.parse(release)) \|ver\| {
	57	if (std.SemanticVersion.parse(release)) \|ver\| {
59	58	os.version_range.semver.min = ver;
60	59	os.version_range.semver.max = ver;
61	60	} else \|err\| switch (err) {
62	61	error.Overflow => {},
63		error.InvalidCharacter => {},
64	62	error.InvalidVersion => {},
65	63	}
66	64	},
...	...	@@ -144,7 +142,7 @@ pub fn detect(cross_target: CrossTarget) DetectError!NativeTargetInfo {
144	142	error.Unexpected => return error.OSVersionDetectionFail,
145	143	};
146	144
147		if (std.builtin.Version.parse(buf[0 .. len - 1])) \|ver\| {
	145	if (std.SemanticVersion.parse(buf[0 .. len - 1])) \|ver\| {
148	146	os.version_range.semver.min = ver;
149	147	os.version_range.semver.max = ver;
150	148	} else \|_\| {
...	...	@@ -390,7 +388,7 @@ fn detectAbiAndDynamicLinker(
390	388	};
391	389	}
392	390
393		fn glibcVerFromRPath(rpath: []const u8) !std.builtin.Version {
	391	fn glibcVerFromRPath(rpath: []const u8) !std.SemanticVersion {
394	392	var dir = fs.cwd().openDir(rpath, .{}) catch \|err\| switch (err) {
395	393	error.NameTooLong => unreachable,
396	394	error.InvalidUtf8 => unreachable,
...	...	@@ -471,7 +469,7 @@ fn glibcVerFromRPath(rpath: []const u8) !std.builtin.Version {
471	469	};
472	470	}
473	471
474		fn glibcVerFromSoFile(file: fs.File) !std.builtin.Version {
	472	fn glibcVerFromSoFile(file: fs.File) !std.SemanticVersion {
475	473	var hdr_buf: [@sizeOf(elf.Elf64_Ehdr)]u8 align(@alignOf(elf.Elf64_Ehdr)) = undefined;
476	474	_ = try preadMin(file, &hdr_buf, 0, hdr_buf.len);
477	475	const hdr32 = @ptrCast(*elf.Elf32_Ehdr, &hdr_buf);
...	...	@@ -557,13 +555,12 @@ fn glibcVerFromSoFile(file: fs.File) !std.builtin.Version {
557	555	const dynstr_bytes = buf[0..dynstr_size];
558	556	_ = try preadMin(file, dynstr_bytes, dynstr.offset, dynstr_bytes.len);
559	557	var it = mem.splitScalar(u8, dynstr_bytes, 0);
560		var max_ver: std.builtin.Version = .{ .major = 2, .minor = 2, .patch = 5 };
	558	var max_ver: std.SemanticVersion = .{ .major = 2, .minor = 2, .patch = 5 };
561	559	while (it.next()) \|s\| {
562	560	if (mem.startsWith(u8, s, "GLIBC_2.")) {
563	561	const chopped = s["GLIBC_".len..];
564		const ver = std.builtin.Version.parse(chopped) catch \|err\| switch (err) {
	562	const ver = std.SemanticVersion.parse(chopped) catch \|err\| switch (err) {
565	563	error.Overflow => return error.InvalidGnuLibCVersion,
566		error.InvalidCharacter => return error.InvalidGnuLibCVersion,
567	564	error.InvalidVersion => return error.InvalidGnuLibCVersion,
568	565	};
569	566	switch (ver.order(max_ver)) {
...	...	@@ -575,7 +572,7 @@ fn glibcVerFromSoFile(file: fs.File) !std.builtin.Version {
575	572	return max_ver;
576	573	}
577	574
578		fn glibcVerFromLinkName(link_name: []const u8, prefix: []const u8) !std.builtin.Version {
	575	fn glibcVerFromLinkName(link_name: []const u8, prefix: []const u8) !std.SemanticVersion {
579	576	// example: "libc-2.3.4.so"
580	577	// example: "libc-2.27.so"
581	578	// example: "ld-2.33.so"
...	...	@@ -585,9 +582,8 @@ fn glibcVerFromLinkName(link_name: []const u8, prefix: []const u8) !std.builtin.
585	582	}
586	583	// chop off "libc-" and ".so"
587	584	const link_name_chopped = link_name[prefix.len .. link_name.len - suffix.len];
588		return std.builtin.Version.parse(link_name_chopped) catch \|err\| switch (err) {
	585	return std.SemanticVersion.parse(link_name_chopped) catch \|err\| switch (err) {
589	586	error.Overflow => return error.InvalidGnuLibCVersion,
590		error.InvalidCharacter => return error.InvalidGnuLibCVersion,
591	587	error.InvalidVersion => return error.InvalidGnuLibCVersion,
592	588	};
593	589	}

lib/std/zig/system/darwin.zig+2-1

...	...	@@ -2,7 +2,7 @@ const std = @import("std");
2	2	const mem = std.mem;
3	3	const Allocator = mem.Allocator;
4	4	const Target = std.Target;
5		const Version = std.builtin.Version;
	5	const Version = std.SemanticVersion;
6	6
7	7	pub const macos = @import("darwin/macos.zig");
8	8
...	...	@@ -69,6 +69,7 @@ pub fn getDarwinSDK(allocator: Allocator, target: Target) ?DarwinSDK {
69	69	const version = Version.parse(raw_version) catch Version{
70	70	.major = 0,
71	71	.minor = 0,
	72	.patch = 0,
72	73	};
73	74	break :version version;
74	75	};

lib/std/zig/system/darwin/macos.zig+28-19

...	...	@@ -74,20 +74,39 @@ pub fn detect(target_os: *Target.Os) !void {
74	74	return error.OSVersionDetectionFail;
75	75	}
76	76
77		fn parseSystemVersion(buf: []const u8) !std.builtin.Version {
	77	fn parseSystemVersion(buf: []const u8) !std.SemanticVersion {
78	78	var svt = SystemVersionTokenizer{ .bytes = buf };
79	79	try svt.skipUntilTag(.start, "dict");
80	80	while (true) {
81	81	try svt.skipUntilTag(.start, "key");
82	82	const content = try svt.expectContent();
83	83	try svt.skipUntilTag(.end, "key");
84		if (std.mem.eql(u8, content, "ProductVersion")) break;
	84	if (mem.eql(u8, content, "ProductVersion")) break;
85	85	}
86	86	try svt.skipUntilTag(.start, "string");
87	87	const ver = try svt.expectContent();
88	88	try svt.skipUntilTag(.end, "string");
89	89
90		return std.builtin.Version.parse(ver);
	90	const parseVersionComponent = struct {
	91	fn parseVersionComponent(component: []const u8) !usize {
	92	return std.fmt.parseUnsigned(usize, component, 10) catch \|err\| {
	93	switch (err) {
	94	error.InvalidCharacter => return error.InvalidVersion,
	95	error.Overflow => return error.Overflow,
	96	}
	97	};
	98	}
	99	}.parseVersionComponent;
	100	var version_components = mem.split(u8, ver, ".");
	101	const major = version_components.first();
	102	const minor = version_components.next() orelse return error.InvalidVersion;
	103	const patch = version_components.next() orelse "0";
	104	if (version_components.next() != null) return error.InvalidVersion;
	105	return .{
	106	.major = try parseVersionComponent(major),
	107	.minor = try parseVersionComponent(minor),
	108	.patch = try parseVersionComponent(patch),
	109	};
91	110	}
92	111
93	112	const SystemVersionTokenizer = struct {
...	...	@@ -246,7 +265,7 @@ const SystemVersionTokenizer = struct {
246	265	while (try self.next()) \|tok\| {
247	266	switch (tok) {
248	267	.tag => \|tag\| {
249		if (tag.kind == kind and std.mem.eql(u8, tag.name, name)) return;
	268	if (tag.kind == kind and mem.eql(u8, tag.name, name)) return;
250	269	},
251	270	else => {},
252	271	}
...	...	@@ -297,7 +316,7 @@ test "detect" {
297	316	\\</dict>
298	317	\\</plist>
299	318	,
300		.{ .major = 10, .minor = 3 },
	319	.{ .major = 10, .minor = 3, .patch = 0 },
301	320	},
302	321	.{
303	322	\\<?xml version="1.0" encoding="UTF-8"?>
...	...	@@ -361,7 +380,7 @@ test "detect" {
361	380	\\</dict>
362	381	\\</plist>
363	382	,
364		.{ .major = 11, .minor = 0 },
	383	.{ .major = 11, .minor = 0, .patch = 0 },
365	384	},
366	385	.{
367	386	\\<?xml version="1.0" encoding="UTF-8"?>
...	...	@@ -383,27 +402,17 @@ test "detect" {
383	402	\\</dict>
384	403	\\</plist>
385	404	,
386		.{ .major = 11, .minor = 1 },
	405	.{ .major = 11, .minor = 1, .patch = 0 },
387	406	},
388	407	};
389	408
390	409	inline for (cases) \|case\| {
391	410	const ver0 = try parseSystemVersion(case[0]);
392		const ver1: std.builtin.Version = case[1];
393		try testVersionEquality(ver1, ver0);
	411	const ver1: std.SemanticVersion = case[1];
	412	try testing.expectEqual(@as(std.math.Order, .eq), ver0.order(ver1));
394	413	}
395	414	}
396	415
397		fn testVersionEquality(expected: std.builtin.Version, got: std.builtin.Version) !void {
398		var b_expected: [64]u8 = undefined;
399		const s_expected: []const u8 = try std.fmt.bufPrint(b_expected[0..], "{}", .{expected});
400
401		var b_got: [64]u8 = undefined;
402		const s_got: []const u8 = try std.fmt.bufPrint(b_got[0..], "{}", .{got});
403
404		try testing.expectEqualStrings(s_expected, s_got);
405		}
406
407	416	pub fn detectNativeCpuAndFeatures() ?Target.Cpu {
408	417	var cpu_family: std.c.CPUFAMILY = undefined;
409	418	var len: usize = @sizeOf(std.c.CPUFAMILY);

src/Compilation.zig+2-2

...	...	@@ -615,8 +615,8 @@ pub const InitOptions = struct {
615	615	stack_size_override: ?u64 = null,
616	616	image_base_override: ?u64 = null,
617	617	self_exe_path: ?[]const u8 = null,
618		version: ?std.builtin.Version = null,
619		compatibility_version: ?std.builtin.Version = null,
	618	version: ?std.SemanticVersion = null,
	619	compatibility_version: ?std.SemanticVersion = null,
620	620	libc_installation: ?*const LibCInstallation = null,
621	621	machine_code_model: std.builtin.CodeModel = .default,
622	622	clang_preprocessor_mode: ClangPreprocessorMode = .no,

src/codegen/spirv/spec.zig+1-1

...	...	@@ -1,6 +1,6 @@
1	1	//! This file is auto-generated by tools/gen_spirv_spec.zig.
2	2
3		const Version = @import("std").builtin.Version;
	3	const Version = @import("std").SemanticVersion;
4	4
5	5	pub const Word = u32;
6	6	pub const IdResult = struct {

src/glibc.zig+2-2

...	...	@@ -5,7 +5,7 @@ const log = std.log;
5	5	const fs = std.fs;
6	6	const path = fs.path;
7	7	const assert = std.debug.assert;
8		const Version = std.builtin.Version;
	8	const Version = std.SemanticVersion;
9	9
10	10	const target_util = @import("target.zig");
11	11	const Compilation = @import("Compilation.zig");
...	...	@@ -172,7 +172,7 @@ pub fn buildCRTFile(comp: Compilation, crt_file: CRTFile, prog_node: std.Progr
172	172
173	173	const target = comp.getTarget();
174	174	const target_ver = target.os.version_range.linux.glibc;
175		const start_old_init_fini = target_ver.order(.{ .major = 2, .minor = 33 }) != .gt;
	175	const start_old_init_fini = target_ver.order(.{ .major = 2, .minor = 33, .patch = 0 }) != .gt;
176	176
177	177	// In all cases in this function, we add the C compiler flags to
178	178	// cache_exempt_flags rather than extra_flags, because these arguments

src/link.zig+2-2

...	...	@@ -197,8 +197,8 @@ pub const Options = struct {
197	197	/// __real_symbol.
198	198	symbol_wrap_set: std.StringArrayHashMapUnmanaged(void),
199	199
200		version: ?std.builtin.Version,
201		compatibility_version: ?std.builtin.Version,
	200	version: ?std.SemanticVersion,
	201	compatibility_version: ?std.SemanticVersion,
202	202	libc_installation: ?*const LibCInstallation,
203	203
204	204	dwarf_format: ?std.dwarf.Format,

src/link/Elf.zig+1-1

...	...	@@ -3414,7 +3414,7 @@ const CsuObjects = struct {
3414	3414	if (result.crtn) \|obj\| obj. = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
3415	3415
3416	3416	var gccv: []const u8 = undefined;
3417		if (link_options.target.os.version_range.semver.isAtLeast(.{ .major = 5, .minor = 4 }) orelse true) {
	3417	if (link_options.target.os.version_range.semver.isAtLeast(.{ .major = 5, .minor = 4, .patch = 0 }) orelse true) {
3418	3418	gccv = "gcc80";
3419	3419	} else {
3420	3420	gccv = "gcc54";

src/link/MachO/load_commands.zig+6-6

...	...	@@ -204,12 +204,12 @@ pub fn writeDylibIdLC(gpa: Allocator, options: *const link.Options, lc_writer: a
204	204	const emit = options.emit.?;
205	205	const install_name = options.install_name orelse try emit.directory.join(gpa, &.{emit.sub_path});
206	206	defer if (options.install_name == null) gpa.free(install_name);
207		const curr = options.version orelse std.builtin.Version{
	207	const curr = options.version orelse std.SemanticVersion{
208	208	.major = 1,
209	209	.minor = 0,
210	210	.patch = 0,
211	211	};
212		const compat = options.compatibility_version orelse std.builtin.Version{
	212	const compat = options.compatibility_version orelse std.SemanticVersion{
213	213	.major = 1,
214	214	.minor = 0,
215	215	.patch = 0,
...	...	@@ -217,8 +217,8 @@ pub fn writeDylibIdLC(gpa: Allocator, options: *const link.Options, lc_writer: a
217	217	try writeDylibLC(.{
218	218	.cmd = .ID_DYLIB,
219	219	.name = install_name,
220		.current_version = curr.major << 16 \| curr.minor << 8 \| curr.patch,
221		.compatibility_version = compat.major << 16 \| compat.minor << 8 \| compat.patch,
	220	.current_version = @intCast(u32, curr.major << 16 \| curr.minor << 8 \| curr.patch),
	221	.compatibility_version = @intCast(u32, compat.major << 16 \| compat.minor << 8 \| compat.patch),
222	222	}, lc_writer);
223	223	}
224	224
...	...	@@ -275,12 +275,12 @@ pub fn writeBuildVersionLC(options: *const link.Options, lc_writer: anytype) !vo
275	275	const cmdsize = @sizeOf(macho.build_version_command) + @sizeOf(macho.build_tool_version);
276	276	const platform_version = blk: {
277	277	const ver = options.target.os.version_range.semver.min;
278		const platform_version = ver.major << 16 \| ver.minor << 8;
	278	const platform_version = @intCast(u32, ver.major << 16 \| ver.minor << 8);
279	279	break :blk platform_version;
280	280	};
281	281	const sdk_version = if (options.native_darwin_sdk) \|sdk\| blk: {
282	282	const ver = sdk.version;
283		const sdk_version = ver.major << 16 \| ver.minor << 8;
	283	const sdk_version = @intCast(u32, ver.major << 16 \| ver.minor << 8);
284	284	break :blk sdk_version;
285	285	} else platform_version;
286	286	const is_simulator_abi = options.target.abi == .simulator;

src/main.zig+6-7

...	...	@@ -724,9 +724,9 @@ fn buildOutputType(
724	724	var dll_export_fns: ?bool = null;
725	725	var single_threaded: ?bool = null;
726	726	var root_src_file: ?[]const u8 = null;
727		var version: std.builtin.Version = .{ .major = 0, .minor = 0, .patch = 0 };
	727	var version: std.SemanticVersion = .{ .major = 0, .minor = 0, .patch = 0 };
728	728	var have_version = false;
729		var compatibility_version: ?std.builtin.Version = null;
	729	var compatibility_version: ?std.SemanticVersion = null;
730	730	var strip: ?bool = null;
731	731	var formatted_panics: ?bool = null;
732	732	var function_sections = false;
...	...	@@ -1121,7 +1121,7 @@ fn buildOutputType(
1121	1121	try cssan.addIncludePath(.iframework, arg, args_iter.nextOrFatal(), false);
1122	1122	} else if (mem.eql(u8, arg, "--version")) {
1123	1123	const next_arg = args_iter.nextOrFatal();
1124		version = std.builtin.Version.parse(next_arg) catch \|err\| {
	1124	version = std.SemanticVersion.parse(next_arg) catch \|err\| {
1125	1125	fatal("unable to parse --version '{s}': {s}", .{ next_arg, @errorName(err) });
1126	1126	};
1127	1127	have_version = true;
...	...	@@ -2152,12 +2152,12 @@ fn buildOutputType(
2152	2152	try system_libs.put(linker_args_it.nextOrFatal(), .{ .weak = true });
2153	2153	} else if (mem.eql(u8, arg, "-compatibility_version")) {
2154	2154	const compat_version = linker_args_it.nextOrFatal();
2155		compatibility_version = std.builtin.Version.parse(compat_version) catch \|err\| {
	2155	compatibility_version = std.SemanticVersion.parse(compat_version) catch \|err\| {
2156	2156	fatal("unable to parse -compatibility_version '{s}': {s}", .{ compat_version, @errorName(err) });
2157	2157	};
2158	2158	} else if (mem.eql(u8, arg, "-current_version")) {
2159	2159	const curr_version = linker_args_it.nextOrFatal();
2160		version = std.builtin.Version.parse(curr_version) catch \|err\| {
	2160	version = std.SemanticVersion.parse(curr_version) catch \|err\| {
2161	2161	fatal("unable to parse -current_version '{s}': {s}", .{ curr_version, @errorName(err) });
2162	2162	};
2163	2163	have_version = true;
...	...	@@ -2207,10 +2207,9 @@ fn buildOutputType(
2207	2207	} else if (mem.startsWith(u8, arg, "/version:")) {
2208	2208	var split_it = mem.splitBackwardsScalar(u8, arg, ':');
2209	2209	const version_arg = split_it.first();
2210		version = std.builtin.Version.parse(version_arg) catch \|err\| {
	2210	version = std.SemanticVersion.parse(version_arg) catch \|err\| {
2211	2211	fatal("unable to parse /version '{s}': {s}", .{ arg, @errorName(err) });
2212	2212	};
2213
2214	2213	have_version = true;
2215	2214	} else {
2216	2215	fatal("unsupported linker arg: {s}", .{arg});

src/target.zig+7-7

...	...	@@ -6,7 +6,7 @@ pub const ArchOsAbi = struct {
6	6	arch: std.Target.Cpu.Arch,
7	7	os: std.Target.Os.Tag,
8	8	abi: std.Target.Abi,
9		os_ver: ?std.builtin.Version = null,
	9	os_ver: ?std.SemanticVersion = null,
10	10	};
11	11
12	12	pub const available_libcs = [_]ArchOsAbi{
...	...	@@ -16,9 +16,9 @@ pub const available_libcs = [_]ArchOsAbi{
16	16	.{ .arch = .aarch64, .os = .linux, .abi = .gnu },
17	17	.{ .arch = .aarch64, .os = .linux, .abi = .musl },
18	18	.{ .arch = .aarch64, .os = .windows, .abi = .gnu },
19		.{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 11, .minor = 0 } },
20		.{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 12, .minor = 0 } },
21		.{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 13, .minor = 0 } },
	19	.{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 11, .minor = 0, .patch = 0 } },
	20	.{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 12, .minor = 0, .patch = 0 } },
	21	.{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 13, .minor = 0, .patch = 0 } },
22	22	.{ .arch = .armeb, .os = .linux, .abi = .gnueabi },
23	23	.{ .arch = .armeb, .os = .linux, .abi = .gnueabihf },
24	24	.{ .arch = .armeb, .os = .linux, .abi = .musleabi },
...	...	@@ -71,9 +71,9 @@ pub const available_libcs = [_]ArchOsAbi{
71	71	.{ .arch = .x86_64, .os = .linux, .abi = .gnux32 },
72	72	.{ .arch = .x86_64, .os = .linux, .abi = .musl },
73	73	.{ .arch = .x86_64, .os = .windows, .abi = .gnu },
74		.{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 11, .minor = 0 } },
75		.{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 12, .minor = 0 } },
76		.{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 13, .minor = 0 } },
	74	.{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 11, .minor = 0, .patch = 0 } },
	75	.{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 12, .minor = 0, .patch = 0 } },
	76	.{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 13, .minor = 0, .patch = 0 } },
77	77	};
78	78
79	79	pub fn libCGenericName(target: std.Target) [:0]const u8 {

test/link/macho/dylib/build.zig+1-1

...	...	@@ -17,7 +17,7 @@ fn add(b: std.Build, test_step: std.Build.Step, optimize: std.builtin.Optimize
17	17
18	18	const dylib = b.addSharedLibrary(.{
19	19	.name = "a",
20		.version = .{ .major = 1, .minor = 0 },
	20	.version = .{ .major = 1, .minor = 0, .patch = 0 },
21	21	.optimize = optimize,
22	22	.target = target,
23	23	});

test/link/macho/needed_library/build.zig+1-1

...	...	@@ -17,7 +17,7 @@ fn add(b: std.Build, test_step: std.Build.Step, optimize: std.builtin.Optimize
17	17
18	18	const dylib = b.addSharedLibrary(.{
19	19	.name = "a",
20		.version = .{ .major = 1, .minor = 0 },
	20	.version = .{ .major = 1, .minor = 0, .patch = 0 },
21	21	.optimize = optimize,
22	22	.target = target,
23	23	});

test/link/macho/search_strategy/build.zig+1-1

...	...	@@ -61,7 +61,7 @@ fn createScenario(
61	61
62	62	const dylib = b.addSharedLibrary(.{
63	63	.name = name,
64		.version = .{ .major = 1, .minor = 0 },
	64	.version = .{ .major = 1, .minor = 0, .patch = 0 },
65	65	.optimize = optimize,
66	66	.target = target,
67	67	});

test/link/macho/tls/build.zig+1-1

...	...	@@ -17,7 +17,7 @@ fn add(b: std.Build, test_step: std.Build.Step, optimize: std.builtin.Optimize
17	17
18	18	const lib = b.addSharedLibrary(.{
19	19	.name = "a",
20		.version = .{ .major = 1, .minor = 0 },
	20	.version = .{ .major = 1, .minor = 0, .patch = 0 },
21	21	.optimize = optimize,
22	22	.target = target,
23	23	});

test/link/macho/uuid/build.zig+1-1

...	...	@@ -62,7 +62,7 @@ fn simpleDylib(
62	62	) *std.Build.Step.Compile {
63	63	const dylib = b.addSharedLibrary(.{
64	64	.name = "test",
65		.version = .{ .major = 1, .minor = 0 },
	65	.version = .{ .major = 1, .minor = 0, .patch = 0 },
66	66	.optimize = optimize,
67	67	.target = target,
68	68	});

test/standalone/load_dynamic_library/build.zig+1-1

...	...	@@ -13,7 +13,7 @@ pub fn build(b: *std.Build) void {
13	13	const lib = b.addSharedLibrary(.{
14	14	.name = "add",
15	15	.root_source_file = .{ .path = "add.zig" },
16		.version = .{ .major = 1, .minor = 0 },
	16	.version = .{ .major = 1, .minor = 0, .patch = 0 },
17	17	.optimize = optimize,
18	18	.target = target,
19	19	});

test/standalone/shared_library/build.zig+1-1

...	...	@@ -9,7 +9,7 @@ pub fn build(b: *std.Build) void {
9	9	const lib = b.addSharedLibrary(.{
10	10	.name = "mathtest",
11	11	.root_source_file = .{ .path = "mathtest.zig" },
12		.version = .{ .major = 1, .minor = 0 },
	12	.version = .{ .major = 1, .minor = 0, .patch = 0 },
13	13	.target = target,
14	14	.optimize = optimize,
15	15	});

tools/gen_spirv_spec.zig+1-1

...	...	@@ -76,7 +76,7 @@ fn render(writer: anytype, allocator: Allocator, registry: g.CoreRegistry) !void
76	76	try writer.writeAll(
77	77	\\//! This file is auto-generated by tools/gen_spirv_spec.zig.
78	78	\\
79		\\const Version = @import("std").builtin.Version;
	79	\\const Version = @import("std").SemanticVersion;
80	80	\\
81	81	\\pub const Word = u32;
82	82	\\pub const IdResult = struct{

author	Wooster <r00ster91@proton.me> 2023-02-21 18:39:22+01:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-06-17 13:17:34-07:00
log	6e84f469904a24615a6721265a88ad8dcb4ed83a
tree	d390e7738b996686749adbbd9a1c18f647058b3b
parent	96acc204b2c6080f0169ca3721c3b95a433c185b

std: replace builtin.Version with SemanticVersion