Commit a0d3a87ce15a9f68047dc900109f5b76184d046f | zig

doc/langref.html.in+4-4

...	...	@@ -574,7 +574,7 @@ pub fn main() void {
574	574	var optional_value: ?[]const u8 = null;
575	575	assert(optional_value == null);
576	576
577		print("\noptional 1\ntype: {s}\nvalue: {s}\n", .{
	577	print("\noptional 1\ntype: {s}\nvalue: {?s}\n", .{
578	578	@typeName(@TypeOf(optional_value)),
579	579	optional_value,
580	580	});
...	...	@@ -582,7 +582,7 @@ pub fn main() void {
582	582	optional_value = "hi";
583	583	assert(optional_value != null);
584	584
585		print("\noptional 2\ntype: {s}\nvalue: {s}\n", .{
	585	print("\noptional 2\ntype: {s}\nvalue: {?s}\n", .{
586	586	@typeName(@TypeOf(optional_value)),
587	587	optional_value,
588	588	});
...	...	@@ -590,14 +590,14 @@ pub fn main() void {
590	590	// error union
591	591	var number_or_error: anyerror!i32 = error.ArgNotFound;
592	592
593		print("\nerror union 1\ntype: {s}\nvalue: {}\n", .{
	593	print("\nerror union 1\ntype: {s}\nvalue: {!}\n", .{
594	594	@typeName(@TypeOf(number_or_error)),
595	595	number_or_error,
596	596	});
597	597
598	598	number_or_error = 1234;
599	599
600		print("\nerror union 2\ntype: {s}\nvalue: {}\n", .{
	600	print("\nerror union 2\ntype: {s}\nvalue: {!}\n", .{
601	601	@typeName(@TypeOf(number_or_error)),
602	602	number_or_error,
603	603	});

lib/std/build.zig+2-2

...	...	@@ -751,7 +751,7 @@ pub const Builder = struct {
751	751	\\Available CPU features for architecture '{s}':
752	752	\\
753	753	, .{
754		diags.unknown_feature_name,
	754	diags.unknown_feature_name.?,
755	755	@tagName(diags.arch.?),
756	756	});
757	757	for (diags.arch.?.allFeaturesList()) \|feature\| {
...	...	@@ -765,7 +765,7 @@ pub const Builder = struct {
765	765	\\Unknown OS: '{s}'
766	766	\\Available operating systems:
767	767	\\
768		, .{diags.os_name});
	768	, .{diags.os_name.?});
769	769	inline for (std.meta.fields(std.Target.Os.Tag)) \|field\| {
770	770	log.err(" {s}", .{field.name});
771	771	}

lib/std/crypto/phc_encoding.zig+1-1

...	...	@@ -216,7 +216,7 @@ fn serializeTo(params: anytype, out: anytype) !void {
216	216
217	217	var has_params = false;
218	218	inline for (comptime meta.fields(HashResult)) \|p\| {
219		if (!(mem.eql(u8, p.name, "alg_id") or
	219	if (comptime !(mem.eql(u8, p.name, "alg_id") or
220	220	mem.eql(u8, p.name, "alg_version") or
221	221	mem.eql(u8, p.name, "hash") or
222	222	mem.eql(u8, p.name, "salt")))

lib/std/fmt.zig+33-11

...	...	@@ -60,8 +60,10 @@ pub const FormatOptions = struct {
60	60	/// - `o`: output integer value in octal notation
61	61	/// - `c`: output integer as an ASCII character. Integer type must have 8 bits at max.
62	62	/// - `u`: output integer as an UTF-8 sequence. Integer type must have 21 bits at max.
	63	/// - `?`: output optional value as either the unwrapped value, or `null`; may be followed by a format specifier for the underlying value.
	64	/// - `!`: output error union value as either the unwrapped value, or the formatted error value; may be followed by a format specifier for the underlying value.
63	65	/// - `*`: output the address of the value instead of the value itself.
64		/// - `any`: output a value of any type using its default format
	66	/// - `any`: output a value of any type using its default format.
65	67	///
66	68	/// If a formatted user type contains a function of the type
67	69	/// ```
...	...	@@ -438,12 +440,20 @@ fn defaultSpec(comptime T: type) [:0]const u8 {
438	440	.Many, .C => return "*",
439	441	.Slice => return ANY,
440	442	},
441		.Optional => \|info\| return defaultSpec(info.child),
	443	.Optional => \|info\| return "?" ++ defaultSpec(info.child),
	444	.ErrorUnion => \|info\| return "!" ++ defaultSpec(info.payload),
442	445	else => {},
443	446	}
444	447	return "";
445	448	}
446	449
	450	fn stripOptionalOrErrorUnionSpec(comptime fmt: []const u8) []const u8 {
	451	return if (std.mem.eql(u8, fmt[1..], ANY))
	452	ANY
	453	else
	454	fmt[1..];
	455	}
	456
447	457	pub fn formatType(
448	458	value: anytype,
449	459	comptime fmt: []const u8,
...	...	@@ -451,12 +461,18 @@ pub fn formatType(
451	461	writer: anytype,
452	462	max_depth: usize,
453	463	) @TypeOf(writer).Error!void {
454		const actual_fmt = comptime if (std.mem.eql(u8, fmt, ANY)) defaultSpec(@TypeOf(value)) else fmt;
	464	const T = @TypeOf(value);
	465	const actual_fmt = comptime if (std.mem.eql(u8, fmt, ANY))
	466	defaultSpec(@TypeOf(value))
	467	else if (fmt.len != 0 and (fmt[0] == '?' or fmt[0] == '!')) switch (@typeInfo(T)) {
	468	.Optional, .ErrorUnion => fmt,
	469	else => stripOptionalOrErrorUnionSpec(fmt),
	470	} else fmt;
	471
455	472	if (comptime std.mem.eql(u8, actual_fmt, "*")) {
456	473	return formatAddress(value, options, writer);
457	474	}
458	475
459		const T = @TypeOf(value);
460	476	if (comptime std.meta.trait.hasFn("format")(T)) {
461	477	return try value.format(actual_fmt, options, writer);
462	478	}
...	...	@@ -472,17 +488,23 @@ pub fn formatType(
472	488	return formatBuf(if (value) "true" else "false", options, writer);
473	489	},
474	490	.Optional => {
	491	if (actual_fmt.len == 0 or actual_fmt[0] != '?')
	492	@compileError("cannot format optional without a specifier (i.e. {?} or {any})");
	493	const remaining_fmt = comptime stripOptionalOrErrorUnionSpec(actual_fmt);
475	494	if (value) \|payload\| {
476		return formatType(payload, actual_fmt, options, writer, max_depth);
	495	return formatType(payload, remaining_fmt, options, writer, max_depth);
477	496	} else {
478	497	return formatBuf("null", options, writer);
479	498	}
480	499	},
481	500	.ErrorUnion => {
	501	if (actual_fmt.len == 0 or actual_fmt[0] != '!')
	502	@compileError("cannot format error union without a specifier (i.e. {!} or {any})");
	503	const remaining_fmt = comptime stripOptionalOrErrorUnionSpec(actual_fmt);
482	504	if (value) \|payload\| {
483		return formatType(payload, actual_fmt, options, writer, max_depth);
	505	return formatType(payload, remaining_fmt, options, writer, max_depth);
484	506	} else \|err\| {
485		return formatType(err, actual_fmt, options, writer, max_depth);
	507	return formatType(err, remaining_fmt, options, writer, max_depth);
486	508	}
487	509	},
488	510	.ErrorSet => {
...	...	@@ -1977,11 +1999,11 @@ test "escaped braces" {
1977	1999	test "optional" {
1978	2000	{
1979	2001	const value: ?i32 = 1234;
1980		try expectFmt("optional: 1234\n", "optional: {}\n", .{value});
	2002	try expectFmt("optional: 1234\n", "optional: {?}\n", .{value});
1981	2003	}
1982	2004	{
1983	2005	const value: ?i32 = null;
1984		try expectFmt("optional: null\n", "optional: {}\n", .{value});
	2006	try expectFmt("optional: null\n", "optional: {?}\n", .{value});
1985	2007	}
1986	2008	{
1987	2009	const value = @intToPtr(?*i32, 0xf000d000);
...	...	@@ -1992,11 +2014,11 @@ test "optional" {
1992	2014	test "error" {
1993	2015	{
1994	2016	const value: anyerror!i32 = 1234;
1995		try expectFmt("error union: 1234\n", "error union: {}\n", .{value});
	2017	try expectFmt("error union: 1234\n", "error union: {!}\n", .{value});
1996	2018	}
1997	2019	{
1998	2020	const value: anyerror!i32 = error.InvalidChar;
1999		try expectFmt("error union: error.InvalidChar\n", "error union: {}\n", .{value});
	2021	try expectFmt("error union: error.InvalidChar\n", "error union: {!}\n", .{value});
2000	2022	}
2001	2023	}
2002	2024

lib/std/x/os/net.zig+1-1

...	...	@@ -544,7 +544,7 @@ test "ip: convert to and from ipv6" {
544	544	try testing.expect(IPv4.localhost.mapToIPv6().mapsToIPv4());
545	545
546	546	try testing.expect(IPv4.localhost.toIPv6().toIPv4() == null);
547		try testing.expectFmt("127.0.0.1", "{}", .{IPv4.localhost.mapToIPv6().toIPv4()});
	547	try testing.expectFmt("127.0.0.1", "{?}", .{IPv4.localhost.mapToIPv6().toIPv4()});
548	548	}
549	549
550	550	test "ipv4: parse & format" {

src/Cache.zig+1-1

...	...	@@ -747,7 +747,7 @@ pub const Manifest = struct {
747	747	file.stat.inode,
748	748	file.stat.mtime,
749	749	&encoded_digest,
750		file.path,
	750	file.path.?,
751	751	});
752	752	}
753	753

src/Compilation.zig+1-1

...	...	@@ -1465,7 +1465,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1465	1465	.handle = artifact_dir,
1466	1466	.path = try options.local_cache_directory.join(arena, &[_][]const u8{artifact_sub_dir}),
1467	1467	};
1468		log.debug("zig_cache_artifact_directory='{s}' use_stage1={}", .{
	1468	log.debug("zig_cache_artifact_directory='{?s}' use_stage1={}", .{
1469	1469	zig_cache_artifact_directory.path, use_stage1,
1470	1470	});
1471	1471

src/link/MachO.zig+9-9

...	...	@@ -363,7 +363,7 @@ pub fn openPath(allocator: Allocator, options: link.Options) !*MachO {
363	363
364	364	// Create dSYM bundle.
365	365	const dir = options.module.?.zig_cache_artifact_directory;
366		log.debug("creating {s}.dSYM bundle in {s}", .{ emit.sub_path, dir.path });
	366	log.debug("creating {s}.dSYM bundle in {?s}", .{ emit.sub_path, dir.path });
367	367
368	368	const d_sym_path = try fmt.allocPrint(
369	369	allocator,
...	...	@@ -2378,7 +2378,7 @@ fn writeAtomsOneShot(self: *MachO) !void {
2378	2378	break :blk math.cast(usize, size) orelse return error.Overflow;
2379	2379	} else 0;
2380	2380
2381		log.debug(" (adding ATOM(%{d}, '{s}') from object({d}) to buffer)", .{
	2381	log.debug(" (adding ATOM(%{d}, '{s}') from object({?d}) to buffer)", .{
2382	2382	atom.sym_index,
2383	2383	atom.getName(self),
2384	2384	atom.file,
...	...	@@ -2911,7 +2911,7 @@ fn createTentativeDefAtoms(self: *MachO) !void {
2911	2911	const sym = self.getSymbolPtr(global);
2912	2912	if (!sym.tentative()) continue;
2913	2913
2914		log.debug("creating tentative definition for ATOM(%{d}, '{s}') in object({d})", .{
	2914	log.debug("creating tentative definition for ATOM(%{d}, '{s}') in object({?d})", .{
2915	2915	global.sym_index, self.getSymbolName(global), global.file,
2916	2916	});
2917	2917
...	...	@@ -3694,7 +3694,7 @@ pub fn lowerUnnamedConst(self: *MachO, typed_value: TypedValue, decl_index: Modu
3694	3694	};
3695	3695	const name = self.strtab.get(name_str_index);
3696	3696
3697		log.debug("allocating symbol indexes for {s}", .{name});
	3697	log.debug("allocating symbol indexes for {?s}", .{name});
3698	3698
3699	3699	const required_alignment = typed_value.ty.abiAlignment(self.base.options.target);
3700	3700	const sym_index = try self.allocateSymbol();
...	...	@@ -3734,7 +3734,7 @@ pub fn lowerUnnamedConst(self: *MachO, typed_value: TypedValue, decl_index: Modu
3734	3734	);
3735	3735	const addr = try self.allocateAtom(atom, code.len, required_alignment, match);
3736	3736
3737		log.debug("allocated atom for {s} at 0x{x}", .{ name, addr });
	3737	log.debug("allocated atom for {?s} at 0x{x}", .{ name, addr });
3738	3738	log.debug(" (required alignment 0x{x})", .{required_alignment});
3739	3739
3740	3740	errdefer self.freeAtom(atom, match, true);
...	...	@@ -7040,7 +7040,7 @@ fn logSymtab(self: *MachO) void {
7040	7040	@divTrunc(sym.n_desc, macho.N_SYMBOL_RESOLVER)
7041	7041	else
7042	7042	sym.n_sect;
7043		log.debug(" %{d}: {s} @{x} in {s}({d}), {s}", .{
	7043	log.debug(" %{d}: {?s} @{x} in {s}({d}), {s}", .{
7044	7044	sym_id,
7045	7045	self.strtab.get(sym.n_strx),
7046	7046	sym.n_value,
...	...	@@ -7053,7 +7053,7 @@ fn logSymtab(self: *MachO) void {
7053	7053	log.debug("globals table:", .{});
7054	7054	for (self.globals.keys()) \|name, id\| {
7055	7055	const value = self.globals.values()[id];
7056		log.debug(" {s} => %{d} in object({d})", .{ name, value.sym_index, value.file });
	7056	log.debug(" {s} => %{d} in object({?d})", .{ name, value.sym_index, value.file });
7057	7057	}
7058	7058
7059	7059	log.debug("GOT entries:", .{});
...	...	@@ -7068,7 +7068,7 @@ fn logSymtab(self: *MachO) void {
7068	7068	self.getSymbolName(entry.target),
7069	7069	});
7070	7070	} else {
7071		log.debug(" {d}@{x} => local(%{d}) in object({d}) {s}", .{
	7071	log.debug(" {d}@{x} => local(%{d}) in object({?d}) {s}", .{
7072	7072	i,
7073	7073	atom_sym.n_value,
7074	7074	entry.target.sym_index,
...	...	@@ -7137,7 +7137,7 @@ fn logAtoms(self: *MachO) void {
7137	7137	pub fn logAtom(self: MachO, atom: const Atom) void {
7138	7138	const sym = atom.getSymbol(self);
7139	7139	const sym_name = atom.getName(self);
7140		log.debug(" ATOM(%{d}, '{s}') @ {x} (sizeof({x}), alignof({x})) in object({d}) in sect({d})", .{
	7140	log.debug(" ATOM(%{d}, '{s}') @ {x} (sizeof({x}), alignof({x})) in object({?d}) in sect({d})", .{
7141	7141	atom.sym_index,
7142	7142	sym_name,
7143	7143	sym.n_value,

src/link/MachO/Atom.zig+3-3

...	...	@@ -541,7 +541,7 @@ pub fn resolveRelocs(self: Atom, macho_file: MachO) !void {
541	541	const arch = macho_file.base.options.target.cpu.arch;
542	542	switch (arch) {
543	543	.aarch64 => {
544		log.debug(" RELA({s}) @ {x} => %{d} in object({d})", .{
	544	log.debug(" RELA({s}) @ {x} => %{d} in object({?d})", .{
545	545	@tagName(@intToEnum(macho.reloc_type_arm64, rel.@"type")),
546	546	rel.offset,
547	547	rel.target.sym_index,
...	...	@@ -549,7 +549,7 @@ pub fn resolveRelocs(self: Atom, macho_file: MachO) !void {
549	549	});
550	550	},
551	551	.x86_64 => {
552		log.debug(" RELA({s}) @ {x} => %{d} in object({d})", .{
	552	log.debug(" RELA({s}) @ {x} => %{d} in object({?d})", .{
553	553	@tagName(@intToEnum(macho.reloc_type_x86_64, rel.@"type")),
554	554	rel.offset,
555	555	rel.target.sym_index,
...	...	@@ -579,7 +579,7 @@ pub fn resolveRelocs(self: Atom, macho_file: MachO) !void {
579	579	log.debug(" \| atomless target '{s}'", .{target_name});
580	580	break :blk atomless_sym.n_value;
581	581	};
582		log.debug(" \| target ATOM(%{d}, '{s}') in object({d})", .{
	582	log.debug(" \| target ATOM(%{d}, '{s}') in object({?d})", .{
583	583	target_atom.sym_index,
584	584	target_atom.getName(macho_file),
585	585	target_atom.file,

src/link/Wasm.zig+1-1

...	...	@@ -1629,7 +1629,7 @@ fn setupMemory(self: *Wasm) !void {
1629	1629	return error.MemoryTooBig;
1630	1630	}
1631	1631	self.memories.limits.max = @intCast(u32, max_memory / page_size);
1632		log.debug("Maximum memory pages: {d}", .{self.memories.limits.max});
	1632	log.debug("Maximum memory pages: {?d}", .{self.memories.limits.max});
1633	1633	}
1634	1634	}
1635	1635

src/link/Wasm/Object.zig+1-1

...	...	@@ -548,7 +548,7 @@ fn Parser(comptime ReaderType: type) type {
548	548	.index = try leb.readULEB128(u32, reader),
549	549	.addend = if (rel_type_enum.addendIsPresent()) try leb.readULEB128(u32, reader) else null,
550	550	};
551		log.debug("Found relocation: type({s}) offset({d}) index({d}) addend({d})", .{
	551	log.debug("Found relocation: type({s}) offset({d}) index({d}) addend({?d})", .{
552	552	@tagName(relocation.relocation_type),
553	553	relocation.offset,
554	554	relocation.index,

src/main.zig+5-3

...	...	@@ -3168,7 +3168,7 @@ fn parseCrossTargetOrReportFatalError(
3168	3168	@tagName(diags.arch.?), help_text.items,
3169	3169	});
3170	3170	}
3171		fatal("Unknown CPU feature: '{s}'", .{diags.unknown_feature_name});
	3171	fatal("Unknown CPU feature: '{s}'", .{diags.unknown_feature_name.?});
3172	3172	},
3173	3173	else => \|e\| return e,
3174	3174	};
...	...	@@ -3496,7 +3496,8 @@ fn cmdTranslateC(comp: *Compilation, arena: Allocator, enable_cache: bool, stage
3496	3496	} else {
3497	3497	const out_zig_path = try fs.path.join(arena, &[_][]const u8{ "o", &digest, translated_zig_basename });
3498	3498	const zig_file = comp.local_cache_directory.handle.openFile(out_zig_path, .{}) catch \|err\| {
3499		fatal("unable to open cached translated zig file '{s}{s}{s}': {s}", .{ comp.local_cache_directory.path, fs.path.sep_str, out_zig_path, @errorName(err) });
	3499	const path = comp.local_cache_directory.path orelse ".";
	3500	fatal("unable to open cached translated zig file '{s}{s}{s}': {s}", .{ path, fs.path.sep_str, out_zig_path, @errorName(err) });
3500	3501	};
3501	3502	defer zig_file.close();
3502	3503	try io.getStdOut().writeFileAll(zig_file, .{});
...	...	@@ -3626,7 +3627,8 @@ pub fn cmdInit(
3626	3627	.Exe => "init-exe",
3627	3628	};
3628	3629	var template_dir = zig_lib_directory.handle.openDir(template_sub_path, .{}) catch \|err\| {
3629		fatal("unable to open zig project template directory '{s}{s}{s}': {s}", .{ zig_lib_directory.path, s, template_sub_path, @errorName(err) });
	3630	const path = zig_lib_directory.path orelse ".";
	3631	fatal("unable to open zig project template directory '{s}{s}{s}': {s}", .{ path, s, template_sub_path, @errorName(err) });
3630	3632	};
3631	3633	defer template_dir.close();
3632	3634

src/register_manager.zig+1-1

...	...	@@ -301,7 +301,7 @@ pub fn RegisterManager(
301	301	/// register.
302	302	pub fn getReg(self: *Self, reg: Register, inst: ?Air.Inst.Index) AllocateRegistersError!void {
303	303	const index = indexOfRegIntoTracked(reg) orelse return;
304		log.debug("getReg {} for inst {}", .{ reg, inst });
	304	log.debug("getReg {} for inst {?}", .{ reg, inst });
305	305	self.markRegAllocated(reg);
306	306
307	307	if (inst) \|tracked_inst\|

src/translate_c.zig+7-6

...	...	@@ -2765,7 +2765,7 @@ fn transInitListExpr(
2765	2765	qual_type,
2766	2766	));
2767	2767	} else {
2768		const type_name = c.str(qual_type.getTypeClassName());
	2768	const type_name = try c.str(qual_type.getTypeClassName());
2769	2769	return fail(c, error.UnsupportedType, source_loc, "unsupported initlist type: '{s}'", .{type_name});
2770	2770	}
2771	2771	}
...	...	@@ -4812,11 +4812,11 @@ fn transType(c: Context, scope: Scope, ty: *const clang.Type, source_loc: clan
4812	4812	});
4813	4813	},
4814	4814	.BitInt, .ExtVector => {
4815		const type_name = c.str(ty.getTypeClassName());
	4815	const type_name = try c.str(ty.getTypeClassName());
4816	4816	return fail(c, error.UnsupportedType, source_loc, "TODO implement translation of type: '{s}'", .{type_name});
4817	4817	},
4818	4818	else => {
4819		const type_name = c.str(ty.getTypeClassName());
	4819	const type_name = try c.str(ty.getTypeClassName());
4820	4820	return fail(c, error.UnsupportedType, source_loc, "unsupported type: '{s}'", .{type_name});
4821	4821	},
4822	4822	}
...	...	@@ -5052,8 +5052,8 @@ fn finishTransFnProto(
5052	5052	}
5053	5053
5054	5054	fn warn(c: Context, scope: Scope, loc: clang.SourceLocation, comptime format: []const u8, args: anytype) !void {
5055		const args_prefix = .{c.locStr(loc)};
5056		const value = try std.fmt.allocPrint(c.arena, "// {s}: warning: " ++ format, args_prefix ++ args);
	5055	const str = try c.locStr(loc);
	5056	const value = try std.fmt.allocPrint(c.arena, "// {s}: warning: " ++ format, .{str} ++ args);
5057	5057	try scope.appendNode(try Tag.warning.create(c.arena, value));
5058	5058	}
5059	5059
...	...	@@ -5073,7 +5073,8 @@ pub fn failDecl(c: *Context, loc: clang.SourceLocation, name: []const u8, compti
5073	5073	// pub const name = @compileError(msg);
5074	5074	const fail_msg = try std.fmt.allocPrint(c.arena, format, args);
5075	5075	try addTopLevelDecl(c, name, try Tag.fail_decl.create(c.arena, .{ .actual = name, .mangled = fail_msg }));
5076		const location_comment = try std.fmt.allocPrint(c.arena, "// {s}", .{c.locStr(loc)});
	5076	const str = try c.locStr(loc);
	5077	const location_comment = try std.fmt.allocPrint(c.arena, "// {s}", .{str});
5077	5078	try c.global_scope.nodes.append(try Tag.warning.create(c.arena, location_comment));
5078	5079	}
5079	5080

author	InKryption <inkryption07@gmail.com> 2022-07-25 15:29:07+03:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-07-26 11:25:49-07:00
log	a0d3a87ce15a9f68047dc900109f5b76184d046f
tree	5fb7b787347a7061bc072e76787983c82698b00d
parent	1a16b7214d88261f0e38b7ca4d15bcd76caaec4c

std.fmt: require specifier for unwrapping ?T and E!T